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>
2026-04-19 09:32:36 +00:00
15 changed files with 266 additions and 886 deletions
--- a/.gitignore
+++ b/.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
--- a/README.md
+++ b/README.md
@@ -1,107 +1,84 @@
 # HarborForge OpenClaw Plugin

-OpenClaw plugin that exposes OpenClaw-side metadata to the HarborForge Monitor, provides an optional local Monitor bridge, drives the HarborForge Calendar scheduler, and can optionally install the `hf` CLI.
+OpenClaw 插件：向 HarborForge Monitor 暴露 OpenClaw 侧元数据，并提供可选的本地桥接能力；安装时也可顺带安装 `hf` CLI。

-Part of the [HarborForge](../README.md) platform.
+## 当前状态

- Role: OpenClaw integration layer for HarborForge (registered plugin id: `harbor-forge`).
- Talks to the HarborForge backend (`backendUrl`, default `https://monitor.hangman-lab.top`) for Calendar APIs.
- Talks to a local HarborForge.Monitor bridge over `127.0.0.1:<monitor_port>` (no fixed default; commonly `9100`).
+- 插件注册名：`harbor-forge`
+- 旧 sidecar `server/` 架构已移除
+- 监控桥接走本地 `monitor_port`
+- 安装脚本支持 `--install-cli`
+- `skills/hf/` 仅在 `--install-cli` 时一并安装

-## Current State
-
- Plugin registration id: `harbor-forge` (was `harborforge-monitor`)
- Plugin version: `0.2.0` (package manifests); telemetry reports `pluginVersion` `0.3.1`
- Legacy sidecar `server/` architecture removed — telemetry is served directly by the plugin
- Monitor bridge runs over the local `monitor_port`
- Calendar scheduler integration (PLG-CAL-001 / 002 / 004)
- Installer supports `--install-cli` and an optional managed Monitor (`--install-monitor`)
- `skills/hf/` is installed only with `--install-cli`
-
-## Project Structure
+## 项目结构

 ```text
 HarborForge.OpenclawPlugin/
 ├── package.json
 ├── README.md
-├── docs/                         # design notes (calendar, monitor connector)
 ├── plugin/
-│   ├── openclaw.plugin.json      # plugin manifest + config schema
-│   ├── index.ts                  # plugin entry, tool registration
-│   ├── tsconfig.json
+│   ├── openclaw.plugin.json
+│   ├── index.ts
 │   ├── core/
-│   │   ├── config.ts             # config defaults / resolution
-│   │   ├── managed-monitor.ts    # optionally spawn HarborForge.Monitor
-│   │   ├── monitor-bridge.ts     # client for the Monitor bridge
-│   │   └── openclaw-agents.ts    # enumerate OpenClaw agents
-│   ├── calendar/                 # Calendar scheduler + bridge
-│   │   ├── index.ts
-│   │   ├── scheduler.ts
-│   │   ├── calendar-bridge.ts
-│   │   └── types.ts
+│   │   ├── config.ts
+│   │   ├── managed-monitor.ts
+│   │   └── monitor-bridge.ts
 │   ├── hooks/
 │   │   ├── gateway-start.ts
 │   │   └── gateway-stop.ts
 │   └── package.json
 ├── skills/
 │   └── hf/
-│       └── SKILL.md              # installed only with --install-cli
+│       └── SKILL.md
 └── scripts/
    └── install.mjs
 ```

-## Installation
+## 安装

-### Standard Install
+### 普通安装

 ```bash
 node scripts/install.mjs
 ```

-This will:
- Build and install the OpenClaw plugin
- Copy regular skills
- **Not** install the `hf` binary
- **Not** copy `skills/hf/`
+这会：
+- 构建并安装 OpenClaw 插件
+- 复制常规 skills
+- **不会**安装 `hf` 二进制
+- **不会**复制 `skills/hf/`

-### Plugin + `hf` CLI
+### 安装插件 + `hf` CLI

 ```bash
 node scripts/install.mjs --install-cli
 ```

-This additionally:
- Builds `HarborForge.Cli` (`go build ./cmd/hf`)
- Installs `hf` to `<openclaw>/bin/hf` (default `~/.openclaw/bin/hf`) and `chmod +x`
- Copies `skills/hf/` into the OpenClaw skills directory
+这会额外：
+- 构建 `HarborForge.Cli`
+- 安装 `hf` 到 `~/.openclaw/bin/hf`
+- `chmod +x ~/.openclaw/bin/hf`
+- 复制 `skills/hf/` 到 OpenClaw profile skills 目录

-### Common Options
+### 常用选项

 ```bash
-# Build only (no install / config)
+# 仅构建
 node scripts/install.mjs --build-only

-# Install only, skip dependency checks
-node scripts/install.mjs --skip-check
-
-# Specify OpenClaw profile path (also honors OPENCLAW_PATH env)
+# 指定 OpenClaw profile
 node scripts/install.mjs --openclaw-profile-path /custom/path/.openclaw

-# Build and install a managed HarborForge.Monitor binary alongside the plugin
-node scripts/install.mjs --install-monitor yes --monitor-branch main
-
-# Verbose logs
+# 详细日志
 node scripts/install.mjs --verbose

-# Uninstall (plugin, config entries, hf binary, managed monitor)
+# 卸载
 node scripts/install.mjs --uninstall
 ```

-The installer also updates OpenClaw config (`plugins.load.paths`, `plugins.allow`, `plugins.entries.harbor-forge.enabled`) via `openclaw config`.
+## 配置

-## Configuration
-
-Edit `~/.openclaw/openclaw.json`:
+编辑 `~/.openclaw/openclaw.json`：

 ```json
 {
@@ -117,9 +94,7 @@ Edit `~/.openclaw/openclaw.json`:
          "monitor_port": 9100,
          "reportIntervalSec": 30,
          "httpFallbackIntervalSec": 60,
-          "logLevel": "info",
-          "calendarEnabled": true,
-          "calendarHeartbeatIntervalSec": 60
+          "logLevel": "info"
        }
      }
    }
@@ -127,72 +102,51 @@ Edit `~/.openclaw/openclaw.json`:
 }
 ```

-Then restart:
+然后重启：

 ```bash
 openclaw gateway restart
 ```

-## Config Options
+## 配置项

-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `enabled` | boolean | `true` | Enable the plugin |
-| `backendUrl` | string | `https://monitor.hangman-lab.top` | HarborForge backend base URL (Monitor + Calendar APIs) |
-| `identifier` | string | hostname | Server / claw identifier |
-| `apiKey` | string | (none) | Server API key from the HarborForge Monitor admin panel |
-| `monitor_port` | number | (none) | Local bridge port; plugin talks to HarborForge.Monitor via `127.0.0.1:<monitor_port>` |
-| `reportIntervalSec` | number | `30` | Metadata push interval (seconds) |
-| `httpFallbackIntervalSec` | number | `60` | HTTP heartbeat interval when WS unavailable |
-| `logLevel` | string | `info` | Log level: `debug` / `info` / `warn` / `error` |
-| `calendarEnabled` | boolean | `true` | Enable Calendar scheduler integration (PLG-CAL-001) |
-| `calendarHeartbeatIntervalSec` | number | `60` | Calendar heartbeat interval (seconds) |
-| `calendarApiKey` | string | (none) | API key for Calendar API auth; falls back to `apiKey` / `X-Agent-ID` |
-| `managedMonitor` | string | (none) | Absolute path to a HarborForge.Monitor binary; if set, gateway start/stop hooks spawn/stop it |
+| 选项 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `enabled` | boolean | `true` | 是否启用插件 |
+| `backendUrl` | string | `https://monitor.hangman-lab.top` | HarborForge Monitor 后端地址 |
+| `identifier` | string | 主机名 | 服务器标识符 |
+| `apiKey` | string | 无 | HarborForge Monitor 生成的服务器 API Key |
+| `monitor_port` | number | 无 | 本地桥接端口；插件通过 `127.0.0.1:<monitor_port>` 与 HarborForge.Monitor 通信 |
+| `reportIntervalSec` | number | `30` | 报告间隔（秒） |
+| `httpFallbackIntervalSec` | number | `60` | HTTP 回退间隔（秒） |
+| `logLevel` | string | `info` | 日志级别：`debug` / `info` / `warn` / `error` |

