@mutagent/cli 0.1.131 → 0.1.133

package/dist/bin/cli.js

@@ -1243,8 +1243,8 @@ var init_sdk_client = __esm(() => {
 // src/bin/cli.ts
 import { Command as Command21 } from "commander";
 import chalk39 from "chalk";
-import { readFileSync as readFileSync12, existsSync as existsSync14 } from "fs";
-import { join as join10, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync15 } from "fs";
+import { join as join11, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/auth.ts
@@ -10684,28 +10684,16 @@ Examples:
   return usage;
 }
 
-// src/commands/hooks.ts
-init_config();
+// src/commands/hooks/index.ts
 import { Command as Command19 } from "commander";
+
+// src/commands/hooks/handlers-core.ts
 import { randomUUID } from "crypto";
+
+// src/commands/hooks/state.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, renameSync, unlinkSync, existsSync as existsSync13 } from "fs";
 import { join as join8 } from "path";
 import { tmpdir } from "os";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, unlinkSync, existsSync as existsSync13, mkdirSync as mkdirSync5 } from "fs";
-async function safeExecute(fn) {
-  try {
-    await fn();
-  } catch (err) {
-    process.stderr.write(`[mutagent hooks] Warning: ${err instanceof Error ? err.message : String(err)}
-`);
-  }
-}
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  }
-  return JSON.parse(Buffer.concat(chunks).toString("utf-8"));
-}
 function stateFilePath(sessionId) {
   return join8(tmpdir(), `mutagent-hook-${sessionId}.json`);
 }
@@ -10714,13 +10702,23 @@ function readState(sessionId) {
   if (!existsSync13(path))
     return null;
   try {
-    return JSON.parse(readFileSync10(path, "utf-8"));
+    const raw = JSON.parse(readFileSync10(path, "utf-8"));
+    if (!Array.isArray(raw.parentStack)) {
+      raw.parentStack = [];
+    }
+    if (!Array.isArray(raw.parentStackKinds)) {
+      raw.parentStackKinds = raw.parentStack.map(() => "agent");
+    }
+    return raw;
   } catch {
     return null;
   }
 }
 function writeState(sessionId, state) {
-  writeFileSync6(stateFilePath(sessionId), JSON.stringify(state), "utf-8");
+  const path = stateFilePath(sessionId);
+  const tmpPath = `${path}.${process.pid.toString()}.tmp`;
+  writeFileSync6(tmpPath, JSON.stringify(state), "utf-8");
+  renameSync(tmpPath, path);
 }
 function deleteState(sessionId) {
   const path = stateFilePath(sessionId);
@@ -10730,6 +10728,30 @@ function deleteState(sessionId) {
     } catch {}
   }
 }
+function pushParent(state, spanId, kind = "agent") {
+  state.parentStack.push(spanId);
+  state.parentStackKinds.push(kind);
+  return state;
+}
+function popParent(state) {
+  if (state.parentStack.length === 0)
+    return null;
+  state.parentStackKinds.pop();
+  return state.parentStack.pop() ?? null;
+}
+function peekParent(state) {
+  if (state.parentStack.length === 0)
+    return null;
+  return state.parentStack[state.parentStack.length - 1] ?? null;
+}
+function peekParentKind(state) {
+  if (state.parentStackKinds.length === 0)
+    return null;
+  return state.parentStackKinds[state.parentStackKinds.length - 1] ?? null;
+}
+
+// src/commands/hooks/api.ts
+init_config();
 var API_TIMEOUT_MS = 5000;
 async function sendBatchTrace(traces) {
   const apiKey = getApiKey();
@@ -10770,6 +10792,23 @@ async function sendBatchTrace(traces) {
     clearTimeout(timeout);
   }
 }
