@cleocode/core 2026.3.72 → 2026.3.74

package/dist/index.js

@@ -631,6 +631,13 @@ var init_discovery = __esm({
 });
 
 // packages/core/src/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  closeLogger: () => closeLogger,
+  getLogDir: () => getLogDir,
+  getLogger: () => getLogger,
+  initLogger: () => initLogger
+});
 import { existsSync as existsSync2 } from "node:fs";
 import { dirname, join as join3 } from "node:path";
 import pino from "pino";
@@ -732,22 +739,42 @@ __export(registry_exports, {
   HookRegistry: () => HookRegistry,
   hooks: () => hooks
 });
-var DEFAULT_HOOK_CONFIG, HookRegistry, hooks;
+var LEGACY_EVENT_MAP, DEFAULT_HOOK_CONFIG, HookRegistry, hooks;
 var init_registry = __esm({
   "packages/core/src/hooks/registry.ts"() {
     "use strict";
     init_logger();
+    LEGACY_EVENT_MAP = {
+      onSessionStart: "SessionStart",
+      onSessionEnd: "SessionEnd",
+      onToolStart: "PreToolUse",
+      onToolComplete: "PostToolUse",
+      onFileChange: "Notification",
+      onError: "PostToolUseFailure",
+      onPromptSubmit: "PromptSubmit",
+      onResponseComplete: "ResponseComplete"
+    };
     DEFAULT_HOOK_CONFIG = {
       enabled: true,
       events: {
-        onSessionStart: true,
-        onSessionEnd: true,
-        onToolStart: true,
-        onToolComplete: true,
-        onFileChange: true,
-        onError: true,
-        onPromptSubmit: true,
-        onResponseComplete: true,
+        // CAAMP canonical events (16)
+        SessionStart: true,
+        SessionEnd: true,
+        PromptSubmit: true,
+        ResponseComplete: true,
+        PreToolUse: true,
+        PostToolUse: true,
+        PostToolUseFailure: true,
+        PermissionRequest: true,
+        SubagentStart: true,
+        SubagentStop: true,
+        PreModel: true,
+        PostModel: true,
+        PreCompact: true,
+        PostCompact: true,
+        Notification: true,
+        ConfigChange: true,
+        // CLEO internal coordination events (5)
         onWorkAvailable: true,
         onAgentSpawn: true,
         onAgentComplete: true,
@@ -758,12 +785,33 @@ var init_registry = __esm({
     HookRegistry = class {
       handlers = /* @__PURE__ */ new Map();
       config = DEFAULT_HOOK_CONFIG;
+      /**
+       * Resolve a potentially-legacy event name to its canonical equivalent.
+       *
+       * If the event name matches a known legacy `on`-prefix name, it is
+       * remapped and a deprecation warning is logged. Unknown names pass through
+       * unchanged so callers using the new canonical names are unaffected.
+       */
+      resolveEvent(event) {
+        const canonical = LEGACY_EVENT_MAP[event];
+        if (canonical) {
+          getLogger("hooks").warn(
+            { legacyEvent: event, canonicalEvent: canonical },
+            `[DEPRECATED] Hook event '${event}' has been renamed to '${canonical}'. Update your handler registration.`
+          );
+          return canonical;
+        }
+        return event;
+      }
       /**
        * Register a hook handler for a specific event.
        *
        * Handlers are sorted by priority (highest first) and executed
        * in parallel when the event is dispatched.
        *
+       * Backward compatibility: legacy `on`-prefix event names are automatically
+       * remapped to their canonical equivalents.
+       *
        * @param registration - The hook registration containing event, handler, priority, and ID
        * @returns A function to unregister the handler
        *
@@ -771,7 +819,7 @@ var init_registry = __esm({
        * ```typescript
        * const unregister = hooks.register({
        *   id: 'my-handler',
-       *   event: 'onSessionStart',
+       *   event: 'SessionStart',
        *   handler: async (root, payload) => { console.log('Session started'); },
        *   priority: 100
        * });
@@ -780,12 +828,14 @@ var init_registry = __esm({
        * ```
        */
       register(registration) {
-        const list = this.handlers.get(registration.event) || [];
-        list.push(registration);
+        const resolvedEvent = this.resolveEvent(registration.event);
+        const resolvedRegistration = { ...registration, event: resolvedEvent };
+        const list = this.handlers.get(resolvedEvent) || [];
+        list.push(resolvedRegistration);
         list.sort((a, b) => b.priority - a.priority);
-        this.handlers.set(registration.event, list);
+        this.handlers.set(resolvedEvent, list);
         return () => {
-          const handlers = this.handlers.get(registration.event);
+          const handlers = this.handlers.get(resolvedEvent);
           if (handlers) {
             const idx = handlers.findIndex((h) => h.id === registration.id);
             if (idx !== -1) handlers.splice(idx, 1);
@@ -799,14 +849,17 @@ var init_registry = __esm({
        * execution. Errors in individual handlers are logged but do not block
        * other handlers or propagate to the caller.
        *
-       * @param event - The CAAMP hook event to dispatch
+       * Backward compatibility: legacy `on`-prefix event names are automatically
+       * remapped to their canonical equivalents.
+       *
+       * @param event - The CAAMP canonical hook event to dispatch
        * @param projectRoot - The project root directory path
        * @param payload - The event payload (typed by event)
        * @returns Promise that resolves when all handlers have completed
        *
        * @example
        * ```typescript
-       * await hooks.dispatch('onSessionStart', '/project', {
+       * await hooks.dispatch('SessionStart', '/project', {
        *   timestamp: new Date().toISOString(),
        *   sessionId: 'sess-123',
        *   name: 'My Session',
@@ -816,15 +869,19 @@ var init_registry = __esm({
        */
       async dispatch(event, projectRoot, payload) {
         if (!this.config.enabled) return;
-        if (!this.config.events[event]) return;
-        const handlers = this.handlers.get(event);
+        const resolvedEvent = this.resolveEvent(event);
+        if (!this.config.events[resolvedEvent]) return;
+        const handlers = this.handlers.get(resolvedEvent);
         if (!handlers || handlers.length === 0) return;
         await Promise.allSettled(
           handlers.map(async (reg) => {
             try {
               await reg.handler(projectRoot, payload);
             } catch (error40) {
-              getLogger("hooks").warn({ err: error40, hookId: reg.id, event }, "Hook handler failed");
+              getLogger("hooks").warn(
+                { err: error40, hookId: reg.id, event: resolvedEvent },
+                "Hook handler failed"
+              );
             }
           })
         );
@@ -833,12 +890,14 @@ var init_registry = __esm({
        * Check if a specific event is currently enabled.
        *
        * Both the global enabled flag and the per-event flag must be true.
+       * Automatically resolves legacy `on`-prefix event names.
        *
        * @param event - The CAAMP hook event to check
        * @returns True if the event is enabled
        */
       isEnabled(event) {
-        return this.config.enabled && this.config.events[event];
+        const resolvedEvent = this.resolveEvent(event);
+        return this.config.enabled && this.config.events[resolvedEvent];
       }
       /**
        * Update the hook system configuration.
@@ -850,7 +909,7 @@ var init_registry = __esm({
        * @example
        * ```typescript
        * hooks.setConfig({ enabled: false }); // Disable all hooks
-       * hooks.setConfig({ events: { onError: false } }); // Disable specific event
+       * hooks.setConfig({ events: { PostToolUseFailure: false } }); // Disable specific event
        * ```
        */
       setConfig(config2) {
@@ -868,12 +927,14 @@ var init_registry = __esm({
        * List all registered handlers for a specific event.
        *
        * Returns handlers in priority order (highest first).
+       * Automatically resolves legacy `on`-prefix event names.
        *
        * @param event - The CAAMP hook event
        * @returns Array of hook registrations
        */
       listHandlers(event) {
-        return [...this.handlers.get(event) || []];
+        const resolvedEvent = this.resolveEvent(event);
+        return [...this.handlers.get(resolvedEvent) || []];
       }
     };
     hooks = new HookRegistry();
@@ -13584,7 +13645,7 @@ async function saveJson(filePath, data, options) {
     }
     await atomicWriteJson(filePath, data, { indent: options?.indent });
     Promise.resolve().then(() => (init_registry(), registry_exports)).then(
-      ({ hooks: h }) => h.dispatch("onFileChange", process.cwd(), {
+      ({ hooks: h }) => h.dispatch("Notification", process.cwd(), {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         filePath,
         changeType: "write"
@@ -18379,13 +18440,13 @@ var init_session_hooks = __esm({
     init_memory_bridge_refresh();
     hooks.register({
       id: "brain-session-start",
-      event: "onSessionStart",
+      event: "SessionStart",
       handler: handleSessionStart,
       priority: 100
     });
     hooks.register({
       id: "brain-session-end",
-      event: "onSessionEnd",
+      event: "SessionEnd",
       handler: handleSessionEnd,
       priority: 100
     });
@@ -18432,13 +18493,13 @@ var init_task_hooks = __esm({
     init_memory_bridge_refresh();
     hooks.register({
       id: "brain-tool-start",
-      event: "onToolStart",
+      event: "PreToolUse",
       handler: handleToolStart,
       priority: 100
     });
     hooks.register({
       id: "brain-tool-complete",
-      event: "onToolComplete",
+      event: "PostToolUse",
       handler: handleToolComplete,
       priority: 100
     });
@@ -18468,7 +18529,7 @@ var init_error_hooks = __esm({
     init_registry();
     hooks.register({
       id: "brain-error",
-      event: "onError",
+      event: "PostToolUseFailure",
       handler: handleError,
       priority: 100
     });
@@ -18499,6 +18560,7 @@ async function isFileCaptureEnabled(projectRoot) {
   }
 }
 async function handleFileChange(projectRoot, payload) {
+  if (!payload.filePath || !payload.changeType) return;
   if (!await isFileCaptureEnabled(projectRoot)) return;
   const now = Date.now();
   const lastWrite = recentWrites.get(payload.filePath);
@@ -18545,7 +18607,7 @@ var init_file_hooks = __esm({
     ];
     hooks.register({
       id: "brain-file-change",
-      event: "onFileChange",
+      event: "Notification",
       handler: handleFileChange,
       priority: 100
     });
@@ -18599,22 +18661,51 @@ async function handleResponseComplete(projectRoot, payload) {
     if (!isMissingBrainSchemaError4(err)) throw err;
   }
 }
+async function handleSystemNotification(projectRoot, payload) {
+  if (payload.filePath || payload.changeType) return;
+  if (!payload.message) return;
+  try {
+    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig3(projectRoot);
+    if (!config2.brain?.autoCapture) return;
+  } catch {
+    return;
+  }
+  const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
+  try {
+    await observeBrain2(projectRoot, {
+      text: `System notification: ${payload.message}`,
+      title: `Notification: ${payload.message.slice(0, 60)}`,
+      type: "discovery",
+      sourceSessionId: payload.sessionId,
+      sourceType: "agent"
+    });
+  } catch (err) {
+    if (!isMissingBrainSchemaError4(err)) throw err;
+  }
+}
 var init_mcp_hooks = __esm({
   "packages/core/src/hooks/handlers/mcp-hooks.ts"() {
     "use strict";
     init_registry();
     hooks.register({
       id: "brain-prompt-submit",
-      event: "onPromptSubmit",
+      event: "PromptSubmit",
       handler: handlePromptSubmit,
       priority: 100
     });
     hooks.register({
       id: "brain-response-complete",
-      event: "onResponseComplete",
+      event: "ResponseComplete",
       handler: handleResponseComplete,
       priority: 100
     });
+    hooks.register({
+      id: "brain-system-notification",
+      event: "Notification",
+      handler: handleSystemNotification,
+      priority: 90
+    });
   }
 });
 
@@ -18691,19 +18782,158 @@ var init_work_capture_hooks = __esm({
     ]);
     hooks.register({
       id: "work-capture-prompt-submit",
-      event: "onPromptSubmit",
+      event: "PromptSubmit",
       handler: handleWorkPromptSubmit,
       priority: 90
     });
     hooks.register({
       id: "work-capture-response-complete",
-      event: "onResponseComplete",
+      event: "ResponseComplete",
       handler: handleWorkResponseComplete,
       priority: 90
     });
   }
 });
 
+// packages/core/src/hooks/handlers/agent-hooks.ts
+function isMissingBrainSchemaError6(err) {
+  if (!(err instanceof Error)) return false;
+  const message = String(err.message || "").toLowerCase();
+  return message.includes("no such table") && message.includes("brain_");
+}
+async function isAutoCaptureEnabled(projectRoot) {
+  try {
+    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig3(projectRoot);
+    return config2.brain?.autoCapture ?? false;
+  } catch {
+    return false;
+  }
+}
+async function handleSubagentStart(projectRoot, payload) {
+  if (!await isAutoCaptureEnabled(projectRoot)) return;
+  const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
+  const rolePart = payload.role ? ` role=${payload.role}` : "";
+  const taskPart = payload.taskId ? ` task=${payload.taskId}` : "";
+  try {
+    await observeBrain2(projectRoot, {
+      text: `Subagent spawned: ${payload.agentId}${rolePart}${taskPart}`,
+      title: `Subagent start: ${payload.agentId}`,
+      type: "discovery",
+      sourceSessionId: payload.sessionId,
+      sourceType: "agent"
+    });
+  } catch (err) {
+    if (!isMissingBrainSchemaError6(err)) throw err;
+  }
+}
+async function handleSubagentStop(projectRoot, payload) {
+  if (!await isAutoCaptureEnabled(projectRoot)) return;
+  const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
+  const statusPart = payload.status ? ` status=${payload.status}` : "";
+  const taskPart = payload.taskId ? ` task=${payload.taskId}` : "";
+  const summaryPart = payload.summary ? `
+Summary: ${payload.summary}` : "";
+  try {
+    await observeBrain2(projectRoot, {
+      text: `Subagent completed: ${payload.agentId}${statusPart}${taskPart}${summaryPart}`,
+      title: `Subagent stop: ${payload.agentId}`,
+      type: "change",
+      sourceSessionId: payload.sessionId,
+      sourceType: "agent"
+    });
+  } catch (err) {
+    if (!isMissingBrainSchemaError6(err)) throw err;
+  }
+}
+var init_agent_hooks = __esm({
+  "packages/core/src/hooks/handlers/agent-hooks.ts"() {
+    "use strict";
+    init_registry();
+    hooks.register({
+      id: "brain-subagent-start",
+      event: "SubagentStart",
+      handler: handleSubagentStart,
+      priority: 100
+    });
+    hooks.register({
+      id: "brain-subagent-stop",
+      event: "SubagentStop",
+      handler: handleSubagentStop,
+      priority: 100
+    });
+  }
+});
+
+// packages/core/src/hooks/handlers/context-hooks.ts
+function isMissingBrainSchemaError7(err) {
+  if (!(err instanceof Error)) return false;
+  const message = String(err.message || "").toLowerCase();
+  return message.includes("no such table") && message.includes("brain_");
+}
+async function isAutoCaptureEnabled2(projectRoot) {
+  try {
+    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig3(projectRoot);
+    return config2.brain?.autoCapture ?? false;
+  } catch {
+    return false;
+  }
+}
+async function handlePreCompact(projectRoot, payload) {
+  if (!await isAutoCaptureEnabled2(projectRoot)) return;
+  const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
+  const tokensPart = payload.tokensBefore != null ? ` (~${payload.tokensBefore.toLocaleString()} tokens)` : "";
+  const reasonPart = payload.reason ? ` Reason: ${payload.reason}` : "";
+  try {
+    await observeBrain2(projectRoot, {
+      text: `Context compaction about to begin${tokensPart}.${reasonPart}`,
+      title: "Pre-compaction context snapshot",
+      type: "discovery",
+      sourceSessionId: payload.sessionId,
+      sourceType: "agent"
+    });
+  } catch (err) {
+    if (!isMissingBrainSchemaError7(err)) throw err;
+  }
+}
+async function handlePostCompact(projectRoot, payload) {
+  if (!await isAutoCaptureEnabled2(projectRoot)) return;
+  const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
+  const statusPart = payload.success ? "succeeded" : "failed";
+  const beforePart = payload.tokensBefore != null ? ` before=${payload.tokensBefore.toLocaleString()}` : "";
+  const afterPart = payload.tokensAfter != null ? ` after=${payload.tokensAfter.toLocaleString()}` : "";
+  try {
+    await observeBrain2(projectRoot, {
+      text: `Context compaction ${statusPart}${beforePart}${afterPart}`,
+      title: "Post-compaction record",
+      type: "change",
+      sourceSessionId: payload.sessionId,
+      sourceType: "agent"
+    });
+  } catch (err) {
+    if (!isMissingBrainSchemaError7(err)) throw err;
+  }
+}
+var init_context_hooks = __esm({
+  "packages/core/src/hooks/handlers/context-hooks.ts"() {
+    "use strict";
+    init_registry();
+    hooks.register({
+      id: "brain-pre-compact",
+      event: "PreCompact",
+      handler: handlePreCompact,
+      priority: 100
+    });
+    hooks.register({
+      id: "brain-post-compact",
+      event: "PostCompact",
+      handler: handlePostCompact,
+      priority: 100
+    });
+  }
+});
+
 // packages/core/src/hooks/handlers/index.ts
 var init_handlers = __esm({
   "packages/core/src/hooks/handlers/index.ts"() {
@@ -18714,6 +18944,10 @@ var init_handlers = __esm({
     init_file_hooks();
     init_mcp_hooks();
     init_work_capture_hooks();
+    init_agent_hooks();
+    init_context_hooks();
+    init_agent_hooks();
+    init_context_hooks();
     init_error_hooks();
     init_file_hooks();
     init_mcp_hooks();
@@ -20564,7 +20798,7 @@ async function startSession(options, cwd, accessor) {
     });
   }
   const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-  hooks2.dispatch("onSessionStart", cwd ?? process.cwd(), {
+  hooks2.dispatch("SessionStart", cwd ?? process.cwd(), {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: session.id,
     name: options.name,
@@ -20602,7 +20836,7 @@ async function endSession(options = {}, cwd, accessor) {
   session.endedAt = (/* @__PURE__ */ new Date()).toISOString();
   const duration3 = Math.floor((Date.now() - new Date(session.startedAt).getTime()) / 1e3);
   const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-  hooks2.dispatch("onSessionEnd", cwd ?? process.cwd(), {
+  hooks2.dispatch("SessionEnd", cwd ?? process.cwd(), {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: session.id,
     duration: duration3,
@@ -21285,6 +21519,54 @@ var init_codebase_map = __esm({
   }
 });
 
+// packages/core/src/tasks/dependency-check.ts
+function getUnresolvedDeps(taskId, tasks2) {
+  const task = tasks2.find((t) => t.id === taskId);
+  if (!task?.depends?.length) return [];
+  const completedIds = new Set(
+    tasks2.filter((t) => t.status === "done" || t.status === "cancelled").map((t) => t.id)
+  );
+  return task.depends.filter((depId) => !completedIds.has(depId));
+}
+function topologicalSort2(tasks2) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjList = /* @__PURE__ */ new Map();
+  for (const task of tasks2) {
+    inDegree.set(task.id, 0);
+    adjList.set(task.id, []);
+  }
+  for (const task of tasks2) {
+    if (!task.depends?.length) continue;
+    for (const depId of task.depends) {
+      if (adjList.has(depId)) {
+        adjList.get(depId).push(task.id);
+        inDegree.set(task.id, (inDegree.get(task.id) ?? 0) + 1);
+      }
+    }
+  }
+  const queue = [];
+  for (const [id, degree] of inDegree) {
+    if (degree === 0) queue.push(id);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    sorted.push(id);
+    for (const dependent of adjList.get(id) ?? []) {
+      const newDegree = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, newDegree);
+      if (newDegree === 0) queue.push(dependent);
+    }
+  }
+  if (sorted.length !== tasks2.length) return null;
+  return sorted;
+}
+var init_dependency_check = __esm({
+  "packages/core/src/tasks/dependency-check.ts"() {
+    "use strict";
+  }
+});
+
 // packages/core/src/tasks/hierarchy.ts
 function getParentChain(taskId, tasks2) {
   const chain = [];
@@ -24731,7 +25013,150 @@ var init_registry3 = __esm({
   }
 });
 
+// packages/core/src/task-work/index.ts
+var task_work_exports = {};
+__export(task_work_exports, {
+  currentTask: () => currentTask,
+  getTaskHistory: () => getTaskHistory,
+  getWorkHistory: () => getWorkHistory,
+  startTask: () => startTask,
+  stopTask: () => stopTask
+});
+async function currentTask(cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const focus = await acc.getMetaValue("focus_state");
+  return {
+    currentTask: focus?.currentTask ?? null,
+    currentPhase: focus?.currentPhase ?? null,
+    sessionNote: focus?.sessionNote ?? null,
+    nextAction: focus?.nextAction ?? null
+  };
+}
+async function startTask(taskId, cwd, accessor) {
+  if (!taskId) {
+    throw new CleoError(2 /* INVALID_INPUT */, "Task ID is required");
+  }
+  const acc = accessor ?? await getAccessor(cwd);
+  const task = await acc.loadSingleTask(taskId);
+  if (!task) {
+    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${taskId}`, {
+      fix: `Use 'cleo find "${taskId}"' to search`
+    });
+  }
+  const { tasks: allTasks } = await acc.queryTasks({});
+  const unresolvedDeps = getUnresolvedDeps(taskId, allTasks);
+  if (unresolvedDeps.length > 0) {
+    throw new CleoError(
+      5 /* DEPENDENCY_ERROR */,
+      `Task ${taskId} is blocked by unresolved dependencies: ${unresolvedDeps.join(", ")}`,
+      {
+        fix: `Complete blockers first: ${unresolvedDeps.map((d) => `cleo complete ${d}`).join(", ")}`
+      }
+    );
+  }
+  const focus = await acc.getMetaValue("focus_state") ?? {};
+  const previousTask = focus.currentTask ?? null;
+  focus.currentTask = taskId;
+  focus.currentPhase = task.phase ?? null;
+  const noteEntry = {
+    note: `Started work on ${taskId}: ${task.title}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (!focus.sessionNotes) {
+    focus.sessionNotes = [];
+  }
+  focus.sessionNotes.push(noteEntry);
+  await acc.setMetaValue("focus_state", focus);
+  await logOperation(
+    "task_start",
+    taskId,
+    {
+      previousTask,
+      title: task.title
+    },
+    accessor
+  );
+  const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  hooks2.dispatch("PreToolUse", cwd ?? process.cwd(), {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    taskId,
+    taskTitle: task.title
+  }).catch(() => {
+  });
+  return {
+    taskId,
+    taskTitle: task.title,
+    previousTask
+  };
+}
+async function stopTask(cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const focus = await acc.getMetaValue("focus_state");
+  const previousTask = focus?.currentTask ?? null;
+  if (!focus) {
+    return { previousTask: null };
+  }
+  const taskId = focus.currentTask;
+  const task = taskId ? await acc.loadSingleTask(taskId) : void 0;
+  focus.currentTask = null;
+  focus.nextAction = null;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (taskId && task) {
+    const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    hooks2.dispatch("PostToolUse", cwd ?? process.cwd(), {
+      timestamp: now,
+      taskId,
+      taskTitle: task.title,
+      status: "done"
+    }).catch(() => {
+    });
+  }
+  await acc.setMetaValue("focus_state", focus);
+  await logOperation(
+    "task_stop",
+    previousTask ?? "none",
+    {
+      previousTask
+    },
+    accessor
+  );
+  return { previousTask };
+}
+async function getWorkHistory(cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const focus = await acc.getMetaValue("focus_state");
+  const notes = focus?.sessionNotes ?? [];
+  const history = [];
+  for (const note of notes) {
+    const match = note.note.match(/^(?:Focus set to|Started work on) (T\d+)/);
+    if (match) {
+      history.push({
+        taskId: match[1],
+        timestamp: note.timestamp
+      });
+    }
+  }
+  return history.reverse();
+}
+var getTaskHistory;
+var init_task_work = __esm({
+  "packages/core/src/task-work/index.ts"() {
+    "use strict";
+    init_src();
+    init_errors3();
+    init_data_accessor();
+    init_add();
+    init_dependency_check();
+    init_handlers();
+    getTaskHistory = getWorkHistory;
+  }
+});
+
 // packages/core/src/tasks/complete.ts
+var complete_exports = {};
+__export(complete_exports, {
+  completeTask: () => completeTask
+});
 function isVerificationGate(value) {
   return VERIFICATION_GATES.has(value);
 }
@@ -28502,10 +28927,15 @@ __export(hooks_exports, {
   OnWorkAvailablePayloadSchema: () => OnWorkAvailablePayloadSchema,
   handleError: () => handleError,
   handleFileChange: () => handleFileChange,
+  handlePostCompact: () => handlePostCompact,
+  handlePreCompact: () => handlePreCompact,
   handlePromptSubmit: () => handlePromptSubmit,
   handleResponseComplete: () => handleResponseComplete,
   handleSessionEnd: () => handleSessionEnd,
   handleSessionStart: () => handleSessionStart,
+  handleSubagentStart: () => handleSubagentStart,
+  handleSubagentStop: () => handleSubagentStop,
+  handleSystemNotification: () => handleSystemNotification,
   handleToolComplete: () => handleToolComplete,
   handleToolStart: () => handleToolStart,
   handleWorkPromptSubmit: () => handleWorkPromptSubmit,
@@ -39662,33 +40092,42 @@ var HookPayloadSchema = external_exports.object({
   providerId: external_exports.string().optional(),
   metadata: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
 });
-var OnSessionStartPayloadSchema = HookPayloadSchema.extend({
+var SessionStartPayloadSchema = HookPayloadSchema.extend({
   sessionId: external_exports.string(),
   name: external_exports.string(),
   scope: external_exports.string(),
   agent: external_exports.string().optional()
 });
-var OnSessionEndPayloadSchema = HookPayloadSchema.extend({
+var OnSessionStartPayloadSchema = SessionStartPayloadSchema;
+var SessionEndPayloadSchema = HookPayloadSchema.extend({
   sessionId: external_exports.string(),
   duration: external_exports.number(),
   tasksCompleted: external_exports.array(external_exports.string())
 });
-var OnToolStartPayloadSchema = HookPayloadSchema.extend({
+var OnSessionEndPayloadSchema = SessionEndPayloadSchema;
+var PreToolUsePayloadSchema = HookPayloadSchema.extend({
   taskId: external_exports.string(),
   taskTitle: external_exports.string(),
-  previousTask: external_exports.string().optional()
+  previousTask: external_exports.string().optional(),
+  toolName: external_exports.string().optional(),
+  toolInput: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
 });
-var OnToolCompletePayloadSchema = HookPayloadSchema.extend({
+var OnToolStartPayloadSchema = PreToolUsePayloadSchema;
+var PostToolUsePayloadSchema = HookPayloadSchema.extend({
   taskId: external_exports.string(),
   taskTitle: external_exports.string(),
-  status: external_exports.enum(["done", "archived", "cancelled"])
+  status: external_exports.enum(["done", "archived", "cancelled"]),
+  toolResult: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
 });
-var OnFileChangePayloadSchema = HookPayloadSchema.extend({
-  filePath: external_exports.string(),
-  changeType: external_exports.enum(["write", "create", "delete"]),
-  sizeBytes: external_exports.number().optional()
+var OnToolCompletePayloadSchema = PostToolUsePayloadSchema;
+var NotificationPayloadSchema = HookPayloadSchema.extend({
+  filePath: external_exports.string().optional(),
+  changeType: external_exports.enum(["write", "create", "delete"]).optional(),
+  sizeBytes: external_exports.number().optional(),
+  message: external_exports.string().optional()
 });
-var OnErrorPayloadSchema = HookPayloadSchema.extend({
+var OnFileChangePayloadSchema = NotificationPayloadSchema;
+var PostToolUseFailurePayloadSchema = HookPayloadSchema.extend({
   errorCode: external_exports.union([external_exports.number(), external_exports.string()]),
   message: external_exports.string(),
   domain: external_exports.string().optional(),
@@ -39696,13 +40135,15 @@ var OnErrorPayloadSchema = HookPayloadSchema.extend({
   gateway: external_exports.string().optional(),
   stack: external_exports.string().optional()
 });
-var OnPromptSubmitPayloadSchema = HookPayloadSchema.extend({
+var OnErrorPayloadSchema = PostToolUseFailurePayloadSchema;
+var PromptSubmitPayloadSchema = HookPayloadSchema.extend({
   gateway: external_exports.string(),
   domain: external_exports.string(),
   operation: external_exports.string(),
   source: external_exports.string().optional()
 });
-var OnResponseCompletePayloadSchema = HookPayloadSchema.extend({
+var OnPromptSubmitPayloadSchema = PromptSubmitPayloadSchema;
+var ResponseCompletePayloadSchema = HookPayloadSchema.extend({
   gateway: external_exports.string(),
   domain: external_exports.string(),
   operation: external_exports.string(),
@@ -39710,6 +40151,32 @@ var OnResponseCompletePayloadSchema = HookPayloadSchema.extend({
   durationMs: external_exports.number().optional(),
   errorCode: external_exports.string().optional()
 });
+var OnResponseCompletePayloadSchema = ResponseCompletePayloadSchema;
+var SubagentStartPayloadSchema = HookPayloadSchema.extend({
+  agentId: external_exports.string(),
+  role: external_exports.string().optional(),
+  taskId: external_exports.string().optional()
+});
+var SubagentStopPayloadSchema = HookPayloadSchema.extend({
+  agentId: external_exports.string(),
+  status: external_exports.enum(["complete", "partial", "blocked", "failed"]).optional(),
+  taskId: external_exports.string().optional(),
+  summary: external_exports.string().optional()
+});
+var PreCompactPayloadSchema = HookPayloadSchema.extend({
+  tokensBefore: external_exports.number().optional(),
+  reason: external_exports.string().optional()
+});
+var PostCompactPayloadSchema = HookPayloadSchema.extend({
+  tokensBefore: external_exports.number().optional(),
+  tokensAfter: external_exports.number().optional(),
+  success: external_exports.boolean()
+});
+var ConfigChangePayloadSchema = HookPayloadSchema.extend({
+  key: external_exports.string(),
+  previousValue: external_exports.unknown().optional(),
+  newValue: external_exports.unknown().optional()
+});
 var OnWorkAvailablePayloadSchema = HookPayloadSchema.extend({
   taskIds: external_exports.array(external_exports.string()),
   epicId: external_exports.string().optional(),
@@ -39741,14 +40208,21 @@ var OnPatrolPayloadSchema = HookPayloadSchema.extend({
   scope: external_exports.string().optional()
 });
 var EVENT_SCHEMA_MAP = {
-  onSessionStart: OnSessionStartPayloadSchema,
-  onSessionEnd: OnSessionEndPayloadSchema,
-  onToolStart: OnToolStartPayloadSchema,
-  onToolComplete: OnToolCompletePayloadSchema,
-  onFileChange: OnFileChangePayloadSchema,
-  onError: OnErrorPayloadSchema,
-  onPromptSubmit: OnPromptSubmitPayloadSchema,
-  onResponseComplete: OnResponseCompletePayloadSchema,
+  // CAAMP canonical events (16)
+  SessionStart: SessionStartPayloadSchema,
+  SessionEnd: SessionEndPayloadSchema,
+  PreToolUse: PreToolUsePayloadSchema,
+  PostToolUse: PostToolUsePayloadSchema,
+  Notification: NotificationPayloadSchema,
+  PostToolUseFailure: PostToolUseFailurePayloadSchema,
+  PromptSubmit: PromptSubmitPayloadSchema,
+  ResponseComplete: ResponseCompletePayloadSchema,
+  SubagentStart: SubagentStartPayloadSchema,
+  SubagentStop: SubagentStopPayloadSchema,
+  PreCompact: PreCompactPayloadSchema,
+  PostCompact: PostCompactPayloadSchema,
+  ConfigChange: ConfigChangePayloadSchema,
+  // CLEO internal coordination events (5)
   onWorkAvailable: OnWorkAvailablePayloadSchema,
   onAgentSpawn: OnAgentSpawnPayloadSchema,
   onAgentComplete: OnAgentCompletePayloadSchema,
@@ -40590,50 +41064,8 @@ async function maybeExtractLearning(taskId, task, verification, confidenceScore,
 // packages/core/src/intelligence/impact.ts
 init_data_accessor();
 
-// packages/core/src/tasks/dependency-check.ts
-function getUnresolvedDeps(taskId, tasks2) {
-  const task = tasks2.find((t) => t.id === taskId);
-  if (!task?.depends?.length) return [];
-  const completedIds = new Set(
-    tasks2.filter((t) => t.status === "done" || t.status === "cancelled").map((t) => t.id)
-  );
-  return task.depends.filter((depId) => !completedIds.has(depId));
-}
-function topologicalSort2(tasks2) {
-  const inDegree = /* @__PURE__ */ new Map();
-  const adjList = /* @__PURE__ */ new Map();
-  for (const task of tasks2) {
-    inDegree.set(task.id, 0);
-    adjList.set(task.id, []);
-  }
-  for (const task of tasks2) {
-    if (!task.depends?.length) continue;
-    for (const depId of task.depends) {
-      if (adjList.has(depId)) {
-        adjList.get(depId).push(task.id);
-        inDegree.set(task.id, (inDegree.get(task.id) ?? 0) + 1);
-      }
-    }
-  }
-  const queue = [];
-  for (const [id, degree] of inDegree) {
-    if (degree === 0) queue.push(id);
-  }
-  const sorted = [];
-  while (queue.length > 0) {
-    const id = queue.shift();
-    sorted.push(id);
-    for (const dependent of adjList.get(id) ?? []) {
-      const newDegree = (inDegree.get(dependent) ?? 1) - 1;
-      inDegree.set(dependent, newDegree);
-      if (newDegree === 0) queue.push(dependent);
-    }
-  }
-  if (sorted.length !== tasks2.length) return null;
-  return sorted;
-}
-
 // packages/core/src/tasks/graph-ops.ts
+init_dependency_check();
 function getCriticalPath(tasks2) {
   const activeTasks = tasks2.filter((t) => t.status !== "done" && t.status !== "cancelled");
   if (activeTasks.length === 0) return [];
@@ -46510,6 +46942,7 @@ __export(nexus_exports, {
   nexusSyncAll: () => nexusSyncAll,
   nexusUnregister: () => nexusUnregister,
   orphanDetection: () => orphanDetection,
+  parseDirective: () => parseDirective,
   parseQuery: () => parseQuery,
   permissionLevel: () => permissionLevel,
   previewTransfer: () => previewTransfer,
@@ -46520,10 +46953,13 @@ __export(nexus_exports, {
   resolveCrossDeps: () => resolveCrossDeps,
   resolveProjectPath: () => resolveProjectPath2,
   resolveTask: () => resolveTask,
+  routeDirective: () => routeDirective,
   searchAcrossProjects: () => searchAcrossProjects,
   setPermission: () => setPermission,
   syncGitignore: () => syncGitignore,
-  validateSyntax: () => validateSyntax
+  validateSyntax: () => validateSyntax,
+  workspaceAgents: () => workspaceAgents,
+  workspaceStatus: () => workspaceStatus
 });
 
 // packages/core/src/nexus/deps.ts
@@ -47749,6 +48185,275 @@ async function executeTransferInternal(params) {
   return result;
 }
 
+// packages/core/src/nexus/workspace.ts
+init_src();
+init_errors3();
+init_data_accessor();
+init_registry3();
+var RATE_LIMIT_WINDOW_MS = 6e4;
+var RATE_LIMIT_MAX_OPS = 100;
+var rateLimitCounters = /* @__PURE__ */ new Map();
+function checkRateLimit(agentId) {
+  const now = Date.now();
+  const entry = rateLimitCounters.get(agentId);
+  if (!entry || now - entry.windowStart > RATE_LIMIT_WINDOW_MS) {
+    rateLimitCounters.set(agentId, { count: 1, windowStart: now });
+    return;
+  }
+  entry.count++;
+  if (entry.count > RATE_LIMIT_MAX_OPS) {
+    throw new CleoError(
+      1 /* GENERAL_ERROR */,
+      `Agent '${agentId}' exceeded rate limit: ${RATE_LIMIT_MAX_OPS} routing ops per ${RATE_LIMIT_WINDOW_MS / 1e3}s`
+    );
+  }
+}
+var DEFAULT_ACL = { authorizedAgents: ["*"] };
+async function loadProjectACL(projectPath) {
+  try {
+    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig3(projectPath);
+    const agents = config2?.authorizedAgents;
+    if (Array.isArray(agents) && agents.length > 0) {
+      return { authorizedAgents: agents };
+    }
+  } catch {
+  }
+  return DEFAULT_ACL;
+}
+function isAuthorized(acl, agentId) {
+  if (acl.authorizedAgents.includes("*")) return true;
+  return acl.authorizedAgents.includes(agentId);
+}
+var TASK_REF_PATTERN = /\bT(\d+)\b/g;
+function parseDirective(message) {
+  const content = message.content;
+  const verbMatch = content.match(/^\/(\w+)/);
+  if (!verbMatch) return null;
+  const verb = verbMatch[1];
+  const taskRefs = [];
+  const pattern = new RegExp(TASK_REF_PATTERN.source, "g");
+  for (const m of content.matchAll(pattern)) {
+    taskRefs.push(`T${m[1]}`);
+  }
+  const metaRefs = message.metadata?.taskRefs;
+  if (Array.isArray(metaRefs)) {
+    for (const ref of metaRefs) {
+      if (typeof ref === "string" && !taskRefs.includes(ref)) {
+        taskRefs.push(ref);
+      }
+    }
+  }
+  if (taskRefs.length === 0) return null;
+  return {
+    verb,
+    taskRefs,
+    agentId: message.from,
+    messageId: message.id,
+    timestamp: message.timestamp
+  };
+}
+var VERB_TO_OPERATION = {
+  claim: "tasks.start",
+  done: "tasks.complete",
+  complete: "tasks.complete",
+  blocked: "tasks.update",
+  // Update status to blocked
+  start: "tasks.start",
+  stop: "tasks.stop"
+};
+async function routeDirective(directive) {
+  checkRateLimit(directive.agentId);
+  const results = [];
+  const operation = VERB_TO_OPERATION[directive.verb];
+  if (!operation) {
+    return results;
+  }
+  const projects = await nexusList();
+  for (const taskRef of directive.taskRefs) {
+    const result = await routeSingleTask(taskRef, directive, operation, projects);
+    results.push(result);
+  }
+  return results;
+}
+async function routeSingleTask(taskId, directive, operation, projects) {
+  let targetProject = null;
+  let targetAccessor = null;
+  for (const project of projects) {
+    try {
+      const acc = await getAccessor(project.path);
+      const { tasks: tasks2 } = await acc.queryTasks({});
+      const task = tasks2.find((t) => t.id === taskId);
+      if (task) {
+        targetProject = project;
+        targetAccessor = acc;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!targetProject || !targetAccessor) {
+    return {
+      success: false,
+      project: "unknown",
+      projectPath: "",
+      taskId,
+      operation,
+      error: `Task ${taskId} not found in any registered project`
+    };
+  }
+  const acl = await loadProjectACL(targetProject.path);
+  if (!isAuthorized(acl, directive.agentId)) {
+    return {
+      success: false,
+      project: targetProject.name,
+      projectPath: targetProject.path,
+      taskId,
+      operation,
+      error: `Agent '${directive.agentId}' not authorized to mutate project '${targetProject.name}'`
+    };
+  }
+  try {
+    await executeOperation(operation, taskId, targetProject.path, targetAccessor, directive);
+    await logRouteAudit(directive, targetProject.name, taskId, operation, true);
+    return {
+      success: true,
+      project: targetProject.name,
+      projectPath: targetProject.path,
+      taskId,
+      operation
+    };
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    await logRouteAudit(directive, targetProject.name, taskId, operation, false, errorMsg);
+    return {
+      success: false,
+      project: targetProject.name,
+      projectPath: targetProject.path,
+      taskId,
+      operation,
+      error: errorMsg
+    };
+  }
+}
+async function executeOperation(operation, taskId, projectPath, accessor, directive) {
+  switch (operation) {
+    case "tasks.start": {
+      const { startTask: startTask2 } = await Promise.resolve().then(() => (init_task_work(), task_work_exports));
+      await startTask2(taskId, projectPath, accessor);
+      break;
+    }
+    case "tasks.complete": {
+      const { completeTask: completeTask2 } = await Promise.resolve().then(() => (init_complete(), complete_exports));
+      await completeTask2(
+        { taskId, notes: `Completed via Conduit directive from ${directive.agentId}` },
+        projectPath,
+        accessor
+      );
+      break;
+    }
+    case "tasks.stop": {
+      const { stopTask: stopTask2 } = await Promise.resolve().then(() => (init_task_work(), task_work_exports));
+      await stopTask2(projectPath, accessor);
+      break;
+    }
+    case "tasks.update": {
+      const { updateTask: updateTask2 } = await Promise.resolve().then(() => (init_update2(), update_exports));
+      await updateTask2(
+        { taskId, notes: `Marked blocked via Conduit directive from ${directive.agentId}` },
+        projectPath,
+        accessor
+      );
+      break;
+    }
+  }
+}
+async function logRouteAudit(directive, projectName, taskId, operation, success2, error40) {
+  try {
+    const { getLogger: getLogger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+    const log9 = getLogger2("nexus.route");
+    const level = success2 ? "info" : "warn";
+    log9[level](
+      {
+        directive: directive.verb,
+        agentId: directive.agentId,
+        messageId: directive.messageId,
+        project: projectName,
+        taskId,
+        operation,
+        success: success2,
+        error: error40
+      },
+      `Conduit directive routed: ${directive.verb} ${taskId} \u2192 ${projectName} (${success2 ? "OK" : "FAILED"})`
+    );
+  } catch {
+  }
+}
+async function workspaceStatus() {
+  const projects = await nexusList();
+  const summaries = [];
+  const totals = { pending: 0, active: 0, done: 0, total: 0 };
+  for (const project of projects) {
+    try {
+      const acc = await getAccessor(project.path);
+      const { tasks: tasks2 } = await acc.queryTasks({});
+      const counts = {
+        pending: tasks2.filter((t) => t.status === "pending").length,
+        active: tasks2.filter((t) => t.status === "active").length,
+        done: tasks2.filter((t) => t.status === "done").length,
+        total: tasks2.length
+      };
+      summaries.push({
+        name: project.name,
+        path: project.path,
+        counts,
+        health: project.healthStatus,
+        lastSync: project.lastSync
+      });
+      totals.pending += counts.pending;
+      totals.active += counts.active;
+      totals.done += counts.done;
+      totals.total += counts.total;
+    } catch {
+      summaries.push({
+        name: project.name,
+        path: project.path,
+        counts: { pending: 0, active: 0, done: 0, total: 0 },
+        health: "unreachable",
+        lastSync: project.lastSync
+      });
+    }
+  }
+  return {
+    projectCount: projects.length,
+    projects: summaries,
+    totals,
+    computedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function workspaceAgents() {
+  const projects = await nexusList();
+  const agents = [];
+  for (const project of projects) {
+    try {
+      const { listAgentInstances: listAgentInstances2 } = await Promise.resolve().then(() => (init_registry2(), registry_exports2));
+      const instances = await listAgentInstances2(void 0, project.path);
+      for (const inst of instances) {
+        agents.push({
+          agentId: inst.id,
+          agentType: inst.agentType,
+          status: inst.status,
+          project: project.name,
+          taskId: inst.taskId ?? null,
+          lastHeartbeat: inst.lastHeartbeat
+        });
+      }
+    } catch {
+    }
+  }
+  return agents;
+}
+
 // packages/core/src/observability/index.ts
 var observability_exports = {};
 __export(observability_exports, {
@@ -60551,137 +61256,8 @@ async function uncancelTask(projectRoot, params) {
   };
 }
 
-// packages/core/src/task-work/index.ts
-var task_work_exports = {};
-__export(task_work_exports, {
-  currentTask: () => currentTask,
-  getTaskHistory: () => getTaskHistory,
-  getWorkHistory: () => getWorkHistory,
-  startTask: () => startTask,
-  stopTask: () => stopTask
-});
-init_src();
-init_errors3();
-init_data_accessor();
-init_add();
-init_handlers();
-async function currentTask(cwd, accessor) {
-  const acc = accessor ?? await getAccessor(cwd);
-  const focus = await acc.getMetaValue("focus_state");
-  return {
-    currentTask: focus?.currentTask ?? null,
-    currentPhase: focus?.currentPhase ?? null,
-    sessionNote: focus?.sessionNote ?? null,
-    nextAction: focus?.nextAction ?? null
-  };
-}
-async function startTask(taskId, cwd, accessor) {
-  if (!taskId) {
-    throw new CleoError(2 /* INVALID_INPUT */, "Task ID is required");
-  }
-  const acc = accessor ?? await getAccessor(cwd);
-  const task = await acc.loadSingleTask(taskId);
-  if (!task) {
-    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${taskId}`, {
-      fix: `Use 'cleo find "${taskId}"' to search`
-    });
-  }
-  const { tasks: allTasks } = await acc.queryTasks({});
-  const unresolvedDeps = getUnresolvedDeps(taskId, allTasks);
-  if (unresolvedDeps.length > 0) {
-    throw new CleoError(
-      5 /* DEPENDENCY_ERROR */,
-      `Task ${taskId} is blocked by unresolved dependencies: ${unresolvedDeps.join(", ")}`,
-      {
-        fix: `Complete blockers first: ${unresolvedDeps.map((d) => `cleo complete ${d}`).join(", ")}`
-      }
-    );
-  }
-  const focus = await acc.getMetaValue("focus_state") ?? {};
-  const previousTask = focus.currentTask ?? null;
-  focus.currentTask = taskId;
-  focus.currentPhase = task.phase ?? null;
-  const noteEntry = {
-    note: `Started work on ${taskId}: ${task.title}`,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  if (!focus.sessionNotes) {
-    focus.sessionNotes = [];
-  }
-  focus.sessionNotes.push(noteEntry);
-  await acc.setMetaValue("focus_state", focus);
-  await logOperation(
-    "task_start",
-    taskId,
-    {
-      previousTask,
-      title: task.title
-    },
-    accessor
-  );
-  const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-  hooks2.dispatch("onToolStart", cwd ?? process.cwd(), {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    taskId,
-    taskTitle: task.title
-  }).catch(() => {
-  });
-  return {
-    taskId,
-    taskTitle: task.title,
-    previousTask
-  };
-}
-async function stopTask(cwd, accessor) {
-  const acc = accessor ?? await getAccessor(cwd);
-  const focus = await acc.getMetaValue("focus_state");
-  const previousTask = focus?.currentTask ?? null;
-  if (!focus) {
-    return { previousTask: null };
-  }
-  const taskId = focus.currentTask;
-  const task = taskId ? await acc.loadSingleTask(taskId) : void 0;
-  focus.currentTask = null;
-  focus.nextAction = null;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  if (taskId && task) {
-    const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-    hooks2.dispatch("onToolComplete", cwd ?? process.cwd(), {
-      timestamp: now,
-      taskId,
-      taskTitle: task.title,
-      status: "done"
-    }).catch(() => {
-    });
-  }
-  await acc.setMetaValue("focus_state", focus);
-  await logOperation(
-    "task_stop",
-    previousTask ?? "none",
-    {
-      previousTask
-    },
-    accessor
-  );
-  return { previousTask };
-}
-async function getWorkHistory(cwd, accessor) {
-  const acc = accessor ?? await getAccessor(cwd);
-  const focus = await acc.getMetaValue("focus_state");
-  const notes = focus?.sessionNotes ?? [];
-  const history = [];
-  for (const note of notes) {
-    const match = note.note.match(/^(?:Focus set to|Started work on) (T\d+)/);
-    if (match) {
-      history.push({
-        taskId: match[1],
-        timestamp: note.timestamp
-      });
-    }
-  }
-  return history.reverse();
-}
-var getTaskHistory = getWorkHistory;
+// packages/core/src/index.ts
+init_task_work();
 
 // packages/core/src/tasks/index.ts
 var tasks_exports = {};
@@ -65364,7 +65940,7 @@ async function restoreSession(projectRoot, snapshot, options = {}, accessor) {
   await acc.upsertSingleSession(restoredSession);
   try {
     const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-    await hooks2.dispatch("onSessionStart", projectRoot, {
+    await hooks2.dispatch("SessionStart", projectRoot, {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       sessionId: restoredSession.id,
       name: restoredSession.name,
@@ -65380,6 +65956,7 @@ async function restoreSession(projectRoot, snapshot, options = {}, accessor) {
 
 // packages/core/src/cleo.ts
 init_data_accessor();
+init_task_work();
 init_add();
 init_complete();
 init_update2();
@@ -65604,7 +66181,14 @@ var Cleo = class _Cleo {
       discover: (p) => discoverRelated(p.query, p.method, p.limit),
       search: (p) => searchAcrossProjects(p.pattern, p.project, p.limit),
       setPermission: (p) => setPermission(p.name, p.level),
-      sharingStatus: () => getSharingStatus()
+      sharingStatus: () => getSharingStatus(),
+      route: (message) => {
+        const directive = parseDirective(message);
+        if (!directive) return Promise.resolve([]);
+        return routeDirective(directive);
+      },
+      workspaceStatus: () => workspaceStatus(),
+      workspaceAgents: () => workspaceAgents()
     };
   }
   // === Agents ===
@@ -65665,6 +66249,7 @@ init_registry();
 init_brain_retrieval();
 init_brain_search();
 init_sessions();
+init_task_work();
 init_add();
 init_complete();
 init_update2();