Merge pull request 'perf(meta-push): use cached api.config instead of deprecated loadConfig() — kills ~25% chronic baseline CPU' (#11) from fix/meta-push-use-cached-api-config into main

`pushMetaToMonitor` and `resolveAgentId` were both calling
`api.runtime?.config?.loadConfig?.()` to read the agent list. That
deprecated path (openclaw warns at gateway start:
"plugin runtime config.loadConfig() is deprecated; use config.current()")
synchronously rebuilds the full plugin-metadata snapshot — realpathSync
walks every plugin's package.json + manifest + source up the directory
tree, hashWatchedFiles fingerprints every watched plugin file, and
discoverInDirectory re-scans every `dist/extensions/<plugin>` (~100 of
them on prod t2). Each rebuild costs ~6-7s of gateway CPU.

`pushMetaToMonitor` fires every `reportIntervalSec` (default 30s)
from `hooks/gateway-start.js`. With 100 plugins that put the gateway
into a chronic ~22-30% CPU baseline even with zero agent activity. V8
profile 2026-05-27 08:14:00 60s window (0 turns, 2 metadata pushes
during): lstat 44.2%, statSync(buildInstalledManifestRegistryIndexKey)
6.9%, hashWatchedFiles via memo key 1.7%, all routed through
`readPersistedInstalledPluginIndexInstallRecordsSync` -> per-plugin
`discoverInDirectory`.

Switching to `(api as any).config ?? api.runtime?.config?.loadConfig?.()`
reads from the snapshot cache the gateway already maintains — the same
pattern already used elsewhere in this file (e.g. the calendar wakeAgent
dispatcher at line 284). Same change applied to `resolveAgentId` (only
runs once at start, but same anti-pattern).

This is a plugin-side perf workaround. The underlying openclaw bug is
that `loadConfig()` rebuilds the snapshot rather than returning the
cached one — a chronic 'all sync cache validity checks pay the full
discovery cost' design issue worth pushing upstream separately (the
walks per-call cost we measured here is unrelated to and amplifies any
agent-turn-triggered walk path).

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

.gitignore

@@ -1,5 +1,8 @@
 plugin/node_modules/
