@usevalt/cli 0.7.3 → 0.8.0

package/dist/index.js

@@ -1035,13 +1035,340 @@ proxyCommand.command("stop").description("Stop the MCP proxy").action(() => {
 
 // src/commands/hook.ts
 import { Command as Command13 } from "commander";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, existsSync as existsSync3, readdirSync } from "fs";
-import { createReadStream } from "fs";
-import { createInterface } from "readline";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, existsSync as existsSync4, readdirSync, statSync, openSync, readSync, closeSync } from "fs";
+import { createReadStream as createReadStream2 } from "fs";
+import { createInterface as createInterface2 } from "readline";
 import { execSync } from "child_process";
 import { basename, join } from "path";
 import { createHash } from "crypto";
 import os2 from "os";
+
+// src/lib/content.ts
+import { basename as pathBasename } from "path";
+var MAX_CONTENT_LENGTH = 2048;
+function truncateContent(s, max = MAX_CONTENT_LENGTH) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 3) + "...";
+}
+function fileBasename(p) {
+  if (!p) return "unknown";
+  return pathBasename(p);
+}
+var COMMAND_PATTERNS = [
+  ["test", /vitest|jest|pytest|go\s+test|cargo\s+test|npm\s+test|pnpm\s+test|mocha|ava/i],
+  ["typecheck", /tsc\s+--noEmit|mypy|pyright|pnpm\s+typecheck/i],
+  ["build", /tsc(?!\s+--noEmit)|webpack|vite\s+build|cargo\s+build|go\s+build|npm\s+run\s+build|pnpm\s+build|esbuild|tsup/i],
+  ["lint", /eslint|biome(?!\s+format)|ruff|clippy|golangci-lint|pylint|oxlint/i],
+  ["format", /prettier|black|gofmt|rustfmt|biome\s+format/i],
+  ["git", /^git\s/i],
+  ["deploy", /vercel|fly\s|docker\s+push|kubectl|railway/i],
+  ["install", /npm\s+install|pnpm\s+(add|install)|pip\s+install|cargo\s+add|yarn\s+add|bun\s+add/i],
+  ["dev", /npm\s+run\s+dev|pnpm\s+dev|cargo\s+run|go\s+run|bun\s+dev/i],
+  ["search", /grep|rg\s|find\s|fd\s|ag\s/i]
+];
+function classifyCommand(command) {
+  for (const [category, pattern] of COMMAND_PATTERNS) {
+    if (pattern.test(command)) return category;
+  }
+  return "other";
+}
+function summarizeToolInput(toolName, toolInput) {
+  switch (toolName) {
+    case "Read":
+      return `Read ${fileBasename(toolInput["file_path"])}`;
+    case "Write": {
+      const content = toolInput["content"];
+      const chars = content ? ` (${content.length} chars)` : "";
+      return `Write ${fileBasename(toolInput["file_path"])}${chars}`;
+    }
+    case "Edit":
+      return `Edit ${fileBasename(toolInput["file_path"])}`;
+    case "NotebookEdit":
+      return `Edit notebook ${fileBasename(toolInput["notebook_path"])}`;
+    case "Bash": {
+      const cmd = toolInput["command"] ?? "";
+      const desc = toolInput["description"];
+      const category = classifyCommand(cmd);
+      const label = desc || truncateContent(cmd, 200);
+      return `[${category}] ${label}`;
+    }
+    case "Glob":
+      return `Search files: ${toolInput["pattern"] ?? "*"}`;
+    case "Grep":
+      return `Search content: /${toolInput["pattern"] ?? ""}/ in ${fileBasename(toolInput["path"])}`;
+    case "WebFetch":
+      return `Fetch: ${truncateContent(toolInput["url"] ?? "", 120)}`;
+    case "WebSearch":
+      return `Search web: ${truncateContent(toolInput["query"] ?? "", 120)}`;
+    case "Task":
+      return `Subagent: ${toolInput["description"] ?? "task"}`;
+    case "TaskCreate":
+      return `Create task: ${toolInput["subject"] ?? ""}`;
+    case "TaskUpdate":
+      return `Update task #${toolInput["taskId"] ?? "?"}: ${toolInput["status"] ?? ""}`;
+    case "Skill":
+      return `Skill: ${toolInput["skill"] ?? ""}`;
+    case "AskUserQuestion": {
+      const questions = toolInput["questions"];
+      const q = questions?.[0]?.question ?? "";
+      return `Ask user: ${truncateContent(q, 120)}`;
+    }
+    default:
+      return `Tool: ${toolName}`;
+  }
+}
+function summarizeToolResponse(toolName, _toolInput, toolResponse) {
+  switch (toolName) {
+    case "Bash": {
+      const exitCode = toolResponse["exit_code"] ?? toolResponse["exitCode"] ?? 0;
+      const stdout = toolResponse["stdout"] ?? toolResponse["output"] ?? "";
+      const stderr = toolResponse["stderr"] ?? "";
+      const output = Number(exitCode) !== 0 ? stderr || stdout : stdout;
+      return `Result: exit=${exitCode} \u2014 ${lastLine(output)}`;
+    }
+    case "Read": {
+      const content = toolResponse["content"] ?? "";
+      const lines = content ? content.split("\n").length : 0;
+      return `Result: Read \u2014 ${lines} lines`;
+    }
+    case "Write":
+      return "Result: Write \u2014 success";
+    case "Edit":
+      return "Result: Edit \u2014 success";
+    case "Glob": {
+      const files = toolResponse["files"];
+      const numFiles = toolResponse["numFiles"] ?? files?.length ?? 0;
+      return `Result: Glob \u2014 ${numFiles} matches`;
+    }
+    case "Grep": {
+      const numFiles = toolResponse["numFiles"] ?? toolResponse["numLines"] ?? 0;
+      return `Result: Grep \u2014 ${numFiles} matches`;
+    }
+    case "WebFetch": {
+      const content = toolResponse["content"] ?? "";
+      return `Result: Fetch \u2014 ${content.length} chars`;
+    }
+    case "WebSearch": {
+      const results = toolResponse["results"];
+      const numResults = toolResponse["numResults"] ?? results?.length ?? 0;
+      return `Result: Search \u2014 ${numResults} results`;
+    }
+    case "Task": {
+      const status = toolResponse["status"] ?? "done";
+      return `Result: Subagent \u2014 ${status}`;
+    }
+    default:
+      return `Result: ${toolName} \u2014 success`;
+  }
+}
+function lastLine(text) {
+  if (!text) return "";
+  const lines = text.split("\n").filter((l) => l.trim() !== "");
+  const line = lines[lines.length - 1] ?? "";
+  return truncateContent(line, 120);
+}
+
+// src/lib/transcriptParser.ts
+import { existsSync as existsSync3 } from "fs";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { randomUUID } from "crypto";
+var MAX_TOOL_DATA_LENGTH = 2048;
+var MAX_THINKING_LENGTH = 500;
+var MAX_TEXT_LENGTH = 500;
+function truncateObject(obj, maxLen) {
+  const str = JSON.stringify(obj);
+  if (str.length <= maxLen) return obj;
+  const result = {};
+  let currentLen = 2;
+  for (const [key, value] of Object.entries(obj)) {
+    const valStr = typeof value === "string" ? `"${value.slice(0, 200)}"` : JSON.stringify(value)?.slice(0, 200) ?? "null";
+    const entryLen = key.length + valStr.length + 4;
+    if (currentLen + entryLen > maxLen) {
+      result["_truncated"] = true;
+      break;
+    }
+    result[key] = typeof value === "string" && value.length > 200 ? value.slice(0, 200) + "..." : value;
+    currentLen += entryLen;
+  }
+  return result;
+}
+async function extractTranscriptEvents(transcriptPath) {
+  const events = [];
+  if (!existsSync3(transcriptPath)) return events;
+  const seenMessageIds = /* @__PURE__ */ new Map();
+  const toolUseIdMap = /* @__PURE__ */ new Map();
+  try {
+    const rl = createInterface({
+      input: createReadStream(transcriptPath, "utf-8"),
+      crlfDelay: Infinity
+    });
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        const entryType = entry.type ?? entry.role ?? "";
+        const subtype = entry.subtype;
+        if (["file-history-snapshot", "progress", "queue-operation"].includes(entryType)) {
+          continue;
+        }
+        const message = entry.message;
+        const messageId = message?.id;
+        const timestamp = entry.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+        let usage;
+        let model;
+        if (message) {
+          const rawUsage = message.usage;
+          if (rawUsage) {
+            usage = {
+              inputTokens: rawUsage.input_tokens ?? 0,
+              outputTokens: rawUsage.output_tokens ?? 0,
+              cacheReadTokens: rawUsage.cache_read_input_tokens ?? 0,
+              cacheCreationTokens: rawUsage.cache_creation_input_tokens ?? 0
+            };
+          }
+          model = message.model;
+          if (messageId) {
+            seenMessageIds.set(messageId, { usage, model });
+          }
+        }
+        const content = message?.content ?? entry.content;
+        if (entryType === "assistant") {
+          if (!Array.isArray(content)) continue;
+          for (const block of content) {
+            if (typeof block !== "object" || block === null) continue;
+            const blockRec = block;
+            const blockType = blockRec.type;
+            if (blockType === "tool_use") {
+              const toolName = blockRec.name ?? "unknown";
+              const toolUseId = blockRec.id;
+              const toolInput = truncateObject(
+                blockRec.input ?? {},
+                MAX_TOOL_DATA_LENGTH
+              );
+              const contentSummary = summarizeToolInput(toolName, toolInput);
+              const eventUuid = randomUUID();
+              if (toolUseId) {
+                toolUseIdMap.set(toolUseId, eventUuid);
+              }
+              events.push({
+                uuid: eventUuid,
+                parentUuid: null,
+                timestamp,
+                type: "tool_use",
+                toolName,
+                toolUseId,
+                toolInput,
+                usage,
+                model,
+                content: contentSummary
+              });
+            } else if (blockType === "thinking") {
+              const thinkingText = blockRec.thinking ?? "";
+              events.push({
+                uuid: randomUUID(),
+                parentUuid: null,
+                timestamp,
+                type: "thinking",
+                thinkingText: thinkingText.slice(0, MAX_THINKING_LENGTH),
+                usage,
+                model,
+                content: `Thinking: ${truncateContent(thinkingText, 120)}`
+              });
+            } else if (blockType === "text") {
+              const text = blockRec.text ?? "";
+              events.push({
+                uuid: randomUUID(),
+                parentUuid: null,
+                timestamp,
+                type: "text",
+                text: text.slice(0, MAX_TEXT_LENGTH),
+                usage,
+                model,
+                content: `Text: ${truncateContent(text, 120)}`
+              });
+            }
+          }
+        }
+        if (entryType === "human" || entryType === "user") {
+          if (!Array.isArray(content)) continue;
+          for (const block of content) {
+            if (typeof block !== "object" || block === null) continue;
+            const blockRec = block;
+            if (blockRec.type !== "tool_result") continue;
+            const toolUseId = blockRec.tool_use_id;
+            const isError = blockRec.is_error ?? false;
+            const resultContent = blockRec.content;
+            const toolResponse = truncateObject(
+              typeof resultContent === "string" ? { output: resultContent.slice(0, MAX_TOOL_DATA_LENGTH) } : resultContent ?? {},
+              MAX_TOOL_DATA_LENGTH
+            );
+            const parentUuid = toolUseId ? toolUseIdMap.get(toolUseId) ?? null : null;
+            let toolName = "unknown";
+            if (parentUuid) {
+              const parent = events.find((e) => e.uuid === parentUuid);
+              if (parent?.toolName) toolName = parent.toolName;
+            }
+            const contentSummary = isError ? `Error: ${toolName} \u2014 ${truncateContent(typeof resultContent === "string" ? resultContent : "failed", 200)}` : summarizeToolResponse(toolName, {}, toolResponse);
+            events.push({
+              uuid: randomUUID(),
+              parentUuid,
+              timestamp,
+              type: "tool_result",
+              toolUseId,
+              toolName,
+              toolResponse,
+              isError,
+              content: contentSummary
+            });
+          }
+        }
+        if (entryType === "system") {
+          if (subtype === "compact_boundary") {
+            const trigger = entry.trigger ?? "auto";
+            const preTokens = entry.pre_tokens;
+            events.push({
+              uuid: randomUUID(),
+              parentUuid: null,
+              timestamp,
+              type: "compact",
+              compactTrigger: trigger,
+              preTokens,
+              content: `Context compacted (${trigger}${preTokens ? `, ${preTokens} tokens` : ""})`
+            });
+          } else if (subtype === "api_error") {
+            const errorCause = entry.error ?? entry.message ?? "unknown";
+            const retryAttempt = entry.retry_attempt;
+            events.push({
+              uuid: randomUUID(),
+              parentUuid: null,
+              timestamp,
+              type: "api_error",
+              errorCause: typeof errorCause === "string" ? errorCause : "unknown",
+              retryAttempt,
+              content: `API error: ${truncateContent(typeof errorCause === "string" ? errorCause : "unknown", 200)}`
+            });
+          } else if (subtype === "turn_duration") {
+            const durationMs = entry.duration_ms;
+            events.push({
+              uuid: randomUUID(),
+              parentUuid: null,
+              timestamp,
+              type: "turn_duration",
+              durationMs,
+              content: `Turn duration: ${durationMs ?? 0}ms`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return events;
+}
+
+// src/commands/hook.ts
 function getSessionFile(claudeSessionId) {
   return join(os2.tmpdir(), `valt-session-${claudeSessionId}.json`);
 }
@@ -1144,7 +1471,7 @@ function readSessionFile(claudeSessionId) {
   if (claudeSessionId) {
     const path = getSessionFile(claudeSessionId);
     try {
-      if (existsSync3(path)) {
+      if (existsSync4(path)) {
         return JSON.parse(readFileSync3(path, "utf-8"));
       }
     } catch {
@@ -1272,10 +1599,10 @@ async function parseTranscript(transcriptPath) {
     cacheCreationTokens: 0,
     model: "unknown"
   };
-  if (!existsSync3(transcriptPath)) return result;
+  if (!existsSync4(transcriptPath)) return result;
   try {
-    const rl = createInterface({
-      input: createReadStream(transcriptPath, "utf-8"),
+    const rl = createInterface2({
+      input: createReadStream2(transcriptPath, "utf-8"),
       crlfDelay: Infinity
     });
     for await (const line of rl) {
@@ -1311,6 +1638,51 @@ async function parseTranscript(transcriptPath) {
   }
   return result;
 }
+function parseTranscriptIncremental(transcriptPath, fromByteOffset, model) {
+  const result = {
+    deltaPromptTokens: 0,
+    deltaCompletionTokens: 0,
+    deltaCacheReadTokens: 0,
+    deltaCostUsd: 0,
+    newByteOffset: fromByteOffset
+  };
+  try {
+    const fileSize = statSync(transcriptPath).size;
+    if (fileSize <= fromByteOffset) return result;
+    const bytesToRead = fileSize - fromByteOffset;
+    const buffer = Buffer.alloc(bytesToRead);
+    const fd = openSync(transcriptPath, "r");
+    try {
+      readSync(fd, buffer, 0, bytesToRead, fromByteOffset);
+    } finally {
+      closeSync(fd);
+    }
+    const chunk = buffer.toString("utf-8");
+    const lines = chunk.split("\n");
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        const usage = entry.message?.usage ?? entry.usage;
+        if (usage) {
+          result.deltaPromptTokens += usage.input_tokens ?? 0;
+          result.deltaCompletionTokens += usage.output_tokens ?? 0;
+          result.deltaCacheReadTokens += usage.cache_read_input_tokens ?? 0;
+        }
+      } catch {
+      }
+    }
+    result.newByteOffset = fileSize;
+    result.deltaCostUsd = calculateCost(
+      model,
+      result.deltaPromptTokens,
+      result.deltaCompletionTokens,
+      result.deltaCacheReadTokens
+    );
+  } catch {
+  }
+  return result;
+}
 var sessionStartCommand = new Command13("session-start").description("Hook: called when a Claude Code session starts").action(async () => {
   try {
     const { apiKey, endpoint, apiEndpoint } = resolveConfig();
@@ -1322,6 +1694,7 @@ var sessionStartCommand = new Command13("session-start").description("Hook: call
     const model = hookData["model"] || process.env["CLAUDE_MODEL"] || "unknown";
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const cwd = hookData["cwd"] || process.cwd();
+    const transcriptPath = hookData["transcript_path"] || void 0;
     const state = {
       sessionId,
       claudeSessionId,
@@ -1331,7 +1704,8 @@ var sessionStartCommand = new Command13("session-start").description("Hook: call
       apiEndpoint,
       projectSlug,
       model,
-      cwd
+      cwd,
+      transcriptPath
     };
     writeFileSync3(getSessionFile(claudeSessionId), JSON.stringify(state, null, 2), { mode: 384 });
     let gitCommitBefore;
@@ -1350,6 +1724,7 @@ var sessionStartCommand = new Command13("session-start").description("Hook: call
         session_id: sessionId,
         event_type: "session.start",
         timestamp: startedAt,
+        content: `Session started \u2014 ${model} on ${projectSlug}`,
         tool: "claude-code",
         model,
         metadata: {
@@ -1421,6 +1796,8 @@ var toolCallCommand = new Command13("tool-call").description("Hook: called on ea
       }
     }
     const { eventType, filePath, command } = classifyToolCall(toolName, toolInput);
+    const contentSummary = summarizeToolInput(toolName, toolInput);
+    const toolInputSummaryMeta = JSON.stringify(toolInput).slice(0, 1024);
     const events = [];
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     events.push({
@@ -1428,20 +1805,23 @@ var toolCallCommand = new Command13("tool-call").description("Hook: called on ea
       session_id: session.sessionId,
       event_type: "tool.call",
       timestamp,
+      content: contentSummary,
       tool: "claude-code",
       tool_name: toolName,
       metadata: {
         tool_name: toolName,
         file_path: filePath,
-        command
+        command,
+        tool_input_summary: toolInputSummaryMeta
       }
     });
     if (eventType !== "tool.call") {
-      events.push({
+      const classifiedEvent = {
         event_id: crypto.randomUUID(),
         session_id: session.sessionId,
         event_type: eventType,
         timestamp,
+        content: contentSummary,
         tool: "claude-code",
         tool_name: toolName,
         file_path: filePath,
@@ -1450,7 +1830,11 @@ var toolCallCommand = new Command13("tool-call").description("Hook: called on ea
           ...filePath ? { file_path: filePath } : {},
           ...command ? { command } : {}
         }
-      });
+      };
+      if (eventType === "command.execute" && command) {
+        classifiedEvent["command_category"] = classifyCommand(command);
+      }
+      events.push(classifiedEvent);
     }
     await sendEvents(session.endpoint, session.apiKey, events);
   } catch {
@@ -1463,19 +1847,24 @@ var postToolUseCommand = new Command13("post-tool-use").description("Hook: calle
     const session = readSessionFile(claudeSessionId);
     if (!session) return;
     const toolName = hookData["tool_name"] ?? "unknown";
+    const toolInput = hookData["tool_input"] ?? {};
     const toolResponse = hookData["tool_response"];
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const resultContent = summarizeToolResponse(toolName, toolInput, toolResponse ?? {});
+    const toolResponseSummaryMeta = JSON.stringify(toolResponse ?? {}).slice(0, 1024);
     const events = [{
       event_id: crypto.randomUUID(),
       session_id: session.sessionId,
       event_type: "tool.result",
       timestamp,
+      content: resultContent,
       tool: "claude-code",
       tool_name: toolName,
       metadata: {
         tool_name: toolName,
         exit_code: toolResponse?.["exit_code"],
-        success: toolResponse?.["success"] ?? true
+        success: toolResponse?.["success"] ?? true,
+        tool_response_summary: toolResponseSummaryMeta
       }
     }];
     if (toolName === "Bash" && toolResponse) {
@@ -1483,11 +1872,13 @@ var postToolUseCommand = new Command13("post-tool-use").description("Hook: calle
       if (stdout) {
         const testResults = parseTestResults(stdout);
         if (testResults) {
+          const testContent = `Tests: ${testResults.testsPassed}/${testResults.testsRun} passed (${testResults.framework}) ${testResults.testsFailed === 0 ? "PASS" : "FAIL"}`;
           events.push({
             event_id: crypto.randomUUID(),
             session_id: session.sessionId,
             event_type: "test.run",
             timestamp,
+            content: testContent,
             tool: "claude-code",
             metadata: {
               tests_run: testResults.testsRun,
@@ -1500,6 +1891,45 @@ var postToolUseCommand = new Command13("post-tool-use").description("Hook: calle
         }
       }
     }
+    try {
+      const tPath = hookData["transcript_path"] ?? session.transcriptPath;
+      if (tPath && existsSync4(tPath)) {
+        if (!session.transcriptPath) session.transcriptPath = tPath;
+        const deltas = parseTranscriptIncremental(
+          tPath,
+          session.transcriptByteOffset ?? 0,
+          session.model ?? "unknown"
+        );
+        if (deltas.deltaPromptTokens > 0 || deltas.deltaCompletionTokens > 0) {
+          events.push({
+            event_id: crypto.randomUUID(),
+            session_id: session.sessionId,
+            event_type: "cost",
+            timestamp,
+            tool: "claude-code",
+            tokens_prompt: deltas.deltaPromptTokens,
+            tokens_completion: deltas.deltaCompletionTokens,
+            cost_usd: deltas.deltaCostUsd,
+            metadata: {
+              model: session.model,
+              source: "incremental",
+              cache_read_tokens: deltas.deltaCacheReadTokens
+            }
+          });
+        }
+        session.transcriptByteOffset = deltas.newByteOffset;
+        session.runningPromptTokens = (session.runningPromptTokens ?? 0) + deltas.deltaPromptTokens;
+        session.runningCompletionTokens = (session.runningCompletionTokens ?? 0) + deltas.deltaCompletionTokens;
+        session.runningCacheReadTokens = (session.runningCacheReadTokens ?? 0) + deltas.deltaCacheReadTokens;
+        session.runningCostUsd = (session.runningCostUsd ?? 0) + deltas.deltaCostUsd;
+        writeFileSync3(
+          getSessionFile(session.claudeSessionId),
+          JSON.stringify(session, null, 2),
+          { mode: 384 }
+        );
+      }
+    } catch {
+    }
     await sendEvents(session.endpoint, session.apiKey, events);
   } catch {
   }
@@ -1518,6 +1948,7 @@ var toolErrorCommand = new Command13("tool-error").description("Hook: called whe
       session_id: session.sessionId,
       event_type: "tool.error",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Error: ${toolName} \u2014 ${truncateContent(errorMsg, 200)}`,
       tool: "claude-code",
       tool_name: toolName,
       metadata: {
@@ -1535,15 +1966,17 @@ var subagentStartCommand = new Command13("subagent-start").description("Hook: ca
     const claudeSessionId = hookData["session_id"];
     const session = readSessionFile(claudeSessionId);
     if (!session) return;
+    const agentType = hookData["agent_type"] ?? "unknown";
     await sendEvents(session.endpoint, session.apiKey, [{
       event_id: crypto.randomUUID(),
       session_id: session.sessionId,
       event_type: "subagent.start",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Subagent started: ${agentType}`,
       tool: "claude-code",
       metadata: {
         agent_id: hookData["agent_id"],
-        agent_type: hookData["agent_type"]
+        agent_type: agentType
       }
     }]);
   } catch {
@@ -1555,15 +1988,17 @@ var subagentStopCommand = new Command13("subagent-stop").description("Hook: call
     const claudeSessionId = hookData["session_id"];
     const session = readSessionFile(claudeSessionId);
     if (!session) return;
+    const stopAgentType = hookData["agent_type"] ?? "unknown";
     await sendEvents(session.endpoint, session.apiKey, [{
       event_id: crypto.randomUUID(),
       session_id: session.sessionId,
       event_type: "subagent.stop",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Subagent stopped: ${stopAgentType}`,
       tool: "claude-code",
       metadata: {
         agent_id: hookData["agent_id"],
-        agent_type: hookData["agent_type"],
+        agent_type: stopAgentType,
         transcript_path: hookData["agent_transcript_path"]
       }
     }]);
@@ -1583,6 +2018,7 @@ var promptSubmitCommand = new Command13("prompt-submit").description("Hook: call
       session_id: session.sessionId,
       event_type: "prompt.submit",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Prompt submitted (${promptText.length} chars)`,
       tool: "claude-code",
       metadata: {
         prompt_hash: promptHashValue,
@@ -1626,6 +2062,12 @@ var sessionEndCommand = new Command13("session-end").description("Hook: called w
     const durationMs = now.getTime() - startedAt.getTime();
     const transcriptPath = hookData["transcript_path"];
     const metrics = transcriptPath ? await parseTranscript(transcriptPath) : null;
+    if (metrics && (session.runningPromptTokens || session.runningCostUsd)) {
+      metrics.promptTokens = Math.max(0, metrics.promptTokens - (session.runningPromptTokens ?? 0));
+      metrics.completionTokens = Math.max(0, metrics.completionTokens - (session.runningCompletionTokens ?? 0));
+      metrics.cacheReadTokens = Math.max(0, metrics.cacheReadTokens - (session.runningCacheReadTokens ?? 0));
+      metrics.totalCostUsd = Math.max(0, metrics.totalCostUsd - (session.runningCostUsd ?? 0));
+    }
     let gitCommitAfter;
     try {
       gitCommitAfter = execSync("git rev-parse HEAD", {
@@ -1636,12 +2078,15 @@ var sessionEndCommand = new Command13("session-end").description("Hook: called w
       }).trim();
     } catch {
     }
+    const durationSec = Math.round(durationMs / 1e3);
+    const costStr = metrics?.totalCostUsd ? `$${metrics.totalCostUsd.toFixed(4)}` : "$0";
     const events = [
       {
         event_id: crypto.randomUUID(),
         session_id: session.sessionId,
         event_type: "session.end",
         timestamp: now.toISOString(),
+        content: `Session ended \u2014 ${durationSec}s, ${costStr}`,
         duration_ms: durationMs,
         tool: "claude-code",
         model: metrics?.model ?? session.model,
@@ -1660,11 +2105,13 @@ var sessionEndCommand = new Command13("session-end").description("Hook: called w
       }
     ];
     if (metrics && (metrics.totalCostUsd > 0 || metrics.promptTokens > 0)) {
+      const totalTokens = metrics.promptTokens + metrics.completionTokens;
       events.push({
         event_id: crypto.randomUUID(),
         session_id: session.sessionId,
         event_type: "cost",
         timestamp: now.toISOString(),
+        content: `Cost: $${metrics.totalCostUsd.toFixed(4)} (${totalTokens} tokens)`,
         tool: "claude-code",
         tokens_prompt: metrics.promptTokens,
         tokens_completion: metrics.completionTokens,
@@ -1678,23 +2125,342 @@ var sessionEndCommand = new Command13("session-end").description("Hook: called w
     }
     sendEvents(session.endpoint, session.apiKey, events).catch(() => {
     });
+    if (transcriptPath) {
+      extractTranscriptEvents(transcriptPath).then((transcriptEvents) => {
+        if (transcriptEvents.length === 0) return;
+        const valtEvents = transcriptEvents.map((te) => ({
+          event_id: te.uuid,
+          session_id: session.sessionId,
+          event_type: te.type === "tool_use" ? "tool.call" : te.type === "tool_result" ? "tool.result" : te.type === "thinking" ? "reasoning" : te.type === "text" ? "completion" : te.type === "compact" ? "context.compact" : te.type === "api_error" ? "error" : "cost",
+          event_subtype: `transcript.${te.type}`,
+          timestamp: te.timestamp,
+          content: te.content,
+          tool: "claude-code",
+          tool_name: te.toolName ?? "",
+          model: te.model ?? "",
+          tokens_prompt: te.usage?.inputTokens ?? 0,
+          tokens_completion: te.usage?.outputTokens ?? 0,
+          metadata: {
+            source: "transcript",
+            parent_uuid: te.parentUuid,
+            tool_use_id: te.toolUseId,
+            is_error: te.isError,
+            cache_read_tokens: te.usage?.cacheReadTokens,
+            cache_creation_tokens: te.usage?.cacheCreationTokens
+          }
+        }));
+        const BATCH_SIZE = 100;
+        for (let i = 0; i < valtEvents.length; i += BATCH_SIZE) {
+          const batch = valtEvents.slice(i, i + BATCH_SIZE);
+          sendEvents(session.endpoint, session.apiKey, batch).catch(() => {
+          });
+        }
+      }).catch(() => {
+      });
+    }
     if (sessionFilePath) {
       try {
         unlinkSync2(sessionFilePath);
       } catch {
       }
     }
-    const costStr = metrics?.totalCostUsd ? ` $${metrics.totalCostUsd.toFixed(4)}` : "";
-    const tokenStr = metrics?.promptTokens ? ` ${metrics.promptTokens + metrics.completionTokens} tokens` : "";
-    success(`Valt session ended: ${session.sessionId.slice(0, 8)} (${Math.round(durationMs / 1e3)}s${costStr}${tokenStr})`);
+    const logCostStr = metrics?.totalCostUsd ? ` $${metrics.totalCostUsd.toFixed(4)}` : "";
+    const logTokenStr = metrics?.promptTokens ? ` ${metrics.promptTokens + metrics.completionTokens} tokens` : "";
+    success(`Valt session ended: ${session.sessionId.slice(0, 8)} (${Math.round(durationMs / 1e3)}s${logCostStr}${logTokenStr})`);
+  } catch {
+  }
+});
+var stopCommand = new Command13("stop").description("Hook: called when the agent stops responding (Stop)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const lastMsg = truncateContent(hookData["last_assistant_message"] ?? "", 120);
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "session.stop",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Agent stopping \u2014 "${lastMsg}"`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var stopFailureCommand = new Command13("stop-failure").description("Hook: called when a stop attempt fails (StopFailure)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const err = hookData["error"] ?? "unknown";
+    const details = hookData["error_details"] ?? "";
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "session.stop_failure",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Stop failed: ${err} \u2014 ${truncateContent(details, 150)}`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
   } catch {
   }
 });
-var hookCommand = new Command13("hook").description("Claude Code hook handlers for Valt session tracking").addCommand(sessionStartCommand).addCommand(toolCallCommand).addCommand(postToolUseCommand).addCommand(toolErrorCommand).addCommand(subagentStartCommand).addCommand(subagentStopCommand).addCommand(promptSubmitCommand).addCommand(sessionEndCommand);
+var compactCommand = new Command13("compact").description("Hook: called on context compaction (PreCompact/PostCompact)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const hookEventName = hookData["hook_event_name"] ?? "";
+    const isPost = hookEventName.toLowerCase().includes("post");
+    const trigger = hookData["trigger"] ?? "auto";
+    const preTokens = hookData["pre_tokens"];
+    const summary = hookData["summary"] ?? "";
+    const content = isPost ? `Context compacted (${trigger}) \u2014 ${truncateContent(summary, 150)}` : `Context compacting (${trigger}${preTokens ? `, ${preTokens} tokens` : ""})`;
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "context.compact",
+      event_subtype: isPost ? "post" : "pre",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content,
+      tool: "claude-code",
+      metadata: { trigger, pre_tokens: preTokens, ...hookData }
+    }]);
+  } catch {
+  }
+});
+var notificationCommand = new Command13("notification").description("Hook: called on agent notifications (Notification)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const nType = hookData["type"] ?? "info";
+    const title = hookData["title"] ?? hookData["message"] ?? "";
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "notification",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Notification [${nType}]: ${truncateContent(title, 200)}`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var permissionRequestCommand = new Command13("permission-request").description("Hook: called when a permission dialog appears (PermissionRequest)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const toolName = hookData["tool_name"] ?? "unknown";
+    const toolInput = hookData["tool_input"] ?? {};
+    const inputSummary = summarizeToolInput(toolName, toolInput);
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "permission.request",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Permission requested: ${toolName} \u2014 ${inputSummary}`,
+      tool: "claude-code",
+      tool_name: toolName,
+      metadata: { ...hookData, tool_input_summary: JSON.stringify(toolInput).slice(0, 500) }
+    }]);
+  } catch {
+  }
+});
+var configLoadedCommand = new Command13("config-loaded").description("Hook: called when instructions are loaded (InstructionsLoaded)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const filePath = hookData["file_path"] ?? "";
+    const memoryType = hookData["memory_type"] ?? "";
+    const loadReason = hookData["load_reason"] ?? "";
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "config.loaded",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Instructions loaded: ${fileBasename(filePath)} (${memoryType}, ${loadReason})`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var configChangeCommand = new Command13("config-change").description("Hook: called when config changes (ConfigChange)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const source = hookData["source"] ?? "unknown";
+    const filePath = hookData["file_path"];
+    const label = filePath ? `${source} (${fileBasename(filePath)})` : source;
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "config.change",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Config changed: ${label}`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var elicitationCommand = new Command13("elicitation").description("Hook: called on MCP elicitation (Elicitation)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const mode = hookData["mode"] ?? "unknown";
+    const serverName = hookData["server_name"] ?? "unknown";
+    const message = hookData["message"] ?? "";
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "mcp.elicitation",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `MCP elicitation [${mode}]: ${serverName} \u2014 ${truncateContent(message, 150)}`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var elicitationResultCommand = new Command13("elicitation-result").description("Hook: called on MCP elicitation result (ElicitationResult)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const serverName = hookData["server_name"] ?? "unknown";
+    const action = hookData["action"] ?? "unknown";
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "mcp.elicitation_result",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `MCP elicitation result: ${serverName} \u2014 ${action}`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var worktreeCreateCommand = new Command13("worktree-create").description("Hook: called when a worktree is created (WorktreeCreate)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const name = hookData["name"] ?? "unknown";
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "worktree.create",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Worktree creating: ${name}`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var worktreeRemoveCommand = new Command13("worktree-remove").description("Hook: called when a worktree is removed (WorktreeRemove)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const worktreePath = hookData["worktree_path"] ?? "";
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "worktree.remove",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Worktree removing: ${fileBasename(worktreePath)}`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var teammateIdleCommand = new Command13("teammate-idle").description("Hook: called when a teammate is idle (TeammateIdle)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const teammateName = hookData["teammate_name"] ?? "unknown";
+    const teamName = hookData["team_name"] ?? "unknown";
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "agent.team",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Teammate idle: ${teammateName} in ${teamName}`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var taskCompletedCommand = new Command13("task-completed").description("Hook: called when a task completes (TaskCompleted)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const taskId = hookData["task_id"] ?? "?";
+    const taskSubject = hookData["task_subject"] ?? "";
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "task.completed",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Task completed: #${taskId} \u2014 ${truncateContent(taskSubject, 150)}`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var setupHookCommand = new Command13("setup-hook").description("Hook: called during setup (Setup)").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const source = hookData["source"] ?? "unknown";
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "setup",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: `Setup: ${source}`,
+      tool: "claude-code",
+      metadata: { ...hookData }
+    }]);
+  } catch {
+  }
+});
+var hookCommand = new Command13("hook").description("Claude Code hook handlers for Valt session tracking").addCommand(sessionStartCommand).addCommand(toolCallCommand).addCommand(postToolUseCommand).addCommand(toolErrorCommand).addCommand(subagentStartCommand).addCommand(subagentStopCommand).addCommand(promptSubmitCommand).addCommand(sessionEndCommand).addCommand(stopCommand).addCommand(stopFailureCommand).addCommand(compactCommand).addCommand(notificationCommand).addCommand(permissionRequestCommand).addCommand(configLoadedCommand).addCommand(configChangeCommand).addCommand(elicitationCommand).addCommand(elicitationResultCommand).addCommand(worktreeCreateCommand).addCommand(worktreeRemoveCommand).addCommand(teammateIdleCommand).addCommand(taskCompletedCommand).addCommand(setupHookCommand);
 
 // src/commands/setup.ts
 import { Command as Command14 } from "commander";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync4, unlinkSync as unlinkSync3 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync5, unlinkSync as unlinkSync3 } from "fs";
 import { join as join2 } from "path";
 import os3 from "os";
 var CLAUDE_DIR = join2(os3.homedir(), ".claude");
@@ -1703,89 +2469,133 @@ var LEGACY_HOOKS_FILE = join2(CLAUDE_DIR, "hooks.json");
 var HOOK_PREFIX = "npx --yes @usevalt/cli";
 function getValtHooks() {
   return {
+    Setup: [
+      {
+        matcher: "*",
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook setup-hook` }]
+      }
+    ],
     SessionStart: [
       {
-        hooks: [
-          {
-            type: "command",
-            command: `${HOOK_PREFIX} hook session-start`
-          }
-        ]
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook session-start` }]
+      }
+    ],
+    InstructionsLoaded: [
+      {
+        matcher: "*",
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook config-loaded` }]
+      }
+    ],
+    UserPromptSubmit: [
+      {
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook prompt-submit` }]
       }
     ],
     PreToolUse: [
       {
         matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: `${HOOK_PREFIX} hook tool-call`
-          }
-        ]
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook tool-call` }]
+      }
+    ],
+    PermissionRequest: [
+      {
+        matcher: "*",
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook permission-request` }]
       }
     ],
     PostToolUse: [
       {
         matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: `${HOOK_PREFIX} hook post-tool-use`
-          }
-        ]
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook post-tool-use` }]
       }
     ],
     PostToolUseFailure: [
       {
         matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: `${HOOK_PREFIX} hook tool-error`
-          }
-        ]
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook tool-error` }]
+      }
+    ],
+    Notification: [
+      {
+        matcher: "*",
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook notification` }]
       }
     ],
     SubagentStart: [
       {
-        hooks: [
-          {
-            type: "command",
-            command: `${HOOK_PREFIX} hook subagent-start`
-          }
-        ]
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook subagent-start` }]
       }
     ],
     SubagentStop: [
       {
-        hooks: [
-          {
-            type: "command",
-            command: `${HOOK_PREFIX} hook subagent-stop`
-          }
-        ]
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook subagent-stop` }]
       }
     ],
-    UserPromptSubmit: [
+    Stop: [
       {
-        hooks: [
-          {
-            type: "command",
-            command: `${HOOK_PREFIX} hook prompt-submit`
-          }
-        ]
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook stop` }]
+      }
+    ],
+    StopFailure: [
+      {
+        matcher: "*",
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook stop-failure` }]
+      }
+    ],
+    TeammateIdle: [
+      {
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook teammate-idle` }]
+      }
+    ],
+    TaskCompleted: [
+      {
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook task-completed` }]
+      }
+    ],
+    ConfigChange: [
+      {
+        matcher: "*",
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook config-change` }]
+      }
+    ],
+    WorktreeCreate: [
+      {
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook worktree-create` }]
+      }
+    ],
+    WorktreeRemove: [
+      {
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook worktree-remove` }]
+      }
+    ],
+    PreCompact: [
+      {
+        matcher: "*",
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook compact` }]
+      }
+    ],
+    PostCompact: [
+      {
+        matcher: "*",
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook compact` }]
+      }
+    ],
+    Elicitation: [
+      {
+        matcher: "*",
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook elicitation` }]
+      }
+    ],
+    ElicitationResult: [
+      {
+        matcher: "*",
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook elicitation-result` }]
       }
     ],
     SessionEnd: [
       {
         matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: `${HOOK_PREFIX} hook session-end`,
-            timeout: 1e4
-          }
-        ]
+        hooks: [{ type: "command", command: `${HOOK_PREFIX} hook session-end`, timeout: 15e3 }]
       }
     ]
   };