+
+// src/commands/hooks/handlers-core.ts
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+}
+async function safeExecute(fn) {
+  try {
+    await fn();
+  } catch (err) {
+    process.stderr.write(`[mutagent hooks] Warning: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
 function getString(input, ...keys) {
   for (const key of keys) {
     const val = input[key];
@@ -10790,12 +10829,16 @@ async function handleSessionStart() {
     throw new Error("Missing session_id in stdin");
   const now = new Date().toISOString();
   const traceId = `cc-${sessionId}`;
+  const rootSpanId = randomUUID();
   const state = {
     traceId,
     sessionId,
     startTime: now,
-    openSpans: {}
+    openSpans: {},
+    parentStack: [],
+    parentStackKinds: []
   };
+  pushParent(state, rootSpanId, "agent");
   writeState(sessionId, state);
   await sendBatchTrace([
     {
@@ -10805,7 +10848,16 @@ async function handleSessionStart() {
       source: "sdk",
       startTime: now,
       status: "running",
-      spans: []
+      spans: [
+        {
+          spanId: rootSpanId,
+          name: "Claude Code Session",
+          kind: "agent",
+          startTime: now,
+          status: "running",
+          parentSpanId: null
+        }
+      ]
     }
   ]);
 }
@@ -10818,6 +10870,39 @@ async function handleSessionEnd() {
   const state = readState(sessionId);
   const traceId = state?.traceId ?? `cc-${sessionId}`;
   const startTime = state?.startTime ?? now;
+  const spansToClose = [];
+  if (state && state.parentStack.length > 0) {
+    const stackCopy = [...state.parentStack];
+    const kindsCopy = [...state.parentStackKinds];
+    for (let i = stackCopy.length - 1;i > 0; i--) {
+      const orphanId = stackCopy[i];
+      const orphanKind = kindsCopy[i] ?? "agent";
+      if (orphanId) {
+        spansToClose.push({
+          spanId: orphanId,
+          name: "orphaned span",
+          kind: orphanKind,
+          startTime: now,
+          endTime: now,
+          status: "error",
+          output: "orphaned at session end",
+          parentSpanId: stackCopy[i - 1] ?? null
+        });
+      }
+    }
+    const rootSpanId = stackCopy[0];
+    if (rootSpanId) {
+      spansToClose.push({
+        spanId: rootSpanId,
+        name: "Claude Code Session",
+        kind: "agent",
+        startTime: state.startTime,
+        endTime: now,
+        status: "completed",
+        parentSpanId: null
+      });
+    }
+  }
   await sendBatchTrace([
     {
       traceId,
@@ -10827,7 +10912,7 @@ async function handleSessionEnd() {
       startTime,
       endTime: now,
       status: "completed",
-      spans: []
+      spans: spansToClose
     }
   ]);
   deleteState(sessionId);
@@ -10843,8 +10928,11 @@ async function handlePreToolUse() {
     traceId: `cc-${sessionId}`,
     sessionId,
     startTime: now,
-    openSpans: {}
+    openSpans: {},
+    parentStack: [],
+    parentStackKinds: []
   };
+  const parentSpanId = peekParent(state);
   const spanId = randomUUID();
   state.openSpans[spanId] = {
     spanId,
@@ -10868,7 +10956,8 @@ async function handlePreToolUse() {
           kind: "tool",
           startTime: now,
           status: "running",
-          input: toolInput
+          ...toolInput !== undefined ? { input: toolInput } : {},
+          ...parentSpanId !== null ? { parentSpanId } : {}
         }
       ]
     }
@@ -10884,21 +10973,23 @@ async function handlePostToolUse() {
   const state = readState(sessionId);
   const traceId = state?.traceId ?? `cc-${sessionId}`;
   const startTime = state?.startTime ?? now;
-  let matchedSpan = null;
+  let matchedSpanId = null;
+  let matchedSpanStart = now;
   let matchedKey = null;
   if (state?.openSpans) {
     const entries = Object.entries(state.openSpans);
     for (let i = entries.length - 1;i >= 0; i--) {
       const entry = entries[i];
       if (entry && entry[1].toolName === toolName) {
-        matchedSpan = entry[1];
+        matchedSpanId = entry[1].spanId;
+        matchedSpanStart = entry[1].startTime;
         matchedKey = entry[0];
         break;
       }
     }
   }
-  const spanId = matchedSpan?.spanId ?? randomUUID();
-  const spanStartTime = matchedSpan?.startTime ?? now;
+  const spanId = matchedSpanId ?? randomUUID();
+  const spanStartTime = matchedSpanStart;
   if (state && matchedKey) {
     state.openSpans = Object.fromEntries(Object.entries(state.openSpans).filter(([k]) => k !== matchedKey));
     writeState(sessionId, state);
@@ -10920,35 +11011,401 @@ async function handlePostToolUse() {
           startTime: spanStartTime,
           endTime: now,
           status: "completed",
-          output: toolOutput
+          ...toolOutput !== undefined ? { output: toolOutput } : {}
+        }
+      ]
+    }
+  ]);
+}
+
+// src/commands/hooks/handlers-v2.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function handleUserPromptSubmit() {
+  const input = await readStdin();
+  const sessionId = getString(input, "session_id", "sessionId");
+  if (!sessionId)
+    throw new Error("Missing session_id in stdin");
+  const now = new Date().toISOString();
+  const state = readState(sessionId) ?? {
+    traceId: `cc-${sessionId}`,
+    sessionId,
+    startTime: now,
+    openSpans: {},
+    parentStack: [],
+    parentStackKinds: []
+  };
+  const parentSpanId = peekParent(state);
+  const turnSpanId = randomUUID2();
+  const prompt = input.prompt ?? input.message ?? input.text;
+  const inputPayload = serializePayload(prompt ? { prompt } : undefined);
+  pushParent(state, turnSpanId, "chain");
+  writeState(sessionId, state);
+  await sendBatchTrace([
+    {
+      traceId: state.traceId,
+      sessionId,
+      name: "Claude Code Session",
+      source: "sdk",
+      startTime: state.startTime,
+      status: "running",
+      spans: [
+        {
+          spanId: turnSpanId,
+          name: "User turn",
+          kind: "chain",
+          startTime: now,
+          status: "running",
+          ...inputPayload !== undefined ? { input: inputPayload } : {},
+          ...parentSpanId !== null ? { parentSpanId } : {}
+        }
+      ]
+    }
+  ]);
+}
+async function handleStop() {
+  const input = await readStdin();
+  const sessionId = getString(input, "session_id", "sessionId");
+  if (!sessionId)
+    throw new Error("Missing session_id in stdin");
+  const now = new Date().toISOString();
+  const state = readState(sessionId);
+  if (!state)
+    return;
+  if (state.parentStack.length <= 1)
+    return;
+  const topKind = peekParentKind(state);
+  if (topKind !== "chain") {
+    process.stderr.write(`[mutagent hooks] Warning: Stop fired but stack top is kind="${topKind ?? "unknown"}" (expected "chain"). Skipping pop.
+`);
+    return;
+  }
+  const turnSpanId = popParent(state);
+  writeState(sessionId, state);
+  if (!turnSpanId)
+    return;
+  await sendBatchTrace([
+    {
+      traceId: state.traceId,
+      sessionId,
+      name: "Claude Code Session",
+      source: "sdk",
+      startTime: state.startTime,
+      status: "running",
+      spans: [
+        {
+          spanId: turnSpanId,
+          name: "User turn",
+          kind: "chain",
+          startTime: now,
+          endTime: now,
+          status: "completed",
+          parentSpanId: peekParent(state)
+        }
+      ]
+    }
+  ]);
+}
+async function handleSubagentStart() {
+  const input = await readStdin();
+  const sessionId = getString(input, "session_id", "sessionId");
+  if (!sessionId)
+    throw new Error("Missing session_id in stdin");
+  const now = new Date().toISOString();
+  const state = readState(sessionId) ?? {
+    traceId: `cc-${sessionId}`,
+    sessionId,
+    startTime: now,
+    openSpans: {},
+    parentStack: [],
+    parentStackKinds: []
+  };
+  const parentSpanId = peekParent(state);
+  const agentSpanId = randomUUID2();
+  const agentType = getString(input, "agent_type", "agentType") || "subagent";
+  const agentId = getString(input, "agent_id", "agentId");
+  const agentName = agentId ? `${agentType}:${agentId}` : agentType;
+  pushParent(state, agentSpanId, "agent");
+  writeState(sessionId, state);
+  await sendBatchTrace([
+    {
+      traceId: state.traceId,
+      sessionId,
+      name: "Claude Code Session",
+      source: "sdk",
+      startTime: state.startTime,
+      status: "running",
+      spans: [
+        {
+          spanId: agentSpanId,
+          name: agentName,
+          kind: "agent",
+          startTime: now,
+          status: "running",
+          ...parentSpanId !== null ? { parentSpanId } : {}
+        }
+      ]
+    }
+  ]);
+}
+async function handleSubagentStop() {
+  const input = await readStdin();
+  const sessionId = getString(input, "session_id", "sessionId");
+  if (!sessionId)
+    throw new Error("Missing session_id in stdin");
+  const now = new Date().toISOString();
+  const state = readState(sessionId);
+  if (!state) {
+    process.stderr.write(`[mutagent hooks] Warning: SubagentStop received but no state found for session ${sessionId}
+`);
+    return;
+  }
+  if (state.parentStack.length <= 1) {
+    process.stderr.write(`[mutagent hooks] Warning: SubagentStop with no matching SubagentStart in session ${sessionId}
+`);
+    return;
+  }
+  const topKind = peekParentKind(state);
+  if (topKind !== "agent") {
+    process.stderr.write(`[mutagent hooks] Warning: SubagentStop but stack top is kind="${topKind ?? "unknown"}" (expected "agent"). Skipping pop.
+`);
+    return;
+  }
+  const agentSpanId = popParent(state);
+  const newParent = peekParent(state);
+  writeState(sessionId, state);
+  if (!agentSpanId)
+    return;
+  await sendBatchTrace([
+    {
+      traceId: state.traceId,
+      sessionId,
+      name: "Claude Code Session",
+      source: "sdk",
+      startTime: state.startTime,
+      status: "running",
+      spans: [
+        {
+          spanId: agentSpanId,
+          name: "subagent",
+          kind: "agent",
+          startTime: now,
+          endTime: now,
+          status: "completed",
+          ...newParent !== null ? { parentSpanId: newParent } : {}
+        }
+      ]
+    }
+  ]);
+}
+async function handlePreCompact() {
+  const input = await readStdin();
+  const sessionId = getString(input, "session_id", "sessionId");
+  if (!sessionId)
+    throw new Error("Missing session_id in stdin");
+  const now = new Date().toISOString();
+  const state = readState(sessionId) ?? {
+    traceId: `cc-${sessionId}`,
+    sessionId,
+    startTime: now,
+    openSpans: {},
+    parentStack: [],
+    parentStackKinds: []
+  };
+  const parentSpanId = peekParent(state);
+  const compactSpanId = randomUUID2();
+  pushParent(state, compactSpanId, "custom");
+  writeState(sessionId, state);
+  await sendBatchTrace([
+    {
+      traceId: state.traceId,
+      sessionId,
+      name: "Claude Code Session",
+      source: "sdk",
+      startTime: state.startTime,
+      status: "running",
+      spans: [
+        {
+          spanId: compactSpanId,
+          name: "Compaction",
+          kind: "custom",
+          startTime: now,
+          status: "running",
+          ...parentSpanId !== null ? { parentSpanId } : {}
         }
       ]
     }
   ]);
 }
+async function handlePostCompact() {
+  const input = await readStdin();
+  const sessionId = getString(input, "session_id", "sessionId");
+  if (!sessionId)
+    throw new Error("Missing session_id in stdin");
+  const now = new Date().toISOString();
+  const state = readState(sessionId);
+  if (!state) {
+    process.stderr.write(`[mutagent hooks] Warning: PostCompact received but no state found for session ${sessionId}
+`);
+    return;
+  }
+  if (state.parentStack.length <= 1) {
+    process.stderr.write(`[mutagent hooks] Warning: PostCompact with no matching PreCompact in session ${sessionId}
+`);
+    return;
+  }
+  const compactSpanId = popParent(state);
+  const newParent = peekParent(state);
+  writeState(sessionId, state);
+  if (!compactSpanId)
+    return;
+  const summary = input.summary ?? input.compaction_summary ?? input.compactionSummary;
+  const outputPayload = serializePayload(summary ?? "Context compacted");
+  await sendBatchTrace([
+    {
+      traceId: state.traceId,
+      sessionId,
+      name: "Claude Code Session",
+      source: "sdk",
+      startTime: state.startTime,
+      status: "running",
+      spans: [
+        {
+          spanId: compactSpanId,
+          name: "Compaction",
+          kind: "custom",
+          startTime: now,
+          endTime: now,
+          status: "completed",
+          ...outputPayload !== undefined ? { output: outputPayload } : {},
+          ...newParent !== null ? { parentSpanId: newParent } : {}
+        }
+      ]
+    }
+  ]);
+}
+async function handlePostToolUseFailure() {
+  const input = await readStdin();
+  const sessionId = getString(input, "session_id", "sessionId");
+  const toolName = getString(input, "tool_name", "toolName") || "unknown";
+  if (!sessionId)
+    throw new Error("Missing session_id in stdin");
+  const now = new Date().toISOString();
+  const state = readState(sessionId);
+  if (!state) {
+    process.stderr.write(`[mutagent hooks] Warning: PostToolUseFailure received but no state found for session ${sessionId}
+`);
+    return;
+  }
+  const traceId = state.traceId;
+  const startTime = state.startTime;
+  let matchedSpanId = null;
+  let matchedSpanStart = now;
+  let matchedKey = null;
+  const entries = Object.entries(state.openSpans);
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const entry = entries[i];
+    if (entry && entry[1].toolName === toolName) {
+      matchedSpanId = entry[1].spanId;
+      matchedSpanStart = entry[1].startTime;
+      matchedKey = entry[0];
+      break;
+    }
+  }
+  if (!matchedSpanId) {
+    process.stderr.write(`[mutagent hooks] Warning: PostToolUseFailure — no matching open span for tool "${toolName}"
+`);
+    return;
+  }
+  state.openSpans = Object.fromEntries(Object.entries(state.openSpans).filter(([k]) => k !== matchedKey));
+  writeState(sessionId, state);
+  const reason = getString(input, "error", "reason", "message") || "Tool use failed";
+  const errorPayload = serializePayload(reason);
+  await sendBatchTrace([
+    {
+      traceId,
+      sessionId,
+      name: "Claude Code Session",
+      source: "sdk",
+      startTime,
+      status: "running",
+      spans: [
+        {
+          spanId: matchedSpanId,
+          name: toolName,
+          kind: "tool",
+          startTime: matchedSpanStart,
+          endTime: now,
+          status: "error",
+          ...errorPayload !== undefined ? { output: errorPayload } : {}
+        }
+      ]
+    }
+  ]);
+}
+
+// src/commands/hooks/install.ts
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, existsSync as existsSync14, mkdirSync as mkdirSync5 } from "fs";
+import { join as join9 } from "path";
+var V1_MIGRATIONS = {
+  Stop: ["mutagent hooks claude-code session-end"]
+};
 var MUTAGENT_HOOKS = {
   SessionStart: [{ matcher: "startup", hooks: [{ type: "command", command: "mutagent hooks claude-code session-start" }] }],
-  Stop: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code session-end" }] }],
   PreToolUse: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code pre-tool-use" }] }],
-  PostToolUse: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code post-tool-use" }] }]
+  PostToolUse: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code post-tool-use" }] }],
+  Stop: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code stop" }] }],
+  SessionEnd: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code session-end" }] }],
+  UserPromptSubmit: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code user-prompt-submit" }] }],
+  SubagentStart: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code subagent-start" }] }],
+  SubagentStop: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code subagent-stop" }] }],
+  PreCompact: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code pre-compact" }] }],
+  PostCompact: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code post-compact" }] }],
+  PostToolUseFailure: [{ hooks: [{ type: "command", command: "mutagent hooks claude-code post-tool-use-failure" }] }]
 };
 function hasCommand(matchers, command) {
   return matchers.some((m) => m.hooks.some((h) => h.command === command));
 }
+function migrateV1Hooks(settings) {
+  const migrated = [];
+  if (!settings.hooks)
+    return migrated;
+  for (const [event, commandsToRemove] of Object.entries(V1_MIGRATIONS)) {
+    const matchers = settings.hooks[event];
+    if (!matchers)
+      continue;
+    const filtered = matchers.map((matcher) => {
+      const keptHooks = matcher.hooks.filter((h) => {
+        if (commandsToRemove.includes(h.command)) {
+          migrated.push({ event, command: h.command });
+          return false;
+        }
+        return true;
+      });
+      return keptHooks.length > 0 ? { ...matcher, hooks: keptHooks } : null;
+    }).filter(Boolean);
+    if (filtered.length === 0) {
+      delete settings.hooks[event];
+    } else {
+      settings.hooks[event] = filtered;
+    }
+  }
+  return migrated;
+}
 function installHooks(cwd) {
-  const claudeDir = join8(cwd, ".claude");
-  const settingsPath = join8(claudeDir, "settings.local.json");
-  const existed = existsSync13(settingsPath);
+  const claudeDir = join9(cwd, ".claude");
+  const settingsPath = join9(claudeDir, "settings.local.json");
+  const existed = existsSync14(settingsPath);
   let settings = {};
   if (existed) {
     try {
-      settings = JSON.parse(readFileSync10(settingsPath, "utf-8"));
+      settings = JSON.parse(readFileSync11(settingsPath, "utf-8"));
     } catch {
       settings = {};
     }
   }
   const added = [];
   const alreadyPresent = [];
+  const migrated = migrateV1Hooks(settings);
   for (const [event, newMatchers] of Object.entries(MUTAGENT_HOOKS)) {
     if (!newMatchers)
       continue;
@@ -10970,15 +11427,17 @@ function installHooks(cwd) {
       }
     }
   }
-  if (added.length > 0) {
-    if (!existsSync13(claudeDir)) {
+  if (added.length > 0 || migrated.length > 0) {
+    if (!existsSync14(claudeDir)) {
       mkdirSync5(claudeDir, { recursive: true });
     }
-    writeFileSync6(settingsPath, JSON.stringify(settings, null, 2) + `
+    writeFileSync7(settingsPath, JSON.stringify(settings, null, 2) + `
 `, "utf-8");
   }
-  return { settingsPath, existed, added, alreadyPresent };
+  return { settingsPath, existed, added, alreadyPresent, migrated };
 }
+
+// src/commands/hooks/index.ts
 function createHooksCommand() {
   const hooks = new Command19("hooks").description("Hook handlers for AI coding assistants").addHelpText("after", `
 Claude Code Session Telemetry:
@@ -10991,20 +11450,30 @@ Claude Code Session Telemetry:
       "SessionStart": [{"matcher": "startup", "hooks": [{"type": "command", "command": "mutagent hooks claude-code session-start"}]}],
       "Stop": [{"hooks": [{"type": "command", "command": "mutagent hooks claude-code session-end"}]}],
       "PreToolUse": [{"hooks": [{"type": "command", "command": "mutagent hooks claude-code pre-tool-use"}]}],
-      "PostToolUse": [{"hooks": [{"type": "command", "command": "mutagent hooks claude-code post-tool-use"}]}]
+      "PostToolUse": [{"hooks": [{"type": "command", "command": "mutagent hooks claude-code post-tool-use"}]}],
+      "UserPromptSubmit": [{"hooks": [{"type": "command", "command": "mutagent hooks claude-code user-prompt-submit"}]}],
+      "SubagentStart": [{"hooks": [{"type": "command", "command": "mutagent hooks claude-code subagent-start"}]}],
+      "SubagentStop": [{"hooks": [{"type": "command", "command": "mutagent hooks claude-code subagent-stop"}]}],
+      "PreCompact": [{"hooks": [{"type": "command", "command": "mutagent hooks claude-code pre-compact"}]}],
+      "PostCompact": [{"hooks": [{"type": "command", "command": "mutagent hooks claude-code post-compact"}]}],
+      "PostToolUseFailure": [{"hooks": [{"type": "command", "command": "mutagent hooks claude-code post-tool-use-failure"}]}]
     }
   }
 
-  Or run: mutagent init (option 1 installs skill + hooks together)
+  Or run: mutagent hooks install
     `);
   hooks.command("install").description("Install MutagenT hooks into .claude/settings.local.json (safe merge — never overwrites existing hooks)").option("--cwd <dir>", "Target directory (defaults to cwd)", process.cwd()).addHelpText("after", `
 Reads existing .claude/settings.local.json (if present) and deep-merges
-MutagenT telemetry hooks into each event array (SessionStart, Stop,
-PreToolUse, PostToolUse). Skips any hook already present (checked by
-command string) so running this multiple times is safe.
+MutagenT telemetry hooks into each event array (all 10 events). Skips any
+hook already present (checked by command string) so running this multiple
+times is safe.
     `).action((opts) => {
     const targetDir = opts.cwd ?? process.cwd();
     const result = installHooks(targetDir);
+    for (const { event, command } of result.migrated) {
+      process.stderr.write(`[mutagent hooks install] ⚠️  Migrated v1 hook: removed '${event} → ${command}' (v2 wires this as 'SessionEnd')
+`);
+    }
     if (result.added.length === 0 && result.alreadyPresent.length === 0) {
       process.stdout.write(JSON.stringify({
         success: true,
@@ -11039,6 +11508,27 @@ command string) so running this multiple times is safe.
   claudeCode.command("post-tool-use").description("Handle post-tool-use event").action(async () => {
     await safeExecute(handlePostToolUse);
   });
+  claudeCode.command("user-prompt-submit").description("Handle user prompt submit event (creates turn span)").action(async () => {
+    await safeExecute(handleUserPromptSubmit);
+  });
+  claudeCode.command("stop").description("Handle stop event (closes current turn span)").action(async () => {
+    await safeExecute(handleStop);
+  });
+  claudeCode.command("subagent-start").description("Handle subagent start event (creates nested agent span)").action(async () => {
+    await safeExecute(handleSubagentStart);
+  });
+  claudeCode.command("subagent-stop").description("Handle subagent stop event (closes subagent span)").action(async () => {
+    await safeExecute(handleSubagentStop);
+  });
+  claudeCode.command("pre-compact").description("Handle pre-compact event (opens compaction span)").action(async () => {
+    await safeExecute(handlePreCompact);
+  });
+  claudeCode.command("post-compact").description("Handle post-compact event (closes compaction span with summary)").action(async () => {
+    await safeExecute(handlePostCompact);
+  });
+  claudeCode.command("post-tool-use-failure").description("Handle post-tool-use-failure event (closes failed span with error status)").action(async () => {
+    await safeExecute(handlePostToolUseFailure);
+  });
   return hooks;
 }
 
@@ -11047,8 +11537,8 @@ import { Command as Command20 } from "commander";
 import chalk38 from "chalk";
 init_errors();
 init_config();
-import { readFileSync as readFileSync11 } from "fs";
-import { join as join9, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync12 } from "fs";
+import { join as join10, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 var VALID_CATEGORIES = ["bug", "feature", "improvement", "praise"];
 function getCliVersion() {
@@ -11057,8 +11547,8 @@ function getCliVersion() {
   }
   try {
     const __dirname2 = dirname2(fileURLToPath(import.meta.url));
-    const pkgPath = join9(__dirname2, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    const pkgPath = join10(__dirname2, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     return pkg.version ?? "0.1.1";
   } catch {
     return "0.1.1";
@@ -11183,8 +11673,8 @@ if (process.env.CLI_VERSION) {
 } else {
   try {
     const __dirname2 = dirname3(fileURLToPath2(import.meta.url));
-    const pkgPath = join10(__dirname2, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+    const pkgPath = join11(__dirname2, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
     cliVersion = pkg.version ?? cliVersion;
   } catch {}
 }
@@ -11353,12 +11843,12 @@ program.addCommand(createFeedbackCommand());
 var isInteractive = process.stdin.isTTY && !rawArgs.includes("--json") && process.env.CI !== "true";
 var isSkillCommand = rawArgs[0] === "skills" || rawArgs[0] === "hooks";
 if (isInteractive && !isSkillCommand) {
-  const skillPath = join10(process.cwd(), ".claude/skills/mutagent-cli/SKILL.md");
-  if (!existsSync14(skillPath)) {
+  const skillPath = join11(process.cwd(), ".claude/skills/mutagent-cli/SKILL.md");
+  if (!existsSync15(skillPath)) {
     console.log(chalk39.dim("MutagenT SKILL not installed. Install it for AI agent support? Run:"), chalk39.cyan("mutagent skills install"));
   }
 }
 program.parse();
 
-//# debugId=A0F1B767D1BF2A2364756E2164756E21
+//# debugId=A1F82C134C46598C64756E2164756E21
 //# sourceMappingURL=cli.js.map