-plugin/*.js
+plugin/dist/
-plugin/*.js.map
+plugin/**/*.js
-plugin/*.d.ts
+plugin/**/*.js.map
-plugin/*.d.ts.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

README.md

@@ -1,80 +1,107 @@
 # HarborForge OpenClaw Plugin
 
-OpenClaw 插件：向 HarborForge Monitor 暴露 OpenClaw 侧元数据，并提供可选的本地桥接能力；安装时也可顺带安装 `hf` CLI。
+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.
 
-## 当前状态
+Part of the [HarborForge](../README.md) platform.
 
-- 插件注册名：`harbor-forge`
+- Role: OpenClaw integration layer for HarborForge (registered plugin id: `harbor-forge`).
-- 旧 sidecar `server/` 架构已移除
+- Talks to the HarborForge backend (`backendUrl`, default `https://monitor.hangman-lab.top`) for Calendar APIs.
-- 监控桥接走本地 `monitor_port`
+- Talks to a local HarborForge.Monitor bridge over `127.0.0.1:<monitor_port>` (no fixed default; commonly `9100`).
-- 安装脚本支持 `--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
+│   ├── openclaw.plugin.json      # plugin manifest + config schema
-│   ├── index.ts
+│   ├── index.ts                  # plugin entry, tool registration
+│   ├── tsconfig.json
 │   ├── core/
-│   │   ├── live-config.ts
+│   │   ├── config.ts             # config defaults / resolution
-│   │   └── monitor-bridge.ts
+│   │   ├── 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
+│   ├── hooks/
+│   │   ├── gateway-start.ts
+│   │   └── gateway-stop.ts
 │   └── package.json
 ├── skills/
 │   └── hf/
-│       └── SKILL.md
+│       └── SKILL.md              # installed only with --install-cli
 └── scripts/
     └── install.mjs
 ```
 
-## 安装
+## Installation
 
-### 普通安装
+### Standard Install
 
 ```bash
 node scripts/install.mjs
 ```
 
-这会：
+This will:
-- 构建并安装 OpenClaw 插件
+- Build and install the OpenClaw plugin
-- 复制常规 skills
+- Copy regular skills
-- **不会**安装 `hf` 二进制
+- **Not** install the `hf` binary
-- **不会**复制 `skills/hf/`
+- **Not** copy `skills/hf/`
 
-### 安装插件 + `hf` CLI
+### Plugin + `hf` CLI
 
 ```bash
 node scripts/install.mjs --install-cli
 ```
 
-这会额外：
+This additionally:
-- 构建 `HarborForge.Cli`
+- Builds `HarborForge.Cli` (`go build ./cmd/hf`)
-- 安装 `hf` 到 `~/.openclaw/bin/hf`
+- Installs `hf` to `<openclaw>/bin/hf` (default `~/.openclaw/bin/hf`) and `chmod +x`
-- `chmod +x ~/.openclaw/bin/hf`
+- Copies `skills/hf/` into the OpenClaw skills directory
-- 复制 `skills/hf/` 到 OpenClaw profile skills 目录
 
-### 常用选项
+### Common Options
 
 ```bash
-# 仅构建
+# Build only (no install / config)
 node scripts/install.mjs --build-only
 
-# 指定 OpenClaw profile
+# Install only, skip dependency checks
+node scripts/install.mjs --skip-check
+
+# Specify OpenClaw profile path (also honors OPENCLAW_PATH env)
 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`.
 
-编辑 `~/.openclaw/openclaw.json`：
+## Configuration
+
+Edit `~/.openclaw/openclaw.json`:
 
 ```json
 {
@@ -90,7 +117,9 @@ node scripts/install.mjs --uninstall
           "monitor_port": 9100,
           "reportIntervalSec": 30,
           "httpFallbackIntervalSec": 60,
-          "logLevel": "info"
+          "logLevel": "info",
+          "calendarEnabled": true,
+          "calendarHeartbeatIntervalSec": 60
         }
       }
     }
@@ -98,53 +127,72 @@ node scripts/install.mjs --uninstall
 }
 ```
 
-> 说明：`monitor_port` 是当前主字段；为兼容旧配置，插件仍接受 `monitorPort`。
+Then restart:
-
-然后重启：
 
 ```bash
 openclaw gateway restart
 ```
 
-## 配置项
+## Config Options
 
-| 选项 | 类型 | 默认值 | 说明 |
+| Option | Type | Default | Description |
-|------|------|--------|------|
+|--------|------|---------|-------------|
-| `enabled` | boolean | `true` | 是否启用插件 |
+| `enabled` | boolean | `true` | Enable the plugin |
-| `backendUrl` | string | `https://monitor.hangman-lab.top` | HarborForge Monitor 后端地址 |
+| `backendUrl` | string | `https://monitor.hangman-lab.top` | HarborForge backend base URL (Monitor + Calendar APIs) |
-| `identifier` | string | 主机名 | 服务器标识符 |
+| `identifier` | string | hostname | Server / claw identifier |
-| `apiKey` | string | 无 | HarborForge Monitor 生成的服务器 API Key |
+| `apiKey` | string | (none) | Server API key from the HarborForge Monitor admin panel |
-| `monitor_port` | number | 无 | 本地桥接端口；插件通过 `127.0.0.1:<monitor_port>` 与 HarborForge.Monitor 通信 |
+| `monitor_port` | number | (none) | Local bridge port; plugin talks to HarborForge.Monitor via `127.0.0.1:<monitor_port>` |
-| `reportIntervalSec` | number | `30` | 报告间隔（秒） |
+| `reportIntervalSec` | number | `30` | Metadata push interval (seconds) |
-| `httpFallbackIntervalSec` | number | `60` | HTTP 回退间隔（秒） |
+| `httpFallbackIntervalSec` | number | `60` | HTTP heartbeat interval when WS unavailable |
-| `logLevel` | string | `info` | 日志级别：`debug` / `info` / `warn` / `error` |
+| `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 |
 
-## 本地桥接说明
+## Local Monitor Bridge
 
-当插件配置了 `monitor_port`，并且 HarborForge.Monitor 也使用相同的 `MONITOR_PORT` 时：
+When the plugin has `monitor_port` configured and HarborForge.Monitor uses the same `MONITOR_PORT`:
 
-- Monitor 在 `127.0.0.1:<MONITOR_PORT>` 提供本地桥接服务
+- Monitor serves a local bridge on `127.0.0.1:<MONITOR_PORT>`
-- 插件可探测 `GET /health`
+- The plugin probes `GET /health`
-- 插件工具 `harborforge_monitor_telemetry` 可读取 `GET /telemetry`
+- 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 心跳的前置条件。
+This link is an **optional enhancement**, not a precondition for the plugin to start or for Monitor heartbeats.
 
-## 插件提供的信息
+## Managed Monitor
 
-### OpenClaw 元数据
+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 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
@@ -152,14 +200,16 @@ 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+（仅 `--install-cli` 需要）
+- Go 1.20+ (only for `--install-cli` / `--install-monitor`)
 
-## 相关提示
+## Tips
 
-- 安装 `hf` 后，建议把 `~/.openclaw/bin` 加到 `PATH`
+- After installing `hf`, add `~/.openclaw/bin` to your `PATH`
-- Agent 使用 `hf` 时，优先试 `hf --help-brief`
+- When an agent uses `hf`, try `hf --help-brief` first
-- 完整命令树看 `hf --help`
+- For the full command tree, see `hf --help`

REFACTOR_PLAN.md

@@ -0,0 +1,118 @@
+# CalendarScheduler Refactor Plan (v2)
+
+> Updated 2026-04-19 based on architecture discussion with hang
+
+## Current Issues
+
+1. `process.env.AGENT_ID` doesn't exist in plugins subprocess — always 'unknown'
+2. Heartbeat is per-agent but should be per-claw-instance (global)
+3. Scheduler only handles one agent — should manage all agents on this instance
+4. wakeAgent used api.spawn (non-existent) → now uses dispatchInboundMessage (verified)
+
+## Target Design
+
+### Plugin State
+
+```typescript
+// Local schedule cache: { agentId → [slots] }
+const schedules: Map<string, CalendarSlotResponse[]> = new Map();
+```
+
+### Sync Flow (every 5 min)
+
+```
+1. GET /calendar/sync?claw_identifier=xxx
+   - First call: server returns full { agentId → [slots] }
+   - Subsequent: server returns diff since last sync
+2. Update local schedules map
+3. Scan schedules for due slots:
+   for each agentId in schedules:
+     if has slot where scheduled_at <= now && status == not_started:
+       getAgentStatus(agentId, clawIdentifier) → busy?
+       if not busy → wakeAgent(agentId)
+```
+
+### Heartbeat (every 60s)
+
+Simplified to liveness ping only:
+```
+POST /monitor/server/heartbeat
+  claw_identifier: xxx
+  → server returns empty/ack
+```
+
+No slot data in heartbeat response.
+
+### Wake Flow
+
+```
+dispatchInboundMessage:
+  SessionKey: agent:{agentId}:hf-wakeup
+  Body: "You have due slots. Follow the hf-wakeup workflow of skill hf-hangman-lab to proceed. Only reply WAKEUP_OK in this session."
+
+Agent reads workflow → calls hf tools → sets own status to busy
+```
+
+### Agent ID Resolution
+
+- **Sync**: agentId comes from server response (dict keys)
+- **Wake**: agentId from local schedules dict key
+- **Tool calls by agent**: agentId from tool ctx (same as padded-cell)
+
+## Backend API Changes Needed
+
+### New: GET /calendar/sync
+
+```
+GET /calendar/sync?claw_identifier=xxx
+Headers: X-Claw-Identifier
+
+Response (first call):
+{
+  "full": true,
+  "schedules": {
+    "developer": [slot1, slot2, ...],
+    "operator": [slot3, ...]
+  },
+  "syncToken": "abc123"
+}
+
+Response (subsequent, with ?since=abc123):
+{
+  "full": false,
+  "diff": [
+    { "op": "add", "agent": "developer", "slot": {...} },
+    { "op": "update", "agent": "developer", "slotId": 5, "patch": {...} },
+    { "op": "remove", "agent": "operator", "slotId": 3 }
+  ],
+  "syncToken": "def456"
+}
+```
+
+### Existing: POST /calendar/agent/status
+
+Keep as-is but ensure it accepts agentId + clawIdentifier as params:
+```
+POST /calendar/agent/status
+  { agent_id, claw_identifier, status }
+```
+
+## Implementation Order
+
+1. Backend: Add /calendar/sync endpoint
+2. Plugin: Replace CalendarBridgeClient single-agent design with multi-agent
+3. Plugin: Replace CalendarScheduler with new sync+check loop
+4. Plugin: wakeAgent uses dispatchInboundMessage (done)
+5. Plugin: Tool handlers get agentId from ctx (like padded-cell)
+
+## Files to Change
+
+### Backend (HarborForge.Backend)
+- New route: `/calendar/sync`
+- New service: schedule diff tracking per claw_identifier
+
+### Plugin
+- `plugin/calendar/calendar-bridge.ts` — remove agentId binding, add sync()
+- `plugin/calendar/scheduler.ts` — rewrite to multi-agent sync+check
+- `plugin/calendar/schedule-cache.ts` — already exists, adapt to multi-agent
+- `plugin/index.ts` — update wakeAgent, getAgentStatus to accept agentId

docs/PLG-CAL-001-calendar-heartbeat-format.md

@@ -0,0 +1,261 @@
+# PLG-CAL-001 — Calendar Heartbeat Format Specification
+
+> **Task:** HarborForge OpenclawPlugin / Monitor 联动  
+> **Subtask:** PLG-CAL-001 — 插件侧定义 Calendar 心跳请求格式  
+> **Status:** ✅ Implemented (types + client + spec)  
+> **Date:** 2026-04-01
+
+---
+
+## Overview
+
+This document specifies the request/response format for the Calendar heartbeat
+communication between the OpenClaw HarborForge plugin and the HarborForge backend.
+
+Heartbeat direction: **Plugin → Backend**
+
+The plugin sends a heartbeat every minute (aligned with the existing Monitor
+heartbeat interval). The backend returns today's pending TimeSlots for the agent.
+
+---
+
+## 1. How `claw_identifier` is Determined
+
+`claw_identifier` identifies the server/claw instance. It is the same value used
+in the Monitor heartbeat system (`MonitoredServer.identifier`).
+
+**Priority order:**
+
+1. **`config.identifier`** — if set in the plugin config (`harbor-forge.identifier`)
+2. **`os.hostname()`** — auto-detected from the machine hostname (fallback)
+
+```typescript
+// In plugin/calendar/calendar-bridge.ts
+const clawIdentifier = baseConfig.identifier || hostname();
+```
+
+---
+
+## 2. How `agent_id` is Determined
+
+`agent_id` is the OpenClaw agent identifier (`$AGENT_ID`).
+
+- Set by OpenClaw at agent startup as an environment variable
+- The plugin reads it via `process.env.AGENT_ID`
+- Globally unique within a single OpenClaw gateway deployment
+
+```typescript
+// In plugin/index.ts (caller)
+const agentId = process.env.AGENT_ID || 'unknown';
+```
+
+---
+
+## 3. Heartbeat Request
+
+**Endpoint:** `GET /calendar/agent/heartbeat`
+
+### Headers
+
+| Header | Value | Notes |
+|--------|-------|-------|
+| `Content-Type` | `application/json` | Always set |
+| `X-Agent-ID` | `$AGENT_ID` | OpenClaw agent identifier |
+| `X-Claw-Identifier` | `claw_identifier` | Server identifier |
+
+### Request Body (JSON)
+
+```json
+{
+  "claw_identifier": "srv1390517",
+  "agent_id": "developer"
+}
+```
+
+### Field Definitions
+
+| Field | Type | Source | Notes |
+|-------|------|--------|-------|
+| `claw_identifier` | string | Plugin config or `hostname()` | Identifies the OpenClaw server instance |
+| `agent_id` | string | `process.env.AGENT_ID` | Identifies the agent session |
+
+---
+
+## 4. Heartbeat Response
+
+### Success (HTTP 200)
+
+```json
+{
+  "slots": [
+    {
+      "id": 42,
+      "virtual_id": null,
+      "user_id": 1,
+      "date": "2026-04-01",
+      "slot_type": "work",
+      "estimated_duration": 30,
+      "scheduled_at": "09:00:00",
+      "started_at": null,
+      "attended": false,
+      "actual_duration": null,
+      "event_type": "job",
+      "event_data": {
+        "type": "Task",
+        "code": "TASK-123"
+      },
+      "priority": 50,
+      "status": "not_started",
+      "plan_id": null
+    }
+  ],
+  "agent_status": "idle",
+  "message": "2 slots pending"
+}
+```
+
+### Field Definitions
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `slots` | `CalendarSlotResponse[]` | Pending slots, sorted by `priority` DESC |
+| `agent_status` | `AgentStatusValue` | Current backend-observed agent status |
+| `message` | string (optional) | Human-readable summary |
+
+### `CalendarSlotResponse` Fields
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `id` | `number \| null` | Real slot DB id. `null` for virtual slots. |
+| `virtual_id` | `string \| null` | `plan-{plan_id}-{date}`. `null` for real slots. |
+| `user_id` | number | Owner HarborForge user id |
+| `date` | string | ISO date `YYYY-MM-DD` |
+| `slot_type` | `SlotType` | `work \| on_call \| entertainment \| system` |
+| `estimated_duration` | number | Minutes (1-50) |
+| `scheduled_at` | string | ISO time `HH:MM:SS` |
+| `started_at` | `string \| null` | Actual start time when slot begins |
+| `attended` | boolean | `true` once agent begins the slot |
+| `actual_duration` | `number \| null` | Real minutes when slot finishes |
+| `event_type` | `EventType \| null` | `job \| entertainment \| system_event` |
+| `event_data` | object \| null | See §4a below |
+| `priority` | number | 0-99, higher = more urgent |
+| `status` | `SlotStatus` | `not_started \| deferred \| ...` |
+| `plan_id` | `number \| null` | Source plan if materialized from SchedulePlan |
+
+### §4a — `event_data` Shapes
+
+**When `event_type == "job"`:**
+```json
+{
+  "type": "Task",
+  "code": "TASK-42",
+  "working_sessions": ["session-id-1"]
+}
+```
+
+**When `event_type == "system_event"`:**
+```json
+{
+  "event": "ScheduleToday"
+}
+```
+Valid events: `ScheduleToday | SummaryToday | ScheduledGatewayRestart`
+
+---
+
+## 5. Slot Update Requests (Plugin → Backend after execution)
+
+After attending / finishing / deferring a slot, the plugin calls:
+
+**Real slot:** `PATCH /calendar/slots/{slot_id}/agent-update`
+**Virtual slot:** `PATCH /calendar/slots/virtual/{virtual_id}/agent-update`
+
+### Headers
+
+Same as heartbeat (see §3).
+
+### Request Body
+
+```json
+{
+  "status": "ongoing",
+  "started_at": "09:02:31",
+  "actual_duration": null
+}
+```
+
+| Field | Type | Required | Notes |
+|-------|------|----------|-------|
+| `status` | `SlotStatus` | **Required** | New status after agent action |
+| `started_at` | string | On attending | ISO time `HH:MM:SS` |
+| `actual_duration` | number | On finishing | Real minutes |
+
+### Status Transition Values
+
+| Action | `status` value |
+|--------|---------------|
+| Agent begins slot | `ongoing` |
+| Agent finishes slot | `finished` |
+| Agent defers slot | `deferred` |
+| Agent aborts slot | `aborted` |
+| Agent pauses slot | `paused` |
+
+---
+
+## 6. Backend Endpoint Summary
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| GET | `/calendar/agent/heartbeat` | X-Agent-ID + X-Claw-Identifier | Fetch pending slots for today |
+| PATCH | `/calendar/slots/{id}/agent-update` | X-Agent-ID + X-Claw-Identifier | Update real slot status |
+| PATCH | `/calendar/slots/virtual/{vid}/agent-update` | X-Agent-ID + X-Claw-Identifier | Update virtual slot status |
+| POST | `/calendar/agent/status` | X-Agent-ID + X-Claw-Identifier | Report agent status change |
+
+---
+
+## 7. Error Handling
+
+- **Backend unreachable:** Plugin logs warning, returns `null` from heartbeat.  
+  Agent continues to operate without Calendar integration.
+- **Invalid credentials (401/403):** Logged as error. No retry on same interval.
+- **Rate limiting (429):** Plugin should mark agent as `Exhausted` and not retry
+  until the `Retry-After` header indicates.
+
+---
+
+## 8. TypeScript Reference
+
+Full type definitions are in `plugin/calendar/types.ts`:
+
+```typescript
+// Request
+interface CalendarHeartbeatRequest {
+  claw_identifier: string;
+  agent_id: string;
+}
+
+// Response
+interface CalendarHeartbeatResponse {
+  slots: CalendarSlotResponse[];
+  agent_status: AgentStatusValue;
+  message?: string;
+}
+
+// Slot update
+interface SlotAgentUpdate {
+  status: SlotStatus;
+  started_at?: string;   // ISO time HH:MM:SS
+  actual_duration?: number;
+}
+```
+
+---
+
+## 9. Implementation Files
+
+| File | Purpose |
+|------|---------|
+| `plugin/calendar/types.ts` | TypeScript interfaces for all request/response shapes |
+| `plugin/calendar/calendar-bridge.ts` | `CalendarBridgeClient` HTTP client |
+| `plugin/calendar/index.ts` | Module entry point |
+| `docs/PLG-CAL-001-calendar-heartbeat-format.md` | This specification |

package-lock.json

@@ -0,0 +1,17 @@
+{
+  "name": "harbor-forge-openclaw-plugin",
+  "version": "0.2.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "harbor-forge-openclaw-plugin",
+      "version": "0.2.0",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    }
+  }
+}

plugin/calendar/calendar-bridge.ts

@@ -0,0 +1,356 @@
+/**
+ * HarborForge Calendar Bridge Client
+ *
+ * PLG-CAL-001: Handles HTTP communication between the OpenClaw plugin
+ * and the HarborForge backend for Calendar heartbeat and slot updates.
+ *
+ * Request authentication:
+ *   • X-Agent-ID header — set to process.env.AGENT_ID
+ *   • X-Claw-Identifier header — set to the server's claw_identifier
+ *     (from plugin config or hostname fallback)
+ *
+ * Base URL:
+ *   Derived from plugin config: backendUrl + "/calendar"
+ *   Default backendUrl: "https://monitor.hangman-lab.top"
+ *
+ * Endpoints used:
+ *   POST /calendar/agent/heartbeat        — fetch pending slots
+ *   PATCH /calendar/slots/{id}/agent-update   — update real slot status
+ *   PATCH /calendar/slots/virtual/{vid}/agent-update — update virtual slot status
+ *
+ * References:
+ *   • NEXT_WAVE_DEV_DIRECTION.md §6.1 (Heartbeat flow)
+ *   • HarborForge.Backend/app/services/agent_heartbeat.py (BE-AGT-001)
+ */
+
+import {
+  CalendarHeartbeatRequest,
+  CalendarHeartbeatResponse,
+  CalendarSlotResponse,
+  SlotAgentUpdate,
+  SlotStatus,
+} from './types.js';
+
+export interface CalendarBridgeConfig {
+  /** HarborForge backend base URL (e.g. "https://monitor.hangman-lab.top") */
+  backendUrl: string;
+  /** Server/claw identifier (from plugin config or hostname fallback) */
+  clawIdentifier: string;
+  /** OpenClaw agent ID ($AGENT_ID), set at agent startup */
+  agentId: string;
+  /** HTTP request timeout in milliseconds (default: 5000) */
+  timeoutMs?: number;
+}
+
+export class CalendarBridgeClient {
+  private baseUrl: string;
+  private config: Required<CalendarBridgeConfig>;
+  private timeoutMs: number;
+
+  constructor(config: CalendarBridgeConfig) {
+    this.baseUrl = config.backendUrl.replace(/\/$/, ''); // strip trailing slash
+    this.config = {
+      timeoutMs: 5000,
+      ...config,
+    };
+    this.timeoutMs = this.config.timeoutMs;
+  }
+
+  /**
+   * Fetch today's pending calendar slots for this agent.
+   *
+   * Heartbeat flow (§6.1):
+   *  1. Plugin sends heartbeat every minute
+   *  2. Backend returns slots where status is NotStarted or Deferred
+   *     AND scheduled_at <= now
+   *  3. Plugin selects highest-priority slot (if any)
+   *  4. For remaining slots, plugin sets status = Deferred + priority += 1
+   *
+   * @returns CalendarHeartbeatResponse or null if the backend is unreachable
+   */
+  async heartbeat(): Promise<CalendarHeartbeatResponse | null> {
+    const url = `${this.baseUrl}/calendar/agent/heartbeat`;
+    const body: CalendarHeartbeatRequest = {
+      claw_identifier: this.config.clawIdentifier,
+      agent_id: this.config.agentId,
+    };
+
+    try {
+      const response = await this.fetchJson<CalendarHeartbeatResponse>(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Agent-ID': this.config.agentId,
+          'X-Claw-Identifier': this.config.clawIdentifier,
+        },
+        body: JSON.stringify(body),
+      });
+      return response;
+    } catch (err) {
+      // Non-fatal: backend unreachable — return null, plugin continues
+      return null;
+    }
+  }
+
+  /**
+   * Update a real (materialized) slot's status after agent execution.
+   *
+   * Used by the plugin to report:
+   *   - Slot attended (attended=true, started_at=now, status=Ongoing)
+   *   - Slot finished (actual_duration set, status=Finished)
+   *   - Slot deferred (status=Deferred, priority += 1)
+   *   - Slot aborted (status=Aborted)
+   *
+   * @param slotId  Real slot DB id
+   * @param update  Status update payload
+   * @returns true on success, false on failure
+   */
+  async updateSlot(slotId: number, update: SlotAgentUpdate): Promise<boolean> {
+    const url = `${this.baseUrl}/calendar/slots/${slotId}/agent-update`;
+    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.
+   *
+   * When updating a virtual slot, the backend first materializes it
+   * (creates a real TimeSlot row), then applies the update.
+   * The returned slot will have a real id on subsequent calls.
+   *
+   * @param virtualId  Virtual slot id in format "plan-{plan_id}-{date}"
+   * @param update     Status update payload
+   * @returns Updated CalendarSlotResponse on success, null on failure
+   */
+  async updateVirtualSlot(
+    virtualId: string,
+    update: SlotAgentUpdate
+  ): Promise<CalendarSlotResponse | null> {
+    const url = `${this.baseUrl}/calendar/slots/virtual/${encodeURIComponent(virtualId)}/agent-update`;
+    try {
+      const response = await this.fetchJson<{ slot: CalendarSlotResponse }>(url, {
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Agent-ID': this.config.agentId,
+          'X-Claw-Identifier': this.config.clawIdentifier,
+        },
+        body: JSON.stringify(update),
+      });
+      return response?.slot ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Report the agent's current runtime status to HarborForge.
+   *
+   * Used to push agent status transitions:
+   *   idle → busy / on_call  (when starting a slot)
+   *   busy / on_call → idle  (when finishing a slot)
+   *   → exhausted (on rate-limit / billing error, with recovery_at)
+   *   → offline (after 2 min with no heartbeat)
+   *
+   * @param status  New agent status
+   * @param recoveryAt  ISO timestamp for expected Exhausted recovery (optional)
+   * @param exhaustReason "rate_limit" | "billing" (required if status=exhausted)
+   */
+  async reportAgentStatus(params: {
+    status: 'idle' | 'on_call' | 'busy' | 'exhausted' | 'offline';
+    recoveryAt?: string;
+    exhaustReason?: 'rate_limit' | 'billing';
+  }): Promise<boolean> {
+    const url = `${this.baseUrl}/calendar/agent/status`;
+    const body = {
+      agent_id: this.config.agentId,
+      claw_identifier: this.config.clawIdentifier,
+      ...params,
+    };
+    return this.sendBoolean('POST', url, body);
+  }
+
+  /**
+   * Fetch the full day schedule for this agent.
+   *
+   * Unlike heartbeat() which only returns pending (NOT_STARTED/DEFERRED) slots,
+   * this returns ALL slots for the given date, enabling the plugin to maintain
+   * a complete local view of today's schedule.
+   *
+   * @param date  Date string in YYYY-MM-DD format
+   * @returns Array of all slots for the day, or null if unreachable
+   */
+  async getDaySchedule(date: string): Promise<CalendarSlotResponse[] | null> {
+    const url = `${this.baseUrl}/calendar/day?date=${encodeURIComponent(date)}`;
+    try {
+      const response = await this.fetchJson<{ slots: CalendarSlotResponse[] }>(url, {
+        method: 'GET',
+        headers: {
+          'X-Agent-ID': this.config.agentId,
+          'X-Claw-Identifier': this.config.clawIdentifier,
+        },
+      });
+      return response?.slots ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Sync today's schedules for all agents on this claw instance.
+   *
+   * Returns { agentId → slots[] } for all agents with matching claw_identifier.
+   * This is the primary data source for the multi-agent schedule cache.
+   */
+  async syncSchedules(): Promise<{ schedules: Record<string, any[]>; date: string } | null> {
+    const url = `${this.baseUrl}/calendar/sync`;
+    try {
+      const response = await this.fetchJson<{ schedules: Record<string, any[]>; date: string }>(url, {
+        method: 'GET',
+        headers: {
+          'X-Claw-Identifier': this.config.clawIdentifier,
+        },
+      });
+      return response;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get a specific agent's status.
+   *
+   * @param agentId  The agent ID to query
+   */
+  async getAgentStatus(agentId: string): Promise<string | null> {
+    const url = `${this.baseUrl}/calendar/agent/status?agent_id=${encodeURIComponent(agentId)}`;
+    try {
+      const response = await this.fetchJson<{ status: string }>(url, {
+        method: 'GET',
+        headers: {
+          'X-Agent-ID': agentId,
+          'X-Claw-Identifier': this.config.clawIdentifier,
+        },
+      });
+      return response?.status ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Internal helpers
+  // -------------------------------------------------------------------------
+
+  private async fetchJson<T>(
+    url: string,
+    init: RequestInit
+  ): Promise<T | null> {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+
+    try {
+      const response = await fetch(url, {
+        ...init,
+        signal: controller.signal,
+      });
+      clearTimeout(timeout);
+
+      if (!response.ok) return null;
+      return (await response.json()) as T;
+    } catch {
+      clearTimeout(timeout);
+      return null;
+    }
+  }
+
+  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);
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Agent-ID': agentId,
+          'X-Claw-Identifier': this.config.clawIdentifier,
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+      clearTimeout(timeout);
+      return response.ok;
+    } catch {
+      clearTimeout(timeout);
+      return false;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Utility: build CalendarBridgeConfig from plugin API context
+// ---------------------------------------------------------------------------
+
+import { hostname } from 'os';
+import { getPluginConfig } from '../core/config.js';
+
+export interface CalendarPluginConfig {
+  /** Backend URL for calendar API (overrides monitor backendUrl) */
+  calendarBackendUrl?: string;
+  /** Server identifier (overrides auto-detected hostname) */
+  identifier?: string;
+  /** Agent ID from OpenClaw ($AGENT_ID) */
+  agentId: string;
+  /** HTTP timeout for calendar API calls (default: 5000) */
+  timeoutMs?: number;
+}
+
+/**
+ * Build a CalendarBridgeClient from the OpenClaw plugin API context.
+ *
+ * @param api           OpenClaw plugin API (register() receives this)
+ * @param fallbackUrl   Fallback backend URL if not configured
+ * @param agentId       $AGENT_ID from OpenClaw environment
+ */
+export function createCalendarBridgeClient(
+  api: { config?: Record<string, unknown>; logger?: { debug?: (...args: unknown[]) => void } },
+  fallbackUrl: string,
+  agentId: string
+): CalendarBridgeClient {
+  const baseConfig = getPluginConfig(api as any);
+
+  const clawIdentifier = baseConfig.identifier || hostname();
+
+  return new CalendarBridgeClient({
+    backendUrl: baseConfig.backendUrl || fallbackUrl,
+    clawIdentifier,
+    agentId,
+    timeoutMs: 5000,
+  });
+}

plugin/calendar/index.ts

@@ -0,0 +1,34 @@
+/**
+ * HarborForge Calendar — Plugin Module
+ *
+ * PLG-CAL-001: Calendar heartbeat request/response format definition.
+ * PLG-CAL-002: Plugin-side slot execution scheduler and agent wakeup.
+ *
+ * Exports:
+ *   • Types for heartbeat request/response and slot update
+ *   • CalendarBridgeClient — HTTP client for backend communication
+ *   • createCalendarBridgeClient — factory from plugin API context
+ *   • CalendarScheduler — manages periodic heartbeat and slot execution
+ *   • createCalendarScheduler — factory for scheduler
+ *   • AgentWakeContext — context passed to agent when waking
+ *
+ * Usage in plugin/index.ts:
+ *   import { createCalendarBridgeClient, createCalendarScheduler } from './calendar.js';
+ *
+ *   const agentId = process.env.AGENT_ID || 'unknown';
+ *   const calendar = createCalendarBridgeClient(api, 'https://monitor.hangman-lab.top', agentId);
+ *
+ *   const scheduler = createCalendarScheduler({
+ *     bridge: calendar,
+ *     getAgentStatus: async () => { ... },
+ *     wakeAgent: async (context) => { ... },
+ *     logger: api.logger,
+ *   });
+ *
+ *   scheduler.start();
+ */
+
+export * from './types.js';
+export * from './calendar-bridge.js';
+export * from './scheduler.js';
+export * from './schedule-cache.js';

plugin/calendar/multi-agent-handle.ts

@@ -0,0 +1,240 @@
+/**
+ * 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;
+}

plugin/calendar/schedule-cache.ts

@@ -0,0 +1,101 @@
+/**
+ * Multi-agent local schedule cache.
+ *
+ * Maintains today's schedule for all agents on this claw instance.
+ * Synced periodically from HF backend via /calendar/sync endpoint.
+ */
+
+export interface CachedSlot {
+  id: number | null;
+  virtual_id: string | null;
+  slot_type: string;
+  estimated_duration: number;
+  scheduled_at: string;
+  status: string;
+  priority: number;
+  event_type: string | null;
+  event_data: Record<string, unknown> | null;
+  [key: string]: unknown;
+}
+
+export class MultiAgentScheduleCache {
+  /** { agentId → slots[] } */
+  private schedules: Map<string, CachedSlot[]> = new Map();
+  private lastSyncAt: Date | null = null;
+  private cachedDate: string | null = null;
+
+  /**
+   * Replace cache with data from /calendar/sync response.
+   */
+  sync(date: string, schedules: Record<string, CachedSlot[]>): void {
+    if (this.cachedDate !== date) {
+      this.schedules.clear();
+    }
+    this.cachedDate = date;
+
+    for (const [agentId, slots] of Object.entries(schedules)) {
+      this.schedules.set(agentId, slots);
+    }
+    this.lastSyncAt = new Date();
+  }
+
+  /**
+   * Get agents that have due (overdue or current) slots.
+   * Returns [agentId, dueSlots[]] pairs.
+   */
+  getAgentsWithDueSlots(now: Date): Array<{ agentId: string; slots: CachedSlot[] }> {
+    const results: Array<{ agentId: string; slots: CachedSlot[] }> = [];
+
+    for (const [agentId, slots] of this.schedules) {
+      const due = slots.filter((s) => {
+        if (s.status !== 'not_started' && s.status !== 'deferred') return false;
+        const scheduledAt = this.parseScheduledTime(s.scheduled_at);
+        return scheduledAt !== null && scheduledAt <= now;
+      });
+
+      if (due.length > 0) {
+        // Sort by priority descending
+        due.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        results.push({ agentId, slots: due });
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Get all agent IDs in the cache.
+   */
+  getAgentIds(): string[] {
+    return Array.from(this.schedules.keys());
+  }
+
+  /**
+   * Get slots for a specific agent.
+   */
+  getAgentSlots(agentId: string): CachedSlot[] {
+    return this.schedules.get(agentId) ?? [];
+  }
+
+  /**
+   * Get cache status for debugging.
+   */
+  getStatus(): { agentCount: number; totalSlots: number; lastSyncAt: string | null; cachedDate: string | null } {
+    let totalSlots = 0;
+    for (const slots of this.schedules.values()) totalSlots += slots.length;
+    return {
+      agentCount: this.schedules.size,
+      totalSlots,
+      lastSyncAt: this.lastSyncAt?.toISOString() ?? null,
+      cachedDate: this.cachedDate,
+    };
+  }
+
+  private parseScheduledTime(scheduledAt: string): Date | null {
+    if (/^\d{2}:\d{2}(:\d{2})?$/.test(scheduledAt)) {
+      if (!this.cachedDate) return null;
+      return new Date(`${this.cachedDate}T${scheduledAt}Z`);
+    }
+    const d = new Date(scheduledAt);
+    return isNaN(d.getTime()) ? null : d;
+  }
+}

plugin/calendar/scheduler.ts

@@ -0,0 +1,953 @@
+/**
+ * HarborForge Calendar Scheduler
+ *
+ * PLG-CAL-002: Plugin-side handling for pending slot execution.
+ * PLG-CAL-004: ScheduledGatewayRestart event handling with state persistence.
+ *
+ * Responsibilities:
+ *   - Run calendar heartbeat every minute
+ *   - Detect when agent is Idle and slots are pending
+ *   - Wake agent with task context
+ *   - Handle slot status transitions (attended, ongoing, deferred)
+ *   - Manage agent status transitions (idle → busy/on_call)
+ *   - Persist state on ScheduledGatewayRestart and restore on startup
+ *   - Send final heartbeat before graceful shutdown
+ *
+ * Design reference: NEXT_WAVE_DEV_DIRECTION.md §6 (Agent wakeup mechanism)
+ */
+
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { CalendarBridgeClient } from './calendar-bridge.js';
+import {
+  CalendarSlotResponse,
+  SlotStatus,
+  AgentStatusValue,
+  SlotAgentUpdate,
+  CalendarEventDataJob,
+  CalendarEventDataSystemEvent,
+} from './types.js';
+
+export interface CalendarSchedulerConfig {
+  /** Calendar bridge client for backend communication */
+  bridge: CalendarBridgeClient;
+  /** Function to get current agent status from backend */
+  getAgentStatus: () => Promise<AgentStatusValue | null>;
+  /** Function to wake/spawn agent with task context */
+  wakeAgent: (context: AgentWakeContext) => Promise<boolean>;
+  /** Logger instance */
+  logger: {
+    info: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+  };
+  /** Heartbeat interval in milliseconds (default: 60000) */
+  heartbeatIntervalMs?: number;
+  /** Enable verbose debug logging */
+  debug?: boolean;
+  /** Directory for state persistence (default: plugin data dir) */
+  stateDir?: string;
+}
+
+/**
+ * Context passed to agent when waking for slot execution.
+ * This is the payload the agent receives to understand what to do.
+ */
+export interface AgentWakeContext {
+  /** The slot to execute */
+  slot: CalendarSlotResponse;
+  /** Human-readable task description */
+  taskDescription: string;
+  /** Prompt/instructions for the agent */
+  prompt: string;
+  /** Whether this is a virtual slot (needs materialization) */
+  isVirtual: boolean;
+}
+
+/**
+ * Persisted state structure for recovery after restart.
+ */
+interface PersistedState {
+  /** Version for migration compatibility */
+  version: number;
+  /** When the state was persisted */
+  persistedAt: string;
+  /** Reason for persistence (e.g., 'ScheduledGatewayRestart') */
+  reason: string;
+  /** The slot that was being executed when persisted */
+  currentSlot: CalendarSlotResponse | null;
+  /** Deferred slot IDs at persistence time */
+  deferredSlotIds: string[];
+  /** Whether a slot was in progress */
+  isProcessing: boolean;
+  /** Agent status at persistence time */
+  agentStatus: AgentStatusValue | null;
+}
+
+/**
+ * Current execution state tracked by the scheduler.
+ */
+interface SchedulerState {
+  /** Whether scheduler is currently running */
+  isRunning: boolean;
+  /** Currently executing slot (null if idle) */
+  currentSlot: CalendarSlotResponse | null;
+  /** Last heartbeat timestamp */
+  lastHeartbeatAt: Date | null;
+  /** Interval handle for cleanup */
+  intervalHandle: 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 */
+  isProcessing: boolean;
+  /** Whether a gateway restart is scheduled/pending */
+  isRestartPending: boolean;
+}
+
+/** State file name */
+const STATE_FILENAME = 'calendar-scheduler-state.json';
+/** State file version for migration compatibility */
+const STATE_VERSION = 1;
+
+/**
+ * CalendarScheduler manages the periodic heartbeat and slot execution lifecycle.
+ */
+export class CalendarScheduler {
+  private config: Required<CalendarSchedulerConfig>;
+  private state: SchedulerState;
+  private stateFilePath: string;
+
+  constructor(config: CalendarSchedulerConfig) {
+    this.config = {
+      heartbeatIntervalMs: 60000, // 1 minute default
+      debug: false,
+      stateDir: this.getDefaultStateDir(),
+      ...config,
+    };
+
+    this.stateFilePath = join(this.config.stateDir, STATE_FILENAME);
+
+    this.state = {
+      isRunning: false,
+      currentSlot: null,
+      lastHeartbeatAt: null,
+      intervalHandle: null,
+      deferredSlotIds: new Set(),
+      isProcessing: false,
+      isRestartPending: false,
+    };
+
+    // Attempt to restore state from previous persistence
+    this.restoreState();
+  }
+
+  /**
+   * Get default state directory (plugin data directory or temp fallback).
+   */
+  private getDefaultStateDir(): string {
+    // Try to use the plugin's directory or a standard data location
+    const candidates = [
+      process.env.OPENCLAW_PLUGIN_DATA_DIR,
+      process.env.HARBORFORGE_PLUGIN_DIR,
+      join(process.cwd(), '.harborforge'),
+      join(process.cwd(), 'data'),
+      '/tmp/harborforge',
+    ];
+
+    for (const dir of candidates) {
+      if (dir) {
+        try {
+          if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+          }
+          // Test write access
+          const testFile = join(dir, '.write-test');
+          writeFileSync(testFile, '', { flag: 'w' });
+          return dir;
+        } catch {
+          continue;
+        }
+      }
+    }
+
+    // Fallback to current working directory
+    return process.cwd();
+  }
+
+  /**
+   * Persist current state to disk for recovery after restart.
+   */
+  private persistState(reason: string): void {
+    try {
+      const persistedState: PersistedState = {
+        version: STATE_VERSION,
+        persistedAt: new Date().toISOString(),
+        reason,
+        currentSlot: this.state.currentSlot,
+        deferredSlotIds: Array.from(this.state.deferredSlotIds),
+        isProcessing: this.state.isProcessing,
+        agentStatus: null, // Will be determined at restore time
+      };
+
+      writeFileSync(this.stateFilePath, JSON.stringify(persistedState, null, 2));
+      this.config.logger.info(`[PLG-CAL-004] State persisted to ${this.stateFilePath} (reason: ${reason})`);
+    } catch (err) {
+      this.config.logger.error('[PLG-CAL-004] Failed to persist state:', err);
+    }
+  }
+
+  /**
+   * Restore state from disk if available.
+   */
+  private restoreState(): void {
+    try {
+      if (!existsSync(this.stateFilePath)) {
+        return;
+      }
+
+      const data = readFileSync(this.stateFilePath, 'utf-8');
+      const persisted: PersistedState = JSON.parse(data);
+
+      // Validate version
+      if (persisted.version !== STATE_VERSION) {
+        this.config.logger.warn(`[PLG-CAL-004] State version mismatch: ${persisted.version} vs ${STATE_VERSION}`);
+        this.clearPersistedState();
+        return;
+      }
+
+      // Restore deferred slot IDs
+      if (persisted.deferredSlotIds && persisted.deferredSlotIds.length > 0) {
+        this.state.deferredSlotIds = new Set(persisted.deferredSlotIds);
+        this.config.logger.info(`[PLG-CAL-004] Restored ${persisted.deferredSlotIds.length} deferred slot(s)`);
+      }
+
+      // If there was a slot in progress, mark it for replanning
+      if (persisted.isProcessing && persisted.currentSlot) {
+        this.config.logger.warn(
+          `[PLG-CAL-004] Previous session had in-progress slot: ${this.getSlotId(persisted.currentSlot)}`
+        );
+        // The slot will be picked up by the next heartbeat and can be resumed or deferred
+      }
+
+      this.config.logger.info(`[PLG-CAL-004] State restored from ${persisted.persistedAt} (reason: ${persisted.reason})`);
+
+      // Clear the persisted state after successful restore
+      this.clearPersistedState();
+    } catch (err) {
+      this.config.logger.error('[PLG-CAL-004] Failed to restore state:', err);
+    }
+  }
+
+  /**
+   * Clear persisted state file after successful restore.
+   */
+  private clearPersistedState(): void {
+    try {
+      if (existsSync(this.stateFilePath)) {
+        // In a real implementation, we might want to archive instead of delete
+        // For now, we'll just clear the content to mark as processed
+        writeFileSync(this.stateFilePath, JSON.stringify({ restored: true, at: new Date().toISOString() }));
+      }
+    } catch (err) {
+      this.config.logger.error('[PLG-CAL-004] Failed to clear persisted state:', err);
+    }
+  }
+
+  /**
+   * Send a final heartbeat to the backend before shutdown.
+   */
+  private async sendFinalHeartbeat(reason: string): Promise<void> {
+    try {
+      this.config.logger.info(`[PLG-CAL-004] Sending final heartbeat (reason: ${reason})`);
+
+      // Send agent status update indicating we're going offline
+      await this.config.bridge.reportAgentStatus({ status: 'offline' });
+
+      this.config.logger.info('[PLG-CAL-004] Final heartbeat sent successfully');
+    } catch (err) {
+      this.config.logger.error('[PLG-CAL-004] Failed to send final heartbeat:', err);
+    }
+  }
+
+  /**
+   * Handle ScheduledGatewayRestart event.
+   * PLG-CAL-004: Persist state, send final heartbeat, pause scheduled tasks.
+   */
+  private async handleScheduledGatewayRestart(slot: CalendarSlotResponse): Promise<void> {
+    this.config.logger.info('[PLG-CAL-004] Handling ScheduledGatewayRestart event');
+
+    // 1. Mark restart as pending to prevent new slot processing
+    this.state.isRestartPending = true;
+
+    // 2. Persist current state
+    this.persistState('ScheduledGatewayRestart');
+
+    // 3. If there's a current slot, pause it gracefully
+    if (this.state.isProcessing && this.state.currentSlot) {
+      this.config.logger.info('[PLG-CAL-004] Pausing current slot before restart');
+      await this.pauseCurrentSlot();
+    }
+
+    // 4. Send final heartbeat
+    await this.sendFinalHeartbeat('ScheduledGatewayRestart');
+
+    // 5. Stop the scheduler (pause scheduled tasks)
+    this.config.logger.info('[PLG-CAL-004] Stopping scheduler due to gateway restart');
+    this.stop();
+
+    // 6. Mark the slot as finished (since we've handled the restart)
+    const update: SlotAgentUpdate = {
+      status: SlotStatus.FINISHED,
+      actual_duration: 0, // Restart preparation doesn't take time
+    };
+
+    try {
+      if (slot.id) {
+        await this.config.bridge.updateSlot(slot.id, update);
+      } else if (slot.virtual_id) {
+        await this.config.bridge.updateVirtualSlot(slot.virtual_id, update);
+      }
+    } catch (err) {
+      this.config.logger.error('[PLG-CAL-004] Failed to mark restart slot as finished:', err);
+    }
+  }
+
+  /**
+   * Start the calendar scheduler.
+   * Begins periodic heartbeat to check for pending slots.
+   */
+  start(): void {
+    if (this.state.isRunning) {
+      this.config.logger.warn('Calendar scheduler already running');
+      return;
+    }
+
+    this.state.isRunning = true;
+    this.state.isRestartPending = false;
+    this.config.logger.info('Calendar scheduler started');
+
+    // Run initial heartbeat immediately
+    this.runHeartbeat();
+
+    // Schedule periodic heartbeats
+    this.state.intervalHandle = setInterval(
+      () => this.runHeartbeat(),
+      this.config.heartbeatIntervalMs
+    );
+  }
+
+  /**
+   * Stop the calendar scheduler.
+   * Cleans up intervals and resets state.
+   */
+  stop(): void {
+    this.state.isRunning = false;
+
+    if (this.state.intervalHandle) {
+      clearInterval(this.state.intervalHandle);
+      this.state.intervalHandle = null;
+    }
+
+    this.config.logger.info('Calendar scheduler stopped');
+  }
+
+  /**
+   * Execute a single heartbeat cycle.
+   * Fetches pending slots and handles execution logic.
+   */
+  async runHeartbeat(): Promise<void> {
+    if (!this.state.isRunning) {
+      return;
+    }
+
+    // Skip heartbeat if restart is pending
+    if (this.state.isRestartPending) {
+      this.logDebug('Heartbeat skipped: gateway restart pending');
+      return;
+    }
+
+    this.state.lastHeartbeatAt = new Date();
+
+    try {
+      // Fetch pending slots from backend
+      const response = await this.config.bridge.heartbeat();
+
+      if (!response) {
+        this.logDebug('Heartbeat: backend unreachable');
+        return;
+      }
+
+      this.logDebug(
+        `Heartbeat: ${response.slots.length} slots pending, agent_status=${response.agent_status}`
+      );
+
+      // If agent is not idle, defer all pending slots
+      if (response.agent_status !== 'idle') {
+        await this.handleNonIdleAgent(response.slots, response.agent_status);
+        return;
+      }
+
+      // Agent is idle again - previously deferred slots should become eligible
+      // for selection in the next planning pass.
+      if (this.state.deferredSlotIds.size > 0) {
+        this.logDebug(
+          `Agent returned to idle; clearing ${this.state.deferredSlotIds.size} deferred slot marker(s) for replanning`
+        );
+        this.state.deferredSlotIds.clear();
+      }
+
+      // Agent is idle - handle pending slots
+      await this.handleIdleAgent(response.slots);
+    } catch (err) {
+      this.config.logger.error('Heartbeat error:', err);
+    }
+  }
+
+  /**
+   * Handle slots when agent is not idle.
+   * Defer all pending slots with priority boost.
+   */
+  private async handleNonIdleAgent(
+    slots: CalendarSlotResponse[],
+    agentStatus: AgentStatusValue
+  ): Promise<void> {
+    if (slots.length === 0) {
+      return;
+    }
+
+    this.config.logger.info(
+      `Agent not idle (status=${agentStatus}), deferring ${slots.length} slot(s)`
+    );
+
+    for (const slot of slots) {
+      const slotId = this.getSlotId(slot);
+
+      // Skip if already deferred this session
+      if (this.state.deferredSlotIds.has(slotId)) {
+        continue;
+      }
+
+      // Mark slot as deferred with priority boost (+1)
+      await this.deferSlot(slot);
+      this.state.deferredSlotIds.add(slotId);
+    }
+  }
+
+  /**
+   * Handle slots when agent is idle.
+   * Select highest priority slot and wake agent.
+   */
+  private async handleIdleAgent(slots: CalendarSlotResponse[]): Promise<void> {
+    if (slots.length === 0) {
+      return;
+    }
+
+    // Filter out already deferred slots in this session
+    const eligibleSlots = slots.filter(
+      (s) => !this.state.deferredSlotIds.has(this.getSlotId(s))
+    );
+
+    if (eligibleSlots.length === 0) {
+      this.logDebug('All pending slots have been deferred this session');
+      return;
+    }
+
+    // Select highest priority slot (backend already sorts by priority DESC)
+    const [selectedSlot, ...remainingSlots] = eligibleSlots;
+
+    this.config.logger.info(
+      `Selected slot for execution: id=${this.getSlotId(selectedSlot)}, ` +
+        `type=${selectedSlot.slot_type}, priority=${selectedSlot.priority}`
+    );
+
+    // Mark remaining slots as deferred
+    for (const slot of remainingSlots) {
+      await this.deferSlot(slot);
+      this.state.deferredSlotIds.add(this.getSlotId(slot));
+    }
+
+    // Check if this is a ScheduledGatewayRestart event
+    if (this.isScheduledGatewayRestart(selectedSlot)) {
+      await this.handleScheduledGatewayRestart(selectedSlot);
+      return;
+    }
+
+    // Wake agent to execute selected slot
+    await this.executeSlot(selectedSlot);
+  }
+
+  /**
+   * Check if a slot is a ScheduledGatewayRestart system event.
+   */
+  private isScheduledGatewayRestart(slot: CalendarSlotResponse): boolean {
+    if (slot.event_type !== 'system_event' || !slot.event_data) {
+      return false;
+    }
+    const sysData = slot.event_data as CalendarEventDataSystemEvent;
+    return sysData.event === 'ScheduledGatewayRestart';
+  }
+
+  /**
+   * Execute a slot by waking the agent.
+   */
+  private async executeSlot(slot: CalendarSlotResponse): Promise<void> {
+    if (this.state.isProcessing) {
+      this.config.logger.warn('Already processing a slot, deferring new slot');
+      await this.deferSlot(slot);
+      return;
+    }
+
+    this.state.isProcessing = true;
+    this.state.currentSlot = slot;
+
+    try {
+      // Mark slot as attended and ongoing before waking agent
+      const update: SlotAgentUpdate = {
+        status: SlotStatus.ONGOING,
+        started_at: this.formatTime(new Date()),
+      };
+
+      let updateSuccess: boolean;
+      if (slot.id) {
+        updateSuccess = await this.config.bridge.updateSlot(slot.id, update);
+      } else if (slot.virtual_id) {
+        const updated = await this.config.bridge.updateVirtualSlot(slot.virtual_id, update);
+        updateSuccess = updated !== null;
+        // Update slot reference if materialized
+        if (updated) {
+          this.state.currentSlot = updated;
+        }
+      } else {
+        updateSuccess = false;
+      }
+
+      if (!updateSuccess) {
+        this.config.logger.error('Failed to update slot status before execution');
+        this.state.isProcessing = false;
+        this.state.currentSlot = null;
+        return;
+      }
+
+      // Report agent status change to backend
+      const newAgentStatus = slot.slot_type === 'on_call' ? 'on_call' : 'busy';
+      await this.config.bridge.reportAgentStatus({ status: newAgentStatus });
+
+      // Build wake context for agent
+      const wakeContext = this.buildWakeContext(slot);
+
+      // Wake the agent
+      const wakeSuccess = await this.config.wakeAgent(wakeContext);
+
+      if (!wakeSuccess) {
+        this.config.logger.error('Failed to wake agent for slot execution');
+        // Revert slot to not_started status
+        await this.revertSlot(slot);
+        await this.config.bridge.reportAgentStatus({ status: 'idle' });
+        this.state.isProcessing = false;
+        this.state.currentSlot = null;
+        await this.triggerReplan('wake failure');
+        return;
+      }
+
+      // Note: isProcessing remains true until agent signals completion
+      // This is handled by external completion callback
+    } catch (err) {
+      this.config.logger.error('Error executing slot:', err);
+      this.state.isProcessing = false;
+      this.state.currentSlot = null;
+    }
+  }
+
+  /**
+   * Build the wake context for an agent based on slot details.
+   */
+  private buildWakeContext(slot: CalendarSlotResponse): AgentWakeContext {
+    const isVirtual = slot.virtual_id !== null;
+    const slotId = this.getSlotId(slot);
+
+    // Build task description based on event type
+    let taskDescription: string;
+    let prompt: string;
+
+    if (slot.event_type === 'job' && slot.event_data) {
+      const jobData = slot.event_data as CalendarEventDataJob;
+      taskDescription = `${jobData.type} ${jobData.code}`;
+      prompt = this.buildJobPrompt(slot, jobData);
+    } else if (slot.event_type === 'system_event' && slot.event_data) {
+      const sysData = slot.event_data as CalendarEventDataSystemEvent;
+      taskDescription = `System Event: ${sysData.event}`;
+      prompt = this.buildSystemPrompt(slot, sysData);
+    } else if (slot.event_type === 'entertainment') {
+      taskDescription = 'Entertainment slot';
+      prompt = this.buildEntertainmentPrompt(slot);
+    } else {
+      taskDescription = `Generic ${slot.slot_type} slot`;
+      prompt = this.buildGenericPrompt(slot);
+    }
+
+    return {
+      slot,
+      taskDescription,
+      prompt,
+      isVirtual,
+    };
+  }
+
+  /**
+   * Build prompt for job-type slots.
+   */
+  private buildJobPrompt(
+    slot: CalendarSlotResponse,
+    jobData: CalendarEventDataJob
+  ): string {
+    const duration = slot.estimated_duration;
+    const type = jobData.type;
+    const code = jobData.code;
+
+    return `You have a scheduled ${type} job to work on.
+
+Task Code: ${code}
+Estimated Duration: ${duration} minutes
+Slot Type: ${slot.slot_type}
+Priority: ${slot.priority}
+
+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.`;
+  }
+
+  /**
+   * Build prompt for system event slots.
+   */
+  private buildSystemPrompt(
+    slot: CalendarSlotResponse,
+    sysData: CalendarEventDataSystemEvent
+  ): string {
+    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.`;
+
+      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.`;
+
+      case 'ScheduledGatewayRestart':
+        return `System Event: Scheduled Gateway Restart
+
+The OpenClaw gateway is scheduled to restart soon.
+Please:
+1. Persist any important state
+2. Complete or gracefully pause current tasks
+3. Prepare for restart
+
+Time remaining: ${slot.estimated_duration} minutes.`;
+
+      default:
+        return `System Event: ${sysData.event}
+
+A system event has been scheduled. Please handle accordingly.
+Estimated time: ${slot.estimated_duration} minutes.`;
+    }
+  }
+
+  /**
+   * Build prompt for entertainment slots.
+   */
+  private buildEntertainmentPrompt(slot: CalendarSlotResponse): string {
+    return `Scheduled Entertainment Break
+
+Duration: ${slot.estimated_duration} minutes
+
+Take a break and enjoy some leisure time. This slot is reserved for non-work activities
+ to help maintain work-life balance.`;
+  }
+
+  /**
+   * Build generic prompt for slots without specific event data.
+   */
+  private buildGenericPrompt(slot: CalendarSlotResponse): string {
+    return `Scheduled Calendar Slot
+
+Type: ${slot.slot_type}
+Duration: ${slot.estimated_duration} minutes
+Priority: ${slot.priority}
+
+Please use this time for the scheduled activity.`;
+  }
+
+  /**
+   * Mark a slot as deferred with priority boost.
+   */
+  private async deferSlot(slot: CalendarSlotResponse): Promise<void> {
+    const update: SlotAgentUpdate = {
+      status: SlotStatus.DEFERRED,
+    };
+
+    try {
+      if (slot.id) {
+        await this.config.bridge.updateSlot(slot.id, update);
+      } else if (slot.virtual_id) {
+        await this.config.bridge.updateVirtualSlot(slot.virtual_id, update);
+      }
+      this.logDebug(`Deferred slot: ${this.getSlotId(slot)}`);
+    } catch (err) {
+      this.config.logger.error('Failed to defer slot:', err);
+    }
+  }
+
+  /**
+   * Revert a slot to not_started status after failed execution attempt.
+   */
+  private async revertSlot(slot: CalendarSlotResponse): Promise<void> {
+    const update: SlotAgentUpdate = {
+      status: SlotStatus.NOT_STARTED,
+      started_at: undefined,
+    };
+
+    try {
+      if (slot.id) {
+        await this.config.bridge.updateSlot(slot.id, update);
+      } else if (slot.virtual_id) {
+        await this.config.bridge.updateVirtualSlot(slot.virtual_id, update);
+      }
+    } catch (err) {
+      this.config.logger.error('Failed to revert slot:', err);
+    }
+  }
+
+  /**
+   * Complete the current slot execution.
+   * Call this when the agent finishes the task.
+   */
+  async completeCurrentSlot(actualDurationMinutes: number): Promise<void> {
+    if (!this.state.currentSlot) {
+      this.config.logger.warn('No current slot to complete');
+      return;
+    }
+
+    const slot = this.state.currentSlot;
+    const update: SlotAgentUpdate = {
+      status: SlotStatus.FINISHED,
+      actual_duration: actualDurationMinutes,
+    };
+
+    try {
+      if (slot.id) {
+        await this.config.bridge.updateSlot(slot.id, update);
+      } else if (slot.virtual_id) {
+        await this.config.bridge.updateVirtualSlot(slot.virtual_id, update);
+      }
+
+      // Report agent back to idle
+      await this.config.bridge.reportAgentStatus({ status: 'idle' });
+
+      this.config.logger.info(
+        `Completed slot ${this.getSlotId(slot)}, actual_duration=${actualDurationMinutes}min`
+      );
+    } catch (err) {
+      this.config.logger.error('Failed to complete slot:', err);
+    } finally {
+      this.state.isProcessing = false;
+      this.state.currentSlot = null;
+      await this.triggerReplan('slot completion');
+    }
+  }
+
+  /**
+   * Abort the current slot execution.
+   * Call this when the agent cannot complete the task.
+   */
+  async abortCurrentSlot(reason?: string): Promise<void> {
+    if (!this.state.currentSlot) {
+      this.config.logger.warn('No current slot to abort');
+      return;
+    }
+
+    const slot = this.state.currentSlot;
+    const update: SlotAgentUpdate = {
+      status: SlotStatus.ABORTED,
+    };
+
+    try {
+      if (slot.id) {
+        await this.config.bridge.updateSlot(slot.id, update);
+      } else if (slot.virtual_id) {
+        await this.config.bridge.updateVirtualSlot(slot.virtual_id, update);
+      }
+
+      // Report agent back to idle
+      await this.config.bridge.reportAgentStatus({ status: 'idle' });
+
+      this.config.logger.info(
+        `Aborted slot ${this.getSlotId(slot)}${reason ? `: ${reason}` : ''}`
+      );
+    } catch (err) {
+      this.config.logger.error('Failed to abort slot:', err);
+    } finally {
+      this.state.isProcessing = false;
+      this.state.currentSlot = null;
+      await this.triggerReplan('slot abort');
+    }
+  }
+
+  /**
+   * Pause the current slot execution.
+   * Call this when the agent needs to temporarily pause.
+   */
+  async pauseCurrentSlot(): Promise<void> {
+    if (!this.state.currentSlot) {
+      this.config.logger.warn('No current slot to pause');
+      return;
+    }
+
+    const slot = this.state.currentSlot;
+    const update: SlotAgentUpdate = {
+      status: SlotStatus.PAUSED,
+    };
+
+    try {
+      if (slot.id) {
+        await this.config.bridge.updateSlot(slot.id, update);
+      } else if (slot.virtual_id) {
+        await this.config.bridge.updateVirtualSlot(slot.virtual_id, update);
+      }
+
+      this.config.logger.info(`Paused slot ${this.getSlotId(slot)}`);
+    } catch (err) {
+      this.config.logger.error('Failed to pause slot:', err);
+    }
+  }
+
+  /**
+   * Resume a paused slot.
+   */
+  async resumeCurrentSlot(): Promise<void> {
+    if (!this.state.currentSlot) {
+      this.config.logger.warn('No current slot to resume');
+      return;
+    }
+
+    const slot = this.state.currentSlot;
+    const update: SlotAgentUpdate = {
+      status: SlotStatus.ONGOING,
+    };
+
+    try {
+      if (slot.id) {
+        await this.config.bridge.updateSlot(slot.id, update);
+      } else if (slot.virtual_id) {
+        await this.config.bridge.updateVirtualSlot(slot.virtual_id, update);
+      }
+
+      this.config.logger.info(`Resumed slot ${this.getSlotId(slot)}`);
+    } catch (err) {
+      this.config.logger.error('Failed to resume slot:', err);
+    }
+  }
+
+  /**
+   * Trigger an immediate replanning pass after the current slot lifecycle ends.
+   * This lets previously deferred/not-started slots compete again as soon as
+   * the agent becomes idle.
+   */
+  private async triggerReplan(reason: string): Promise<void> {
+    if (!this.state.isRunning) {
+      return;
+    }
+
+    this.logDebug(`Triggering immediate replanning after ${reason}`);
+
+    try {
+      await this.runHeartbeat();
+    } catch (err) {
+      this.config.logger.error(`Failed to trigger replanning after ${reason}:`, err);
+    }
+  }
+
+  /**
+   * Get a stable ID for a slot (real or virtual).
+   */
+  private getSlotId(slot: CalendarSlotResponse): string {
+    return slot.id?.toString() || slot.virtual_id || 'unknown';
+  }
+
+  /**
+   * Format a Date as ISO time string (HH:MM:SS).
+   */
+  private formatTime(date: Date): string {
+    return date.toTimeString().split(' ')[0];
+  }
+
+  /**
+   * Debug logging helper.
+   */
+  private logDebug(message: string): void {
+    if (this.config.debug) {
+      this.config.logger.debug(`[CalendarScheduler] ${message}`);
+    }
+  }
+
+  /**
+   * Get current scheduler state (for introspection).
+   */
+  getState(): Readonly<SchedulerState> {
+    return { ...this.state };
+  }
+
+  /**
+   * Check if scheduler is running.
+   */
+  isRunning(): boolean {
+    return this.state.isRunning;
+  }
+
+  /**
+   * Check if currently processing a slot.
+   */
+  isProcessing(): boolean {
+    return this.state.isProcessing;
+  }
+
+  /**
+   * Get the current slot being executed (if any).
+   */
+  getCurrentSlot(): CalendarSlotResponse | null {
+    return this.state.currentSlot;
+  }
+
+  /**
+   * Check if a gateway restart is pending.
+   */
+  isRestartPending(): boolean {
+    return this.state.isRestartPending;
+  }
+
+  /**
+   * Get the path to the state file.
+   */
+  getStateFilePath(): string {
+    return this.stateFilePath;
+  }
+}
+
+/**
+ * Factory function to create a CalendarScheduler from plugin context.
+ */
+export function createCalendarScheduler(
+  config: CalendarSchedulerConfig
+): CalendarScheduler {
+  return new CalendarScheduler(config);
+}

plugin/calendar/types.ts

@@ -0,0 +1,198 @@
+/**
+ * HarborForge Calendar — Plugin-side type definitions
+ *
+ * PLG-CAL-001: Define the Calendar heartbeat request/response format
+ * between the OpenClaw plugin and HarborForge backend.
+ *
+ * Request flow (plugin → backend):
+ *   POST /calendar/agent/heartbeat
+ *   Headers:
+ *     X-Agent-ID: <agent_id>          — OpenClaw $AGENT_ID of the calling agent
+ *     X-Claw-Identifier: <identifier> — HarborForge server identifier
+ *   Body (JSON):
+ *     { "claw_identifier": "...", "agent_id": "..." }
+ *
+ * Response flow (backend → plugin):
+ *   Returns list of TimeSlots pending execution for today.
+ *   The plugin uses slot.id / slot.virtual_id to update slot status
+ *   via subsequent API calls.
+ *
+ * References:
+ *   • NEXT_WAVE_DEV_DIRECTION.md §6 (Agent wakeup mechanism)
+ *   • HarborForge.Backend/app/models/calendar.py  — TimeSlot DB model
+ *   • HarborForge.Backend/app/schemas/calendar.py — TimeSlot schemas
+ *   • HarborForge.Backend/app/services/agent_heartbeat.py — BE-AGT-001
+ */
+
+// ---------------------------------------------------------------------------
+// Enums (mirror backend enums)
+// ---------------------------------------------------------------------------
+
+/** Slot type — mirrors backend SlotType enum */
+export enum SlotType {
+  WORK = 'work',
+  ON_CALL = 'on_call',
+  ENTERTAINMENT = 'entertainment',
+  SYSTEM = 'system',
+}
+
+/** Slot lifecycle status — mirrors backend SlotStatus enum */
+export enum SlotStatus {
+  NOT_STARTED = 'not_started',
+  ONGOING = 'ongoing',
+  DEFERRED = 'deferred',
+  SKIPPED = 'skipped',
+  PAUSED = 'paused',
+  FINISHED = 'finished',
+  ABORTED = 'aborted',
+}
+
+/** High-level event category — mirrors backend EventType enum */
+export enum EventType {
+  JOB = 'job',
+  ENTERTAINMENT = 'entertainment',
+  SYSTEM_EVENT = 'system_event',
+}
+
+// ---------------------------------------------------------------------------
+// Request types
+// ---------------------------------------------------------------------------
+
+/**
+ * Calendar heartbeat request body sent by the plugin to HarborForge backend.
+ *
+ * How claw_identifier is determined:
+ *   1. Read from plugin config: `config.backendUrl` is the base URL.
+ *   2. If not set, fall back to `os.hostname()` (plugin machine hostname).
+ *
+ * How agent_id is determined:
+ *   - Read from OpenClaw environment variable: `process.env.AGENT_ID`
+ *   - This is set by OpenClaw at agent startup and uniquely identifies
+ *     the running agent instance within a single OpenClaw gateway.
+ */
+export interface CalendarHeartbeatRequest {
+  /** HarborForge server/claw identifier (matches MonitoredServer.identifier) */
+  claw_identifier: string;
+  /** OpenClaw agent ID ($AGENT_ID) for this agent session */
+  agent_id: string;
+}
+
+// ---------------------------------------------------------------------------
+// Response types
+// ---------------------------------------------------------------------------
+
+/**
+ * A single calendar slot returned in the heartbeat response.
+ *
+ * For **real** (materialized) slots: `id` is set, `virtual_id` is null.
+ * For **virtual** (plan-generated) slots: `id` is null, `virtual_id`
+ * is the `plan-{plan_id}-{date}` identifier.
+ *
+ * Key fields the plugin uses:
+ *   - `id` / `virtual_id`  — to update slot status after execution
+ *   - `event_type`          — to determine what action to take
+ *   - `event_data`          — job details / system event type
+ *   - `slot_type`           — work vs on_call (affects agent status transition)
+ *   - `scheduled_at`        — planned start time (HH:MM:SS)
+ *   - `estimated_duration`  — expected minutes (for time-tracking)
+ *   - `priority`            — for multi-slot competition logic
+ *   - `status`              — current status (NotStarted / Deferred)
+ */
+export interface CalendarSlotResponse {
+  /** Real slot DB id. Null for virtual slots. */
+  id: number | null;
+  /** Virtual slot id (plan-{plan_id}-{date}). Null for real slots. */
+  virtual_id: string | null;
+  /** Owner user id */
+  user_id: number;
+  /** Calendar date */
+  date: string; // ISO date string: "YYYY-MM-DD"
+  /** Slot type */
+  slot_type: SlotType;
+  /** Estimated duration in minutes (1-50) */
+  estimated_duration: number;
+  /** Planned start time (ISO time string: "HH:MM:SS") */
+  scheduled_at: string;
+  /** Actual start time, set when slot begins (null until started) */
+  started_at: string | null;
+  /** Whether the slot has been attended */
+  attended: boolean;
+  /** Actual duration in minutes (set when slot finishes) */
+  actual_duration: number | null;
+  /** Event category */
+  event_type: EventType | null;
+  /** Event details JSON — structure depends on event_type (see below) */
+  event_data: CalendarEventData | null;
+  /** Priority 0-99, higher = more urgent */
+  priority: number;
+  /** Current lifecycle status */
+  status: SlotStatus;
+  /** Source plan id if materialized from a SchedulePlan; null otherwise */
+  plan_id: number | null;
+}
+
+/**
+ * Event data stored inside CalendarSlotResponse.event_data.
+ * The shape depends on event_type.
+ *
+ * When event_type == "job":
+ *   { "type": "Task|Support|Meeting|Essential", "code": "TASK-42", "working_sessions": ["..."] }
+ *
+ * When event_type == "system_event":
+ *   { "event": "ScheduleToday|SummaryToday|ScheduledGatewayRestart" }
+ *
+ * When event_type == "entertainment":
+ *   { /* TBD /\ }
+ */
+export interface CalendarEventDataJob {
+  type: 'Task' | 'Support' | 'Meeting' | 'Essential';
+  code: string;
+  working_sessions?: string[];
+}
+
+export interface CalendarEventDataSystemEvent {
+  event: 'ScheduleToday' | 'SummaryToday' | 'ScheduledGatewayRestart';
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type CalendarEventData = CalendarEventDataJob | CalendarEventDataSystemEvent | Record<string, any>;
+
+/**
+ * Full heartbeat response returned by GET /calendar/agent/heartbeat
+ *
+ * Fields:
+ *   slots    — list of pending TimeSlots for today (sorted by priority desc)
+ *   agent_status — current agent status from the backend's perspective
+ *                  (idle | on_call | busy | exhausted | offline)
+ */
+export interface CalendarHeartbeatResponse {
+  /** Pending slots for today — sorted by priority descending */
+  slots: CalendarSlotResponse[];
+  /** Current agent status in HarborForge */
+  agent_status: AgentStatusValue;
+  /** Human-readable message (optional) */
+  message?: string;
+}
+
+/** Agent status values — mirrors backend AgentStatus enum */
+export type AgentStatusValue = 'idle' | 'on_call' | 'busy' | 'exhausted' | 'offline';
+
+// ---------------------------------------------------------------------------
+// Slot update types (for post-execution status updates)
+// ---------------------------------------------------------------------------
+
+/**
+ * Request body for updating a real slot's status after agent execution.
+ * Called by the plugin after attending / finishing / deferring a slot.
+ *
+ * Endpoint: PATCH /calendar/slots/{slot_id}/agent-update
+ * (Plugin-facing variant that bypasses some user-level guards)
+ */
+export interface SlotAgentUpdate {
+  /** New status to set */
+  status: SlotStatus;
+  /** Actual start time (ISO time string HH:MM:SS), required when attending */
+  started_at?: string;
+  /** Actual duration in minutes, set when finishing */
+  actual_duration?: number;
+}

plugin/core/config.ts

@@ -0,0 +1,35 @@
+import { hostname } from 'os';
+
+export interface HarborForgePluginConfig {
+  enabled?: boolean;
+  backendUrl?: string;
+  identifier?: string;
+  apiKey?: string;
+  monitor_port?: number;
+  reportIntervalSec?: number;
+  httpFallbackIntervalSec?: number;
+  logLevel?: 'debug' | 'info' | 'warn' | 'error';
+  calendarEnabled?: boolean;
+  calendarHeartbeatIntervalSec?: number;
+  calendarApiKey?: string;
+  managedMonitor?: string;
+}
+
+interface PluginApiLike {
+  pluginConfig?: Record<string, unknown>;
+}
+
+export function getPluginConfig(api: PluginApiLike): HarborForgePluginConfig {
+  const cfg = (api.pluginConfig || {}) as HarborForgePluginConfig;
+  return {
+    enabled: true,
+    backendUrl: 'https://monitor.hangman-lab.top',
+    identifier: hostname(),
+    reportIntervalSec: 30,
+    httpFallbackIntervalSec: 60,
+    logLevel: 'info',
+    calendarEnabled: true,
+    calendarHeartbeatIntervalSec: 60,
+    ...cfg,
+  };
+}

plugin/core/live-config.d.ts

@@ -1,17 +0,0 @@
-export interface HarborForgeMonitorConfig {
-    enabled?: boolean;
-    backendUrl?: string;
-    identifier?: string;
-    apiKey?: string;
-    monitor_port?: number;
-    monitorPort?: number;
-    reportIntervalSec?: number;
-    httpFallbackIntervalSec?: number;
-    logLevel?: 'debug' | 'info' | 'warn' | 'error';
-}
-interface OpenClawPluginApiLike {
-    config?: Record<string, unknown>;
-}
-export declare function getLivePluginConfig(api: OpenClawPluginApiLike, fallback: HarborForgeMonitorConfig): HarborForgeMonitorConfig;
-export {};
-//# sourceMappingURL=live-config.d.ts.map

plugin/core/live-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"live-config.d.ts","sourceRoot":"","sources":["live-config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,wBAAwB;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CAChD;AAED,UAAU,qBAAqB;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,qBAAqB,EAC1B,QAAQ,EAAE,wBAAwB,GACjC,wBAAwB,CAgC1B"}

plugin/core/live-config.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLivePluginConfig = getLivePluginConfig;
-function getLivePluginConfig(api, fallback) {
-    const root = api.config || {};
-    const plugins = root.plugins || {};
-    const entries = plugins.entries || {};
-    const entry = entries['harbor-forge'] || {};
-    const cfg = entry.config || {};
-    if (Object.keys(cfg).length > 0 || Object.keys(entry).length > 0) {
-        const monitorPort = typeof cfg.monitor_port === 'number'
-            ? cfg.monitor_port
-            : typeof cfg.monitorPort === 'number'
-                ? cfg.monitorPort
-                : typeof fallback.monitor_port === 'number'
-                    ? fallback.monitor_port
-                    : fallback.monitorPort;
-        return {
-            ...fallback,
-            ...cfg,
-            monitor_port: monitorPort,
-            monitorPort,
-            enabled: typeof cfg.enabled === 'boolean'
-                ? cfg.enabled
-                : typeof entry.enabled === 'boolean'
-                    ? entry.enabled
-                    : fallback.enabled,
-        };
-    }
-    return fallback;
-}
-//# sourceMappingURL=live-config.js.map

plugin/core/live-config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"live-config.js","sourceRoot":"","sources":["live-config.ts"],"names":[],"mappings":";;AAgBA,kDAmCC;AAnCD,SAAgB,mBAAmB,CACjC,GAA0B,EAC1B,QAAkC;IAElC,MAAM,IAAI,GAAI,GAAG,CAAC,MAAkC,IAAI,EAAE,CAAC;IAC3D,MAAM,OAAO,GAAI,IAAI,CAAC,OAAmC,IAAI,EAAE,CAAC;IAChE,MAAM,OAAO,GAAI,OAAO,CAAC,OAAmC,IAAI,EAAE,CAAC;IACnE,MAAM,KAAK,GAAI,OAAO,CAAC,cAAc,CAA6B,IAAI,EAAE,CAAC;IACzE,MAAM,GAAG,GAAI,KAAK,CAAC,MAAkC,IAAI,EAAE,CAAC;IAE5D,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACjE,MAAM,WAAW,GACf,OAAO,GAAG,CAAC,YAAY,KAAK,QAAQ;YAClC,CAAC,CAAC,GAAG,CAAC,YAAY;YAClB,CAAC,CAAC,OAAO,GAAG,CAAC,WAAW,KAAK,QAAQ;gBACnC,CAAC,CAAC,GAAG,CAAC,WAAW;gBACjB,CAAC,CAAC,OAAO,QAAQ,CAAC,YAAY,KAAK,QAAQ;oBACzC,CAAC,CAAC,QAAQ,CAAC,YAAY;oBACvB,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;QAE/B,OAAO;YACL,GAAG,QAAQ;YACX,GAAG,GAAG;YACN,YAAY,EAAE,WAAW;YACzB,WAAW;YACX,OAAO,EACL,OAAO,GAAG,CAAC,OAAO,KAAK,SAAS;gBAC9B,CAAC,CAAC,GAAG,CAAC,OAAO;gBACb,CAAC,CAAC,OAAO,KAAK,CAAC,OAAO,KAAK,SAAS;oBAClC,CAAC,CAAC,KAAK,CAAC,OAAO;oBACf,CAAC,CAAC,QAAQ,CAAC,OAAO;SACG,CAAC;IAChC,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

plugin/core/live-config.ts

@@ -1,52 +0,0 @@
-export interface HarborForgeMonitorConfig {
-  enabled?: boolean;
-  backendUrl?: string;
-  identifier?: string;
-  apiKey?: string;
-  monitor_port?: number;
-  monitorPort?: number;
-  reportIntervalSec?: number;
-  httpFallbackIntervalSec?: number;
-  logLevel?: 'debug' | 'info' | 'warn' | 'error';
-}
-
-interface OpenClawPluginApiLike {
-  config?: Record<string, unknown>;
-}
-
-export function getLivePluginConfig(
-  api: OpenClawPluginApiLike,
-  fallback: HarborForgeMonitorConfig
-): HarborForgeMonitorConfig {
-  const root = (api.config as Record<string, unknown>) || {};
-  const plugins = (root.plugins as Record<string, unknown>) || {};
-  const entries = (plugins.entries as Record<string, unknown>) || {};
-  const entry = (entries['harbor-forge'] as Record<string, unknown>) || {};
-  const cfg = (entry.config as Record<string, unknown>) || {};
-
-  if (Object.keys(cfg).length > 0 || Object.keys(entry).length > 0) {
-    const monitorPort =
-      typeof cfg.monitor_port === 'number'
-        ? cfg.monitor_port
-        : typeof cfg.monitorPort === 'number'
-          ? cfg.monitorPort
-          : typeof fallback.monitor_port === 'number'
-            ? fallback.monitor_port
-            : fallback.monitorPort;
-
-    return {
-      ...fallback,
-      ...cfg,
-      monitor_port: monitorPort,
-      monitorPort,
-      enabled:
-        typeof cfg.enabled === 'boolean'
-          ? cfg.enabled
-          : typeof entry.enabled === 'boolean'
-            ? entry.enabled
-            : fallback.enabled,
-    } as HarborForgeMonitorConfig;
-  }
-
-  return fallback;
-}

plugin/core/managed-monitor.ts

@@ -0,0 +1,59 @@
+import { spawn, type ChildProcess } from 'child_process';
+import { existsSync } from 'fs';
+
+export interface ManagedMonitorConfig {
+  managedMonitor?: string;
+  backendUrl?: string;
+  identifier?: string;
+  apiKey?: string;
+  monitor_port?: number;
+  reportIntervalSec?: number;
+  logLevel?: string;
+}
+
+let monitorProcess: ChildProcess | null = null;
+
+export function startManagedMonitor(
+  logger: { info: (...args: any[]) => void; warn: (...args: any[]) => void; error: (...args: any[]) => void },
+  config: ManagedMonitorConfig,
+): void {
+  if (!config.managedMonitor) return;
+  if (monitorProcess) {
+    logger.info('HarborForge managed monitor already running');
+    return;
+  }
+  if (!existsSync(config.managedMonitor)) {
+    logger.warn(`HarborForge managed monitor path not found: ${config.managedMonitor}`);
+    return;
+  }
+
+  const args: string[] = [];
+  if (config.backendUrl) args.push('--backend-url', String(config.backendUrl));
+  if (config.identifier) args.push('--identifier', String(config.identifier));
+  if (config.apiKey) args.push('--api-key', String(config.apiKey));
+  if (config.monitor_port) args.push('--monitor-port', String(config.monitor_port));
+  if (config.reportIntervalSec) args.push('--report-interval', String(config.reportIntervalSec));
+  if (config.logLevel) args.push('--log-level', String(config.logLevel));
+
+  monitorProcess = spawn(config.managedMonitor, args, {
+    stdio: 'inherit',
+    detached: false,
+  });
+
+  monitorProcess.on('exit', (code, signal) => {
+    logger.warn(`HarborForge managed monitor exited code=${code ?? 'null'} signal=${signal ?? 'null'}`);
+    monitorProcess = null;
+  });
+
+  logger.info(`HarborForge managed monitor started: ${config.managedMonitor}`);
+}
+
+export function stopManagedMonitor(
+  logger: { info: (...args: any[]) => void; warn: (...args: any[]) => void },
+): void {
+  if (!monitorProcess) return;
+  const pid = monitorProcess.pid;
+  monitorProcess.kill('SIGTERM');
+  monitorProcess = null;
+  logger.info(`HarborForge managed monitor stopped pid=${pid ?? 'unknown'}`);
+}

plugin/core/monitor-bridge.d.ts

@@ -1,55 +0,0 @@
-/**
- * Monitor Bridge Client
- *
- * Queries the local HarborForge.Monitor bridge endpoint on MONITOR_PORT
- * to enrich plugin telemetry with host/hardware data.
- *
- * If the bridge is unreachable, all methods return null gracefully —
- * the plugin continues to function without Monitor data.
- */
-export interface MonitorHealth {
-    status: string;
-    monitor_version: string;
-    identifier: string;
-}
-export interface MonitorTelemetryResponse {
-    status: string;
-    monitor_version: string;
-    identifier: string;
-    telemetry?: {
-        identifier: string;
-        plugin_version: string;
-        cpu_pct: number;
-        mem_pct: number;
-        disk_pct: number;
-        swap_pct: number;
-        load_avg: number[];
-        uptime_seconds: number;
-        nginx_installed: boolean;
-        nginx_sites: string[];
-    };
-    last_updated?: string;
-}
-export declare class MonitorBridgeClient {
-    private baseUrl;
-    private timeoutMs;
-    constructor(port: number, timeoutMs?: number);
-    health(): Promise<MonitorHealth | null>;
-    telemetry(): Promise<MonitorTelemetryResponse | null>;
-    /**
-     * POST OpenClaw metadata to the Monitor bridge so it can enrich
-     * its heartbeat uploads with OpenClaw version, plugin version,
-     * and agent information.
-     */
-    pushOpenClawMeta(meta: OpenClawMeta): Promise<boolean>;
-    private fetchJson;
-}
-/**
- * OpenClaw metadata payload sent to the Monitor bridge.
- */
-export interface OpenClawMeta {
-    version: string;
-    plugin_version: string;
-    agents?: any[];
-}
-//# sourceMappingURL=monitor-bridge.d.ts.map

plugin/core/monitor-bridge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"monitor-bridge.d.ts","sourceRoot":"","sources":["monitor-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE;QACV,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC;QACvB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,OAAO,CAAC;QACzB,WAAW,EAAE,MAAM,EAAE,CAAC;KACvB,CAAC;IACF,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAS;gBAEd,IAAI,EAAE,MAAM,EAAE,SAAS,SAAO;IAKpC,MAAM,IAAI,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAIvC,SAAS,IAAI,OAAO,CAAC,wBAAwB,GAAG,IAAI,CAAC;IAI3D;;;;OAIG;IACG,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;YAmB9C,SAAS;CAgBxB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC;CAChB"}

plugin/core/monitor-bridge.js

@@ -1,66 +0,0 @@
-"use strict";
-/**
- * Monitor Bridge Client
- *
- * Queries the local HarborForge.Monitor bridge endpoint on MONITOR_PORT
- * to enrich plugin telemetry with host/hardware data.
- *
- * If the bridge is unreachable, all methods return null gracefully —
- * the plugin continues to function without Monitor data.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonitorBridgeClient = void 0;
-class MonitorBridgeClient {
-    baseUrl;
-    timeoutMs;
-    constructor(port, timeoutMs = 3000) {
-        this.baseUrl = `http://127.0.0.1:${port}`;
-        this.timeoutMs = timeoutMs;
-    }
-    async health() {
-        return this.fetchJson('/health');
-    }
-    async telemetry() {
-        return this.fetchJson('/telemetry');
-    }
-    /**
-     * POST OpenClaw metadata to the Monitor bridge so it can enrich
-     * its heartbeat uploads with OpenClaw version, plugin version,
-     * and agent information.
-     */
-    async pushOpenClawMeta(meta) {
-        try {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
-            const response = await fetch(`${this.baseUrl}/openclaw`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(meta),
-                signal: controller.signal,
-            });
-            clearTimeout(timeout);
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    async fetchJson(path) {
-        try {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
-            const response = await fetch(`${this.baseUrl}${path}`, {
-                signal: controller.signal,
-            });
-            clearTimeout(timeout);
-            if (!response.ok)
-                return null;
-            return (await response.json());
-        }
-        catch {
-            return null;
-        }
-    }
-}
-exports.MonitorBridgeClient = MonitorBridgeClient;
-//# sourceMappingURL=monitor-bridge.js.map

plugin/core/monitor-bridge.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"monitor-bridge.js","sourceRoot":"","sources":["monitor-bridge.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AA2BH,MAAa,mBAAmB;IACtB,OAAO,CAAS;IAChB,SAAS,CAAS;IAE1B,YAAY,IAAY,EAAE,SAAS,GAAG,IAAI;QACxC,IAAI,CAAC,OAAO,GAAG,oBAAoB,IAAI,EAAE,CAAC;QAC1C,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,MAAM;QACV,OAAO,IAAI,CAAC,SAAS,CAAgB,SAAS,CAAC,CAAC;IAClD,CAAC;IAED,KAAK,CAAC,SAAS;QACb,OAAO,IAAI,CAAC,SAAS,CAA2B,YAAY,CAAC,CAAC;IAChE,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,gBAAgB,CAAC,IAAkB;QACvC,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;YACzC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YAErE,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,WAAW,EAAE;gBACvD,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;gBAC1B,MAAM,EAAE,UAAU,CAAC,MAAM;aAC1B,CAAC,CAAC;YACH,YAAY,CAAC,OAAO,CAAC,CAAC;YAEtB,OAAO,QAAQ,CAAC,EAAE,CAAC;QACrB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,SAAS,CAAI,IAAY;QACrC,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;YACzC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YAErE,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,EAAE,EAAE;gBACrD,MAAM,EAAE,UAAU,CAAC,MAAM;aAC1B,CAAC,CAAC;YACH,YAAY,CAAC,OAAO,CAAC,CAAC;YAEtB,IAAI,CAAC,QAAQ,CAAC,EAAE;gBAAE,OAAO,IAAI,CAAC;YAC9B,OAAO,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAM,CAAC;QACtC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;CACF;AAzDD,kDAyDC"}

plugin/core/openclaw-agents.ts

@@ -0,0 +1,48 @@
+export interface OpenClawAgentInfo {
+  name: string;
+  isDefault?: boolean;
+  identity?: string;
+  workspace?: string;
+  agentDir?: string;
+  model?: string;
+  routingRules?: number;
+  routing?: string;
+}
+
+export async function listOpenClawAgents(_logger?: { debug?: (...args: any[]) => void; warn?: (...args: any[]) => void }): Promise<OpenClawAgentInfo[]> {
+  return [];
+}
+
+export function parseOpenClawAgents(text: string): OpenClawAgentInfo[] {
+  const lines = text.split(/\r?\n/);
+  const out: OpenClawAgentInfo[] = [];
+  let current: OpenClawAgentInfo | null = null;
+  const push = () => { if (current) out.push(current); current = null; };
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+    if (!line.trim() || line.startsWith("Agents:") || line.startsWith("Routing rules map") || line.startsWith("Channel status reflects")) continue;
+    if (line.startsWith("- ")) {
+      push();
+      const m = line.match(/^-\s+(.+?)(?:\s+\((default)\))?$/);
+      current = { name: m?.[1] || line.slice(2).trim(), isDefault: m?.[2] === "default" };
+      continue;
+    }
+    if (!current) continue;
+    const trimmed = line.trim();
+    const idx = trimmed.indexOf(":");
+    if (idx === -1) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const value = trimmed.slice(idx + 1).trim();
+    switch (key) {
+      case "Identity": current.identity = value; break;
+      case "Workspace": current.workspace = value; break;
+      case "Agent dir": current.agentDir = value; break;
+      case "Model": current.model = value; break;
+      case "Routing rules": { const n = Number(value); current.routingRules = Number.isFinite(n) ? n : undefined; break; }
+      case "Routing": current.routing = value; break;
+      default: break;
+    }
+  }
+  push();
+  return out;
+}

plugin/hooks/gateway-start.ts

@@ -0,0 +1,37 @@
+import { hostname } from 'os';
+import { getPluginConfig } from '../core/config.js';
+import { startManagedMonitor } from '../core/managed-monitor.js';
+
+export function registerGatewayStartHook(api: any, deps: {
+  logger: any;
+  pushMetaToMonitor: () => Promise<void>;
+  startCalendarScheduler: () => void;
+  setMetaPushInterval: (handle: ReturnType<typeof setInterval>) => void;
+}) {
+  const { logger, pushMetaToMonitor, startCalendarScheduler, setMetaPushInterval } = deps;
+
+  api.on('gateway_start', () => {
+    logger.info('HarborForge plugin active');
+    const live = getPluginConfig(api);
+
+    startManagedMonitor(logger, {
+      managedMonitor: live.managedMonitor,
+      backendUrl: live.backendUrl,
+      identifier: live.identifier,
+      apiKey: live.apiKey,
+      monitor_port: live.monitor_port,
+      reportIntervalSec: live.reportIntervalSec,
+      logLevel: live.logLevel,
+    });
+
+    const intervalSec = live.reportIntervalSec || 30;
+    setTimeout(() => void pushMetaToMonitor(), 2000);
+    setMetaPushInterval(setInterval(() => void pushMetaToMonitor(), intervalSec * 1000));
+
+    if (live.enabled !== false && live.calendarEnabled !== false) {
+      setTimeout(() => startCalendarScheduler(), 5000);
+    }
+
+    logger.info(`HarborForge startup config identifier=${live.identifier || hostname()} backend=${live.backendUrl}`);
+  });
+}

plugin/hooks/gateway-stop.ts

@@ -0,0 +1,23 @@
+import { stopManagedMonitor } from '../core/managed-monitor.js';
+
+export function registerGatewayStopHook(api: any, deps: {
+  logger: any;
+  getMetaPushInterval: () => ReturnType<typeof setInterval> | null;
+  clearMetaPushInterval: () => void;
+  stopCalendarScheduler: () => void;
+}) {
+  const { logger, getMetaPushInterval, clearMetaPushInterval, stopCalendarScheduler } = deps;
+
+  api.on('gateway_stop', () => {
+    logger.info('HarborForge plugin stopping');
+
+    const handle = getMetaPushInterval();
+    if (handle) {
+      clearInterval(handle);
+      clearMetaPushInterval();
+    }
+
+    stopCalendarScheduler();
+    stopManagedMonitor(logger);
+  });
+}

plugin/index.ts

@@ -4,13 +4,45 @@
  * Provides monitor-related tools and exposes OpenClaw metadata
  * for the HarborForge Monitor bridge (via monitor_port).
  *
+ * Also integrates with HarborForge Calendar system to wake agents
+ * for scheduled tasks (PLG-CAL-002, PLG-CAL-004).
+ *
  * Sidecar architecture has been removed. Telemetry data is now
  * served directly by the plugin when Monitor queries via the
  * local monitor_port communication path.
  */
-import { hostname, freemem, totalmem, uptime, loadavg, platform } from 'os';
+import { hostname, freemem, totalmem, uptime, loadavg, platform } from 'node:os';
-import { getLivePluginConfig, type HarborForgeMonitorConfig } from './core/live-config';
+import { definePluginEntry } from 'openclaw/plugin-sdk/plugin-entry';
-import { MonitorBridgeClient, type OpenClawMeta } from './core/monitor-bridge';
+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 {
+  createCalendarBridgeClient,
+  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;
 
 interface PluginAPI {
   logger: {
@@ -20,16 +52,52 @@ interface PluginAPI {
     warn: (...args: any[]) => void;
   };
   version?: string;
+  runtime?: {
+    version?: string;
+    config?: {
+      loadConfig?: () => any;
+    };
+  };
   config?: Record<string, unknown>;
   pluginConfig?: Record<string, unknown>;
   on: (event: string, handler: () => void) => void;
   registerTool: (factory: (ctx: any) => any) => void;
+  /** Spawn a sub-agent with task context (OpenClaw 2.1+) */
+  spawn?: (options: {
+    agentId?: string;
+    task: string;
+    model?: string;
+    timeoutSeconds?: number;
+  }) => Promise<{ sessionId: string; status: string }>;
+  /** Get current agent status */
+  getAgentStatus?: () => Promise<{ status: string } | null>;
 }
 
-export default {
+/**
-  id: 'harbor-forge',
+ * Coerce a tool execute() return value into the MCP `{ content: [...] }`
-  name: 'HarborForge',
+ * shape that the openclaw Codex tool dispatcher requires.
-  register(api: PluginAPI) {
+ *
+ * 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 {
     const logger = api.logger || {
       info: (...args: any[]) => console.log('[HarborForge]', ...args),
       error: (...args: any[]) => console.error('[HarborForge]', ...args),
@@ -37,27 +105,41 @@ export default {
       warn: (...args: any[]) => console.warn('[HarborForge]', ...args),
     };
 
-    const baseConfig: HarborForgeMonitorConfig = {
+    // Wrap api.registerTool so every tool's execute() return is coerced into
-      enabled: true,
+    // the MCP `{ content: [...] }` shape openclaw expects. See
-      backendUrl: 'https://monitor.hangman-lab.top',
+    // `ensureMcpContentShape` above.
-      identifier: '',
+    const _origRegisterTool = api.registerTool.bind(api);
-      reportIntervalSec: 30,
+    api.registerTool = (factory: (ctx: any) => any) => {
-      httpFallbackIntervalSec: 60,
+      _origRegisterTool((ctx: any) => {
-      logLevel: 'info',
+        const def = factory(ctx);
-      ...(api.pluginConfig || {}),
+        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 getLivePluginConfig(api, baseConfig);
+      return getPluginConfig(api);
+    }
+
+    /** 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?.();
+      return cfg?.agents?.list?.[0]?.id ?? cfg?.agents?.defaults?.id ?? 'unknown';
     }
 
     /**
      * Get the monitor bridge client if monitor_port is configured.
-     * Legacy alias monitorPort is still accepted.
      */
     function getBridgeClient(): MonitorBridgeClient | null {
-      const live = resolveConfig() as any;
+      const live = resolveConfig();
-      const port = live.monitor_port ?? live.monitorPort;
+      const port = live.monitor_port;
       if (!port || port <= 0) return null;
       return new MonitorBridgeClient(port);
     }
@@ -86,8 +168,8 @@ export default {
           avg15: load[2],
         },
         openclaw: {
-          version: api.version || 'unknown',
+          version: api.runtime?.version || api.version || 'unknown',
-          pluginVersion: '0.2.0',
+          pluginVersion: '0.3.4', // Bumped for PLG-CAL-004
         },
         timestamp: new Date().toISOString(),
       };
@@ -96,19 +178,53 @@ export default {
     // 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.)
+
     /**
      * 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();
       if (!bridgeClient) return;
 
+      let agentNames: string[] = [];
+      try {
+        const cfg = (api as any).config ?? api.runtime?.config?.loadConfig?.();
+        const agentsList = cfg?.agents?.list;
+        if (Array.isArray(agentsList)) {
+          agentNames = agentsList
+            .map((a: any) => typeof a === 'string' ? a : a?.name)
+            .filter(Boolean);
+        }
+      } catch { /* non-fatal */ }
+
       const meta: OpenClawMeta = {
-        version: api.version || 'unknown',
+        version: api.runtime?.version || api.version || 'unknown',
-        plugin_version: '0.2.0',
+        plugin_version: '0.3.4',
-        agents: [], // TODO: populate from api agent list when available
+        agents: agentNames.map(name => ({ name })),
       };
 
       const ok = await bridgeClient.pushOpenClawMeta(meta);
@@ -119,34 +235,384 @@ export default {
       }
     }
 
-    api.on('gateway_start', () => {
+    /**
-      logger.info('HarborForge plugin active');
+     * Get current agent status from OpenClaw.
+     * Falls back to querying backend if OpenClaw API unavailable.
+     */
+    async function getAgentStatus(): Promise<'idle' | 'on_call' | 'busy' | 'exhausted' | 'offline' | null> {
+      // Try OpenClaw API first (if available)
+      if (api.getAgentStatus) {
+        try {
+          const status = await api.getAgentStatus();
+          if (status?.status) {
+            return status.status as 'idle' | 'on_call' | 'busy' | 'exhausted' | 'offline';
+          }
+        } catch (err) {
+          logger.debug('Failed to get agent status from OpenClaw API:', err);
+        }
+      }
 
-      // Push metadata to Monitor bridge on startup and periodically.
+      // Fallback: query backend for agent status
-      // Interval aligns with typical Monitor heartbeat cycle (30s).
-      // If Monitor bridge is unreachable, pushes silently fail.
       const live = resolveConfig();
-      const intervalSec = live.reportIntervalSec || 30;
+      const agentId = resolveAgentId();
+      try {
+        const response = await fetch(`${live.backendUrl}/calendar/agent/status?agent_id=${agentId}`, {
+          headers: {
+            'X-Agent-ID': agentId,
+            'X-Claw-Identifier': live.identifier || hostname(),
+          },
+        });
+        if (response.ok) {
+          const data = await response.json();
+          return data.status;
+        }
+      } catch (err) {
+        logger.debug('Failed to get agent status from backend:', err);
+      }
 
-      // Initial push (delayed 2s to let Monitor bridge start)
+      return null;
-      setTimeout(() => pushMetaToMonitor(), 2000);
+    }
 
-      metaPushInterval = setInterval(
+    /**
-        () => pushMetaToMonitor(),
+     * Wake agent via dispatchInboundMessage — same mechanism used by Discord plugin.
-        intervalSec * 1000,
+     * 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> {
+      logger.info(`Waking agent ${agentId}: has due slots`);
+
+      const sessionKey = `agent:${agentId}:hf-wakeup`;
+
+      try {
+        const sdkPath = 'openclaw/plugin-sdk/reply-runtime';
+        const { dispatchInboundMessageWithDispatcher } = await import(
+          /* 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?.();
+        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 result = await dispatchInboundMessageWithDispatcher({
+          ctx: {
+            Body: wakeupMessage,
+            SessionKey: sessionKey,
+            From: 'harborforge-calendar',
+            Provider: 'harborforge',
+          },
+          cfg,
+          dispatcherOptions: {
+            deliver: async (payload: any) => {
+              const text = (payload.text || '').trim();
+              logger.info(`Agent ${agentId} wakeup reply: ${text.slice(0, 100)}`);
+            },
+          },
+        });
+
+        logger.info(`Agent ${agentId} dispatched: ${result?.status || 'ok'}`);
+        return true;
+
+      } catch (err: any) {
+        const msg = err?.message || err?.code || String(err);
+        const stack = err?.stack?.split('\n').slice(0, 3).join(' | ') || '';
+        logger.error(`Failed to dispatch agent for slot: ${msg} ${stack}`);
+        return false;
+      }
+    }
+
+    // (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.)
+
+    /**
+     * 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)
+      const calendarBridge = createCalendarBridgeClient(
+        api,
+        live.backendUrl || 'https://monitor.hangman-lab.top',
+        'unused' // agentId no longer needed at bridge level
       );
+
+      // Multi-agent sync + check loop
+      const scheduleCache = new MultiAgentScheduleCache();
+
+      const SYNC_INTERVAL_MS = 300_000; // 5 min
+      const CHECK_INTERVAL_MS = 30_000; // 30 sec
+
+      // Sync: pull all agent schedules from backend
+      async function runSync() {
+        try {
+          const result = await calendarBridge.syncSchedules();
+          if (result) {
+            scheduleCache.sync(result.date, result.schedules);
+            const status = scheduleCache.getStatus();
+            logger.info(`Schedule synced: ${status.agentCount} agents, ${status.totalSlots} slots`);
+          }
+        } catch (err) {
+          logger.warn(`Schedule sync failed: ${String(err)}`);
+        }
+      }
+
+      // 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;
+          }
+          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);
+            }
+          }
+        }
+      }
+
+      // Initial sync (also resets the wake-dedupe window)
+      const runSyncReset = async () => {
+        wakedSlotKeys.clear();
+        await runSync();
+      };
+      runSyncReset();
+
+      // Start intervals
+      const syncHandle = setInterval(runSyncReset, 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,
+      });
+
+      logger.info('Calendar scheduler started (multi-agent sync mode)');
+    }
+
+    /**
+     * Stop the calendar scheduler.
+     */
+    function stopCalendarScheduler(): void {
+      if (calendarScheduler) {
+        calendarScheduler.stop();
+        calendarScheduler = null;
+        logger.info('Calendar scheduler stopped');
+      }
+    }
+
+    registerGatewayStartHook(api, {
+      logger,
+      pushMetaToMonitor,
+      startCalendarScheduler,
+      setMetaPushInterval(handle) {
+        metaPushInterval = handle;
+      },
     });
 
-    api.on('gateway_stop', () => {
+    registerGatewayStopHook(api, {
-      logger.info('HarborForge plugin stopping');
+      logger,
-      if (metaPushInterval) {
+      getMetaPushInterval() {
-        clearInterval(metaPushInterval);
+        return metaPushInterval;
+      },
+      clearMetaPushInterval() {
         metaPushInterval = null;
-      }
+      },
+      stopCalendarScheduler,
     });
 
     // Tool: plugin status
-    api.registerTool(() => ({
+    api.registerTool((ctx) => ({
       name: 'harborforge_status',
       description: 'Get HarborForge plugin status and current telemetry snapshot',
       parameters: {
@@ -165,16 +631,39 @@ export default {
             : { 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;
+
         return {
           enabled: live.enabled !== false,
           config: {
             backendUrl: live.backendUrl,
             identifier: live.identifier || hostname(),
-            monitorPort: (live as any).monitor_port ?? (live as any).monitorPort ?? null,
+            monitorPort: live.monitor_port ?? null,
             reportIntervalSec: live.reportIntervalSec,
             hasApiKey: Boolean(live.apiKey),
           },
           monitorBridge,
+          calendar: calendarStatus,
           telemetry: collectTelemetry(),
         };
       },
@@ -220,6 +709,188 @@ export default {
       },
     }));
 
+    // Tool: calendar slot management
+    api.registerTool((ctx) => ({
+      name: 'harborforge_calendar_status',
+      description: 'Get current calendar scheduler status and pending slots',
+      parameters: {
+        type: 'object',
+        properties: {},
+      },
+      async execute() {
+        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(),
+          stateFilePath: calendarScheduler.getStateFilePath(),
+        };
+      },
+    }));
+
+    // Tool: complete current slot (for agent to report completion)
+    api.registerTool((ctx) => ({
+      name: 'harborforge_calendar_complete',
+      description: 'Complete the current calendar slot with actual duration',
+      parameters: {
+        type: 'object',
+        properties: {
+          actualDurationMinutes: {
+            type: 'number',
+            description: 'Actual time spent on the task in minutes',
+          },
+        },
+        required: ['actualDurationMinutes'],
+      },
+      async execute(params: { actualDurationMinutes: number }) {
+        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) => ({
+      name: 'harborforge_calendar_abort',
+      description: 'Abort the current calendar slot',
+      parameters: {
+        type: 'object',
+        properties: {
+          reason: {
+            type: 'string',
+            description: 'Reason for aborting',
+          },
+        },
+      },
+      async execute(params: { reason?: string }) {
+        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) => ({
+      name: 'harborforge_calendar_pause',
+      description: 'Pause the current calendar slot',
+      parameters: {
+        type: 'object',
+        properties: {},
+      },
+      async execute() {
+        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) => ({
+      name: 'harborforge_calendar_resume',
+      description: 'Resume the paused calendar slot',
+      parameters: {
+        type: 'object',
+        properties: {},
+      },
+      async execute() {
+        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' };
+      },
+    }));
+
+    // Tool: check ScheduledGatewayRestart status
+    api.registerTool(() => ({
+      name: 'harborforge_restart_status',
+      description: 'Check if a gateway restart is pending (PLG-CAL-004)',
+      parameters: {
+        type: 'object',
+        properties: {},
+      },
+      async execute() {
+        if (!calendarScheduler) {
+          return { error: 'Calendar scheduler not running' };
+        }
+
+        const isPending = calendarScheduler.isRestartPending();
+        const stateFilePath = calendarScheduler.getStateFilePath();
+
+        return {
+          isRestartPending: isPending,
+          stateFilePath: stateFilePath,
+          message: isPending
+            ? 'A gateway restart has been scheduled. The scheduler has been paused.'
+            : 'No gateway restart is pending.',
+        };
+      },
+    }));
+
     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

@@ -0,0 +1,25 @@
+// 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,50 +1,82 @@
 {
   "id": "harbor-forge",
   "name": "HarborForge",
-  "version": "0.2.0",
   "description": "HarborForge plugin for OpenClaw - project management, monitoring, and CLI integration",
-  "entry": "./index.js",
+  "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"
+    ]
+  },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
     "properties": {
-      "enabled": { 
+      "enabled": {
-        "type": "boolean", 
+        "type": "boolean",
         "default": true,
         "description": "Enable the HarborForge plugin"
       },
-      "backendUrl": { 
+      "backendUrl": {
-        "type": "string", 
+        "type": "string",
         "default": "https://monitor.hangman-lab.top",
-        "description": "HarborForge Monitor backend URL"
+        "description": "HarborForge backend base URL (shared by Monitor and Calendar API)"
       },
-      "identifier": { 
+      "identifier": {
         "type": "string",
-        "description": "Server identifier (auto-detected from hostname if not set)"
+        "description": "Server/claw identifier. Used as claw_identifier in Calendar heartbeat and as MonitoredServer.identifier. Auto-detected from hostname if not set."
       },
-      "apiKey": { 
+      "apiKey": {
         "type": "string",
-        "description": "API Key from HarborForge Monitor admin panel (optional but required for authentication)"
+        "description": "API Key from HarborForge Monitor admin panel (optional but required for Monitor authentication)"
       },
       "monitor_port": {
         "type": "number",
         "description": "Local port for communication between HarborForge Monitor and this plugin"
       },
-      "reportIntervalSec": { 
+      "reportIntervalSec": {
-        "type": "number", 
+        "type": "number",
         "default": 30,
         "description": "How often to report metrics (seconds)"
       },
-      "httpFallbackIntervalSec": { 
+      "httpFallbackIntervalSec": {
-        "type": "number", 
+        "type": "number",
         "default": 60,
         "description": "HTTP heartbeat interval when WS unavailable"
       },
-      "logLevel": { 
+      "logLevel": {
-        "type": "string", 
+        "type": "string",
-        "enum": ["debug", "info", "warn", "error"], 
+        "enum": ["debug", "info", "warn", "error"],
         "default": "info",
         "description": "Logging level"
+      },
+      "calendarEnabled": {
+        "type": "boolean",
+        "default": true,
+        "description": "Enable Calendar heartbeat integration (PLG-CAL-001). When enabled, plugin sends periodic heartbeat to /calendar/agent/heartbeat to receive pending TimeSlots."
+      },
+      "calendarHeartbeatIntervalSec": {
+        "type": "number",
+        "default": 60,
+        "description": "How often to send Calendar heartbeat to backend (seconds). Defaults to 60s (1 minute)."
+      },
+      "calendarApiKey": {
+        "type": "string",
+        "description": "API key for Calendar API authentication. If not set, uses apiKey or plugin auto-authentication via X-Agent-ID header."
+      },
+      "managedMonitor": {
+        "type": "string",
+        "description": "Absolute path to an installed HarborForge.Monitor binary managed by this plugin installer. If set, gateway_start/gateway_stop hooks will start/stop the monitor process automatically."
       }
     }
   }

plugin/package-lock.json

@@ -9,14 +9,14 @@
       "version": "0.2.0",
       "license": "MIT",
       "devDependencies": {
-        "@types/node": "^20.0.0",
+        "@types/node": "^20.19.41",
         "typescript": "^5.0.0"
       }
     },
     "node_modules/@types/node": {
-      "version": "20.19.37",
+      "version": "20.19.41",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.41.tgz",
-      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
+      "integrity": "sha512-ECymXOukMnOoVkC2bb1Vc/w/836DXncOg5m8Xj1RH7xSHZJWNYY6Zh7EH477vcnD5egKNNfy2RpNOmuChhFPgQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {

plugin/package.json

@@ -1,14 +1,16 @@
 {
   "name": "harbor-forge-plugin",
-  "version": "0.2.0",
+  "version": "0.3.4",
   "description": "OpenClaw plugin for HarborForge monitor bridge and CLI integration",
-  "main": "index.js",
+  "type": "module",
+  "main": "dist/index.js",
   "scripts": {
-    "build": "tsc",
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc",
     "watch": "tsc --watch"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
+    "@types/node": "^20.19.41",
     "typescript": "^5.0.0"
   },
   "license": "MIT"

plugin/tsconfig.json

@@ -1,17 +1,16 @@
 {
   "compilerOptions": {
     "target": "ES2022",
-    "module": "CommonJS",
+    "module": "nodenext",
-    "moduleResolution": "node",
+    "moduleResolution": "nodenext",
     "esModuleInterop": true,
     "strict": true,
     "skipLibCheck": true,
-    "outDir": "./",
+    "outDir": "./dist",
     "rootDir": "./",
-    "declaration": true,
+    "declaration": false,
-    "declarationMap": true,
     "sourceMap": true
   },
   "include": ["**/*.ts"],
-  "exclude": ["node_modules"]
+  "exclude": ["node_modules", "dist"]
 }

scripts/install.mjs

@@ -30,6 +30,7 @@ const PLUGIN_NAME = 'harbor-forge';
 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 args = process.argv.slice(2);
 const options = {
@@ -40,6 +41,8 @@ const options = {
   uninstall: args.includes('--uninstall'),
   installOnly: args.includes('--install'),
   installCli: args.includes('--install-cli'),
+  installMonitor: 'no',
+  monitorBranch: 'main',
 };
 
 const profileIdx = args.indexOf('--openclaw-profile-path');
@@ -47,6 +50,16 @@ if (profileIdx !== -1 && args[profileIdx + 1]) {
   options.openclawProfilePath = resolve(args[profileIdx + 1]);
 }
 
+const installMonitorIdx = args.indexOf('--install-monitor');
+if (installMonitorIdx !== -1 && args[installMonitorIdx + 1]) {
+  options.installMonitor = String(args[installMonitorIdx + 1]).toLowerCase();
+}
+
+const monitorBranchIdx = args.indexOf('--monitor-branch');
+if (monitorBranchIdx !== -1 && args[monitorBranchIdx + 1]) {
+  options.monitorBranch = String(args[monitorBranchIdx + 1]);
+}
+
 function resolveOpenclawPath() {
   if (options.openclawProfilePath) return options.openclawProfilePath;
   if (process.env.OPENCLAW_PATH) return resolve(process.env.OPENCLAW_PATH);
@@ -85,6 +98,14 @@ function setOpenclawConfig(key, value) {
   exec(`openclaw config set ${key} '${JSON.stringify(value)}' --json`, { silent: true });
 }
 
+function assertConfigValue(key, predicate, description) {
+  const value = getOpenclawConfig(key, undefined);
+  if (!predicate(value)) {
+    throw new Error(`Config verification failed for ${key}: ${description}`);
+  }
+  return value;
+}
+
 function unsetOpenclawConfig(key) {
   try { exec(`openclaw config unset ${key}`, { silent: true }); } catch {}
 }
@@ -100,6 +121,10 @@ function copyDir(src, dest, { exclude = [] } = {}) {
   }
 }
 
+function shellEscape(value) {
+  return `'${String(value).replace(/'/g, `'"'"'`)}'`;
+}
+
 function detectEnvironment() {
   const totalSteps = options.installCli ? 6 : 5;
   logStep(1, totalSteps, 'Detecting environment...');
@@ -164,6 +189,26 @@ async function build() {
   logOk('plugin compiled');
 }
 
+function installManagedMonitor(openclawPath) {
+  if (options.installMonitor !== 'yes') return null;
+  const tmpDir = join('/tmp', `harborforge-monitor-${Date.now()}`);
+  const monitorDestDir = join(openclawPath, 'plugins', PLUGIN_NAME, 'bin');
+  const binaryPath = join(monitorDestDir, 'HarborForge.Monitor');
+  mkdirSync(monitorDestDir, { recursive: true });
+  try {
+    exec(`git clone --branch ${shellEscape(options.monitorBranch)} ${shellEscape(MONITOR_REPO_URL)} ${shellEscape(tmpDir)}`, { silent: !options.verbose });
+    exec(`go build -o ${shellEscape(binaryPath)} ./cmd/harborforge-monitor`, { cwd: tmpDir, silent: !options.verbose });
+    chmodSync(binaryPath, 0o755);
+    logOk(`Managed monitor installed → ${binaryPath} (branch hint: ${options.monitorBranch})`);
+    return binaryPath;
+  } catch (err) {
+    logWarn(`Managed monitor build failed: ${err.message}`);
+    return null;
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
 function clearInstallTargets(openclawPath) {
   // Remove new plugin dir
   const destDir = join(openclawPath, 'plugins', PLUGIN_NAME);
@@ -244,7 +289,7 @@ async function install() {
   
   // Copy compiled plugin (no server directory — sidecar removed)
   mkdirSync(destDir, { recursive: true });
-  copyDir(PLUGIN_SRC_DIR, destDir);
+  copyDir(PLUGIN_SRC_DIR, destDir, { exclude: ['node_modules', '.git'] });
   logOk(`Plugin files → ${destDir}`);
   
   // Copy skills (exclude hf/ unless --install-cli)
@@ -263,7 +308,8 @@ async function install() {
   exec('npm install --omit=dev', { cwd: destDir, silent: !options.verbose });
   logOk('Runtime deps installed');
   
-  return { destDir };
+  const managedMonitorPath = installManagedMonitor(openclawPath);
+  return { destDir, managedMonitorPath };
 }
 
 async function installCli() {
@@ -321,6 +367,7 @@ async function configure() {
       paths.push(destDir); 
       setOpenclawConfig('plugins.load.paths', paths); 
     }
+    assertConfigValue('plugins.load.paths', (value) => Array.isArray(value) && value.includes(destDir), `missing ${destDir}`);
     logOk(`plugins.load.paths includes ${destDir}`);
     
     const allow = getOpenclawConfig('plugins.allow', []);
@@ -328,12 +375,35 @@ async function configure() {
       allow.push(PLUGIN_NAME); 
       setOpenclawConfig('plugins.allow', allow); 
     }
+    assertConfigValue('plugins.allow', (value) => Array.isArray(value) && value.includes(PLUGIN_NAME), `missing ${PLUGIN_NAME}`);
     logOk(`plugins.allow includes ${PLUGIN_NAME}`);
+
+    const enabledKey = `plugins.entries.${PLUGIN_NAME}.enabled`;
+    const configEnabledKey = `plugins.entries.${PLUGIN_NAME}.config.enabled`;
+    if (getOpenclawConfig(enabledKey, undefined) === undefined) {
+      setOpenclawConfig(enabledKey, true);
+    }
+    if (getOpenclawConfig(configEnabledKey, undefined) === undefined) {
+      setOpenclawConfig(configEnabledKey, true);
+    }
+    assertConfigValue(enabledKey, (value) => value === true, 'expected true');
+    assertConfigValue(configEnabledKey, (value) => value === true, 'expected true');
+
+    if (options.installMonitor === 'yes') {
+      const binaryPath = join(openclawPath, 'plugins', PLUGIN_NAME, 'bin', 'HarborForge.Monitor');
+      const managedMonitorKey = `plugins.entries.${PLUGIN_NAME}.config.managedMonitor`;
+      if (getOpenclawConfig(managedMonitorKey, undefined) === undefined) {
+        setOpenclawConfig(managedMonitorKey, binaryPath);
+      }
+      assertConfigValue(managedMonitorKey, (value) => value === binaryPath, `expected ${binaryPath}`);
+      logOk(`managedMonitor configured → ${binaryPath}`);
+    }
     
     logOk('Plugin configured (remember to set apiKey in plugins.entries.harbor-forge.config)');
     
   } catch (err) {
-    logWarn(`Config failed: ${err.message}`);
+    logErr(`Config failed: ${err.message}`);
+    throw err;
   }
 }
 
@@ -354,7 +424,7 @@ function summary() {
   log('Next steps:', 'blue');
   log(' 1. Register server in HarborForge Monitor to get apiKey', 'cyan');
   log(' 2. Edit ~/.openclaw/openclaw.json under plugins.entries.harbor-forge.config:', 'cyan');
-  log('    (prefer monitor_port; legacy monitorPort is still accepted)', 'cyan');
+  log('    (monitor_port is required for the local monitor bridge)', 'cyan');
   log('    {', 'cyan');
   log('      "plugins": {', 'cyan');
   log('        "entries": {', 'cyan');
@@ -390,6 +460,12 @@ async function uninstall() {
     rmSync(hfBinary, { force: true });
     logOk('Removed hf CLI binary');
   }
+
+  const managedDir = join(openclawPath, 'plugins', PLUGIN_NAME, 'bin');
+  if (existsSync(managedDir)) {
+    rmSync(managedDir, { recursive: true, force: true });
+    logOk('Removed managed HarborForge monitor');
+  }
   
   log('\nRun: openclaw gateway restart', 'yellow');
 }