feat: schedule cache, workflow-aligned prompts, dispatchInbound wakeup

1. ScheduleCache: local cache of today's schedule, synced every 5 min
   from HF backend via new getDaySchedule() API

2. Wakeup prompts updated to reference daily-routine skill workflows
   (task-handson, plan-schedule, slot-complete)

3. Agent wakeup via dispatchInboundMessageWithDispatcher (in-process)
   - Same mechanism as Discord plugin
   - Creates unique session per slot: agent:{agentId}:hf-calendar:slot-{slotId}
   - No WebSocket, CLI, or cron dependency
   - Verified working on test environment

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.gitignore

@@ -4,5 +4,3 @@ plugin/**/*.js
 plugin/**/*.js.map
 plugin/**/*.d.ts
 plugin/**/*.d.ts.map
-# Hand-written ambient declarations are tracked; only compiled .d.ts above is ignored.
-!plugin/openclaw-sdk.d.ts

plugin/calendar/calendar-bridge.ts

@@ -29,7 +29,7 @@ import {
   CalendarSlotResponse,
   SlotAgentUpdate,
   SlotStatus,
-} from './types.js';
+} from './types';
 
 export interface CalendarBridgeConfig {
   /** HarborForge backend base URL (e.g. "https://monitor.hangman-lab.top") */
@@ -292,7 +292,7 @@ export class CalendarBridgeClient {
 // ---------------------------------------------------------------------------
 
 import { hostname } from 'os';
-import { getPluginConfig } from '../core/config.js';
+import { getPluginConfig } from '../core/config';
 
 export interface CalendarPluginConfig {
   /** Backend URL for calendar API (overrides monitor backendUrl) */

plugin/calendar/index.ts

@@ -13,7 +13,7 @@
  *   • AgentWakeContext — context passed to agent when waking
  *
  * Usage in plugin/index.ts:
- *   import { createCalendarBridgeClient, createCalendarScheduler } from './calendar.js';
+ *   import { createCalendarBridgeClient, createCalendarScheduler } from './calendar';
  *
  *   const agentId = process.env.AGENT_ID || 'unknown';
  *   const calendar = createCalendarBridgeClient(api, 'https://monitor.hangman-lab.top', agentId);
@@ -28,7 +28,7 @@
  *   scheduler.start();
  */
 
-export * from './types.js';
-export * from './calendar-bridge.js';
-export * from './scheduler.js';
-export * from './schedule-cache.js';
+export * from './types';
+export * from './calendar-bridge';
+export * from './scheduler';
+export * from './schedule-cache';

plugin/calendar/scheduler.ts

@@ -18,7 +18,8 @@
 
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
-import { CalendarBridgeClient } from './calendar-bridge.js';
+import { CalendarBridgeClient } from './calendar-bridge';
+import { ScheduleCache } from './schedule-cache';
 import {
   CalendarSlotResponse,
   SlotStatus,
@@ -26,7 +27,7 @@ import {
   SlotAgentUpdate,
   CalendarEventDataJob,
   CalendarEventDataSystemEvent,
-} from './types.js';
+} from './types';
 
 export interface CalendarSchedulerConfig {
   /** Calendar bridge client for backend communication */
@@ -44,6 +45,8 @@ export interface CalendarSchedulerConfig {
   };
   /** Heartbeat interval in milliseconds (default: 60000) */
   heartbeatIntervalMs?: number;
+  /** Schedule sync interval in milliseconds (default: 300000 = 5 min) */
+  syncIntervalMs?: number;
   /** Enable verbose debug logging */
   debug?: boolean;
   /** Directory for state persistence (default: plugin data dir) */
@@ -95,8 +98,10 @@ interface SchedulerState {
   currentSlot: CalendarSlotResponse | null;
   /** Last heartbeat timestamp */
   lastHeartbeatAt: Date | null;
-  /** Interval handle for cleanup */
+  /** Heartbeat interval handle */
   intervalHandle: ReturnType<typeof setInterval> | null;
+  /** Schedule sync interval handle */
+  syncIntervalHandle: ReturnType<typeof setInterval> | null;
   /** Set of slot IDs that have been deferred in current session */
   deferredSlotIds: Set<string>;
   /** Whether agent is currently processing a slot */
@@ -117,10 +122,13 @@ export class CalendarScheduler {
   private config: Required<CalendarSchedulerConfig>;
   private state: SchedulerState;
   private stateFilePath: string;
+  /** Local cache of today's full schedule, synced periodically from backend */
+  private scheduleCache: ScheduleCache = new ScheduleCache();
 
   constructor(config: CalendarSchedulerConfig) {
     this.config = {
       heartbeatIntervalMs: 60000, // 1 minute default
+      syncIntervalMs: 300_000,    // 5 minutes default
       debug: false,
       stateDir: this.getDefaultStateDir(),
       ...config,
@@ -133,6 +141,7 @@ export class CalendarScheduler {
       currentSlot: null,
       lastHeartbeatAt: null,
       intervalHandle: null,
+      syncIntervalHandle: null,
       deferredSlotIds: new Set(),
       isProcessing: false,
       isRestartPending: false,
@@ -327,14 +336,21 @@ export class CalendarScheduler {
     this.state.isRestartPending = false;
     this.config.logger.info('Calendar scheduler started');
 
-    // Run initial heartbeat immediately
+    // Run initial sync + heartbeat immediately
+    this.runSync();
     this.runHeartbeat();
 
-    // Schedule periodic heartbeats
+    // Schedule periodic heartbeats (slot execution checks)
     this.state.intervalHandle = setInterval(
       () => this.runHeartbeat(),
       this.config.heartbeatIntervalMs
     );
+
+    // Schedule periodic schedule sync (full day schedule refresh)
+    this.state.syncIntervalHandle = setInterval(
+      () => this.runSync(),
+      this.config.syncIntervalMs
+    );
   }
 
   /**
@@ -348,10 +364,41 @@ export class CalendarScheduler {
       clearInterval(this.state.intervalHandle);
       this.state.intervalHandle = null;
     }
+    if (this.state.syncIntervalHandle) {
+      clearInterval(this.state.syncIntervalHandle);
+      this.state.syncIntervalHandle = null;
+    }
 
     this.config.logger.info('Calendar scheduler stopped');
   }
 
+  /**
+   * Sync today's full schedule from backend into local cache.
+   * Runs every syncIntervalMs (default: 5 min).
+   * Catches new slots assigned by other agents or the manager.
+   */
+  async runSync(): Promise<void> {
+    if (!this.state.isRunning || this.state.isRestartPending) return;
+
+    const today = new Date().toISOString().slice(0, 10);
+    try {
+      const slots = await this.config.bridge.getDaySchedule(today);
+      if (slots) {
+        this.scheduleCache.sync(today, slots);
+        this.logDebug(`Schedule synced: ${slots.length} slots for ${today}`);
+      }
+    } catch (err) {
+      this.config.logger.warn(`Schedule sync failed: ${String(err)}`);
+    }
+  }
+
+  /**
+   * Get the local schedule cache (for status reporting / tools).
+   */
+  getScheduleCache(): ScheduleCache {
+    return this.scheduleCache;
+  }
+
   /**
    * Execute a single heartbeat cycle.
    * Fetches pending slots and handles execution logic.
@@ -611,13 +658,11 @@ Task Code: ${code}
 Estimated Duration: ${duration} minutes
 Slot Type: ${slot.slot_type}
 Priority: ${slot.priority}
+Working Sessions: ${jobData.working_sessions?.join(', ') || 'none recorded'}
 
-Please focus on this task for the allocated time. When you finish or need to pause,
-report your progress back to the calendar system.
-
-Working sessions: ${jobData.working_sessions?.join(', ') || 'none recorded'}
-
-Start working on ${code} now.`;
+Follow the daily-routine skill's task-handson workflow to execute this task.
+Use harborforge_calendar_complete when finished, or harborforge_calendar_pause to pause.
+Before going idle, check for overdue slots as described in the slot-complete workflow.`;
   }
 
   /**
@@ -630,19 +675,15 @@ Start working on ${code} now.`;
     switch (sysData.event) {
       case 'ScheduleToday':
         return `System Event: Schedule Today
-
-Please review today's calendar and schedule any pending tasks or planning activities.
 Estimated time: ${slot.estimated_duration} minutes.
 
-Check your calendar and plan the day's work.`;
+Follow the daily-routine skill's plan-schedule workflow to plan today's work.`;
 
       case 'SummaryToday':
         return `System Event: Daily Summary
-
-Please provide a summary of today's activities and progress.
 Estimated time: ${slot.estimated_duration} minutes.
 
-Review what was accomplished and prepare end-of-day notes.`;
+Review today's completed, deferred, and abandoned slots. Write a summary to your daily note (memory/YYYY-MM-DD.md).`;
 
       case 'ScheduledGatewayRestart':
         return `System Event: Scheduled Gateway Restart

plugin/hooks/gateway-start.ts

@@ -1,6 +1,6 @@
 import { hostname } from 'os';
-import { getPluginConfig } from '../core/config.js';
-import { startManagedMonitor } from '../core/managed-monitor.js';
+import { getPluginConfig } from '../core/config';
+import { startManagedMonitor } from '../core/managed-monitor';
 
 export function registerGatewayStartHook(api: any, deps: {
   logger: any;

plugin/hooks/gateway-stop.ts

@@ -1,4 +1,4 @@
-import { stopManagedMonitor } from '../core/managed-monitor.js';
+import { stopManagedMonitor } from '../core/managed-monitor';
 
 export function registerGatewayStopHook(api: any, deps: {
   logger: any;

plugin/index.ts

@@ -11,20 +11,18 @@
  * served directly by the plugin when Monitor queries via the
  * local monitor_port communication path.
  */
-import { hostname, freemem, totalmem, uptime, loadavg, platform } from 'node:os';
-import { definePluginEntry } from 'openclaw/plugin-sdk/plugin-entry';
-import { MultiAgentScheduleCache } from './calendar/schedule-cache.js';
-import { getPluginConfig } from './core/config.js';
-import { MonitorBridgeClient, type OpenClawMeta } from './core/monitor-bridge.js';
-import type { OpenClawAgentInfo } from './core/openclaw-agents.js';
-import { registerGatewayStartHook } from './hooks/gateway-start.js';
-import { registerGatewayStopHook } from './hooks/gateway-stop.js';
+import { hostname, freemem, totalmem, uptime, loadavg, platform } from 'os';
+import { getPluginConfig } from './core/config';
+import { MonitorBridgeClient, type OpenClawMeta } from './core/monitor-bridge';
+import type { OpenClawAgentInfo } from './core/openclaw-agents';
+import { registerGatewayStartHook } from './hooks/gateway-start';
+import { registerGatewayStopHook } from './hooks/gateway-stop';
 import {
   createCalendarBridgeClient,
   createCalendarScheduler,
   CalendarScheduler,
   AgentWakeContext,
-} from './calendar/index.js';
+} from './calendar';
 
 interface PluginAPI {
   logger: {
@@ -55,7 +53,10 @@ interface PluginAPI {
   getAgentStatus?: () => Promise<{ status: string } | null>;
 }
 
-function register(api: PluginAPI): void {
+export default {
+  id: 'harbor-forge',
+  name: 'HarborForge',
+  register(api: PluginAPI) {
     const logger = api.logger || {
       info: (...args: any[]) => console.log('[HarborForge]', ...args),
       error: (...args: any[]) => console.error('[HarborForge]', ...args),
@@ -289,6 +290,7 @@ function register(api: PluginAPI): void {
       );
 
       // Multi-agent sync + check loop
+      const { MultiAgentScheduleCache } = require('./calendar/schedule-cache') as typeof import('./calendar/schedule-cache');
       const scheduleCache = new MultiAgentScheduleCache();
 
       const SYNC_INTERVAL_MS = 300_000; // 5 min
@@ -593,16 +595,5 @@ function register(api: PluginAPI): void {
     }));
 
     logger.info('HarborForge plugin registered (id: harbor-forge)');
-}
-
-// HarborForge's local PluginAPI is broader than the standard OpenClawPluginApi
-// (it surfaces optional `version`/`runtime`/`spawn` accessors that older
-// OpenClaw builds exposed). The cast at the definePluginEntry boundary
-// acknowledges that gap — the runtime api object is whatever the gateway
-// passes us, and each access is guarded with optional chaining / fallbacks.
-export default definePluginEntry({
-  id: 'harbor-forge',
-  name: 'HarborForge',
-  description: 'HarborForge plugin for OpenClaw - project management, monitoring, and CLI integration',
-  register: register as (api: any) => void,
-});
+  },
+};

plugin/openclaw-sdk.d.ts

@@ -1,25 +0,0 @@
-// Ambient declarations for the focused subpaths of the openclaw plugin SDK
-// that this plugin needs at compile time.
-//
-// We intentionally do NOT take a `dependencies` (or `devDependencies`) entry
-// on the openclaw npm package itself: openclaw is provided by the host
-// gateway at runtime, and listing it as a file:/.../openclaw devDep breaks
-// the installer's `npm install --omit=dev` step because npm/arborist trips
-// over openclaw's own (deeply nested) dependency graph.
-//
-// These declarations cover only what we use here. They are deliberately
-// permissive — the runtime contract is whatever the gateway hands us, and
-// we guard each api access with optional chaining or a fallback at call site.
-
-declare module 'openclaw/plugin-sdk/plugin-entry' {
-  export function definePluginEntry<T extends {
-    id: string;
-    name: string;
-    description?: string;
-    register: (api: any) => void | Promise<void>;
-  }>(opts: T): T;
-}
-
-declare module 'openclaw/plugin-sdk/core' {
-  export type OpenClawPluginApi = unknown;
-}

plugin/openclaw.plugin.json

@@ -1,19 +1,9 @@
 {
   "id": "harbor-forge",
   "name": "HarborForge",
+  "version": "0.2.0",
   "description": "HarborForge plugin for OpenClaw - project management, monitoring, and CLI integration",
-  "activation": {
-    "onStartup": true
-  },
-  "contracts": {
-    "tools": [
-      "harborforge_status",
-      "harborforge_telemetry",
-      "harborforge_monitor_telemetry",
-      "harborforge_calendar_status",
-      "harborforge_calendar_complete"
-    ]
-  },
+  "entry": "./dist/index.js",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

plugin/package.json

@@ -2,7 +2,6 @@
   "name": "harbor-forge-plugin",
   "version": "0.2.0",
   "description": "OpenClaw plugin for HarborForge monitor bridge and CLI integration",
-  "type": "module",
   "main": "dist/index.js",
   "scripts": {
     "clean": "rm -rf dist",

plugin/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
     "target": "ES2022",
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
+    "module": "CommonJS",
+    "moduleResolution": "node",
     "esModuleInterop": true,
     "strict": true,
     "skipLibCheck": true,