@@ -1797,7 +2607,7 @@ var setupCommand = new Command14("setup").description("Configure Claude Code hoo
       error("No API key found. Run `valt login` first.");
       process.exit(1);
     }
-    if (!existsSync4(CLAUDE_DIR)) {
+    if (!existsSync5(CLAUDE_DIR)) {
       mkdirSync2(CLAUDE_DIR, { recursive: true });
     }
     if (opts.remove) {
@@ -1805,7 +2615,7 @@ var setupCommand = new Command14("setup").description("Configure Claude Code hoo
       return;
     }
     let config = {};
-    if (existsSync4(SETTINGS_FILE)) {
+    if (existsSync5(SETTINGS_FILE)) {
       try {
         const raw = readFileSync4(SETTINGS_FILE, "utf-8");
         config = JSON.parse(raw);
@@ -1831,7 +2641,7 @@ var setupCommand = new Command14("setup").description("Configure Claude Code hoo
       }
     }
     writeFileSync4(SETTINGS_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
-    if (existsSync4(LEGACY_HOOKS_FILE)) {
+    if (existsSync5(LEGACY_HOOKS_FILE)) {
       try {
         removeLegacyHooks();
         info(`Migrated hooks from legacy hooks.json to settings.json.`);
@@ -1868,7 +2678,7 @@ function removeValtHooksFromConfig(config) {
   }
 }
 function removeLegacyHooks() {
-  if (!existsSync4(LEGACY_HOOKS_FILE)) return;
+  if (!existsSync5(LEGACY_HOOKS_FILE)) return;
   try {
     const raw = readFileSync4(LEGACY_HOOKS_FILE, "utf-8");
     const config = JSON.parse(raw);
@@ -1887,7 +2697,7 @@ function removeLegacyHooks() {
   }
 }
 function removeHooks() {
-  if (existsSync4(SETTINGS_FILE)) {
+  if (existsSync5(SETTINGS_FILE)) {
     try {
       const raw = readFileSync4(SETTINGS_FILE, "utf-8");
       const config = JSON.parse(raw);
@@ -1899,14 +2709,14 @@ function removeHooks() {
       process.exit(1);
     }
   }
-  if (existsSync4(LEGACY_HOOKS_FILE)) {
+  if (existsSync5(LEGACY_HOOKS_FILE)) {
     try {
       removeLegacyHooks();
       info("Legacy hooks.json cleaned up.");
     } catch {
     }
   }
-  if (!existsSync4(SETTINGS_FILE) && !existsSync4(LEGACY_HOOKS_FILE)) {
+  if (!existsSync5(SETTINGS_FILE) && !existsSync5(LEGACY_HOOKS_FILE)) {
     info("No hooks configured. Nothing to remove.");
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usevalt/cli",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "description": "Valt CLI — trust layer for AI-assisted development",
   "license": "MIT",
   "repository": {
@@ -39,8 +39,8 @@
     "tsup": "^8.4.0",
     "typescript": "^5.7.0",
     "vitest": "^3.2.0",
-    "@usevalt/typescript-config": "0.0.0",
-    "@usevalt/eslint-config": "0.0.0"
+    "@usevalt/eslint-config": "0.0.0",
+    "@usevalt/typescript-config": "0.0.0"
   },
   "scripts": {
     "build": "tsup",