@usevalt/cli 0.4.0 → 0.6.0

package/dist/index.js

@@ -491,6 +491,32 @@ var doctorCommand = new Command5("doctor").description("Check Valt configuration
   } else {
     info("Eval service: not configured (set VALT_EVAL_URL for Semgrep scans)");
   }
+  const signingPrivateKey = process.env["VALT_SIGNING_PRIVATE_KEY"];
+  const signingPublicKey = process.env["VALT_SIGNING_PUBLIC_KEY"];
+  if (signingPrivateKey && signingPublicKey) {
+    success("Signing keys: configured (persistent)");
+  } else {
+    warn("Signing keys: not configured (using ephemeral keys \u2014 certificates will not survive restart)");
+    issues++;
+  }
+  const hooksPath = `${process.env["HOME"] ?? "~"}/.claude/hooks.json`;
+  try {
+    const { existsSync: exists, readFileSync: read } = await import("fs");
+    if (exists(hooksPath)) {
+      const hooksContent = read(hooksPath, "utf-8");
+      const hookCount = (hooksContent.match(/valt/g) ?? []).length;
+      if (hookCount >= 3) {
+        success(`Claude Code hooks: ${dim(hooksPath)} (${hookCount} hooks)`);
+      } else {
+        warn("Claude Code hooks: partially configured. Run `valt setup`.");
+        issues++;
+      }
+    } else {
+      info("Claude Code hooks: not installed. Run `valt setup` to enable.");
+    }
+  } catch {
+    info("Claude Code hooks: could not check.");
+  }
   console.log("");
   if (issues === 0) {
     success("All checks passed!");
@@ -995,13 +1021,43 @@ 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 } from "fs";
+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 { execSync } from "child_process";
-import { basename } from "path";
+import { basename, join } from "path";
+import { createHash } from "crypto";
 import os2 from "os";
-var SESSION_FILE = `${os2.tmpdir()}/valt-session-${process.getuid?.() ?? "default"}.json`;
+function getSessionFile(claudeSessionId) {
+  return join(os2.tmpdir(), `valt-session-${claudeSessionId}.json`);
+}
+function findLatestSessionFile() {
+  try {
+    const tmpDir = os2.tmpdir();
+    const files = readdirSync(tmpDir).filter((f) => f.startsWith("valt-session-") && f.endsWith(".json")).map((f) => ({
+      name: f,
+      path: join(tmpDir, f),
+      mtime: (() => {
+        try {
+          return readFileSync3(join(tmpDir, f), "utf-8");
+        } catch {
+          return "";
+        }
+      })()
+    })).filter((f) => f.mtime.length > 0).sort((a, b) => {
+      try {
+        const aData = JSON.parse(a.mtime);
+        const bData = JSON.parse(b.mtime);
+        return (bData.startedAt ?? "").localeCompare(aData.startedAt ?? "");
+      } catch {
+        return 0;
+      }
+    });
+    return files[0]?.path ?? null;
+  } catch {
+    return null;
+  }
+}
 async function readStdin() {
   if (process.stdin.isTTY) return {};
   try {
@@ -1010,7 +1066,7 @@ async function readStdin() {
       process.stdin.setEncoding("utf-8");
       process.stdin.on("data", (chunk) => chunks.push(String(chunk)));
       process.stdin.on("end", () => resolve4(chunks.join("")));
-      setTimeout(() => resolve4(chunks.join("")), 2e3);
+      setTimeout(() => resolve4(chunks.join("")), 500);
     });
     return data.trim() ? JSON.parse(data) : {};
   } catch {
@@ -1042,14 +1098,53 @@ function detectProjectSlug() {
   }
   return basename(process.cwd());
 }