-## Local Monitor Bridge
+## 本地桥接说明

-When the plugin has `monitor_port` configured and HarborForge.Monitor uses the same `MONITOR_PORT`:
+当插件配置了 `monitor_port`，并且 HarborForge.Monitor 也使用相同的 `MONITOR_PORT` 时：

- Monitor serves a local bridge on `127.0.0.1:<MONITOR_PORT>`
- The plugin probes `GET /health`
- The plugin tool `harborforge_monitor_telemetry` reads `GET /telemetry`
- The plugin pushes OpenClaw metadata (version, plugin version, agents) via `POST /openclaw` on the `reportIntervalSec` cadence, enriching Monitor heartbeats
- If the bridge port is unconfigured or unreachable, the plugin still works normally
+- Monitor 在 `127.0.0.1:<MONITOR_PORT>` 提供本地桥接服务
+- 插件可探测 `GET /health`
+- 插件工具 `harborforge_monitor_telemetry` 可读取 `GET /telemetry`
+- 如果桥接端口未配置或不可达，插件仍可正常运行

-This link is an **optional enhancement**, not a precondition for the plugin to start or for Monitor heartbeats.
+也就是说，这条链路是**可选增强**，不是插件启动或 Monitor 心跳的前置条件。

-## Managed Monitor
+## 插件提供的信息

-If `managedMonitor` points to an installed HarborForge.Monitor binary, the `gateway_start` hook spawns it (passing `--backend-url`, `--identifier`, `--api-key`, `--monitor-port`, `--report-interval`, `--log-level` from the plugin config) and `gateway_stop` terminates it. Use `install.mjs --install-monitor yes` to build and wire this automatically.
+### OpenClaw 元数据
+- OpenClaw version
+- plugin version
+- 标识符 / 主机名
+- 时间戳

-## Calendar Scheduler
+### 系统快照
+- uptime
+- memory total/free/used/usagePercent
+- load avg1/avg5/avg15
+- platform

-When `calendarEnabled` is true, on gateway start the plugin starts a Calendar scheduler that heartbeats the backend (`/calendar/agent/heartbeat`, `/calendar/agent/status`, `/calendar/agent/notify`) to receive and run scheduled TimeSlots, waking/spawning agents via the OpenClaw `spawn` API (with a notification fallback). Scheduler state is persisted to a state file; gateway restarts can be requested by the backend (PLG-CAL-004).
-
-## Tools Provided
-
-| Tool | Description |
-|------|-------------|
-| `harborforge_status` | Plugin status, resolved config, Monitor bridge health, calendar status, telemetry snapshot |
-| `harborforge_telemetry` | Current system telemetry snapshot from this host |
-| `harborforge_monitor_telemetry` | Query the Monitor bridge for host hardware telemetry |
-| `harborforge_calendar_status` | Calendar scheduler status and current slot |
-| `harborforge_calendar_complete` | Complete the current calendar slot with actual duration |
-| `harborforge_calendar_abort` | Abort the current calendar slot |
-| `harborforge_calendar_pause` | Pause the current calendar slot |
-| `harborforge_calendar_resume` | Resume the paused calendar slot |
-| `harborforge_restart_status` | Check whether a gateway restart is pending |
-
-### Telemetry Snapshot Fields
-
- `identifier`, `hostname`, `platform`, `timestamp`
- `uptime`
- `memory`: `total` / `free` / `used` / `usagePercent`
- `load`: `avg1` / `avg5` / `avg15`
- `openclaw`: `version` / `pluginVersion`
-
-## Development
+## 开发

 ```bash
 cd plugin
@@ -200,16 +154,14 @@ npm install
 npm run build
 ```

-The build runs `tsc` and emits `dist/` (`dist/index.js` is the plugin entry).
-
-## Dependencies
+## 依赖

 - Node.js 18+
 - OpenClaw Gateway
- Go 1.20+ (only for `--install-cli` / `--install-monitor`)
+- Go 1.20+（仅 `--install-cli` 需要）

-## Tips
+## 相关提示

- After installing `hf`, add `~/.openclaw/bin` to your `PATH`
- When an agent uses `hf`, try `hf --help-brief` first
- For the full command tree, see `hf --help`
+- 安装 `hf` 后，建议把 `~/.openclaw/bin` 加到 `PATH`
+- Agent 使用 `hf` 时，优先试 `hf --help-brief`
+- 完整命令树看 `hf --help`
--- a/plugin/calendar/calendar-bridge.ts
+++ b/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") */
@@ -110,23 +110,6 @@ export class CalendarBridgeClient {
    return this.sendBoolean('PATCH', url, update);
  }

