@cleocode/cleo 2026.3.72 → 2026.3.74

package/dist/mcp/index.js

@@ -632,6 +632,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";
@@ -733,22 +740,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,
@@ -759,12 +786,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
        *
@@ -772,7 +820,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
        * });
@@ -781,12 +829,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);
@@ -800,14 +850,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',
@@ -817,15 +870,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"
+              );
             }
           })
         );
@@ -834,12 +891,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.
@@ -851,7 +910,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) {
@@ -869,12 +928,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();
@@ -13695,7 +13756,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"
@@ -20929,13 +20990,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
     });
@@ -20982,13 +21043,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
     });
@@ -21018,7 +21079,7 @@ var init_error_hooks = __esm({
     init_registry();
     hooks.register({
       id: "brain-error",
-      event: "onError",
+      event: "PostToolUseFailure",
       handler: handleError,
       priority: 100
     });
@@ -21049,6 +21110,7 @@ async function isFileCaptureEnabled(projectRoot) {
   }
 }
 async function handleFileChange(projectRoot, payload) {
+  if (!payload.filePath || !payload.changeType) return;
   if (!await isFileCaptureEnabled(projectRoot)) return;
   const now2 = Date.now();
   const lastWrite = recentWrites.get(payload.filePath);
@@ -21095,7 +21157,7 @@ var init_file_hooks = __esm({
     ];
     hooks.register({
       id: "brain-file-change",
-      event: "onFileChange",
+      event: "Notification",
       handler: handleFileChange,
       priority: 100
     });
@@ -21149,22 +21211,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: loadConfig4 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig4(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
+    });
   }
 });
 