-function readSessionFile() {
+function detectDeveloper() {
+  const result = {};
+  if (process.env["VALT_USER_EMAIL"]) {
+    result.email = process.env["VALT_USER_EMAIL"];
+  }
+  if (!result.email) {
+    try {
+      result.email = execSync("git config user.email", {
+        encoding: "utf-8",
+        timeout: 3e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim() || void 0;
+    } catch {
+    }
+  }
   try {
-    if (!existsSync3(SESSION_FILE)) return null;
-    const data = readFileSync3(SESSION_FILE, "utf-8");
-    return JSON.parse(data);
+    result.name = execSync("git config user.name", {
+      encoding: "utf-8",
+      timeout: 3e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim() || void 0;
   } catch {
-    return null;
   }
+  if (!result.name) {
+    result.name = process.env["USER"] ?? process.env["LOGNAME"];
+  }
+  return result;
+}
+function readSessionFile(claudeSessionId) {
+  if (claudeSessionId) {
+    const path = getSessionFile(claudeSessionId);
+    try {
+      if (existsSync3(path)) {
+        return JSON.parse(readFileSync3(path, "utf-8"));
+      }
+    } catch {
+    }
+  }
+  const fallbackPath = findLatestSessionFile();
+  if (fallbackPath) {
+    try {
+      return JSON.parse(readFileSync3(fallbackPath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  return null;
 }
 async function sendEvents(endpoint, apiKey, events) {
   try {
@@ -1067,13 +1162,96 @@ async function sendEvents(endpoint, apiKey, events) {
     return false;
   }
 }
+var MODEL_PRICING = {
+  "claude-opus-4-6": { input: 15, output: 75, cacheRead: 1.5 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3 },
+  "claude-haiku-4-5": { input: 0.8, output: 4, cacheRead: 0.08 },
+  "claude-3-5-sonnet": { input: 3, output: 15, cacheRead: 0.3 },
+  "claude-3-5-haiku": { input: 0.8, output: 4, cacheRead: 0.08 },
+  "claude-3-opus": { input: 15, output: 75, cacheRead: 1.5 }
+};
+function calculateCost(model, promptTokens, completionTokens, cacheReadTokens) {
+  const pricing = MODEL_PRICING[model] ?? Object.entries(MODEL_PRICING).find(([key]) => model.startsWith(key))?.[1];
+  if (!pricing) return 0;
+  return promptTokens / 1e6 * pricing.input + completionTokens / 1e6 * pricing.output + cacheReadTokens / 1e6 * pricing.cacheRead;
+}
+function classifyToolCall(toolName, toolInput) {
+  switch (toolName) {
+    case "Read":
+      return { eventType: "file.read", filePath: toolInput["file_path"] };
+    case "Write":
+    case "Edit":
+    case "NotebookEdit":
+      return { eventType: "file.write", filePath: toolInput["file_path"] ?? toolInput["notebook_path"] };
+    case "Bash": {
+      const command = toolInput["command"] ?? "";
+      return { eventType: "command.execute", command };
+    }
+    case "Glob":
+    case "Grep":
+      return { eventType: "file.read", filePath: toolInput["path"] ?? toolInput["pattern"] };
+    default:
+      return { eventType: "tool.call" };
+  }
+}
+function isTestCommand(command) {
+  const testPatterns = [
+    /\b(jest|vitest|mocha|ava)\b/,
+    /\bpnpm\s+(test|t)\b/,
+    /\bnpm\s+(test|t)\b/,
+    /\bnpx\s+(jest|vitest)\b/,
+    /\bpytest\b/,
+    /\bpython\s+-m\s+pytest\b/,
+    /\bcargo\s+test\b/,
+    /\bgo\s+test\b/,
+    /\bmake\s+test\b/
+  ];
+  return testPatterns.some((p) => p.test(command));
+}
+function parseTestResults(stdout) {
+  const vitestMatch = stdout.match(/Tests\s+(\d+)\s+passed.*?(\d+)\s+failed/i) ?? stdout.match(/Tests\s+(\d+)\s+passed\s+\((\d+)\)/i);
+  if (vitestMatch) {
+    const passed = parseInt(vitestMatch[1], 10);
+    const failedOrTotal = parseInt(vitestMatch[2], 10);
+    const failed = stdout.includes("failed") ? failedOrTotal : 0;
+    const total = stdout.includes("failed") ? passed + failed : failedOrTotal;
+    return { testsRun: total, testsPassed: passed, testsFailed: failed, framework: "vitest" };
+  }
+  const jestMatch = stdout.match(/Tests:\s+(?:(\d+)\s+failed,\s+)?(\d+)\s+passed,\s+(\d+)\s+total/i);
+  if (jestMatch) {
+    const failed = parseInt(jestMatch[1] ?? "0", 10);
+    const passed = parseInt(jestMatch[2], 10);
+    const total = parseInt(jestMatch[3], 10);
+    return { testsRun: total, testsPassed: passed, testsFailed: failed, framework: "jest" };
+  }
+  const pytestMatch = stdout.match(/(\d+)\s+passed(?:,\s+(\d+)\s+failed)?/i);
+  if (pytestMatch) {
+    const passed = parseInt(pytestMatch[1], 10);
+    const failed = parseInt(pytestMatch[2] ?? "0", 10);
+    return { testsRun: passed + failed, testsPassed: passed, testsFailed: failed, framework: "pytest" };
+  }
+  const goMatch = stdout.match(/^(ok|FAIL)\s+\S+/m);
+  if (goMatch) {
+    const passed = goMatch[1] === "ok" ? 1 : 0;
+    const failed = goMatch[1] === "FAIL" ? 1 : 0;
+    return { testsRun: 1, testsPassed: passed, testsFailed: failed, framework: "go" };
+  }
+  const cargoMatch = stdout.match(/test result: \w+\.\s+(\d+)\s+passed;\s+(\d+)\s+failed/i);
+  if (cargoMatch) {
+    const passed = parseInt(cargoMatch[1], 10);
+    const failed = parseInt(cargoMatch[2], 10);
+    return { testsRun: passed + failed, testsPassed: passed, testsFailed: failed, framework: "cargo" };
+  }
+  return null;
+}
 async function parseTranscript(transcriptPath) {
   const result = {
     totalCostUsd: 0,
     promptTokens: 0,
     completionTokens: 0,
     cacheReadTokens: 0,
-    cacheCreationTokens: 0
+    cacheCreationTokens: 0,
+    model: "unknown"
   };
   if (!existsSync3(transcriptPath)) return result;
   try {
@@ -1085,11 +1263,16 @@ async function parseTranscript(transcriptPath) {
       if (!line.trim()) continue;
       try {
         const entry = JSON.parse(line);
-        if (entry.usage) {
-          result.promptTokens += entry.usage.input_tokens ?? 0;
-          result.completionTokens += entry.usage.output_tokens ?? 0;
-          result.cacheReadTokens += entry.usage.cache_read_input_tokens ?? 0;
-          result.cacheCreationTokens += entry.usage.cache_creation_input_tokens ?? 0;
+        const usage = entry.message?.usage ?? entry.usage;
+        if (usage) {
+          result.promptTokens += usage.input_tokens ?? 0;
+          result.completionTokens += usage.output_tokens ?? 0;
+          result.cacheReadTokens += usage.cache_read_input_tokens ?? 0;
+          result.cacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
+        }
+        const model = entry.message?.model ?? entry.model;
+        if (model && result.model === "unknown") {
+          result.model = model;
         }
         if (typeof entry.costUSD === "number") {
           result.totalCostUsd += entry.costUSD;
@@ -1099,19 +1282,49 @@ async function parseTranscript(transcriptPath) {
     }
   } catch {
   }
+  if (result.totalCostUsd === 0 && result.promptTokens > 0) {
+    result.totalCostUsd = calculateCost(
+      result.model,
+      result.promptTokens,
+      result.completionTokens,
+      result.cacheReadTokens
+    );
+  }
   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();
     const projectSlug = detectProjectSlug();
+    const developer = detectDeveloper();
     const hookData = await readStdin();
-    const claudeSessionId = hookData["session_id"];
+    const claudeSessionId = hookData["session_id"] ?? crypto.randomUUID();
     const sessionId = crypto.randomUUID();
     const model = hookData["model"] || process.env["CLAUDE_MODEL"] || "unknown";
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const state = { sessionId, startedAt, apiKey, endpoint, apiEndpoint, projectSlug, model };
-    writeFileSync3(SESSION_FILE, JSON.stringify(state, null, 2), { mode: 384 });
+    const cwd = hookData["cwd"] || process.cwd();
+    const state = {
+      sessionId,
+      claudeSessionId,
+      startedAt,
+      apiKey,
+      endpoint,
+      apiEndpoint,
+      projectSlug,
+      model,
+      cwd
+    };
+    writeFileSync3(getSessionFile(claudeSessionId), JSON.stringify(state, null, 2), { mode: 384 });
+    let gitCommitBefore;
+    try {
+      gitCommitBefore = execSync("git rev-parse HEAD", {
+        encoding: "utf-8",
+        timeout: 3e3,
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd
+      }).trim();
+    } catch {
+    }
     const sent = await sendEvents(endpoint, apiKey, [
       {
         event_id: crypto.randomUUID(),
@@ -1127,7 +1340,11 @@ var sessionStartCommand = new Command13("session-start").description("Hook: call
           repository: process.env["CLAUDE_REPO"],
           branch: process.env["CLAUDE_BRANCH"],
           project_slug: projectSlug,
-          cwd: hookData["cwd"] || process.cwd()
+          cwd,
+          commit_sha: gitCommitBefore,
+          // 1.9: Developer attribution
+          developer_email: developer.email,
+          developer_name: developer.name
         }
       }
     ]);
@@ -1140,36 +1357,276 @@ var sessionStartCommand = new Command13("session-start").description("Hook: call
     warn(`Failed to start session: ${err instanceof Error ? err.message : String(err)}`);
   }
 });
-var toolCallCommand = new Command13("tool-call").description("Hook: called on each Claude Code tool call (reads JSON from stdin)").action(async () => {
+var toolCallCommand = new Command13("tool-call").description("Hook: called on each Claude Code tool call (PreToolUse)").action(async () => {
   try {
-    const session = readSessionFile();
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
     if (!session) return;
-    const toolData = await readStdin();
-    const toolName = toolData["tool_name"] ?? toolData["name"] ?? "unknown";
-    await sendEvents(session.endpoint, session.apiKey, [
-      {
+    const toolName = hookData["tool_name"] ?? hookData["name"] ?? "unknown";
+    const toolInput = hookData["tool_input"] ?? {};
+    if (session.apiEndpoint) {
+      try {
+        const gateController = new AbortController();
+        const gateTimeout = setTimeout(() => gateController.abort(), 3e3);
+        const toolInputSummary = JSON.stringify(toolInput).slice(0, 500);
+        const gateRes = await fetch(
+          `${session.apiEndpoint}/api/v1/sessions/${session.sessionId}/gate`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${session.apiKey}`
+            },
+            body: JSON.stringify({
+              tool_name: toolName,
+              tool_input_summary: toolInputSummary
+            }),
+            signal: gateController.signal
+          }
+        );
+        clearTimeout(gateTimeout);
+        if (gateRes.ok) {
+          const gateBody = await gateRes.json();
+          const gateAction = gateBody.data?.action;
+          if (gateAction === "pause") {
+            warn(`Gate: ${gateBody.data?.reason ?? "Paused by administrator"}`);
+            process.exit(2);
+          }
+          if (gateAction === "block") {
+            warn(`Gate: ${gateBody.data?.reason ?? "Blocked by administrator"}`);
+            process.exit(2);
+          }
+        }
+      } catch {
+      }
+    }
+    const { eventType, filePath, command } = classifyToolCall(toolName, toolInput);
+    const events = [];
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    events.push({
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "tool.call",
+      timestamp,
+      tool: "claude-code",
+      tool_name: toolName,
+      metadata: {
+        tool_name: toolName,
+        file_path: filePath,
+        command
+      }
+    });
+    if (eventType !== "tool.call") {
+      events.push({
         event_id: crypto.randomUUID(),
         session_id: session.sessionId,
-        event_type: "tool.call",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        event_type: eventType,
+        timestamp,
         tool: "claude-code",
         tool_name: toolName,
-        metadata: toolData
+        file_path: filePath,
+        metadata: {
+          tool_name: toolName,
+          ...filePath ? { file_path: filePath } : {},
+          ...command ? { command } : {}
+        }
+      });
+      if (eventType === "command.execute" && command && isTestCommand(command)) {
+        events.push({
+          event_id: crypto.randomUUID(),
+          session_id: session.sessionId,
+          event_type: "test.run",
+          timestamp,
+          tool: "claude-code",
+          metadata: { command, source: "pre-tool-detect" }
+        });
       }
-    ]);
+    }
+    await sendEvents(session.endpoint, session.apiKey, events);
   } catch {
   }
 });
-var sessionEndCommand = new Command13("session-end").description("Hook: called when a Claude Code session ends").action(async () => {
+var postToolUseCommand = new Command13("post-tool-use").description("Hook: called after a tool call completes (PostToolUse)").action(async () => {
   try {
-    const session = readSessionFile();
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
     if (!session) return;
+    const toolName = hookData["tool_name"] ?? "unknown";
+    const toolResponse = hookData["tool_response"];
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const events = [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "tool.result",
+      timestamp,
+      tool: "claude-code",
+      tool_name: toolName,
+      metadata: {
+        tool_name: toolName,
+        exit_code: toolResponse?.["exit_code"],
+        success: toolResponse?.["success"] ?? true
+      }
+    }];
+    if (toolName === "Bash" && toolResponse) {
+      const stdout = toolResponse["stdout"] ?? toolResponse["output"] ?? "";
+      if (stdout) {
+        const testResults = parseTestResults(stdout);
+        if (testResults) {
+          events.push({
+            event_id: crypto.randomUUID(),
+            session_id: session.sessionId,
+            event_type: "test.run",
+            timestamp,
+            tool: "claude-code",
+            metadata: {
+              tests_run: testResults.testsRun,
+              tests_passed: testResults.testsPassed,
+              tests_failed: testResults.testsFailed,
+              framework: testResults.framework,
+              source: "post-tool-parse"
+            }
+          });
+        }
+      }
+    }
+    await sendEvents(session.endpoint, session.apiKey, events);
+  } catch {
+  }
+});
+var toolErrorCommand = new Command13("tool-error").description("Hook: called when a tool call fails (PostToolUseFailure)").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 errorMsg = hookData["error"] ?? "unknown error";
+    const isInterrupt = hookData["is_interrupt"] ?? false;
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "tool.error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      tool: "claude-code",
+      tool_name: toolName,
+      metadata: {
+        tool_name: toolName,
+        error_message: errorMsg,
+        is_interrupt: isInterrupt
+      }
+    }]);
+  } catch {
+  }
+});
+var subagentStartCommand = new Command13("subagent-start").description("Hook: called when a subagent starts").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "subagent.start",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      tool: "claude-code",
+      metadata: {
+        agent_id: hookData["agent_id"],
+        agent_type: hookData["agent_type"]
+      }
+    }]);
+  } catch {
+  }
+});
+var subagentStopCommand = new Command13("subagent-stop").description("Hook: called when a subagent stops").action(async () => {
+  try {
     const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "subagent.stop",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      tool: "claude-code",
+      metadata: {
+        agent_id: hookData["agent_id"],
+        agent_type: hookData["agent_type"],
+        transcript_path: hookData["agent_transcript_path"]
+      }
+    }]);
+  } catch {
+  }
+});
+var promptSubmitCommand = new Command13("prompt-submit").description("Hook: called when a user submits a prompt").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    const session = readSessionFile(claudeSessionId);
+    if (!session) return;
+    const promptText = hookData["prompt"] ?? "";
+    const promptHashValue = createHash("sha256").update(promptText).digest("hex");
+    await sendEvents(session.endpoint, session.apiKey, [{
+      event_id: crypto.randomUUID(),
+      session_id: session.sessionId,
+      event_type: "prompt.submit",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      tool: "claude-code",
+      metadata: {
+        prompt_hash: promptHashValue,
+        prompt_length: promptText.length
+      }
+    }]);
+  } catch {
+  }
+});
+var sessionEndCommand = new Command13("session-end").description("Hook: called when a Claude Code session ends").action(async () => {
+  try {
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
+    let session = readSessionFile(claudeSessionId);
+    let sessionFilePath;
+    if (session) {
+      sessionFilePath = claudeSessionId ? getSessionFile(claudeSessionId) : findLatestSessionFile() ?? void 0;
+    } else {
+      const config = (() => {
+        try {
+          return resolveConfig();
+        } catch {
+          return null;
+        }
+      })();
+      if (!config) return;
+      session = {
+        sessionId: claudeSessionId ?? crypto.randomUUID(),
+        claudeSessionId: claudeSessionId ?? "unknown",
+        startedAt: new Date(Date.now() - 6e4).toISOString(),
+        // Assume 1 min ago
+        apiKey: config.apiKey,
+        endpoint: config.endpoint,
+        apiEndpoint: config.apiEndpoint,
+        cwd: hookData["cwd"] || process.cwd()
+      };
+      warn("Session file not found \u2014 sending session data from stdin/config fallback.");
+    }
     const now = /* @__PURE__ */ new Date();
     const startedAt = new Date(session.startedAt);
     const durationMs = now.getTime() - startedAt.getTime();
     const transcriptPath = hookData["transcript_path"];
     const metrics = transcriptPath ? await parseTranscript(transcriptPath) : null;
+    let gitCommitAfter;
+    try {
+      gitCommitAfter = execSync("git rev-parse HEAD", {
+        encoding: "utf-8",
+        timeout: 3e3,
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: session.cwd
+      }).trim();
+    } catch {
+    }
     const events = [
       {
         event_id: crypto.randomUUID(),
@@ -1178,10 +1635,12 @@ var sessionEndCommand = new Command13("session-end").description("Hook: called w
         timestamp: now.toISOString(),
         duration_ms: durationMs,
         tool: "claude-code",
+        model: metrics?.model ?? session.model,
         metadata: {
           started_at: session.startedAt,
           ended_at: now.toISOString(),
           reason: hookData["reason"] ?? "unknown",
+          git_commit_after: gitCommitAfter,
           ...metrics ? {
             prompt_tokens: metrics.promptTokens,
             completion_tokens: metrics.completionTokens,
@@ -1202,34 +1661,35 @@ var sessionEndCommand = new Command13("session-end").description("Hook: called w
         tokens_completion: metrics.completionTokens,
         cost_usd: metrics.totalCostUsd,
         metadata: {
+          model: metrics.model,
           cache_read_tokens: metrics.cacheReadTokens,
           cache_creation_tokens: metrics.cacheCreationTokens
         }
       });
     }
-    const sent = await sendEvents(session.endpoint, session.apiKey, events);
-    try {
-      unlinkSync2(SESSION_FILE);
-    } catch {
-    }
-    if (sent) {
-      const costStr = metrics?.totalCostUsd ? ` $${metrics.totalCostUsd.toFixed(4)}` : "";
-      success(`Valt session ended: ${session.sessionId.slice(0, 8)} (${Math.round(durationMs / 1e3)}s${costStr})`);
-    } else {
-      warn("Session ended locally but failed to send to Valt.");
+    sendEvents(session.endpoint, session.apiKey, events).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})`);
   } catch {
   }
 });
-var hookCommand = new Command13("hook").description("Claude Code hook handlers for Valt session tracking").addCommand(sessionStartCommand).addCommand(toolCallCommand).addCommand(sessionEndCommand);
+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);
 
 // src/commands/setup.ts
 import { Command as Command14 } from "commander";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 import os3 from "os";
-var CLAUDE_DIR = join(os3.homedir(), ".claude");
-var HOOKS_FILE = join(CLAUDE_DIR, "hooks.json");
+var CLAUDE_DIR = join2(os3.homedir(), ".claude");
+var HOOKS_FILE = join2(CLAUDE_DIR, "hooks.json");
 var HOOK_PREFIX = "npx --yes @usevalt/cli";
 function getValtHooks() {
   return {
@@ -1254,13 +1714,66 @@ function getValtHooks() {
         ]
       }
     ],
+    PostToolUse: [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: `${HOOK_PREFIX} hook post-tool-use`
+          }
+        ]
+      }
+    ],
+    PostToolUseFailure: [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: `${HOOK_PREFIX} hook tool-error`
+          }
+        ]
+      }
+    ],
+    SubagentStart: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `${HOOK_PREFIX} hook subagent-start`
+          }
+        ]
+      }
+    ],
+    SubagentStop: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `${HOOK_PREFIX} hook subagent-stop`
+          }
+        ]
+      }
+    ],
+    UserPromptSubmit: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `${HOOK_PREFIX} hook prompt-submit`
+          }
+        ]
+      }
+    ],
     SessionEnd: [
       {
         matcher: "*",
         hooks: [
           {
             type: "command",
-            command: `${HOOK_PREFIX} hook session-end`
+            command: `${HOOK_PREFIX} hook session-end`,
+            timeout: 1e4
           }
         ]
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usevalt/cli",
-  "version": "0.4.0",
+  "version": "0.6.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",