Merge pull request 'refactor(install): clone HarborForge.Cli to /tmp instead of fixed path' (#12) from refactor/install-cli-clone-from-repo into main

`installCli()` used to look for the CLI source at a fixed path relative
to the plugin checkout: either `./HarborForge.Cli` or `../HarborForge.Cli`.
That breaks any install layout where the plugin lives on its own — the
script just logs "Skipping CLI installation" and returns. Same anti-
pattern installManagedMonitor had already fixed for the monitor binary.

Mirror the monitor flow:

  1. git clone --depth 1 --branch <cliBranch> CLI_REPO_URL → /tmp/<dir>
  2. go build -ldflags Version=<date>+<branch>-<sha> -o $openclaw/bin/hf
  3. chmod 755 + delete tmp dir on success or failure

Adds `--cli-branch <name>` (default: main) for parity with --monitor-branch.

Also stamps the binary with a real version string (was 'dev' before this
patch) so `hf version` is informative for debugging.

plugin/calendar/calendar-bridge.ts

@@ -110,6 +110,23 @@ export class CalendarBridgeClient {
     return this.sendBoolean('PATCH', url, update);
   }
 
+  /**
+   * Same as {@link updateSlot} but overrides the `X-Agent-ID` header for a
+   * single call. Used by the multi-agent scheduler handle where the bridge
+   * client is shared across agents and the constructor agentId is `'unused'`.
+   *
+   * Backend identifies the slot purely by `slotId`; the header is informational
+   * for audit. Passing the calling agent's id keeps audit/log lines correct.
+   */
+  async updateSlotAs(
+    agentId: string,
+    slotId: number,
+    update: SlotAgentUpdate
+  ): Promise<boolean> {
+    const url = `${this.baseUrl}/calendar/slots/${slotId}/agent-update`;
+    return this.sendBooleanAs(agentId, 'PATCH', url, update);
+  }
+
   /**
    * Update a virtual (plan-generated) slot's status after agent execution.
    *
@@ -264,6 +281,15 @@ export class CalendarBridgeClient {
   }
 
   private async sendBoolean(method: 'POST' | 'PATCH', url: string, body: unknown): Promise<boolean> {
+    return this.sendBooleanAs(this.config.agentId, method, url, body);
+  }
+
+  private async sendBooleanAs(
+    agentId: string,
+    method: 'POST' | 'PATCH',
+    url: string,
+    body: unknown
+  ): Promise<boolean> {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
 
@@ -272,7 +298,7 @@ export class CalendarBridgeClient {
         method,
         headers: {
           'Content-Type': 'application/json',
-          'X-Agent-ID': this.config.agentId,
+          'X-Agent-ID': agentId,
           'X-Claw-Identifier': this.config.clawIdentifier,
         },
         body: JSON.stringify(body),

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/index.ts

@@ -14,6 +14,7 @@
 import { hostname, freemem, totalmem, uptime, loadavg, platform } from 'node:os';
 import { definePluginEntry } from 'openclaw/plugin-sdk/plugin-entry';
 import { MultiAgentScheduleCache } from './calendar/schedule-cache.js';
+import { MultiAgentSchedulerHandle } from './calendar/multi-agent-handle.js';
 import { getPluginConfig } from './core/config.js';
 import { MonitorBridgeClient, type OpenClawMeta } from './core/monitor-bridge.js';
 import type { OpenClawAgentInfo } from './core/openclaw-agents.js';
@@ -21,11 +22,28 @@ import { registerGatewayStartHook } from './hooks/gateway-start.js';
 import { registerGatewayStopHook } from './hooks/gateway-stop.js';
 import {
   createCalendarBridgeClient,
-  createCalendarScheduler,
   CalendarScheduler,
-  AgentWakeContext,
 } 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: {
     info: (...args: any[]) => void;
@@ -55,6 +73,30 @@ interface PluginAPI {
   getAgentStatus?: () => Promise<{ status: string } | null>;
 }
 
+/**
+ * Coerce a tool execute() return value into the MCP `{ content: [...] }`
+ * shape that the openclaw Codex tool dispatcher requires.
+ *
+ * Background: openclaw's `convertToolContents()` does `result.content.reduce(...)`
+ * to compute total text length before flattening. Every HF tool here returned a
+ * bare object (`{ running, processing, currentSlot, ... }`) which has no
+ * `.content` field, so `undefined.reduce` threw and every call to
+ * `harborforge_*` from a Codex-harness agent surfaced as the cryptic
+ * `Cannot read properties of undefined (reading 'reduce')`. The fix is to
+ * wrap every tool's execute return; doing it at the `registerTool` boundary
+ * keeps each tool body unchanged.
+ */
+function ensureMcpContentShape(result: unknown): { content: Array<{ type: 'text'; text: string }> } {
+  if (
+    result && typeof result === 'object' &&
+    Array.isArray((result as { content?: unknown }).content)
+  ) {
+    return result as { content: Array<{ type: 'text'; text: string }> };
+  }
+  const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+  return { content: [{ type: 'text', text }] };
+}
+
 function register(api: PluginAPI): void {
     const logger = api.logger || {
       info: (...args: any[]) => console.log('[HarborForge]', ...args),
@@ -63,6 +105,22 @@ function register(api: PluginAPI): void {
       warn: (...args: any[]) => console.warn('[HarborForge]', ...args),
     };
 
+    // Wrap api.registerTool so every tool's execute() return is coerced into
+    // the MCP `{ content: [...] }` shape openclaw expects. See
+    // `ensureMcpContentShape` above.
+    const _origRegisterTool = api.registerTool.bind(api);
+    api.registerTool = (factory: (ctx: any) => any) => {
+      _origRegisterTool((ctx: any) => {
+        const def = factory(ctx);
+        if (!def || typeof def.execute !== 'function') return def;
+        const origExecute = def.execute;
+        return {
+          ...def,
+          execute: async (...args: any[]) => ensureMcpContentShape(await origExecute(...args)),
+        };
+      });
+    };
+
     function resolveConfig() {
       return getPluginConfig(api);
     }
@@ -70,7 +128,9 @@ function register(api: PluginAPI): void {
     /** Resolve agent ID from env, config, or fallback. */
     function resolveAgentId(): string {
       if (process.env.AGENT_ID) return process.env.AGENT_ID;
-      const cfg = api.runtime?.config?.loadConfig?.();
+      // 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';
     }
 
@@ -109,7 +169,7 @@ function register(api: PluginAPI): void {
         },
         openclaw: {
           version: api.runtime?.version || api.version || 'unknown',
-          pluginVersion: '0.3.1', // Bumped for PLG-CAL-004
+          pluginVersion: '0.3.4', // Bumped for PLG-CAL-004
         },
         timestamp: new Date().toISOString(),
       };
@@ -118,13 +178,33 @@ function register(api: PluginAPI): void {
     // Periodic metadata push interval handle
     let metaPushInterval: ReturnType<typeof setInterval> | null = null;
 
-    // Calendar scheduler instance
-    let calendarScheduler: CalendarScheduler | 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();
@@ -132,7 +212,7 @@ function register(api: PluginAPI): void {
 
       let agentNames: string[] = [];
       try {
-        const cfg = api.runtime?.config?.loadConfig?.();
+        const cfg = (api as any).config ?? api.runtime?.config?.loadConfig?.();
         const agentsList = cfg?.agents?.list;
         if (Array.isArray(agentsList)) {
           agentNames = agentsList
@@ -143,7 +223,7 @@ function register(api: PluginAPI): void {
 
       const meta: OpenClawMeta = {
         version: api.runtime?.version || api.version || 'unknown',
-        plugin_version: '0.3.1',
+        plugin_version: '0.3.4',
         agents: agentNames.map(name => ({ name })),
       };
 
@@ -248,10 +328,22 @@ function register(api: PluginAPI): void {
           )}\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. Follow the \`hf-wakeup\` workflow of skill ` +
-          `\`hf-hangman-lab\` to proceed. Only reply \`WAKEUP_OK\` in this ` +
-          `session.${slotBlock}`;
+          `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: {
@@ -280,42 +372,23 @@ function register(api: PluginAPI): void {
       }
     }
 
-    /**
-     * Track session completion and update slot status accordingly.
-     */
-    function trackSessionCompletion(sessionId: string, context: AgentWakeContext): void {
-      // Poll for session completion (simplified approach)
-      // In production, this would use webhooks or event streaming
-      const pollInterval = 30000; // 30 seconds
-      const maxDuration = context.slot.estimated_duration * 60 * 1000; // Convert to ms
-      const startTime = Date.now();
-
-      const poll = async () => {
-        if (!calendarScheduler) return;
-
-        const elapsed = Date.now() - startTime;
-
-        // Check if session is complete (would use actual API in production)
-        // For now, estimate completion based on duration
-        if (elapsed >= maxDuration) {
-          // Assume completion
-          const actualMinutes = Math.round(elapsed / 60000);
-          await calendarScheduler.completeCurrentSlot(actualMinutes);
-          return;
-        }
-
-        // Continue polling
-        setTimeout(poll, pollInterval);
-      };
-
-      // Start polling
-      setTimeout(poll, pollInterval);
-    }
+    // (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)
@@ -345,6 +418,94 @@ function register(api: PluginAPI): void {
         }
       }
 
+      // Cross-plugin exposure: agent status lookup for other plugins
+      // (currently Fabric.OpenclawPlugin uses this to skip delivering
+      // `announce` channel messages to busy agents — see DIALECTIC-V2
+      // design doc, Phase 1). Backed by calendarBridge.getAgentStatus
+      // with a small TTL cache to avoid hammering the HF backend.
+      type HfStatus = 'idle' | 'on_call' | 'busy' | 'exhausted' | 'offline';
+      const HF_STATUS_CACHE_TTL_MS = 30_000;
+      const hfStatusCache = new Map<string, { status: HfStatus; at: number }>();
+      const _G = globalThis as Record<string, unknown>;
+      _G['__hfAgentStatus'] = {
+        async get(agentId: string): Promise<HfStatus | undefined> {
+          if (!agentId) return undefined;
+          const cached = hfStatusCache.get(agentId);
+          if (cached && Date.now() - cached.at < HF_STATUS_CACHE_TTL_MS) {
+            return cached.status;
+          }
+          try {
+            const status = await calendarBridge.getAgentStatus(agentId);
+            if (status) {
+              const typed = status as HfStatus;
+              hfStatusCache.set(agentId, { status: typed, at: Date.now() });
+              return typed;
+            }
+          } catch {
+            /* fall through to cached-or-undefined */
+          }
+          return cached?.status;
+        },
+
+        /**
+         * Approximate "does agent have an on_call slot covering [from, to]?"
+         * for cross-plugin pre-check use (currently:
+         * Dialectic.OpenclawPlugin's signup HF coverage).
+         *
+         * v1 honest scope: we only have today's slots in scheduleCache
+         * (synced from /calendar/sync which is today-only). Returns:
+         *   - true  iff window is same-day AND some cached on_call slot
+         *           starts <= from AND ends >= to
+         *   - false iff window is same-day AND no such slot
+         *   - undefined for cross-day windows OR cache empty for this
+         *     agent (caller treats undefined as "I don't know" — see
+         *     Dialectic plugin's hf-precheck.ts which degrades to
+         *     "skipped" gracefully)
+         *
+         * Phase TBD: when HF backend ships a `/calendar/slots?agent&from&to`
+         * endpoint, swap this to call it for arbitrary windows. Until then,
+         * same-day-only coverage gates ~all debates created by analyze-intel
+         * (which schedules <2h windows) without needing a backend change.
+         */
+        async hasOnCallCovering(
+          agentId: string,
+          fromIso: string,
+          toIso: string,
+        ): Promise<boolean | undefined> {
+          if (!agentId || !fromIso || !toIso) return undefined;
+          const from = new Date(fromIso);
+          const to = new Date(toIso);
+          if (isNaN(from.getTime()) || isNaN(to.getTime())) return undefined;
+          if (!(from < to)) return undefined;
+          // Cross-day → cache only has today; can't decide.
+          const fromDate = from.toISOString().slice(0, 10);
+          const toDate = to.toISOString().slice(0, 10);
+          if (fromDate !== toDate) return undefined;
+          // Cache's cachedDate must match our window's date.
+          const cacheStatus = scheduleCache.getStatus();
+          if (cacheStatus.cachedDate !== fromDate) return undefined;
+          const slots = scheduleCache.getAgentSlots(agentId);
+          if (slots.length === 0) return undefined; // cache empty for this agent — can't decide
+          for (const s of slots) {
+            if (s.slot_type !== 'on_call') continue;
+            // status: ignore aborted/cancelled, accept not_started / ongoing / finished
+            if (s.status === 'aborted' || s.status === 'cancelled') continue;
+            const startStr = s.scheduled_at;
+            if (typeof startStr !== 'string') continue;
+            // scheduled_at can be HH:MM:SS (cache-relative date) or full ISO
+            const start =
+              /^\d{2}:\d{2}(:\d{2})?$/.test(startStr)
+                ? new Date(`${fromDate}T${startStr}Z`)
+                : new Date(startStr);
+            if (isNaN(start.getTime())) continue;
+            const dur = typeof s.estimated_duration === 'number' ? s.estimated_duration : 0;
+            const end = new Date(start.getTime() + dur * 60_000);
+            if (start <= from && end >= to) return true;
+          }
+          return false;
+        },
+      };
+
       // Track wakes already dispatched for a slot in the current sync
       // window — the simplified inline scheduler does not PATCH slot
       // status server-side, so without dedupe the check loop re-wakes
@@ -381,6 +542,13 @@ function register(api: PluginAPI): void {
           // 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);
@@ -400,14 +568,14 @@ function register(api: PluginAPI): void {
       const syncHandle = setInterval(runSyncReset, SYNC_INTERVAL_MS);
       const checkHandle = setInterval(runCheck, CHECK_INTERVAL_MS);
 
-      // Store handles for cleanup (reuse calendarScheduler variable)
-      (calendarScheduler as any) = {
-        stop() {
-          clearInterval(syncHandle);
-          clearInterval(checkHandle);
-          logger.info('Calendar scheduler stopped');
-        },
-      };
+      // 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)');
     }
@@ -444,7 +612,7 @@ function register(api: PluginAPI): void {
     });
 
     // Tool: plugin status
-    api.registerTool(() => ({
+    api.registerTool((ctx) => ({
       name: 'harborforge_status',
       description: 'Get HarborForge plugin status and current telemetry snapshot',
       parameters: {
@@ -463,13 +631,27 @@ function register(api: PluginAPI): void {
             : { connected: false, error: 'Monitor bridge unreachable' };
         }
 
-        // Get calendar scheduler status
-        const calendarStatus = calendarScheduler ? {
-          running: calendarScheduler.isRunning(),
-          processing: calendarScheduler.isProcessing(),
-          currentSlot: calendarScheduler.getCurrentSlot(),
-          isRestartPending: calendarScheduler.isRestartPending(),
-        } : null;
+        // 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,
@@ -528,7 +710,7 @@ function register(api: PluginAPI): void {
     }));
 
     // Tool: calendar slot management
-    api.registerTool(() => ({
+    api.registerTool((ctx) => ({
       name: 'harborforge_calendar_status',
       description: 'Get current calendar scheduler status and pending slots',
       parameters: {
@@ -539,10 +721,24 @@ function register(api: PluginAPI): void {
         if (!calendarScheduler) {
           return { error: 'Calendar scheduler not running' };
         }
-
+        const callerAgentId = ctx?.agentId ?? resolveAgentId();
+        if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
+          return {
+            running: calendarScheduler.isRunning(),
+            processing: calendarScheduler.isProcessing(),
+            mode: 'multi-agent',
+            callerAgentId,
+            currentSlot: calendarScheduler.resolveCurrentSlot(callerAgentId),
+            agentSlots: calendarScheduler.cachedSlotsFor(callerAgentId),
+            state: calendarScheduler.getState(),
+            isRestartPending: calendarScheduler.isRestartPending(),
+            stateFilePath: calendarScheduler.getStateFilePath(),
+          };
+        }
         return {
           running: calendarScheduler.isRunning(),
           processing: calendarScheduler.isProcessing(),
+          mode: 'single-agent',
           currentSlot: calendarScheduler.getCurrentSlot(),
           state: calendarScheduler.getState(),
           isRestartPending: calendarScheduler.isRestartPending(),
@@ -552,7 +748,7 @@ function register(api: PluginAPI): void {
     }));
 
     // Tool: complete current slot (for agent to report completion)
-    api.registerTool(() => ({
+    api.registerTool((ctx) => ({
       name: 'harborforge_calendar_complete',
       description: 'Complete the current calendar slot with actual duration',
       parameters: {
@@ -569,14 +765,20 @@ function register(api: PluginAPI): void {
         if (!calendarScheduler) {
           return { error: 'Calendar scheduler not running' };
         }
-
+        if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
+          const agentId = ctx?.agentId ?? resolveAgentId();
+          const res = await calendarScheduler.completeSlot(agentId, params.actualDurationMinutes);
+          return res.ok
+            ? { success: true, message: 'Slot completed', slot: res.slot }
+            : { error: res.error };
+        }
         await calendarScheduler.completeCurrentSlot(params.actualDurationMinutes);
         return { success: true, message: 'Slot completed' };
       },
     }));
 
     // Tool: abort current slot (for agent to report failure)
-    api.registerTool(() => ({
+    api.registerTool((ctx) => ({
       name: 'harborforge_calendar_abort',
       description: 'Abort the current calendar slot',
       parameters: {
@@ -592,14 +794,20 @@ function register(api: PluginAPI): void {
         if (!calendarScheduler) {
           return { error: 'Calendar scheduler not running' };
         }
-
+        if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
+          const agentId = ctx?.agentId ?? resolveAgentId();
+          const res = await calendarScheduler.abortSlot(agentId, params.reason);
+          return res.ok
+            ? { success: true, message: 'Slot aborted', slot: res.slot }
+            : { error: res.error };
+        }
         await calendarScheduler.abortCurrentSlot(params.reason);
         return { success: true, message: 'Slot aborted' };
       },
     }));
 
     // Tool: pause current slot
-    api.registerTool(() => ({
+    api.registerTool((ctx) => ({
       name: 'harborforge_calendar_pause',
       description: 'Pause the current calendar slot',
       parameters: {
@@ -610,14 +818,20 @@ function register(api: PluginAPI): void {
         if (!calendarScheduler) {
           return { error: 'Calendar scheduler not running' };
         }
-
+        if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
+          const agentId = ctx?.agentId ?? resolveAgentId();
+          const res = await calendarScheduler.pauseSlot(agentId);
+          return res.ok
+            ? { success: true, message: 'Slot paused', slot: res.slot }
+            : { error: res.error };
+        }
         await calendarScheduler.pauseCurrentSlot();
         return { success: true, message: 'Slot paused' };
       },
     }));
 
     // Tool: resume current slot
-    api.registerTool(() => ({
+    api.registerTool((ctx) => ({
       name: 'harborforge_calendar_resume',
       description: 'Resume the paused calendar slot',
       parameters: {
@@ -628,7 +842,13 @@ function register(api: PluginAPI): void {
         if (!calendarScheduler) {
           return { error: 'Calendar scheduler not running' };
         }
-
+        if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
+          const agentId = ctx?.agentId ?? resolveAgentId();
+          const res = await calendarScheduler.resumeSlot(agentId);
+          return res.ok
+            ? { success: true, message: 'Slot resumed', slot: res.slot }
+            : { error: res.error };
+        }
         await calendarScheduler.resumeCurrentSlot();
         return { success: true, message: 'Slot resumed' };
       },

plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harbor-forge-plugin",
-  "version": "0.2.0",
+  "version": "0.3.4",
   "description": "OpenClaw plugin for HarborForge monitor bridge and CLI integration",
   "type": "module",
   "main": "dist/index.js",

scripts/install.mjs

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