@@ -21241,19 +21332,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: loadConfig4 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig4(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: loadConfig4 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig4(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"() {
@@ -21264,6 +21494,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();
@@ -23114,7 +23348,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,
@@ -23152,7 +23386,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,
@@ -35888,7 +36122,7 @@ function validatePayload(event, payload) {
   const errors = result.error.issues.map((issue2) => `${issue2.path.join(".")}: ${issue2.message}`);
   return { valid: false, errors };
 }
-var HookPayloadSchema, OnSessionStartPayloadSchema, OnSessionEndPayloadSchema, OnToolStartPayloadSchema, OnToolCompletePayloadSchema, OnFileChangePayloadSchema, OnErrorPayloadSchema, OnPromptSubmitPayloadSchema, OnResponseCompletePayloadSchema, OnWorkAvailablePayloadSchema, OnAgentSpawnPayloadSchema, OnAgentCompletePayloadSchema, OnCascadeStartPayloadSchema, OnPatrolPayloadSchema, EVENT_SCHEMA_MAP;
+var HookPayloadSchema, SessionStartPayloadSchema, OnSessionStartPayloadSchema, SessionEndPayloadSchema, OnSessionEndPayloadSchema, PreToolUsePayloadSchema, OnToolStartPayloadSchema, PostToolUsePayloadSchema, OnToolCompletePayloadSchema, NotificationPayloadSchema, OnFileChangePayloadSchema, PostToolUseFailurePayloadSchema, OnErrorPayloadSchema, PromptSubmitPayloadSchema, OnPromptSubmitPayloadSchema, ResponseCompletePayloadSchema, OnResponseCompletePayloadSchema, SubagentStartPayloadSchema, SubagentStopPayloadSchema, PreCompactPayloadSchema, PostCompactPayloadSchema, ConfigChangePayloadSchema, OnWorkAvailablePayloadSchema, OnAgentSpawnPayloadSchema, OnAgentCompletePayloadSchema, OnCascadeStartPayloadSchema, OnPatrolPayloadSchema, EVENT_SCHEMA_MAP;
 var init_payload_schemas = __esm({
   "packages/core/src/hooks/payload-schemas.ts"() {
     "use strict";
@@ -35900,33 +36134,42 @@ var init_payload_schemas = __esm({
       providerId: external_exports.string().optional(),
       metadata: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
     });
-    OnSessionStartPayloadSchema = HookPayloadSchema.extend({
+    SessionStartPayloadSchema = HookPayloadSchema.extend({
       sessionId: external_exports.string(),
       name: external_exports.string(),
       scope: external_exports.string(),
       agent: external_exports.string().optional()
     });
-    OnSessionEndPayloadSchema = HookPayloadSchema.extend({
+    OnSessionStartPayloadSchema = SessionStartPayloadSchema;
+    SessionEndPayloadSchema = HookPayloadSchema.extend({
       sessionId: external_exports.string(),
       duration: external_exports.number(),
       tasksCompleted: external_exports.array(external_exports.string())
     });
-    OnToolStartPayloadSchema = HookPayloadSchema.extend({
+    OnSessionEndPayloadSchema = SessionEndPayloadSchema;
+    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()
     });
-    OnToolCompletePayloadSchema = HookPayloadSchema.extend({
+    OnToolStartPayloadSchema = PreToolUsePayloadSchema;
+    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()
     });
-    OnFileChangePayloadSchema = HookPayloadSchema.extend({
-      filePath: external_exports.string(),
-      changeType: external_exports.enum(["write", "create", "delete"]),
-      sizeBytes: external_exports.number().optional()
+    OnToolCompletePayloadSchema = PostToolUsePayloadSchema;
+    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()
     });
-    OnErrorPayloadSchema = HookPayloadSchema.extend({
+    OnFileChangePayloadSchema = NotificationPayloadSchema;
+    PostToolUseFailurePayloadSchema = HookPayloadSchema.extend({
       errorCode: external_exports.union([external_exports.number(), external_exports.string()]),
       message: external_exports.string(),
       domain: external_exports.string().optional(),
@@ -35934,13 +36177,15 @@ var init_payload_schemas = __esm({
       gateway: external_exports.string().optional(),
       stack: external_exports.string().optional()
     });
-    OnPromptSubmitPayloadSchema = HookPayloadSchema.extend({
+    OnErrorPayloadSchema = PostToolUseFailurePayloadSchema;
+    PromptSubmitPayloadSchema = HookPayloadSchema.extend({
       gateway: external_exports.string(),
       domain: external_exports.string(),
       operation: external_exports.string(),
       source: external_exports.string().optional()
     });
-    OnResponseCompletePayloadSchema = HookPayloadSchema.extend({
+    OnPromptSubmitPayloadSchema = PromptSubmitPayloadSchema;
+    ResponseCompletePayloadSchema = HookPayloadSchema.extend({
       gateway: external_exports.string(),
       domain: external_exports.string(),
       operation: external_exports.string(),
@@ -35948,6 +36193,32 @@ var init_payload_schemas = __esm({
       durationMs: external_exports.number().optional(),
       errorCode: external_exports.string().optional()
     });
+    OnResponseCompletePayloadSchema = ResponseCompletePayloadSchema;
+    SubagentStartPayloadSchema = HookPayloadSchema.extend({
+      agentId: external_exports.string(),
+      role: external_exports.string().optional(),
+      taskId: external_exports.string().optional()
+    });
+    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()
+    });
+    PreCompactPayloadSchema = HookPayloadSchema.extend({
+      tokensBefore: external_exports.number().optional(),
+      reason: external_exports.string().optional()
+    });
+    PostCompactPayloadSchema = HookPayloadSchema.extend({
+      tokensBefore: external_exports.number().optional(),
+      tokensAfter: external_exports.number().optional(),
+      success: external_exports.boolean()
+    });
+    ConfigChangePayloadSchema = HookPayloadSchema.extend({
+      key: external_exports.string(),
+      previousValue: external_exports.unknown().optional(),
+      newValue: external_exports.unknown().optional()
+    });
     OnWorkAvailablePayloadSchema = HookPayloadSchema.extend({
       taskIds: external_exports.array(external_exports.string()),
       epicId: external_exports.string().optional(),
@@ -35979,14 +36250,21 @@ var init_payload_schemas = __esm({
       scope: external_exports.string().optional()
     });
     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,
@@ -36016,10 +36294,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,
@@ -44975,8 +45258,8 @@ var init_checksum = __esm({
 });
 
 // packages/core/src/migration/logger.ts
-var logger_exports = {};
-__export(logger_exports, {
+var logger_exports2 = {};
+__export(logger_exports2, {
   MigrationLogger: () => MigrationLogger,
   createMigrationLogger: () => createMigrationLogger,
   getLatestMigrationLog: () => getLatestMigrationLog,
@@ -47929,6 +48212,903 @@ var init_transfer = __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 now2 = (/* @__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: now2,
+      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);
+}
+async function loadCompletionEnforcement(cwd) {
+  const isTest = !!process.env.VITEST;
+  const config2 = await loadConfig(cwd);
+  const acceptance = config2.enforcement?.acceptance;
+  const verificationCfg = config2.verification;
+  const acceptanceMode = acceptance?.mode ?? (isTest ? "off" : "block");
+  const acceptanceRequiredForPriorities = acceptance?.requiredForPriorities ?? (isTest ? [] : ["critical", "high", "medium", "low"]);
+  const rawVerificationEnabled = await getRawConfigValue("verification.enabled", cwd);
+  const verificationEnabled = rawVerificationEnabled !== void 0 ? rawVerificationEnabled : !isTest;
+  const verificationRequiredGates = (verificationCfg?.requiredGates ?? []).filter(isVerificationGate).length > 0 ? (verificationCfg?.requiredGates ?? []).filter(isVerificationGate) : DEFAULT_VERIFICATION_REQUIRED_GATES;
+  const verificationMaxRounds = verificationCfg?.maxRounds ?? 5;
+  const lifecycleMode = config2.lifecycle?.mode ?? (isTest ? "off" : "strict");
+  return {
+    acceptanceMode,
+    acceptanceRequiredForPriorities,
+    verificationEnabled,
+    verificationRequiredGates,
+    verificationMaxRounds,
+    lifecycleMode
+  };
+}
+async function completeTask(options, cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const task = await acc.loadSingleTask(options.taskId);
+  if (!task) {
+    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${options.taskId}`, {
+      fix: `Use 'cleo find "${options.taskId}"' to search`
+    });
+  }
+  await requireActiveSession("tasks.complete", cwd);
+  const enforcement = await loadCompletionEnforcement(cwd);
+  if (task.status === "done") {
+    throw new CleoError(17 /* TASK_COMPLETED */, `Task ${options.taskId} is already completed`);
+  }
+  if (task.depends?.length) {
+    const deps = await acc.loadTasks(task.depends);
+    const incompleteDeps = deps.filter((d) => d.status !== "done" && d.status !== "cancelled").map((d) => d.id);
+    if (incompleteDeps.length > 0) {
+      throw new CleoError(
+        5 /* DEPENDENCY_ERROR */,
+        `Task ${options.taskId} has incomplete dependencies: ${incompleteDeps.join(", ")}`,
+        {
+          fix: `Complete dependencies first: ${incompleteDeps.map((d) => `cleo complete ${d}`).join(", ")}`
+        }
+      );
+    }
+  }
+  const acceptanceEnforcement = await createAcceptanceEnforcement(cwd);
+  const completionValidation = acceptanceEnforcement.validateCompletion(task);
+  if (!completionValidation.valid) {
+    throw new CleoError(
+      completionValidation.exitCode ?? 6 /* VALIDATION_ERROR */,
+      completionValidation.error,
+      { fix: completionValidation.fix }
+    );
+  }
+  if (enforcement.verificationEnabled && task.type !== "epic") {
+    if (!task.verification) {
+      throw new CleoError(
+        40 /* VERIFICATION_INIT_FAILED */,
+        `Task ${options.taskId} is missing verification metadata`,
+        {
+          fix: `Initialize verification for ${options.taskId} before completion`
+        }
+      );
+    }
+    if (task.verification.round > enforcement.verificationMaxRounds) {
+      throw new CleoError(
+        44 /* MAX_ROUNDS_EXCEEDED */,
+        `Task ${options.taskId} exceeded verification max rounds (${enforcement.verificationMaxRounds})`,
+        {
+          fix: `Review failure log and resolve blockers before retrying completion`
+        }
+      );
+    }
+    const missingRequiredGates = enforcement.verificationRequiredGates.filter(
+      (gate) => task.verification?.gates?.[gate] !== true
+    );
+    if (missingRequiredGates.length > 0 || task.verification.passed !== true) {
+      const exitCode = enforcement.lifecycleMode === "strict" ? 80 /* LIFECYCLE_GATE_FAILED */ : 45 /* GATE_DEPENDENCY */;
+      throw new CleoError(
+        exitCode,
+        `Task ${options.taskId} failed verification gates: ${missingRequiredGates.join(", ") || "verification.passed=false"}`,
+        {
+          fix: `Set required verification gates before completion: ${enforcement.verificationRequiredGates.join(", ")}`
+        }
+      );
+    }
+  }
+  const children = await acc.getChildren(options.taskId);
+  const incompleteChildren = children.filter(
+    (c) => c.status !== "done" && c.status !== "cancelled"
+  );
+  if (incompleteChildren.length > 0 && task.type === "epic") {
+    if (!task.noAutoComplete) {
+      throw new CleoError(
+        16 /* HAS_CHILDREN */,
+        `Epic ${options.taskId} has ${incompleteChildren.length} incomplete children: ${incompleteChildren.map((c) => c.id).join(", ")}`,
+        {
+          fix: `Complete children first or use 'cleo update ${options.taskId} --no-auto-complete'`
+        }
+      );
+    }
+  }
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const before = { ...task };
+  task.status = "done";
+  task.completedAt = now2;
+  task.updatedAt = now2;
+  if (options.notes) {
+    const timestampedNote = `${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}: ${options.notes}`;
+    if (!task.notes) task.notes = [];
+    task.notes.push(timestampedNote);
+  }
+  if (options.changeset) {
+    if (!task.notes) task.notes = [];
+    task.notes.push(`Changeset: ${options.changeset}`);
+  }
+  const autoCompleted = [];
+  const autoCompletedTasks = [];
+  if (task.parentId) {
+    const parent = await acc.loadSingleTask(task.parentId);
+    if (parent && parent.type === "epic" && !parent.noAutoComplete) {
+      const siblings = await acc.getChildren(parent.id);
+      const allDone = siblings.every(
+        (c) => c.id === task.id || c.status === "done" || c.status === "cancelled"
+      );
+      if (allDone) {
+        parent.status = "done";
+        parent.completedAt = now2;
+        parent.updatedAt = now2;
+        autoCompleted.push(parent.id);
+        autoCompletedTasks.push(parent);
+      }
+    }
+  }
+  await acc.transaction(async (tx) => {
+    await tx.upsertSingleTask(task);
+    for (const parentTask of autoCompletedTasks) {
+      await tx.upsertSingleTask(parentTask);
+    }
+    await tx.appendLog({
+      id: `log-${Math.floor(Date.now() / 1e3)}-${(await import("node:crypto")).randomBytes(3).toString("hex")}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action: "task_completed",
+      taskId: options.taskId,
+      actor: "system",
+      details: { title: task.title, previousStatus: before.status },
+      before: null,
+      after: { title: task.title, previousStatus: before.status }
+    });
+  });
+  const dependents = await acc.getDependents(options.taskId);
+  const unblockedTasks = [];
+  for (const dep of dependents) {
+    if (dep.status === "done" || dep.status === "cancelled") continue;
+    if (dep.depends?.length) {
+      const depDeps = await acc.loadTasks(dep.depends);
+      const stillUnresolved = depDeps.filter(
+        (d) => d.id !== options.taskId && d.status !== "done" && d.status !== "cancelled"
+      );
+      if (stillUnresolved.length === 0) {
+        unblockedTasks.push({ id: dep.id, title: dep.title });
+      }
+    } else {
+      unblockedTasks.push({ id: dep.id, title: dep.title });
+    }
+  }
+  Promise.resolve().then(() => (init_auto_extract(), auto_extract_exports)).then(
+    ({ extractTaskCompletionMemory: extractTaskCompletionMemory2 }) => extractTaskCompletionMemory2(cwd ?? process.cwd(), task)
+  ).catch(() => {
+  });
+  return {
+    task,
+    ...autoCompleted.length > 0 && { autoCompleted },
+    ...unblockedTasks.length > 0 && { unblockedTasks }
+  };
+}
+var DEFAULT_VERIFICATION_REQUIRED_GATES, VERIFICATION_GATES;
+var init_complete = __esm({
+  "packages/core/src/tasks/complete.ts"() {
+    "use strict";
+    init_src();
+    init_config();
+    init_errors3();
+    init_session_enforcement();
+    init_data_accessor();
+    init_enforcement();
+    DEFAULT_VERIFICATION_REQUIRED_GATES = [
+      "implemented",
+      "testsPassed",
+      "qaPassed",
+      "securityPassed",
+      "documented"
+    ];
+    VERIFICATION_GATES = /* @__PURE__ */ new Set([
+      "implemented",
+      "testsPassed",
+      "qaPassed",
+      "cleanupDone",
+      "securityPassed",
+      "documented"
+    ]);
+  }
+});
+
+// packages/core/src/tasks/update.ts
+var update_exports = {};
+__export(update_exports, {
+  updateTask: () => updateTask
+});
+function hasNonStatusDoneFields(options) {
+  return NON_STATUS_DONE_FIELDS.some((field) => options[field] !== void 0);
+}
+async function updateTask(options, cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const task = await acc.loadSingleTask(options.taskId);
+  if (!task) {
+    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${options.taskId}`, {
+      fix: `Use 'cleo find "${options.taskId}"' to search`
+    });
+  }
+  await requireActiveSession("tasks.update", cwd);
+  const changes = [];
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const isStatusOnlyDoneTransition = options.status === "done" && task.status !== "done" && !hasNonStatusDoneFields(options);
+  if (isStatusOnlyDoneTransition) {
+    const result = await completeTask({ taskId: options.taskId }, cwd, accessor);
+    return { task: result.task, changes: ["status"] };
+  }
+  if (options.status === "done" && task.status !== "done") {
+    throw new CleoError(
+      6 /* VALIDATION_ERROR */,
+      "status=done must use complete flow; do not combine with other update fields",
+      {
+        fix: `Run 'cleo complete ${options.taskId}' first, then apply additional updates with 'cleo update ${options.taskId} ...'`
+      }
+    );
+  }
+  const enforcement = await createAcceptanceEnforcement(cwd);
+  const updateValidation = enforcement.validateUpdate(task, { acceptance: options.acceptance });
+  if (!updateValidation.valid) {
+    throw new CleoError(
+      updateValidation.exitCode ?? 6 /* VALIDATION_ERROR */,
+      updateValidation.error,
+      { fix: updateValidation.fix }
+    );
+  }
+  if (options.title !== void 0) {
+    validateTitle(options.title);
+    task.title = options.title;
+    changes.push("title");
+  }
+  if (options.status !== void 0) {
+    validateStatus(options.status);
+    const oldStatus = task.status;
+    task.status = options.status;
+    changes.push("status");
+    if (options.status === "done" && oldStatus !== "done") {
+      task.completedAt = now2;
+    }
+    if (options.status === "cancelled" && oldStatus !== "cancelled") {
+      task.cancelledAt = now2;
+    }
+  }
+  if (options.priority !== void 0) {
+    const normalizedPriority = normalizePriority(options.priority);
+    task.priority = normalizedPriority;
+    changes.push("priority");
+  }
+  if (options.type !== void 0) {
+    validateTaskType(options.type);
+    task.type = options.type;
+    changes.push("type");
+  }
+  if (options.size !== void 0) {
+    validateSize(options.size);
+    task.size = options.size;
+    changes.push("size");
+  }
+  if (options.phase !== void 0) {
+    task.phase = options.phase;
+    changes.push("phase");
+  }
+  if (options.description !== void 0) {
+    task.description = options.description;
+    changes.push("description");
+  }
+  if (options.labels !== void 0) {
+    if (options.labels.length) validateLabels(options.labels);
+    task.labels = options.labels;
+    changes.push("labels");
+  }
+  if (options.addLabels?.length) {
+    validateLabels(options.addLabels);
+    const existing = new Set(task.labels ?? []);
+    for (const l of options.addLabels) existing.add(l.trim());
+    task.labels = [...existing];
+    changes.push("labels");
+  }
+  if (options.removeLabels?.length) {
+    const toRemove = new Set(options.removeLabels.map((l) => l.trim()));
+    task.labels = (task.labels ?? []).filter((l) => !toRemove.has(l));
+    changes.push("labels");
+  }
+  if (options.depends !== void 0) {
+    task.depends = options.depends;
+    changes.push("depends");
+  }
+  if (options.addDepends?.length) {
+    const existing = new Set(task.depends ?? []);
+    for (const d of options.addDepends) existing.add(d.trim());
+    task.depends = [...existing];
+    changes.push("depends");
+  }
+  if (options.removeDepends?.length) {
+    const toRemove = new Set(options.removeDepends.map((d) => d.trim()));
+    task.depends = (task.depends ?? []).filter((d) => !toRemove.has(d));
+    changes.push("depends");
+  }
+  if (options.notes !== void 0) {
+    const timestampedNote = `${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}: ${options.notes}`;
+    if (!task.notes) task.notes = [];
+    task.notes.push(timestampedNote);
+    changes.push("notes");
+  }
+  if (options.acceptance !== void 0) {
+    task.acceptance = options.acceptance;
+    changes.push("acceptance");
+  }
+  if (options.files !== void 0) {
+    task.files = options.files;
+    changes.push("files");
+  }
+  if (options.blockedBy !== void 0) {
+    task.blockedBy = options.blockedBy;
+    changes.push("blockedBy");
+  }
+  if (options.noAutoComplete !== void 0) {
+    task.noAutoComplete = options.noAutoComplete;
+    changes.push("noAutoComplete");
+  }
+  if (options.pipelineStage !== void 0) {
+    validatePipelineTransition(task.pipelineStage, options.pipelineStage);
+    if (task.type === "epic" && task.pipelineStage) {
+      await validateEpicStageAdvancement(
+        {
+          epicId: task.id,
+          currentStage: task.pipelineStage,
+          newStage: options.pipelineStage
+        },
+        acc,
+        cwd
+      );
+    }
+    if (task.type !== "epic") {
+      const epicAncestor = task.parentId ? await findEpicAncestor(task.parentId, acc) : null;
+      const directParent = task.parentId ? await acc.loadSingleTask(task.parentId) : null;
+      const epicToCheck = directParent?.type === "epic" ? directParent : epicAncestor;
+      if (epicToCheck) {
+        await validateChildStageCeiling(
+          { childStage: options.pipelineStage, epicId: epicToCheck.id },
+          acc,
+          cwd
+        );
+      }
+    }
+    task.pipelineStage = options.pipelineStage;
+    changes.push("pipelineStage");
+  }
+  if (options.parentId !== void 0) {
+    const newParentId = options.parentId || null;
+    const currentParentId = task.parentId ?? null;
+    if (newParentId !== currentParentId) {
+      const originalType = task.type;
+      if (!newParentId) {
+        task.parentId = null;
+        if (task.type === "subtask") task.type = "task";
+        changes.push("parentId");
+        if (task.type !== originalType) changes.push("type");
+      } else {
+        const newParent = await acc.loadSingleTask(newParentId);
+        if (!newParent) {
+          throw new CleoError(10 /* PARENT_NOT_FOUND */, `Parent task ${newParentId} not found`);
+        }
+        if (newParent.type === "subtask") {
+          throw new CleoError(
+            13 /* INVALID_PARENT_TYPE */,
+            `Cannot parent under subtask '${newParentId}'`
+          );
+        }
+        const subtree = await acc.getSubtree(options.taskId);
+        if (subtree.some((t) => t.id === newParentId)) {
+          throw new CleoError(
+            14 /* CIRCULAR_REFERENCE */,
+            `Moving '${options.taskId}' under '${newParentId}' would create a circular reference`
+          );
+        }
+        const ancestors = await acc.getAncestorChain(newParentId);
+        const parentDepth = ancestors.length;
+        const config2 = await loadConfig(cwd);
+        const policy = resolveHierarchyPolicy(config2);
+        if (parentDepth + 1 >= policy.maxDepth) {
+          throw new CleoError(
+            11 /* DEPTH_EXCEEDED */,
+            `Maximum nesting depth ${policy.maxDepth} would be exceeded`
+          );
+        }
+        task.parentId = newParentId;
+        const newDepth = parentDepth + 1;
+        if (newDepth === 1) task.type = "task";
+        else if (newDepth >= 2) task.type = "subtask";
+        changes.push("parentId");
+        if (task.type !== originalType) changes.push("type");
+      }
+    }
+  }
+  if (changes.length === 0) {
+    throw new CleoError(102 /* NO_CHANGE */, "No changes specified");
+  }
+  task.updatedAt = now2;
+  await acc.transaction(async (tx) => {
+    await tx.upsertSingleTask(task);
+    await tx.appendLog({
+      id: `log-${Math.floor(Date.now() / 1e3)}-${(await import("node:crypto")).randomBytes(3).toString("hex")}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action: "task_updated",
+      taskId: options.taskId,
+      actor: "system",
+      details: { changes, title: task.title },
+      before: null,
+      after: { changes, title: task.title }
+    });
+  });
+  return { task, changes };
+}
+var NON_STATUS_DONE_FIELDS;
+var init_update2 = __esm({
+  "packages/core/src/tasks/update.ts"() {
+    "use strict";
+    init_src();
+    init_config();
+    init_errors3();
+    init_session_enforcement();
+    init_data_accessor();
+    init_add();
+    init_complete();
+    init_enforcement();
+    init_epic_enforcement();
+    init_hierarchy_policy();
+    init_pipeline_stage();
+    NON_STATUS_DONE_FIELDS = [
+      "title",
+      "priority",
+      "type",
+      "size",
+      "phase",
+      "description",
+      "labels",
+      "addLabels",
+      "removeLabels",
+      "depends",
+      "addDepends",
+      "removeDepends",
+      "notes",
+      "acceptance",
+      "files",
+      "blockedBy",
+      "parentId",
+      "noAutoComplete",
+      "pipelineStage"
+    ];
+  }
+});
+
+// packages/core/src/nexus/workspace.ts
+function checkRateLimit(agentId) {
+  const now2 = Date.now();
+  const entry = rateLimitCounters.get(agentId);
+  if (!entry || now2 - entry.windowStart > RATE_LIMIT_WINDOW_MS) {
+    rateLimitCounters.set(agentId, { count: 1, windowStart: now2 });
+    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`
+    );
+  }
+}
+async function loadProjectACL(projectPath) {
+  try {
+    const { loadConfig: loadConfig4 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig4(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);
+}
+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
+  };
+}
+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: startTask3 } = await Promise.resolve().then(() => (init_task_work(), task_work_exports));
+      await startTask3(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: stopTask3 } = await Promise.resolve().then(() => (init_task_work(), task_work_exports));
+      await stopTask3(projectPath, accessor);
+      break;
+    }
+    case "tasks.update": {
+      const { updateTask: updateTask3 } = await Promise.resolve().then(() => (init_update2(), update_exports));
+      await updateTask3(
+        { 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 log11 = getLogger2("nexus.route");
+    const level = success2 ? "info" : "warn";
+    log11[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 counts2 = {
+        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: counts2,
+        health: project.healthStatus,
+        lastSync: project.lastSync
+      });
+      totals.pending += counts2.pending;
+      totals.active += counts2.active;
+      totals.done += counts2.done;
+      totals.total += counts2.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;
+}
+var RATE_LIMIT_WINDOW_MS, RATE_LIMIT_MAX_OPS, rateLimitCounters, DEFAULT_ACL, TASK_REF_PATTERN, VERB_TO_OPERATION;
+var init_workspace = __esm({
+  "packages/core/src/nexus/workspace.ts"() {
+    "use strict";
+    init_src();
+    init_errors3();
+    init_data_accessor();
+    init_registry3();
+    RATE_LIMIT_WINDOW_MS = 6e4;
+    RATE_LIMIT_MAX_OPS = 100;
+    rateLimitCounters = /* @__PURE__ */ new Map();
+    DEFAULT_ACL = { authorizedAgents: ["*"] };
+    TASK_REF_PATTERN = /\bT(\d+)\b/g;
+    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"
+    };
+  }
+});
+
 // packages/core/src/nexus/index.ts
 var nexus_exports = {};
 __export(nexus_exports, {
@@ -47963,6 +49143,7 @@ __export(nexus_exports, {
   nexusSyncAll: () => nexusSyncAll,
   nexusUnregister: () => nexusUnregister,
   orphanDetection: () => orphanDetection,
+  parseDirective: () => parseDirective,
   parseQuery: () => parseQuery,
   permissionLevel: () => permissionLevel,
   previewTransfer: () => previewTransfer,
@@ -47973,10 +49154,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
 });
 var init_nexus = __esm({
   "packages/core/src/nexus/index.ts"() {
@@ -47989,6 +49173,7 @@ var init_nexus = __esm({
     init_registry3();
     init_sharing();
     init_transfer();
+    init_workspace();
   }
 });
 
@@ -49524,485 +50709,6 @@ var init_pipeline2 = __esm({
   }
 });
 
-// packages/core/src/tasks/complete.ts
-function isVerificationGate(value) {
-  return VERIFICATION_GATES.has(value);
-}
-async function loadCompletionEnforcement(cwd) {
-  const isTest = !!process.env.VITEST;
-  const config2 = await loadConfig(cwd);
-  const acceptance = config2.enforcement?.acceptance;
-  const verificationCfg = config2.verification;
-  const acceptanceMode = acceptance?.mode ?? (isTest ? "off" : "block");
-  const acceptanceRequiredForPriorities = acceptance?.requiredForPriorities ?? (isTest ? [] : ["critical", "high", "medium", "low"]);
-  const rawVerificationEnabled = await getRawConfigValue("verification.enabled", cwd);
-  const verificationEnabled = rawVerificationEnabled !== void 0 ? rawVerificationEnabled : !isTest;
-  const verificationRequiredGates = (verificationCfg?.requiredGates ?? []).filter(isVerificationGate).length > 0 ? (verificationCfg?.requiredGates ?? []).filter(isVerificationGate) : DEFAULT_VERIFICATION_REQUIRED_GATES;
-  const verificationMaxRounds = verificationCfg?.maxRounds ?? 5;
-  const lifecycleMode = config2.lifecycle?.mode ?? (isTest ? "off" : "strict");
-  return {
-    acceptanceMode,
-    acceptanceRequiredForPriorities,
-    verificationEnabled,
-    verificationRequiredGates,
-    verificationMaxRounds,
-    lifecycleMode
-  };
-}
-async function completeTask(options, cwd, accessor) {
-  const acc = accessor ?? await getAccessor(cwd);
-  const task = await acc.loadSingleTask(options.taskId);
-  if (!task) {
-    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${options.taskId}`, {
-      fix: `Use 'cleo find "${options.taskId}"' to search`
-    });
-  }
-  await requireActiveSession("tasks.complete", cwd);
-  const enforcement = await loadCompletionEnforcement(cwd);
-  if (task.status === "done") {
-    throw new CleoError(17 /* TASK_COMPLETED */, `Task ${options.taskId} is already completed`);
-  }
-  if (task.depends?.length) {
-    const deps = await acc.loadTasks(task.depends);
-    const incompleteDeps = deps.filter((d) => d.status !== "done" && d.status !== "cancelled").map((d) => d.id);
-    if (incompleteDeps.length > 0) {
-      throw new CleoError(
-        5 /* DEPENDENCY_ERROR */,
-        `Task ${options.taskId} has incomplete dependencies: ${incompleteDeps.join(", ")}`,
-        {
-          fix: `Complete dependencies first: ${incompleteDeps.map((d) => `cleo complete ${d}`).join(", ")}`
-        }
-      );
-    }
-  }
-  const acceptanceEnforcement = await createAcceptanceEnforcement(cwd);
-  const completionValidation = acceptanceEnforcement.validateCompletion(task);
-  if (!completionValidation.valid) {
-    throw new CleoError(
-      completionValidation.exitCode ?? 6 /* VALIDATION_ERROR */,
-      completionValidation.error,
-      { fix: completionValidation.fix }
-    );
-  }
-  if (enforcement.verificationEnabled && task.type !== "epic") {
-    if (!task.verification) {
-      throw new CleoError(
-        40 /* VERIFICATION_INIT_FAILED */,
-        `Task ${options.taskId} is missing verification metadata`,
-        {
-          fix: `Initialize verification for ${options.taskId} before completion`
-        }
-      );
-    }
-    if (task.verification.round > enforcement.verificationMaxRounds) {
-      throw new CleoError(
-        44 /* MAX_ROUNDS_EXCEEDED */,
-        `Task ${options.taskId} exceeded verification max rounds (${enforcement.verificationMaxRounds})`,
-        {
-          fix: `Review failure log and resolve blockers before retrying completion`
-        }
-      );
-    }
-    const missingRequiredGates = enforcement.verificationRequiredGates.filter(
-      (gate) => task.verification?.gates?.[gate] !== true
-    );
-    if (missingRequiredGates.length > 0 || task.verification.passed !== true) {
-      const exitCode = enforcement.lifecycleMode === "strict" ? 80 /* LIFECYCLE_GATE_FAILED */ : 45 /* GATE_DEPENDENCY */;
-      throw new CleoError(
-        exitCode,
-        `Task ${options.taskId} failed verification gates: ${missingRequiredGates.join(", ") || "verification.passed=false"}`,
-        {
-          fix: `Set required verification gates before completion: ${enforcement.verificationRequiredGates.join(", ")}`
-        }
-      );
-    }
-  }
-  const children = await acc.getChildren(options.taskId);
-  const incompleteChildren = children.filter(
-    (c) => c.status !== "done" && c.status !== "cancelled"
-  );
-  if (incompleteChildren.length > 0 && task.type === "epic") {
-    if (!task.noAutoComplete) {
-      throw new CleoError(
-        16 /* HAS_CHILDREN */,
-        `Epic ${options.taskId} has ${incompleteChildren.length} incomplete children: ${incompleteChildren.map((c) => c.id).join(", ")}`,
-        {
-          fix: `Complete children first or use 'cleo update ${options.taskId} --no-auto-complete'`
-        }
-      );
-    }
-  }
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const before = { ...task };
-  task.status = "done";
-  task.completedAt = now2;
-  task.updatedAt = now2;
-  if (options.notes) {
-    const timestampedNote = `${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}: ${options.notes}`;
-    if (!task.notes) task.notes = [];
-    task.notes.push(timestampedNote);
-  }
-  if (options.changeset) {
-    if (!task.notes) task.notes = [];
-    task.notes.push(`Changeset: ${options.changeset}`);
-  }
-  const autoCompleted = [];
-  const autoCompletedTasks = [];
-  if (task.parentId) {
-    const parent = await acc.loadSingleTask(task.parentId);
-    if (parent && parent.type === "epic" && !parent.noAutoComplete) {
-      const siblings = await acc.getChildren(parent.id);
-      const allDone = siblings.every(
-        (c) => c.id === task.id || c.status === "done" || c.status === "cancelled"
-      );
-      if (allDone) {
-        parent.status = "done";
-        parent.completedAt = now2;
-        parent.updatedAt = now2;
-        autoCompleted.push(parent.id);
-        autoCompletedTasks.push(parent);
-      }
-    }
-  }
-  await acc.transaction(async (tx) => {
-    await tx.upsertSingleTask(task);
-    for (const parentTask of autoCompletedTasks) {
-      await tx.upsertSingleTask(parentTask);
-    }
-    await tx.appendLog({
-      id: `log-${Math.floor(Date.now() / 1e3)}-${(await import("node:crypto")).randomBytes(3).toString("hex")}`,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      action: "task_completed",
-      taskId: options.taskId,
-      actor: "system",
-      details: { title: task.title, previousStatus: before.status },
-      before: null,
-      after: { title: task.title, previousStatus: before.status }
-    });
-  });
-  const dependents = await acc.getDependents(options.taskId);
-  const unblockedTasks = [];
-  for (const dep of dependents) {
-    if (dep.status === "done" || dep.status === "cancelled") continue;
-    if (dep.depends?.length) {
-      const depDeps = await acc.loadTasks(dep.depends);
-      const stillUnresolved = depDeps.filter(
-        (d) => d.id !== options.taskId && d.status !== "done" && d.status !== "cancelled"
-      );
-      if (stillUnresolved.length === 0) {
-        unblockedTasks.push({ id: dep.id, title: dep.title });
-      }
-    } else {
-      unblockedTasks.push({ id: dep.id, title: dep.title });
-    }
-  }
-  Promise.resolve().then(() => (init_auto_extract(), auto_extract_exports)).then(
-    ({ extractTaskCompletionMemory: extractTaskCompletionMemory2 }) => extractTaskCompletionMemory2(cwd ?? process.cwd(), task)
-  ).catch(() => {
-  });
-  return {
-    task,
-    ...autoCompleted.length > 0 && { autoCompleted },
-    ...unblockedTasks.length > 0 && { unblockedTasks }
-  };
-}
-var DEFAULT_VERIFICATION_REQUIRED_GATES, VERIFICATION_GATES;
-var init_complete = __esm({
-  "packages/core/src/tasks/complete.ts"() {
-    "use strict";
-    init_src();
-    init_config();
-    init_errors3();
-    init_session_enforcement();
-    init_data_accessor();
-    init_enforcement();
-    DEFAULT_VERIFICATION_REQUIRED_GATES = [
-      "implemented",
-      "testsPassed",
-      "qaPassed",
-      "securityPassed",
-      "documented"
-    ];
-    VERIFICATION_GATES = /* @__PURE__ */ new Set([
-      "implemented",
-      "testsPassed",
-      "qaPassed",
-      "cleanupDone",
-      "securityPassed",
-      "documented"
-    ]);
-  }
-});
-
-// packages/core/src/tasks/update.ts
-var update_exports = {};
-__export(update_exports, {
-  updateTask: () => updateTask
-});
-function hasNonStatusDoneFields(options) {
-  return NON_STATUS_DONE_FIELDS.some((field) => options[field] !== void 0);
-}
-async function updateTask(options, cwd, accessor) {
-  const acc = accessor ?? await getAccessor(cwd);
-  const task = await acc.loadSingleTask(options.taskId);
-  if (!task) {
-    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${options.taskId}`, {
-      fix: `Use 'cleo find "${options.taskId}"' to search`
-    });
-  }
-  await requireActiveSession("tasks.update", cwd);
-  const changes = [];
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const isStatusOnlyDoneTransition = options.status === "done" && task.status !== "done" && !hasNonStatusDoneFields(options);
-  if (isStatusOnlyDoneTransition) {
-    const result = await completeTask({ taskId: options.taskId }, cwd, accessor);
-    return { task: result.task, changes: ["status"] };
-  }
-  if (options.status === "done" && task.status !== "done") {
-    throw new CleoError(
-      6 /* VALIDATION_ERROR */,
-      "status=done must use complete flow; do not combine with other update fields",
-      {
-        fix: `Run 'cleo complete ${options.taskId}' first, then apply additional updates with 'cleo update ${options.taskId} ...'`
-      }
-    );
-  }
-  const enforcement = await createAcceptanceEnforcement(cwd);
-  const updateValidation = enforcement.validateUpdate(task, { acceptance: options.acceptance });
-  if (!updateValidation.valid) {
-    throw new CleoError(
-      updateValidation.exitCode ?? 6 /* VALIDATION_ERROR */,
-      updateValidation.error,
-      { fix: updateValidation.fix }
-    );
-  }
-  if (options.title !== void 0) {
-    validateTitle(options.title);
-    task.title = options.title;
-    changes.push("title");
-  }
-  if (options.status !== void 0) {
-    validateStatus(options.status);
-    const oldStatus = task.status;
-    task.status = options.status;
-    changes.push("status");
-    if (options.status === "done" && oldStatus !== "done") {
-      task.completedAt = now2;
-    }
-    if (options.status === "cancelled" && oldStatus !== "cancelled") {
-      task.cancelledAt = now2;
-    }
-  }
-  if (options.priority !== void 0) {
-    const normalizedPriority = normalizePriority(options.priority);
-    task.priority = normalizedPriority;
-    changes.push("priority");
-  }
-  if (options.type !== void 0) {
-    validateTaskType(options.type);
-    task.type = options.type;
-    changes.push("type");
-  }
-  if (options.size !== void 0) {
-    validateSize(options.size);
-    task.size = options.size;
-    changes.push("size");
-  }
-  if (options.phase !== void 0) {
-    task.phase = options.phase;
-    changes.push("phase");
-  }
-  if (options.description !== void 0) {
-    task.description = options.description;
-    changes.push("description");
-  }
-  if (options.labels !== void 0) {
-    if (options.labels.length) validateLabels(options.labels);
-    task.labels = options.labels;
-    changes.push("labels");
-  }
-  if (options.addLabels?.length) {
-    validateLabels(options.addLabels);
-    const existing = new Set(task.labels ?? []);
-    for (const l of options.addLabels) existing.add(l.trim());
-    task.labels = [...existing];
-    changes.push("labels");
-  }
-  if (options.removeLabels?.length) {
-    const toRemove = new Set(options.removeLabels.map((l) => l.trim()));
-    task.labels = (task.labels ?? []).filter((l) => !toRemove.has(l));
-    changes.push("labels");
-  }
-  if (options.depends !== void 0) {
-    task.depends = options.depends;
-    changes.push("depends");
-  }
-  if (options.addDepends?.length) {
-    const existing = new Set(task.depends ?? []);
-    for (const d of options.addDepends) existing.add(d.trim());
-    task.depends = [...existing];
-    changes.push("depends");
-  }
-  if (options.removeDepends?.length) {
-    const toRemove = new Set(options.removeDepends.map((d) => d.trim()));
-    task.depends = (task.depends ?? []).filter((d) => !toRemove.has(d));
-    changes.push("depends");
-  }
-  if (options.notes !== void 0) {
-    const timestampedNote = `${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}: ${options.notes}`;
-    if (!task.notes) task.notes = [];
-    task.notes.push(timestampedNote);
-    changes.push("notes");
-  }
-  if (options.acceptance !== void 0) {
-    task.acceptance = options.acceptance;
-    changes.push("acceptance");
-  }
-  if (options.files !== void 0) {
-    task.files = options.files;
-    changes.push("files");
-  }
-  if (options.blockedBy !== void 0) {
-    task.blockedBy = options.blockedBy;
-    changes.push("blockedBy");
-  }
-  if (options.noAutoComplete !== void 0) {
-    task.noAutoComplete = options.noAutoComplete;
-    changes.push("noAutoComplete");
-  }
-  if (options.pipelineStage !== void 0) {
-    validatePipelineTransition(task.pipelineStage, options.pipelineStage);
-    if (task.type === "epic" && task.pipelineStage) {
-      await validateEpicStageAdvancement(
-        {
-          epicId: task.id,
-          currentStage: task.pipelineStage,
-          newStage: options.pipelineStage
-        },
-        acc,
-        cwd
-      );
-    }
-    if (task.type !== "epic") {
-      const epicAncestor = task.parentId ? await findEpicAncestor(task.parentId, acc) : null;
-      const directParent = task.parentId ? await acc.loadSingleTask(task.parentId) : null;
-      const epicToCheck = directParent?.type === "epic" ? directParent : epicAncestor;
-      if (epicToCheck) {
-        await validateChildStageCeiling(
-          { childStage: options.pipelineStage, epicId: epicToCheck.id },
-          acc,
-          cwd
-        );
-      }
-    }
-    task.pipelineStage = options.pipelineStage;
-    changes.push("pipelineStage");
-  }
-  if (options.parentId !== void 0) {
-    const newParentId = options.parentId || null;
-    const currentParentId = task.parentId ?? null;
-    if (newParentId !== currentParentId) {
-      const originalType = task.type;
-      if (!newParentId) {
-        task.parentId = null;
-        if (task.type === "subtask") task.type = "task";
-        changes.push("parentId");
-        if (task.type !== originalType) changes.push("type");
-      } else {
-        const newParent = await acc.loadSingleTask(newParentId);
-        if (!newParent) {
-          throw new CleoError(10 /* PARENT_NOT_FOUND */, `Parent task ${newParentId} not found`);
-        }
-        if (newParent.type === "subtask") {
-          throw new CleoError(
-            13 /* INVALID_PARENT_TYPE */,
-            `Cannot parent under subtask '${newParentId}'`
-          );
-        }
-        const subtree = await acc.getSubtree(options.taskId);
-        if (subtree.some((t) => t.id === newParentId)) {
-          throw new CleoError(
-            14 /* CIRCULAR_REFERENCE */,
-            `Moving '${options.taskId}' under '${newParentId}' would create a circular reference`
-          );
-        }
-        const ancestors = await acc.getAncestorChain(newParentId);
-        const parentDepth = ancestors.length;
-        const config2 = await loadConfig(cwd);
-        const policy = resolveHierarchyPolicy(config2);
-        if (parentDepth + 1 >= policy.maxDepth) {
-          throw new CleoError(
-            11 /* DEPTH_EXCEEDED */,
-            `Maximum nesting depth ${policy.maxDepth} would be exceeded`
-          );
-        }
-        task.parentId = newParentId;
-        const newDepth = parentDepth + 1;
-        if (newDepth === 1) task.type = "task";
-        else if (newDepth >= 2) task.type = "subtask";
-        changes.push("parentId");
-        if (task.type !== originalType) changes.push("type");
-      }
-    }
-  }
-  if (changes.length === 0) {
-    throw new CleoError(102 /* NO_CHANGE */, "No changes specified");
-  }
-  task.updatedAt = now2;
-  await acc.transaction(async (tx) => {
-    await tx.upsertSingleTask(task);
-    await tx.appendLog({
-      id: `log-${Math.floor(Date.now() / 1e3)}-${(await import("node:crypto")).randomBytes(3).toString("hex")}`,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      action: "task_updated",
-      taskId: options.taskId,
-      actor: "system",
-      details: { changes, title: task.title },
-      before: null,
-      after: { changes, title: task.title }
-    });
-  });
-  return { task, changes };
-}
-var NON_STATUS_DONE_FIELDS;
-var init_update2 = __esm({
-  "packages/core/src/tasks/update.ts"() {
-    "use strict";
-    init_src();
-    init_config();
-    init_errors3();
-    init_session_enforcement();
-    init_data_accessor();
-    init_add();
-    init_complete();
-    init_enforcement();
-    init_epic_enforcement();
-    init_hierarchy_policy();
-    init_pipeline_stage();
-    NON_STATUS_DONE_FIELDS = [
-      "title",
-      "priority",
-      "type",
-      "size",
-      "phase",
-      "description",
-      "labels",
-      "addLabels",
-      "removeLabels",
-      "depends",
-      "addDepends",
-      "removeDepends",
-      "notes",
-      "acceptance",
-      "files",
-      "blockedBy",
-      "parentId",
-      "noAutoComplete",
-      "pipelineStage"
-    ];
-  }
-});
-
 // packages/core/src/reconciliation/reconciliation-engine.ts
 function buildTaskMap(tasks2) {
   const map2 = /* @__PURE__ */ new Map();
@@ -62387,145 +63093,6 @@ var init_system2 = __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("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 now2 = (/* @__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: now2,
-      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/archive.ts
 async function archiveTasks(options = {}, cwd, accessor) {
   const acc = accessor ?? await getAccessor(cwd);
@@ -67985,7 +68552,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,
@@ -68028,6 +68595,7 @@ var init_cleo = __esm({
     init_permissions();
     init_registry3();
     init_sharing();
+    init_workspace();
     init_orchestration();
     init_reconciliation();
     init_link_store();
@@ -68266,7 +68834,14 @@ var init_cleo = __esm({
           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 ===
@@ -69575,6 +70150,14 @@ var init_protocol_enforcement = __esm({
 });
 
 // packages/core/src/hooks/types.ts
+import {
+  buildHookMatrix,
+  CANONICAL_HOOK_EVENTS,
+  HOOK_CATEGORIES,
+  supportsHook,
+  toCanonical,
+  toNative
+} from "@cleocode/caamp";
 import { getCommonHookEvents, getProvidersByHookEvent } from "@cleocode/caamp";
 function isProviderHookEvent(event) {
   return !INTERNAL_HOOK_EVENT_SET.has(event);
@@ -75385,7 +75968,7 @@ async function runUpgrade(options = {}) {
           return { success: false, upToDate: false, dryRun: isDryRun, actions, applied: 0, errors };
         }
         await forceCheckpointBeforeOperation("storage-migration", options.cwd);
-        const { MigrationLogger: MigrationLogger2 } = await Promise.resolve().then(() => (init_logger3(), logger_exports));
+        const { MigrationLogger: MigrationLogger2 } = await Promise.resolve().then(() => (init_logger3(), logger_exports2));
         const {
           createMigrationState: createMigrationState2,
           updateMigrationPhase: updateMigrationPhase2,
@@ -82384,6 +82967,30 @@ var init_registry5 = __esm({
         sessionRequired: false,
         requiredParams: []
       },
+      {
+        gateway: "query",
+        domain: "admin",
+        operation: "hooks.matrix",
+        description: "admin.hooks.matrix (query) \u2014 cross-provider hook support matrix using CAAMP canonical taxonomy",
+        tier: 1,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: [],
+        params: [
+          {
+            name: "providerIds",
+            type: "string",
+            required: false,
+            description: "Limit matrix to specific provider IDs (default: all mapped providers)"
+          },
+          {
+            name: "detectProvider",
+            type: "boolean",
+            required: false,
+            description: "Detect current runtime provider (default: true)"
+          }
+        ]
+      },
       {
         gateway: "query",
         domain: "admin",
@@ -83208,6 +83815,114 @@ var init_config_engine = __esm({
   }
 });
 
+// packages/cleo/src/dispatch/engines/hooks-engine.ts
+var hooks_engine_exports = {};
+__export(hooks_engine_exports, {
+  queryCommonHooks: () => queryCommonHooks,
+  queryHookProviders: () => queryHookProviders,
+  systemHooksMatrix: () => systemHooksMatrix
+});
+async function queryHookProviders(event) {
+  if (!isProviderHookEvent(event)) {
+    return engineSuccess({
+      event,
+      providers: []
+    });
+  }
+  const { getProvidersByHookEvent: getProvidersByHookEvent2 } = await import("@cleocode/caamp");
+  const providers = getProvidersByHookEvent2(event);
+  return engineSuccess({
+    event,
+    providers: providers.map((p) => ({
+      id: p.id,
+      name: p.name,
+      supportedHooks: p.capabilities?.hooks?.supported ?? []
+    }))
+  });
+}
+async function queryCommonHooks(providerIds) {
+  const { getCommonHookEvents: getCommonHookEvents2 } = await import("@cleocode/caamp");
+  const commonEvents = getCommonHookEvents2(providerIds);
+  return engineSuccess({
+    providerIds,
+    commonEvents
+  });
+}
+async function systemHooksMatrix(params) {
+  try {
+    const { buildHookMatrix: buildHookMatrix2, getProviderSummary, getHookMappingsVersion, detectAllProviders: detectAllProviders3 } = await import("@cleocode/caamp");
+    const caampVersion = getHookMappingsVersion();
+    const raw = buildHookMatrix2(params?.providerIds);
+    const boolMatrix = {};
+    for (const event of raw.events) {
+      boolMatrix[event] = {};
+      for (const providerId of raw.providers) {
+        const mapping = raw.matrix[event]?.[providerId];
+        boolMatrix[event][providerId] = mapping?.supported ?? false;
+      }
+    }
+    const summary = raw.providers.map((providerId) => {
+      const provSummary = getProviderSummary(providerId);
+      if (provSummary) {
+        return {
+          providerId,
+          supportedCount: provSummary.supportedCount,
+          totalCanonical: provSummary.totalCanonical,
+          coverage: provSummary.coverage,
+          supported: provSummary.supported,
+          unsupported: provSummary.unsupported
+        };
+      }
+      const supported = raw.events.filter((ev) => boolMatrix[ev]?.[providerId] === true);
+      const unsupported = raw.events.filter((ev) => boolMatrix[ev]?.[providerId] !== true);
+      const totalCanonical = raw.events.length;
+      const coverage = totalCanonical > 0 ? Math.round(supported.length / totalCanonical * 100) : 0;
+      return {
+        providerId,
+        supportedCount: supported.length,
+        totalCanonical,
+        coverage,
+        supported,
+        unsupported
+      };
+    });
+    let detectedProvider = null;
+    const shouldDetect = params?.detectProvider !== false;
+    if (shouldDetect) {
+      try {
+        const detectionResults = detectAllProviders3();
+        const detected = detectionResults.find((r) => r.installed && r.projectDetected);
+        if (detected) {
+          detectedProvider = detected.provider.id;
+        } else {
+          const anyInstalled = detectionResults.find((r) => r.installed);
+          if (anyInstalled) {
+            detectedProvider = anyInstalled.provider.id;
+          }
+        }
+      } catch {
+      }
+    }
+    return engineSuccess({
+      caampVersion,
+      events: raw.events,
+      providers: raw.providers,
+      matrix: boolMatrix,
+      summary,
+      detectedProvider
+    });
+  } catch (err) {
+    return engineError("E_GENERAL", err.message);
+  }
+}
+var init_hooks_engine = __esm({
+  "packages/cleo/src/dispatch/engines/hooks-engine.ts"() {
+    "use strict";
+    init_internal();
+    init_error();
+  }
+});
+
 // packages/cleo/src/dispatch/engines/init-engine.ts
 async function initProject2(projectRoot, options) {
   try {
@@ -86573,7 +87288,7 @@ async function dispatchFromCli(gateway, domain2, operation, params, outputOpts)
   const dispatcher = getCliDispatcher();
   const projectRoot = getProjectRoot();
   const dispatchStart = Date.now();
-  hooks.dispatch("onPromptSubmit", projectRoot, {
+  hooks.dispatch("PromptSubmit", projectRoot, {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     gateway,
     domain: domain2,
@@ -86589,7 +87304,7 @@ async function dispatchFromCli(gateway, domain2, operation, params, outputOpts)
     source: "cli",
     requestId: randomUUID10()
   });
-  hooks.dispatch("onResponseComplete", projectRoot, {
+  hooks.dispatch("ResponseComplete", projectRoot, {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     gateway,
     domain: domain2,
@@ -86646,7 +87361,7 @@ async function dispatchRaw(gateway, domain2, operation, params) {
   const dispatcher = getCliDispatcher();
   const projectRoot = getProjectRoot();
   const dispatchStart = Date.now();
-  hooks.dispatch("onPromptSubmit", projectRoot, {
+  hooks.dispatch("PromptSubmit", projectRoot, {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     gateway,
     domain: domain2,
@@ -86662,7 +87377,7 @@ async function dispatchRaw(gateway, domain2, operation, params) {
     source: "cli",
     requestId: randomUUID10()
   });
-  hooks.dispatch("onResponseComplete", projectRoot, {
+  hooks.dispatch("ResponseComplete", projectRoot, {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     gateway,
     domain: domain2,
@@ -88494,6 +89209,7 @@ var init_engine2 = __esm({
     init_internal();
     init_codebase_map_engine();
     init_config_engine();
+    init_hooks_engine();
     init_init_engine();
     init_lifecycle_engine();
     init_memory_engine();
@@ -89022,6 +89738,13 @@ var init_admin2 = __esm({
               const result = await systemSmoke();
               return wrapResult(result, "query", "admin", operation, startTime);
             }
+            case "hooks.matrix": {
+              const result = await systemHooksMatrix({
+                providerIds: params?.providerIds,
+                detectProvider: params?.detectProvider !== false
+              });
+              return wrapResult(result, "query", "admin", operation, startTime);
+            }
             default:
               return unsupportedOp("query", "admin", operation, startTime);
           }
@@ -89506,7 +90229,8 @@ var init_admin2 = __esm({
             "backup",
             "export",
             "map",
-            "smoke"
+            "smoke",
+            "hooks.matrix"
           ],
           mutate: [
             "init",
@@ -93208,46 +93932,6 @@ var init_tasks4 = __esm({
   }
 });
 
-// packages/cleo/src/dispatch/engines/hooks-engine.ts
-var hooks_engine_exports = {};
-__export(hooks_engine_exports, {
-  queryCommonHooks: () => queryCommonHooks,
-  queryHookProviders: () => queryHookProviders
-});
-async function queryHookProviders(event) {
-  if (!isProviderHookEvent(event)) {
-    return engineSuccess({
-      event,
-      providers: []
-    });
-  }
-  const { getProvidersByHookEvent: getProvidersByHookEvent2 } = await import("@cleocode/caamp");
-  const providers = getProvidersByHookEvent2(event);
-  return engineSuccess({
-    event,
-    providers: providers.map((p) => ({
-      id: p.id,
-      name: p.name,
-      supportedHooks: p.capabilities?.hooks?.supported ?? []
-    }))
-  });
-}
-async function queryCommonHooks(providerIds) {
-  const { getCommonHookEvents: getCommonHookEvents2 } = await import("@cleocode/caamp");
-  const commonEvents = getCommonHookEvents2(providerIds);
-  return engineSuccess({
-    providerIds,
-    commonEvents
-  });
-}
-var init_hooks_engine = __esm({
-  "packages/cleo/src/dispatch/engines/hooks-engine.ts"() {
-    "use strict";
-    init_internal();
-    init_error();
-  }
-});
-
 // packages/cleo/src/dispatch/engines/tools-engine.ts
 import {
   buildInjectionContent,
@@ -98936,7 +99620,7 @@ async function main() {
             };
           }
         }
-        hooks.dispatch("onPromptSubmit", process.cwd(), {
+        hooks.dispatch("PromptSubmit", process.cwd(), {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           gateway: name2,
           domain: domain2,
@@ -98946,7 +99630,7 @@ async function main() {
         });
         const dispatchStart = Date.now();
         let result = await handleMcpToolCall(name2, domain2, operation, params);
-        hooks.dispatch("onResponseComplete", process.cwd(), {
+        hooks.dispatch("ResponseComplete", process.cwd(), {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           gateway: name2,
           domain: domain2,
@@ -99014,7 +99698,7 @@ async function main() {
       } catch (error40) {
         reqLog.error({ err: error40 }, "Tool call error");
         const errorMessage = error40 instanceof Error ? error40.message : String(error40);
-        hooks.dispatch("onError", process.cwd(), {
+        hooks.dispatch("PostToolUseFailure", process.cwd(), {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           errorCode: "E_INTERNAL_ERROR",
           message: errorMessage,