-  /**
-   * Same as {@link updateSlot} but overrides the `X-Agent-ID` header for a
-   * single call. Used by the multi-agent scheduler handle where the bridge
-   * client is shared across agents and the constructor agentId is `'unused'`.
-   *
-   * Backend identifies the slot purely by `slotId`; the header is informational
-   * for audit. Passing the calling agent's id keeps audit/log lines correct.
-   */
-  async updateSlotAs(
-    agentId: string,
-    slotId: number,
-    update: SlotAgentUpdate
-  ): Promise<boolean> {
-    const url = `${this.baseUrl}/calendar/slots/${slotId}/agent-update`;
-    return this.sendBooleanAs(agentId, 'PATCH', url, update);
-  }
-
  /**
   * Update a virtual (plan-generated) slot's status after agent execution.
   *
@@ -281,15 +264,6 @@ export class CalendarBridgeClient {
  }

  private async sendBoolean(method: 'POST' | 'PATCH', url: string, body: unknown): Promise<boolean> {
-    return this.sendBooleanAs(this.config.agentId, method, url, body);
-  }
-
-  private async sendBooleanAs(
-    agentId: string,
-    method: 'POST' | 'PATCH',
-    url: string,
-    body: unknown
-  ): Promise<boolean> {
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);

@@ -298,7 +272,7 @@ export class CalendarBridgeClient {
        method,
        headers: {
          'Content-Type': 'application/json',
-          'X-Agent-ID': agentId,
+          'X-Agent-ID': this.config.agentId,
          'X-Claw-Identifier': this.config.clawIdentifier,
        },
        body: JSON.stringify(body),
@@ -318,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) */
--- a/plugin/calendar/index.ts
+++ b/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';
--- a/plugin/calendar/multi-agent-handle.ts
+++ b/plugin/calendar/multi-agent-handle.ts
@@ -1,240 +0,0 @@
-/**
- * MultiAgentSchedulerHandle — runtime façade that backs the public
- * `harborforge_calendar_*` tools when the plugin runs in multi-agent sync
- * mode.
- *
- * Background
- * ----------
- * The old single-agent path used `CalendarScheduler` which kept a "current
- * slot" cursor and exposed `isRunning() / completeCurrentSlot() / abortCurrentSlot() / …`.
- * In multi-agent mode the plugin doesn't own a single cursor — one plugin
- * instance services every agent on the claw — so the previous code stubbed the
- * `calendarScheduler` variable to `{ stop() }`. That made every tool fail
- * with `calendarScheduler.<method> is not a function`.
- *
- * This handle restores the same surface area (`isRunning / getCurrentSlot /
- * completeCurrentSlot / …`) but resolves the "current slot" per caller via
- * the agentId/sessionKey supplied by the OpenClaw tool-factory context. The
- * scheduler records the slot it just dispatched to each agent in
- * {@link recordWoken}; the tool resolves the caller, looks up the last woken
- * slot, and PATCHes the backend via the shared bridge.
- *
- * Tools must pass the calling agentId (from `OpenClawPluginToolContext.agentId`)
- * into every method. The handle does not consult `process.env.AGENT_ID` — the
- * gateway sets that to the host's primary agent which is meaningless in
- * multi-agent mode.
- */
-
-import type { CalendarBridgeClient } from './calendar-bridge.js';
-import type { MultiAgentScheduleCache, CachedSlot } from './schedule-cache.js';
-import { SlotStatus } from './types.js';
-
-export interface MultiAgentSchedulerHandleParams {
-  bridge: CalendarBridgeClient;
-  cache: MultiAgentScheduleCache;
-  /** setInterval handles cleared on stop() */
-  syncHandle: ReturnType<typeof setInterval>;
-  checkHandle: ReturnType<typeof setInterval>;
-  logger: {
-    info: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-  };
-}
-
-/** Last slot we dispatched to an agent. Used as the implicit "current slot". */
-export interface WokenSlot {
-  agentId: string;
-  slotId: number | null;
-  virtualId: string | null;
-  scheduledAt: string | null;
-  slotType: string | null;
-  estimatedDuration: number | null;
-  wokenAt: string;
-}
-
-/** Public surface — mirrors the relevant subset of the old single-agent scheduler. */
-export class MultiAgentSchedulerHandle {
-  private readonly bridge: CalendarBridgeClient;
-  private readonly cache: MultiAgentScheduleCache;
-  private readonly syncHandle: ReturnType<typeof setInterval>;
-  private readonly checkHandle: ReturnType<typeof setInterval>;
-  private readonly logger: MultiAgentSchedulerHandleParams['logger'];
-  private readonly woken: Map<string, WokenSlot> = new Map();
-  private stopped = false;
-
-  constructor(params: MultiAgentSchedulerHandleParams) {
-    this.bridge = params.bridge;
-    this.cache = params.cache;
-    this.syncHandle = params.syncHandle;
-    this.checkHandle = params.checkHandle;
-    this.logger = params.logger;
-  }
-
-  // ---------- lifecycle ----------
-
-  /** True while the sync/check intervals are still ticking. */
-  isRunning(): boolean {
-    return !this.stopped;
-  }
-
-  /** Always false in multi-agent mode — there is no per-instance work queue. */
-  isProcessing(): boolean {
-    return false;
-  }
-
-  stop(): void {
-    if (this.stopped) return;
-    this.stopped = true;
-    clearInterval(this.syncHandle);
-    clearInterval(this.checkHandle);
-    this.logger.info('Calendar scheduler stopped (multi-agent mode)');
-  }
-
-  // ---------- wake bookkeeping ----------
-
-  /** Record that we just dispatched a slot to `agentId`. */
-  recordWoken(agentId: string, slot: CachedSlot): void {
-    this.woken.set(agentId, {
-      agentId,
-      slotId: typeof slot.id === 'number' ? slot.id : null,
-      virtualId: typeof slot.virtual_id === 'string' ? slot.virtual_id : null,
-      scheduledAt: typeof slot.scheduled_at === 'string' ? slot.scheduled_at : null,
-      slotType: typeof slot.slot_type === 'string' ? slot.slot_type : null,
-      estimatedDuration:
-        typeof slot.estimated_duration === 'number' ? slot.estimated_duration : null,
-      wokenAt: new Date().toISOString(),
-    });
-  }
-
-  // ---------- per-agent reads ----------
-
-  /**
-   * The slot most recently dispatched to `agentId`, or null if we never woke
-   * them (e.g. tool called outside a wakeup). Callers can fall back to
-   * scanning {@link cachedSlotsFor} for `not_started`/`deferred` slots if they
-   * want a heuristic "current".
-   */
-  getWokenSlot(agentId: string | null | undefined): WokenSlot | null {
-    if (!agentId) return null;
-    return this.woken.get(agentId) ?? null;
-  }
-
-  /** Today's cached slots for an agent (whatever runSync last pulled). */
-  cachedSlotsFor(agentId: string | null | undefined): CachedSlot[] {
-    if (!agentId) return [];
-    return this.cache.getAgentSlots(agentId);
-  }
-
-  /**
-   * Implicit "current" slot: the last woken slot if we know about it,
-   * otherwise the highest-priority `not_started`/`deferred`/`ongoing` cached
-   * slot for the agent (so a tool called between sync windows still finds
-   * something sensible).
-   */
-  resolveCurrentSlot(agentId: string | null | undefined): WokenSlot | null {
-    const woken = this.getWokenSlot(agentId);
-    if (woken) return woken;
-    if (!agentId) return null;
-    const slots = this.cache.getAgentSlots(agentId)
-      .filter((s) => s.status === 'not_started' || s.status === 'deferred' || s.status === 'ongoing')
-      .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
-    const top = slots[0];
-    if (!top) return null;
-    return {
-      agentId,
-      slotId: typeof top.id === 'number' ? top.id : null,
-      virtualId: typeof top.virtual_id === 'string' ? top.virtual_id : null,
-      scheduledAt: typeof top.scheduled_at === 'string' ? top.scheduled_at : null,
-      slotType: typeof top.slot_type === 'string' ? top.slot_type : null,
-      estimatedDuration:
-        typeof top.estimated_duration === 'number' ? top.estimated_duration : null,
-      wokenAt: 'inferred-from-cache',
-    };
-  }
-
-  // ---------- per-agent writes ----------
-
-  async completeSlot(agentId: string, actualDurationMinutes: number): Promise<SlotMutationResult> {
-    return this.transition(agentId, SlotStatus.FINISHED, { actual_duration: actualDurationMinutes });
-  }
-
-  async abortSlot(agentId: string, reason?: string): Promise<SlotMutationResult> {
-    if (reason) this.logger.info(`Aborting slot for ${agentId}: ${reason}`);
-    return this.transition(agentId, SlotStatus.ABORTED);
-  }
-
-  async pauseSlot(agentId: string): Promise<SlotMutationResult> {
-    return this.transition(agentId, SlotStatus.PAUSED);
-  }
-
-  /** Resume puts the slot back into `ongoing` so it isn't picked up as `not_started`. */
-  async resumeSlot(agentId: string): Promise<SlotMutationResult> {
-    return this.transition(agentId, SlotStatus.ONGOING);
-  }
-
-  private async transition(
-    agentId: string,
-    status: SlotStatus,
-    extra: { actual_duration?: number } = {}
-  ): Promise<SlotMutationResult> {
-    const slot = this.resolveCurrentSlot(agentId);
-    if (!slot) {
-      return { ok: false, error: `No tracked slot for agent '${agentId}'` };
-    }
-    if (slot.slotId == null && slot.virtualId == null) {
-      return { ok: false, error: 'Resolved slot has neither id nor virtual_id' };
-    }
-    const update = { status, ...extra };
-    try {
-      if (slot.slotId != null) {
-        const ok = await this.bridge.updateSlotAs(agentId, slot.slotId, update);
-        if (!ok) return { ok: false, error: `Backend rejected slot ${slot.slotId} → ${status}` };
-        // Clear the wake cursor only on terminal transitions so re-wakes don't
-        // re-trigger the same slot mutation.
-        if (status === SlotStatus.FINISHED || status === SlotStatus.ABORTED) {
-          this.woken.delete(agentId);
-        }
-        return { ok: true, slot, status };
-      }
-      // virtual slot path: bridge has updateVirtualSlot
-      const materialised = await this.bridge.updateVirtualSlot(slot.virtualId!, update);
-      if (!materialised) {
-        return { ok: false, error: `Backend rejected virtual slot ${slot.virtualId}` };
-      }
-      if (status === SlotStatus.FINISHED || status === SlotStatus.ABORTED) {
-        this.woken.delete(agentId);
-      }
-      return { ok: true, slot, status, materialised };
-    } catch (err: unknown) {
-      const msg = (err as { message?: string } | undefined)?.message ?? String(err);
-      return { ok: false, error: msg };
-    }
-  }
-
-  // ---------- gateway-restart parity (no-op in multi-agent mode) ----------
-
-  /** Multi-agent scheduler does not persist a `ScheduledGatewayRestart` flag. */
-  isRestartPending(): boolean {
-    return false;
-  }
-  getStateFilePath(): string | null {
-    return null;
-  }
-  getState(): { mode: 'multi-agent'; agents: number; lastWoken: WokenSlot[] } {
-    return {
-      mode: 'multi-agent',
-      agents: this.cache.getStatus().agentCount,
-      lastWoken: Array.from(this.woken.values()),
-    };
-  }
-}
-
-export interface SlotMutationResult {
-  ok: boolean;
-  error?: string;
-  status?: SlotStatus;
-  slot?: WokenSlot;
-  /** Present only when a virtual slot was materialised. */
-  materialised?: unknown;
-}
--- a/plugin/calendar/scheduler.ts
+++ b/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
--- a/plugin/hooks/gateway-start.ts
+++ b/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;
--- a/plugin/hooks/gateway-stop.ts
+++ b/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;
--- a/plugin/index.ts
+++ b/plugin/index.ts
@@ -11,38 +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 { MultiAgentSchedulerHandle } from './calendar/multi-agent-handle.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,
-} from './calendar/index.js';
-
-// ---------------------------------------------------------------------------
-// Module-scope calendar scheduler singleton.
-//
-// `register()` is called multiple times per gateway boot — once per agent
-// (we see 5 `HarborForge plugin registered` lines for 5 agents on dind-t2).
-// `gateway_start` only fires once, so before this lift the
-// `startCalendarScheduler()` setup ran inside ONE closure while four other
-// closures kept their own `calendarScheduler = null`. Whichever of the five
-// tool registrations the gateway picked at call time was effectively a coin
-// flip, and four times out of five `harborforge_calendar_status` returned
-// `Calendar scheduler not running` even though the scheduler was active.
-//
-// Keeping the singleton at module scope removes the per-`register()` shadow:
-// the scheduler is started once, every closure reads the same binding, and
-// `startCalendarScheduler()` is idempotent so duplicate `gateway_start`
-// firings are harmless.
-// ---------------------------------------------------------------------------
-let calendarScheduler: MultiAgentSchedulerHandle | CalendarScheduler | null = null;
+  AgentWakeContext,
+} from './calendar';

 interface PluginAPI {
  logger: {
@@ -73,31 +53,10 @@ interface PluginAPI {
  getAgentStatus?: () => Promise<{ status: string } | null>;
 }

-/**
- * Coerce a tool execute() return value into the MCP `{ content: [...] }`
- * shape that the openclaw Codex tool dispatcher requires.
- *
- * Background: openclaw's `convertToolContents()` does `result.content.reduce(...)`
- * to compute total text length before flattening. Every HF tool here returned a
- * bare object (`{ running, processing, currentSlot, ... }`) which has no
- * `.content` field, so `undefined.reduce` threw and every call to
- * `harborforge_*` from a Codex-harness agent surfaced as the cryptic
- * `Cannot read properties of undefined (reading 'reduce')`. The fix is to
- * wrap every tool's execute return; doing it at the `registerTool` boundary
- * keeps each tool body unchanged.
- */
-function ensureMcpContentShape(result: unknown): { content: Array<{ type: 'text'; text: string }> } {
-  if (
-    result && typeof result === 'object' &&
-    Array.isArray((result as { content?: unknown }).content)
-  ) {
-    return result as { content: Array<{ type: 'text'; text: string }> };
-  }
-  const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
-  return { content: [{ type: 'text', text }] };
-}
-
-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),
@@ -105,22 +64,6 @@ function register(api: PluginAPI): void {
      warn: (...args: any[]) => console.warn('[HarborForge]', ...args),
    };

-    // Wrap api.registerTool so every tool's execute() return is coerced into
-    // the MCP `{ content: [...] }` shape openclaw expects. See
-    // `ensureMcpContentShape` above.
-    const _origRegisterTool = api.registerTool.bind(api);
-    api.registerTool = (factory: (ctx: any) => any) => {
-      _origRegisterTool((ctx: any) => {
-        const def = factory(ctx);
-        if (!def || typeof def.execute !== 'function') return def;
-        const origExecute = def.execute;
-        return {
-          ...def,
-          execute: async (...args: any[]) => ensureMcpContentShape(await origExecute(...args)),
-        };
-      });
-    };
-
    function resolveConfig() {
      return getPluginConfig(api);
    }
@@ -128,9 +71,7 @@ function register(api: PluginAPI): void {
    /** Resolve agent ID from env, config, or fallback. */
    function resolveAgentId(): string {
      if (process.env.AGENT_ID) return process.env.AGENT_ID;
-      // Read from cached `api.config` first — see pushMetaToMonitor for why
-      // the deprecated `api.runtime?.config?.loadConfig?.()` path is heavy.
-      const cfg = (api as any).config ?? api.runtime?.config?.loadConfig?.();
+      const cfg = api.runtime?.config?.loadConfig?.();
      return cfg?.agents?.list?.[0]?.id ?? cfg?.agents?.defaults?.id ?? 'unknown';
    }

@@ -169,7 +110,7 @@ function register(api: PluginAPI): void {
        },
        openclaw: {
          version: api.runtime?.version || api.version || 'unknown',
-          pluginVersion: '0.3.4', // Bumped for PLG-CAL-004
+          pluginVersion: '0.3.1', // Bumped for PLG-CAL-004
        },
        timestamp: new Date().toISOString(),
      };
@@ -178,33 +119,13 @@ function register(api: PluginAPI): void {
    // Periodic metadata push interval handle
    let metaPushInterval: ReturnType<typeof setInterval> | null = null;

-    // (calendarScheduler is module-scope — see top of file for the why.
-    //  Tools and lifecycle hooks all reference the same binding so the
-    //  multi-register/single-start mismatch can't shadow them again.)
+    // Calendar scheduler instance
+    let calendarScheduler: CalendarScheduler | null = null;

    /**
     * Push OpenClaw metadata to the Monitor bridge.
     * This enriches Monitor heartbeats with OpenClaw version/plugin/agent info.
     * Failures are non-fatal — Monitor continues to work without this data.
-     *
-     * IMPORTANT — read config from the cached `api.config` surface, NOT from
-     * the deprecated `api.runtime?.config?.loadConfig?.()` path. The
-     * deprecated path triggers a full plugin-metadata-snapshot rebuild on
-     * every call: realpathSync walks every plugin's package.json + manifest
-     * + source paths (lstats up the directory tree), `hashWatchedFiles`
-     * fingerprints all watched plugin files, and `discoverInDirectory`
-     * re-scans every `dist/extensions/<plugin>` dir. On t2 with ~100 plugins
-     * each rebuild costs ~6-7s of CPU; with this push firing every 30s
-     * (default reportIntervalSec) the chronic baseline was ~22-25% gateway
-     * CPU even with zero agent activity (V8 profile 2026-05-27 08:14:00 60s:
-     * lstat 44.2%, statSync 6.9%, hashWatchedFiles via memo key 1.7%, all
-     * routed through readPersistedInstalledPluginIndexInstallRecordsSync ->
-     * discoverInDirectory). Switching to `api.config` reads from the
-     * already-loaded snapshot cache; the elsewhere-in-this-file pattern was
-     * already `api.config ?? api.runtime?.config?.loadConfig?.()`.
-     *
-     * Same fix is applied to `resolveAgentId` below — that's read once at
-     * gateway start so the impact is smaller, but it's the same anti-pattern.
     */
    async function pushMetaToMonitor() {
      const bridgeClient = getBridgeClient();
@@ -212,7 +133,7 @@ function register(api: PluginAPI): void {

      let agentNames: string[] = [];
      try {
-        const cfg = (api as any).config ?? api.runtime?.config?.loadConfig?.();
+        const cfg = api.runtime?.config?.loadConfig?.();
        const agentsList = cfg?.agents?.list;
        if (Array.isArray(agentsList)) {
          agentNames = agentsList
@@ -223,7 +144,7 @@ function register(api: PluginAPI): void {

      const meta: OpenClawMeta = {
        version: api.runtime?.version || api.version || 'unknown',
-        plugin_version: '0.3.4',
+        plugin_version: '0.3.1',
        agents: agentNames.map(name => ({ name })),
      };

@@ -277,18 +198,7 @@ function register(api: PluginAPI): void {
     * Wake agent via dispatchInboundMessage — same mechanism used by Discord plugin.
     * Direct in-process call, no WebSocket or CLI needed.
     */
-    async function wakeAgent(
-      agentId: string,
-      dueSlots?: Array<{
-        id?: number | null;
-        virtual_id?: string | null;
-        event_data?: any;
-        scheduled_at?: string;
-        priority?: number;
-        slot_type?: string;
-        [k: string]: unknown;
-      }>
-    ): Promise<boolean> {
+    async function wakeAgent(agentId: string): Promise<boolean> {
      logger.info(`Waking agent ${agentId}: has due slots`);

      const sessionKey = `agent:${agentId}:hf-wakeup`;
@@ -299,51 +209,13 @@ function register(api: PluginAPI): void {
          /* webpackIgnore: true */ sdkPath
        );

-        // api.config first (current public API). Fall back to deprecated
-        // runtime.config.loadConfig() for older host versions. Both should
-        // contain agents.list / channels for dispatch routing.
-        const cfg = (api as any).config ?? api.runtime?.config?.loadConfig?.();
+        const cfg = api.runtime?.config?.loadConfig?.();
        if (!cfg) {
          logger.error('Cannot load OpenClaw config for dispatch');
          return false;
        }

-        // Inline the highest-priority due slot's context so the agent does
-        // not need a second round-trip to harborforge_calendar_status. The
-        // agent can read event_data.task_code / task_title etc. directly.
-        let slotBlock = '';
-        const top = dueSlots && dueSlots.length ? dueSlots[0] : undefined;
-        if (top) {
-          slotBlock = `\n\nMatching slot:\n\`\`\`json\n${JSON.stringify(
-            {
-              slot_id: top.id ?? null,
-              virtual_id: top.virtual_id ?? null,
-              scheduled_at: top.scheduled_at ?? null,
-              priority: top.priority ?? null,
-              slot_type: top.slot_type ?? null,
-              event_data: top.event_data ?? null,
-            },
-            null,
-            2
-          )}\n\`\`\``;
-        }
-
-        // The wakeup dispatcher's `deliver` callback below only logs the
-        // reply text — it does NOT inspect any ack token. The earlier
-        // `WAKEUP_OK` first-line-ack convention was prompt-only theatre;
-        // nothing in this plugin or in openclaw acted on it. The only
-        // thing that ends a wake cycle is the slot transitioning out of
-        // `not_started`, which happens when the agent calls
-        // `harborforge_calendar_complete` or `harborforge_calendar_abort`.
-        // Tell the agent that plainly instead of asking for a fake ack.
-        const wakeupMessage =
-          `You have due slots. Drive the \`hf-wakeup\` workflow of skill ` +
-          `\`hf-hangman-lab\` to completion in this session — read slot ` +
-          `context, call the harborforge_calendar_* tools, route to the ` +
-          `right sub-workflow, and finish with harborforge_calendar_complete ` +
-          `or harborforge_calendar_abort. The scheduler keeps re-waking you ` +
-          `every 30s until the slot transitions out of \`not_started\`, so ` +
-          `partial work or silence just produces another wake.${slotBlock}`;
+        const wakeupMessage = `You have due slots. Follow the \`hf-wakeup\` workflow of skill \`hf-hangman-lab\` to proceed. Only reply \`WAKEUP_OK\` in this session.`;

        const result = await dispatchInboundMessageWithDispatcher({
          ctx: {
@@ -372,23 +244,42 @@ function register(api: PluginAPI): void {
      }
    }

-    // (trackSessionCompletion removed — legacy single-agent poll loop that
-    //  called calendarScheduler.completeCurrentSlot. The multi-agent path
-    //  closes slots via the harborforge_calendar_complete tool, driven by
-    //  the agent itself, not by a timer.)
+    /**
+     * Track session completion and update slot status accordingly.
+     */
+    function trackSessionCompletion(sessionId: string, context: AgentWakeContext): void {
+      // Poll for session completion (simplified approach)
+      // In production, this would use webhooks or event streaming
+      const pollInterval = 30000; // 30 seconds
+      const maxDuration = context.slot.estimated_duration * 60 * 1000; // Convert to ms
+      const startTime = Date.now();
+
+      const poll = async () => {
+        if (!calendarScheduler) return;
+
+        const elapsed = Date.now() - startTime;
+
+        // Check if session is complete (would use actual API in production)
+        // For now, estimate completion based on duration
+        if (elapsed >= maxDuration) {
+          // Assume completion
+          const actualMinutes = Math.round(elapsed / 60000);
+          await calendarScheduler.completeCurrentSlot(actualMinutes);
+          return;
+        }
+
+        // Continue polling
+        setTimeout(poll, pollInterval);
+      };
+
+      // Start polling
+      setTimeout(poll, pollInterval);
+    }

    /**
     * Initialize and start the calendar scheduler.
-     *
-     * Idempotent — `gateway_start` may fire once per `register()` invocation
-     * (the host calls `register` per agent), and we only want one set of
-     * sync/check intervals across the whole process.
     */
    function startCalendarScheduler(): void {
-      if (calendarScheduler) {
-        logger.info('Calendar scheduler already started, skipping duplicate gateway_start');
-        return;
-      }
      const live = resolveConfig();

      // Create bridge client (claw-instance level, not per-agent)
@@ -399,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
@@ -418,164 +310,38 @@ function register(api: PluginAPI): void {
        }
      }

-      // Cross-plugin exposure: agent status lookup for other plugins
-      // (currently Fabric.OpenclawPlugin uses this to skip delivering
-      // `announce` channel messages to busy agents — see DIALECTIC-V2
-      // design doc, Phase 1). Backed by calendarBridge.getAgentStatus
-      // with a small TTL cache to avoid hammering the HF backend.
-      type HfStatus = 'idle' | 'on_call' | 'busy' | 'exhausted' | 'offline';
-      const HF_STATUS_CACHE_TTL_MS = 30_000;
-      const hfStatusCache = new Map<string, { status: HfStatus; at: number }>();
-      const _G = globalThis as Record<string, unknown>;
-      _G['__hfAgentStatus'] = {
-        async get(agentId: string): Promise<HfStatus | undefined> {
-          if (!agentId) return undefined;
-          const cached = hfStatusCache.get(agentId);
-          if (cached && Date.now() - cached.at < HF_STATUS_CACHE_TTL_MS) {
-            return cached.status;
-          }
-          try {
-            const status = await calendarBridge.getAgentStatus(agentId);
-            if (status) {
-              const typed = status as HfStatus;
-              hfStatusCache.set(agentId, { status: typed, at: Date.now() });
-              return typed;
-            }
-          } catch {
-            /* fall through to cached-or-undefined */
-          }
-          return cached?.status;
-        },
-
-        /**
-         * Approximate "does agent have an on_call slot covering [from, to]?"
-         * for cross-plugin pre-check use (currently:
-         * Dialectic.OpenclawPlugin's signup HF coverage).
-         *
-         * v1 honest scope: we only have today's slots in scheduleCache
-         * (synced from /calendar/sync which is today-only). Returns:
-         *   - true  iff window is same-day AND some cached on_call slot
-         *           starts <= from AND ends >= to
-         *   - false iff window is same-day AND no such slot
-         *   - undefined for cross-day windows OR cache empty for this
-         *     agent (caller treats undefined as "I don't know" — see
-         *     Dialectic plugin's hf-precheck.ts which degrades to
-         *     "skipped" gracefully)
-         *
-         * Phase TBD: when HF backend ships a `/calendar/slots?agent&from&to`
-         * endpoint, swap this to call it for arbitrary windows. Until then,
-         * same-day-only coverage gates ~all debates created by analyze-intel
-         * (which schedules <2h windows) without needing a backend change.
-         */
-        async hasOnCallCovering(
-          agentId: string,
-          fromIso: string,
-          toIso: string,
-        ): Promise<boolean | undefined> {
-          if (!agentId || !fromIso || !toIso) return undefined;
-          const from = new Date(fromIso);
-          const to = new Date(toIso);
-          if (isNaN(from.getTime()) || isNaN(to.getTime())) return undefined;
-          if (!(from < to)) return undefined;
-          // Cross-day → cache only has today; can't decide.
-          const fromDate = from.toISOString().slice(0, 10);
-          const toDate = to.toISOString().slice(0, 10);
-          if (fromDate !== toDate) return undefined;
-          // Cache's cachedDate must match our window's date.
-          const cacheStatus = scheduleCache.getStatus();
-          if (cacheStatus.cachedDate !== fromDate) return undefined;
-          const slots = scheduleCache.getAgentSlots(agentId);
-          if (slots.length === 0) return undefined; // cache empty for this agent — can't decide
-          for (const s of slots) {
-            if (s.slot_type !== 'on_call') continue;
-            // status: ignore aborted/cancelled, accept not_started / ongoing / finished
-            if (s.status === 'aborted' || s.status === 'cancelled') continue;
-            const startStr = s.scheduled_at;
-            if (typeof startStr !== 'string') continue;
-            // scheduled_at can be HH:MM:SS (cache-relative date) or full ISO
-            const start =
-              /^\d{2}:\d{2}(:\d{2})?$/.test(startStr)
-                ? new Date(`${fromDate}T${startStr}Z`)
-                : new Date(startStr);
-            if (isNaN(start.getTime())) continue;
-            const dur = typeof s.estimated_duration === 'number' ? s.estimated_duration : 0;
-            const end = new Date(start.getTime() + dur * 60_000);
-            if (start <= from && end >= to) return true;
-          }
-          return false;
-        },
-      };
-
-      // Track wakes already dispatched for a slot in the current sync
-      // window — the simplified inline scheduler does not PATCH slot
-      // status server-side, so without dedupe the check loop re-wakes
-      // the same slot every 30s. Set is cleared by runSync (fresh wake
-      // budget per sync).
-      const wakedSlotKeys = new Set<string>();
-
      // Check: find agents with due slots and wake them
      async function runCheck() {
        const now = new Date();
        const agentsWithDue = scheduleCache.getAgentsWithDueSlots(now);

-        for (const { agentId, slots } of agentsWithDue) {
-          // Filter out slots we've already woken this sync window
-          const fresh = slots.filter((s) => {
-            const key = `${agentId}::${s.id ?? s.virtual_id ?? s.scheduled_at}`;
-            if (wakedSlotKeys.has(key)) return false;
-            return true;
-          });
-          if (fresh.length === 0) continue;
-
-          // Check if agent is busy (best effort; backend may 405 the GET
-          // — treat unknown as not-busy so wakeup still fires)
-          let status: string | null = null;
-          try {
-            status = await calendarBridge.getAgentStatus(agentId);
-          } catch {
-            status = null;
-          }
+        for (const { agentId } of agentsWithDue) {
+          // Check if agent is busy
+          const status = await calendarBridge.getAgentStatus(agentId);
          if (status === 'busy' || status === 'offline' || status === 'exhausted') {
            continue;
          }

-          // Wake the agent with the slot context inlined
-          const ok = await wakeAgent(agentId, fresh);
-          if (ok) {
-            // Top slot is the one inlined in the wakeup message; record it as
-            // the agent's "current" so harborforge_calendar_complete/abort/…
-            // can resolve a slot without an explicit param.
-            const top = fresh[0];
-            if (top && calendarScheduler instanceof MultiAgentSchedulerHandle) {
-              calendarScheduler.recordWoken(agentId, top);
-            }
-            for (const s of fresh) {
-              const key = `${agentId}::${s.id ?? s.virtual_id ?? s.scheduled_at}`;
-              wakedSlotKeys.add(key);
-            }
-          }
+          // Wake the agent
+          await wakeAgent(agentId);
        }
      }

-      // Initial sync (also resets the wake-dedupe window)
-      const runSyncReset = async () => {
-        wakedSlotKeys.clear();
-        await runSync();
-      };
-      runSyncReset();
+      // Initial sync
+      runSync();

      // Start intervals
-      const syncHandle = setInterval(runSyncReset, SYNC_INTERVAL_MS);
+      const syncHandle = setInterval(runSync, SYNC_INTERVAL_MS);
      const checkHandle = setInterval(runCheck, CHECK_INTERVAL_MS);

-      // Install the multi-agent handle so calendar tools resolve per-caller.
-      calendarScheduler = new MultiAgentSchedulerHandle({
-        bridge: calendarBridge,
-        cache: scheduleCache,
-        syncHandle,
-        checkHandle,
-        logger,
-      });
+      // Store handles for cleanup (reuse calendarScheduler variable)
+      (calendarScheduler as any) = {
+        stop() {
+          clearInterval(syncHandle);
+          clearInterval(checkHandle);
+          logger.info('Calendar scheduler stopped');
+        },
+      };

      logger.info('Calendar scheduler started (multi-agent sync mode)');
    }
@@ -612,7 +378,7 @@ function register(api: PluginAPI): void {
    });

    // Tool: plugin status
-    api.registerTool((ctx) => ({
+    api.registerTool(() => ({
      name: 'harborforge_status',
      description: 'Get HarborForge plugin status and current telemetry snapshot',
      parameters: {
@@ -631,27 +397,13 @@ function register(api: PluginAPI): void {
            : { connected: false, error: 'Monitor bridge unreachable' };
        }

-        // Get calendar scheduler status. In multi-agent mode `currentSlot`
-        // depends on the caller, so look it up via ctx.agentId.
-        const callerAgentId = ctx?.agentId ?? resolveAgentId();
-        const calendarStatus = calendarScheduler
-          ? calendarScheduler instanceof MultiAgentSchedulerHandle
-            ? {
-                running: calendarScheduler.isRunning(),
-                processing: calendarScheduler.isProcessing(),
-                mode: 'multi-agent',
-                callerAgentId,
-                currentSlot: calendarScheduler.resolveCurrentSlot(callerAgentId),
-                isRestartPending: calendarScheduler.isRestartPending(),
-              }
-            : {
-                running: calendarScheduler.isRunning(),
-                processing: calendarScheduler.isProcessing(),
-                mode: 'single-agent',
-                currentSlot: calendarScheduler.getCurrentSlot(),
-                isRestartPending: calendarScheduler.isRestartPending(),
-              }
-          : null;
+        // Get calendar scheduler status
+        const calendarStatus = calendarScheduler ? {
+          running: calendarScheduler.isRunning(),
+          processing: calendarScheduler.isProcessing(),
+          currentSlot: calendarScheduler.getCurrentSlot(),
+          isRestartPending: calendarScheduler.isRestartPending(),
+        } : null;

        return {
          enabled: live.enabled !== false,
@@ -710,7 +462,7 @@ function register(api: PluginAPI): void {
    }));

    // Tool: calendar slot management
-    api.registerTool((ctx) => ({
+    api.registerTool(() => ({
      name: 'harborforge_calendar_status',
      description: 'Get current calendar scheduler status and pending slots',
      parameters: {
@@ -721,24 +473,10 @@ function register(api: PluginAPI): void {
        if (!calendarScheduler) {
          return { error: 'Calendar scheduler not running' };
        }
-        const callerAgentId = ctx?.agentId ?? resolveAgentId();
-        if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
-          return {
-            running: calendarScheduler.isRunning(),
-            processing: calendarScheduler.isProcessing(),
-            mode: 'multi-agent',
-            callerAgentId,
-            currentSlot: calendarScheduler.resolveCurrentSlot(callerAgentId),
-            agentSlots: calendarScheduler.cachedSlotsFor(callerAgentId),
-            state: calendarScheduler.getState(),
-            isRestartPending: calendarScheduler.isRestartPending(),
-            stateFilePath: calendarScheduler.getStateFilePath(),
-          };
-        }
+
        return {
          running: calendarScheduler.isRunning(),
          processing: calendarScheduler.isProcessing(),
-          mode: 'single-agent',
          currentSlot: calendarScheduler.getCurrentSlot(),
          state: calendarScheduler.getState(),
          isRestartPending: calendarScheduler.isRestartPending(),
@@ -748,7 +486,7 @@ function register(api: PluginAPI): void {
    }));

    // Tool: complete current slot (for agent to report completion)
-    api.registerTool((ctx) => ({
+    api.registerTool(() => ({
      name: 'harborforge_calendar_complete',
      description: 'Complete the current calendar slot with actual duration',
      parameters: {
@@ -765,20 +503,14 @@ function register(api: PluginAPI): void {
        if (!calendarScheduler) {
          return { error: 'Calendar scheduler not running' };
        }
-        if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
-          const agentId = ctx?.agentId ?? resolveAgentId();
-          const res = await calendarScheduler.completeSlot(agentId, params.actualDurationMinutes);
-          return res.ok
-            ? { success: true, message: 'Slot completed', slot: res.slot }
-            : { error: res.error };
-        }
+
        await calendarScheduler.completeCurrentSlot(params.actualDurationMinutes);
        return { success: true, message: 'Slot completed' };
      },
    }));

    // Tool: abort current slot (for agent to report failure)
-    api.registerTool((ctx) => ({
+    api.registerTool(() => ({
      name: 'harborforge_calendar_abort',
      description: 'Abort the current calendar slot',
      parameters: {
@@ -794,20 +526,14 @@ function register(api: PluginAPI): void {
        if (!calendarScheduler) {
          return { error: 'Calendar scheduler not running' };
        }
-        if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
-          const agentId = ctx?.agentId ?? resolveAgentId();
-          const res = await calendarScheduler.abortSlot(agentId, params.reason);
-          return res.ok
-            ? { success: true, message: 'Slot aborted', slot: res.slot }
-            : { error: res.error };
-        }
+
        await calendarScheduler.abortCurrentSlot(params.reason);
        return { success: true, message: 'Slot aborted' };
      },
    }));

    // Tool: pause current slot
-    api.registerTool((ctx) => ({
+    api.registerTool(() => ({
      name: 'harborforge_calendar_pause',
      description: 'Pause the current calendar slot',
      parameters: {
@@ -818,20 +544,14 @@ function register(api: PluginAPI): void {
        if (!calendarScheduler) {
          return { error: 'Calendar scheduler not running' };
        }
-        if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
-          const agentId = ctx?.agentId ?? resolveAgentId();
-          const res = await calendarScheduler.pauseSlot(agentId);
-          return res.ok
-            ? { success: true, message: 'Slot paused', slot: res.slot }
-            : { error: res.error };
-        }
+
        await calendarScheduler.pauseCurrentSlot();
        return { success: true, message: 'Slot paused' };
      },
    }));

    // Tool: resume current slot
-    api.registerTool((ctx) => ({
+    api.registerTool(() => ({
      name: 'harborforge_calendar_resume',
      description: 'Resume the paused calendar slot',
      parameters: {
@@ -842,13 +562,7 @@ function register(api: PluginAPI): void {
        if (!calendarScheduler) {
          return { error: 'Calendar scheduler not running' };
        }
-        if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
-          const agentId = ctx?.agentId ?? resolveAgentId();
-          const res = await calendarScheduler.resumeSlot(agentId);
-          return res.ok
-            ? { success: true, message: 'Slot resumed', slot: res.slot }
-            : { error: res.error };
-        }
+
        await calendarScheduler.resumeCurrentSlot();
        return { success: true, message: 'Slot resumed' };
      },
@@ -881,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,
-});
+  },
+};
--- a/plugin/openclaw-sdk.d.ts
+++ b/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;
-}
--- a/plugin/openclaw.plugin.json
+++ b/plugin/openclaw.plugin.json
@@ -1,23 +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",
-      "harborforge_calendar_abort",
-      "harborforge_calendar_pause",
-      "harborforge_calendar_resume",
-      "harborforge_restart_status"
-    ]
-  },
+  "entry": "./dist/index.js",
  "configSchema": {
    "type": "object",
    "additionalProperties": false,
--- a/plugin/package-lock.json
+++ b/plugin/package-lock.json
@@ -9,14 +9,14 @@
      "version": "0.2.0",
      "license": "MIT",
      "devDependencies": {
-        "@types/node": "^20.19.41",
+        "@types/node": "^20.0.0",
        "typescript": "^5.0.0"
      }
    },
    "node_modules/@types/node": {
-      "version": "20.19.41",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.41.tgz",
-      "integrity": "sha512-ECymXOukMnOoVkC2bb1Vc/w/836DXncOg5m8Xj1RH7xSHZJWNYY6Zh7EH477vcnD5egKNNfy2RpNOmuChhFPgQ==",
+      "version": "20.19.37",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
--- a/plugin/package.json
+++ b/plugin/package.json
@@ -1,8 +1,7 @@
 {
  "name": "harbor-forge-plugin",
-  "version": "0.3.4",
+  "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",
@@ -10,7 +9,7 @@
    "watch": "tsc --watch"
  },
  "devDependencies": {
-    "@types/node": "^20.19.41",
+    "@types/node": "^20.0.0",
    "typescript": "^5.0.0"
  },
  "license": "MIT"
--- a/plugin/tsconfig.json
+++ b/plugin/tsconfig.json
@@ -1,8 +1,8 @@
 {
  "compilerOptions": {
    "target": "ES2022",
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
+    "module": "CommonJS",
+    "moduleResolution": "node",
    "esModuleInterop": true,
    "strict": true,
    "skipLibCheck": true,
--- a/scripts/install.mjs
+++ b/scripts/install.mjs
@@ -31,7 +31,6 @@ const OLD_PLUGIN_NAME = 'harborforge-monitor';
 const PLUGIN_SRC_DIR = join(__dirname, 'plugin');
 const SKILLS_SRC_DIR = join(__dirname, 'skills');
 const MONITOR_REPO_URL = 'https://git.hangman-lab.top/zhi/HarborForge.Monitor.git';
-const CLI_REPO_URL = 'https://git.hangman-lab.top/zhi/HarborForge.Cli.git';

 const args = process.argv.slice(2);
 const options = {
@@ -44,7 +43,6 @@ const options = {
  installCli: args.includes('--install-cli'),
  installMonitor: 'no',
  monitorBranch: 'main',
-  cliBranch: 'main',
 };

 const profileIdx = args.indexOf('--openclaw-profile-path');
@@ -62,11 +60,6 @@ if (monitorBranchIdx !== -1 && args[monitorBranchIdx + 1]) {
  options.monitorBranch = String(args[monitorBranchIdx + 1]);
 }

-const cliBranchIdx = args.indexOf('--cli-branch');
-if (cliBranchIdx !== -1 && args[cliBranchIdx + 1]) {
-  options.cliBranch = String(args[cliBranchIdx + 1]);
-}
-
 function resolveOpenclawPath() {
  if (options.openclawProfilePath) return options.openclawProfilePath;
  if (process.env.OPENCLAW_PATH) return resolve(process.env.OPENCLAW_PATH);
@@ -323,40 +316,39 @@ async function installCli() {
  if (!options.installCli) return;
  const totalSteps = 6;
  logStep(5, totalSteps, 'Building and installing hf CLI...');
-
+  
  const openclawPath = resolveOpenclawPath();
  const binDir = join(openclawPath, 'bin');
  mkdirSync(binDir, { recursive: true });
-
-  // Clone CLI repo to /tmp, build there, copy artifact out. Mirrors
-  // installManagedMonitor so the install never depends on a checked-out
-  // sibling repo at a fixed path.
-  const tmpDir = join('/tmp', `harborforge-cli-${Date.now()}`);
-  const hfBinary = join(binDir, 'hf');
-
+  
+  // Find CLI source — look for HarborForge.Cli relative to project root
+  const projectRoot = resolve(__dirname, '..');
+  const cliDir = join(projectRoot, 'HarborForge.Cli');
+  
+  if (!existsSync(cliDir)) {
+    // Try parent directory (monorepo layout)
+    const monoCliDir = resolve(projectRoot, '..', 'HarborForge.Cli');
+    if (!existsSync(monoCliDir)) {
+      logErr(`Cannot find HarborForge.Cli at ${cliDir} or ${monoCliDir}`);
+      logWarn('Skipping CLI installation');
+      return;
+    }
+  }
+  
+  const effectiveCliDir = existsSync(cliDir) 
+    ? cliDir 
+    : resolve(projectRoot, '..', 'HarborForge.Cli');
+  
+  log(` Building hf from ${effectiveCliDir}...`, 'blue');
+  
  try {
-    log(` Cloning ${CLI_REPO_URL} (branch ${options.cliBranch}) → ${tmpDir}...`, 'blue');
-    exec(`git clone --branch ${shellEscape(options.cliBranch)} --depth 1 ${shellEscape(CLI_REPO_URL)} ${shellEscape(tmpDir)}`, { silent: !options.verbose });
-
-    // Stamp the binary with the version string the prod CLI surfaces in
-    // `hf version`. Fall back to a date-only label if rev-parse fails for
-    // any reason (shallow clone shouldn't, but be defensive).
-    let versionLabel = `${new Date().toISOString().slice(0, 10)}+install`;
-    try {
-      const sha = exec(`git rev-parse --short HEAD`, { cwd: tmpDir, silent: true }).trim();
-      if (sha) versionLabel = `${new Date().toISOString().slice(0, 10)}+${options.cliBranch}-${sha}`;
-    } catch { /* keep fallback */ }
-
-    log(` Building hf (version=${versionLabel})...`, 'blue');
-    const ldflags = `-X git.hangman-lab.top/zhi/HarborForge.Cli/internal/commands.Version=${versionLabel}`;
-    exec(`go build -ldflags ${shellEscape(ldflags)} -o ${shellEscape(hfBinary)} ./cmd/hf`, { cwd: tmpDir, silent: !options.verbose });
+    const hfBinary = join(binDir, 'hf');
+    exec(`go build -o ${hfBinary} ./cmd/hf`, { cwd: effectiveCliDir, silent: !options.verbose });
    chmodSync(hfBinary, 0o755);
-    logOk(`hf binary → ${hfBinary} (branch hint: ${options.cliBranch})`);
+    logOk(`hf binary → ${hfBinary}`);
  } catch (err) {
    logErr(`Failed to build hf CLI: ${err.message}`);
    logWarn('CLI installation failed, plugin still installed');
-  } finally {
-    rmSync(tmpDir, { recursive: true, force: true });
  }
 }