runtape 0.1.1 → 0.3.0

package/README.md

@@ -6,7 +6,7 @@
 
 ## Status
 
-v0.1 — MVP. The CLI captures Claude Code sessions via hooks and streams them to a Runtape backend.
+v0.3 — Adds subagent (Task tool) capture. The full internal session of every spawned agent — its user prompt, assistant turns with model + token usage, and tool calls — is now recorded as nested children of the parent `Agent` step.
 
 ## Install
 
@@ -44,11 +44,12 @@ If you prefer the granular commands instead of the wizard, `runtape login` and `
 
 ```
 ~/.runtape/
-  config.json                 # api_key (chmod 600), server_url
-  buffer/<session_id>.ndjson  # pending events
-  seq/<session_id>            # monotonic sequence counter
-  flusher.pid                 # daemon PID
-  flusher.log                 # daemon log (append-only)
+  config.json                  # api_key (chmod 600), server_url
+  buffer/<session_id>.ndjson   # pending events
+  seq/<session_id>             # monotonic sequence counter
+  transcript/<session_id>      # uuids of assistant turns already emitted (v0.2+)
+  flusher.pid                  # daemon PID
+  flusher.log                  # daemon log (append-only)
 ```
 
 Override the home dir with `RUNTAPE_HOME` (useful for tests). Override the server with `RUNTAPE_API_URL` or `runtape login --server-url <url>`.
@@ -63,6 +64,36 @@ import { RuntapeEvent, IngestionRequest } from "runtape/types";
 
 The schemas live in `src/types.ts`. The package's `exports` map points TypeScript at the source file (no build step required for type consumers) and Node at the compiled `dist/types.js`.
 
+## Changelog
+
+### 0.3.0 — 2026-05-15
+
+- **Subagent capture.** On `SubagentStop`, the CLI now reads the subagent's `agent_transcript_path` and synthesizes the full internal event stream — user prompt, assistant turns (with model + usage), tool attempts and calls. Every synthesized event carries `agent_tool_use_id` so the server resolves it as a child of the parent `Agent` step. The dashboard renders these inline as nested rows under the Agent.
+- **`agent_tool_use_id` envelope field.** Optional on every event type. Server-side, when set, it overrides the open-Agent temporal heuristic and resolves the parent step directly.
+
+### 0.2.1 — 2026-05-15
+
+- **Skip `<synthetic>` turns.** Claude Code emits placeholder assistant messages with `model: "<synthetic>"` (compaction markers, internal state) that always have zero usage. The transcript scanner now drops them so the dashboard doesn't show empty no-cost turns.
+
+### 0.2.0 — 2026-05-15
+
+- **Model + token usage per turn.** The CLI now reads the Claude Code transcript JSONL on `PostToolUse` / `Stop` / `SubagentStop` and emits a new `assistant_turn` event for every assistant message, carrying `model`, `input_tokens`, `output_tokens`, `cache_read_tokens`, and `cache_creation_tokens`. The dashboard surfaces a per-turn model + cost pill and a run-level total.
+- **Tool error surfacing.** `tool_call` events now carry `is_error` + `error_message` (derived from the tool response shape — Bash exits, Edit/Write rejections, `is_error` content blocks, interrupts). Errored tools are visible in the run timeline without expanding the step.
+- **State.** Adds `~/.runtape/transcript/<session_id>` to track which assistant message uuids have already been emitted (idempotent scans across hook fires).
+
+To upgrade:
+
+```bash
+npm install -g runtape@latest
+runtape install   # safe to re-run; refreshes the hook entries
+```
+
+No changes to the existing hook commands or config file format.
+
+### 0.1.x
+
+Initial MVP. Hook-based capture of Claude Code sessions (`SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `Stop`, `SubagentStop`), buffered to disk and flushed by a detached daemon.
+
 ## Open source
 
 MIT licensed. Audit exactly what's captured. The Runtape backend (dashboard, ingestion API) is closed-source SaaS at [runtape.dev](https://runtape.dev).
@@ -70,7 +101,7 @@ MIT licensed. Audit exactly what's captured. The Runtape backend (dashboard, ing
 ## Repos
 
 - This repo (`runtape`) — the open-source CLI
-- `runtape-mcp` — MCP server for Runtape (coming v0.2)
+- `runtape-mcp` — MCP server for Runtape (planned)
 
 ## License
 

package/dist/{chunk-Q4RSBPGN.js → chunk-PXZACW6S.js}

@@ -9,7 +9,8 @@ var ClaudeHookBase = z.object({
 });
 var CliAugment = z.object({
   wall_ts: z.string().datetime(),
-  sequence: z.number().int().nonnegative()
+  sequence: z.number().int().nonnegative(),
+  agent_tool_use_id: z.string().min(1).optional()
 });
 var SessionStartEvent = ClaudeHookBase.extend(CliAugment.shape).extend({
   type: z.literal("session_start"),
@@ -31,7 +32,22 @@ var ToolCallEvent = ClaudeHookBase.extend(CliAugment.shape).extend({
   tool_input: z.unknown(),
   tool_response: z.unknown(),
   tool_use_id: z.string().min(1),
-  duration_ms: z.number().nonnegative()
+  duration_ms: z.number().nonnegative(),
+  // Set by the CLI when the tool_response signals an error (Bash non-zero
+  // exit, Edit/Write rejection, tool_response.is_error, etc.). Optional so
+  // older CLI versions stay forward-compatible.
+  is_error: z.boolean().optional(),
+  error_message: z.string().optional()
+});
+var AssistantTurnEvent = ClaudeHookBase.extend(CliAugment.shape).extend({
+  type: z.literal("assistant_turn"),
+  message_uuid: z.string().min(1),
+  model: z.string().min(1),
+  input_tokens: z.number().int().nonnegative(),
+  output_tokens: z.number().int().nonnegative(),
+  cache_read_tokens: z.number().int().nonnegative().default(0),
+  cache_creation_tokens: z.number().int().nonnegative().default(0),
+  text: z.string().optional()
 });
 var SubagentEndEvent = ClaudeHookBase.extend(CliAugment.shape).extend({
   type: z.literal("subagent_end"),
@@ -51,6 +67,7 @@ var RuntapeEvent = z.discriminatedUnion("type", [
   UserPromptEvent,
   ToolAttemptEvent,
   ToolCallEvent,
+  AssistantTurnEvent,
   SubagentEndEvent,
   SessionEndEvent
 ]);
@@ -72,10 +89,11 @@ export {
   UserPromptEvent,
   ToolAttemptEvent,
   ToolCallEvent,
+  AssistantTurnEvent,
   SubagentEndEvent,
   SessionEndEvent,
   RuntapeEvent,
   IngestionRequest,
   IngestionResponse
 };
-//# sourceMappingURL=chunk-Q4RSBPGN.js.map
+//# sourceMappingURL=chunk-PXZACW6S.js.map

package/dist/chunk-PXZACW6S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import { z } from 'zod';\n\n// Every Claude Code hook event carries these envelope fields.\nconst ClaudeHookBase = z.object({\n  session_id: z.string().min(1),\n  transcript_path: z.string().min(1),\n  cwd: z.string().min(1),\n  hook_event_name: z.string().min(1),\n  permission_mode: z.string().optional(),\n});\n\n// CLI-augmented envelope adds monotonic ordering + wall-clock timestamp.\n// agent_tool_use_id is set when the CLI is synthesizing events from a\n// subagent transcript — it carries the parent Agent step's tool_use_id so\n// the server can resolve parent_step_id deterministically instead of\n// relying on the temporal open-stack heuristic. Optional so the field is\n// absent for normal top-level events.\nconst CliAugment = z.object({\n  wall_ts: z.string().datetime(),\n  sequence: z.number().int().nonnegative(),\n  agent_tool_use_id: z.string().min(1).optional(),\n});\n\nexport const SessionStartEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('session_start'),\n  source: z.string(),\n});\n\nexport const UserPromptEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('user_prompt'),\n  prompt: z.string(),\n});\n\nexport const ToolAttemptEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('tool_attempt'),\n  tool_name: z.string().min(1),\n  tool_input: z.unknown(),\n  tool_use_id: z.string().min(1),\n});\n\nexport const ToolCallEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('tool_call'),\n  tool_name: z.string().min(1),\n  tool_input: z.unknown(),\n  tool_response: z.unknown(),\n  tool_use_id: z.string().min(1),\n  duration_ms: z.number().nonnegative(),\n  // Set by the CLI when the tool_response signals an error (Bash non-zero\n  // exit, Edit/Write rejection, tool_response.is_error, etc.). Optional so\n  // older CLI versions stay forward-compatible.\n  is_error: z.boolean().optional(),\n  error_message: z.string().optional(),\n});\n\n// Emitted by the CLI on Stop / PostToolUse after scanning the Claude Code\n// transcript JSONL. One event per assistant message we haven't seen yet,\n// keyed by message_uuid so re-deliveries dedupe at the server. Carries the\n// model identifier and token usage for that turn — the only place either\n// datum is available in Claude Code's emit chain.\nexport const AssistantTurnEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('assistant_turn'),\n  message_uuid: z.string().min(1),\n  model: z.string().min(1),\n  input_tokens: z.number().int().nonnegative(),\n  output_tokens: z.number().int().nonnegative(),\n  cache_read_tokens: z.number().int().nonnegative().default(0),\n  cache_creation_tokens: z.number().int().nonnegative().default(0),\n  text: z.string().optional(),\n});\n\nexport const SubagentEndEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('subagent_end'),\n  agent_id: z.string().min(1),\n  agent_type: z.string().min(1),\n  agent_transcript_path: z.string().min(1),\n  last_assistant_message: z.string(),\n  stop_hook_active: z.boolean().optional(),\n});\n\nexport const SessionEndEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('session_end'),\n  last_assistant_message: z.string().optional(),\n  stop_hook_active: z.boolean().optional(),\n});\n\nexport const RuntapeEvent = z.discriminatedUnion('type', [\n  SessionStartEvent,\n  UserPromptEvent,\n  ToolAttemptEvent,\n  ToolCallEvent,\n  AssistantTurnEvent,\n  SubagentEndEvent,\n  SessionEndEvent,\n]);\n\nexport type RuntapeEvent = z.infer<typeof RuntapeEvent>;\n\n// POST /v1/events body — a batch of up to 100 events.\nexport const IngestionRequest = z.object({\n  events: z.array(RuntapeEvent).min(1).max(100),\n});\n\nexport type IngestionRequest = z.infer<typeof IngestionRequest>;\n\n// Response shape (server returns 200 on accepted, 400 on Zod failure, 401 on bad auth).\nexport const IngestionResponse = z.object({\n  accepted: z.number().int().nonnegative(),\n  errors: z\n    .array(\n      z.object({\n        index: z.number().int().nonnegative(),\n        reason: z.string(),\n      }),\n    )\n    .default([]),\n});\n\nexport type IngestionResponse = z.infer<typeof IngestionResponse>;\n"],"mappings":"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","names":[]}

package/dist/index.js

@@ -1,11 +1,11 @@
 import {
   RuntapeEvent
-} from "./chunk-Q4RSBPGN.js";
+} from "./chunk-PXZACW6S.js";
 
 // src/index.ts
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname6, join as join2 } from "path";
+import { dirname as dirname8, join as join2 } from "path";
 import { Command } from "commander";
 
 // src/commands/login.ts
@@ -30,6 +30,11 @@ var paths = {
   flusherLog: join(RUNTAPE_HOME, "flusher.log"),
   bufferFile: (sessionId) => join(RUNTAPE_HOME, "buffer", `${sessionId}.ndjson`),
   seqFile: (sessionId) => join(RUNTAPE_HOME, "seq", sessionId),
+  // Per-session marker recording the last assistant message uuid we've
+  // emitted from the transcript. Lets transcript scans be idempotent across
+  // hook invocations without re-reading + re-emitting everything.
+  transcriptCursorFile: (sessionId) => join(RUNTAPE_HOME, "transcript", sessionId),
+  transcriptDir: join(RUNTAPE_HOME, "transcript"),
   claudeSettings: (scope) => scope === "user" ? join(homedir(), ".claude", "settings.json") : join(process.cwd(), ".claude", "settings.json"),
   claudeSettingsBackup: (scope) => scope === "user" ? join(homedir(), ".claude", "settings.json.runtape-backup") : join(process.cwd(), ".claude", "settings.json.runtape-backup")
 };
@@ -182,6 +187,30 @@ var SUPPORTED_HOOKS = [
   "Stop",
   "SubagentStop"
 ];
+function inspectToolResponse(tool_response) {
+  if (!tool_response || typeof tool_response !== "object") return { is_error: false };
+  const r = tool_response;
+  if (r.is_error === true) {
+    const content = r.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block && typeof block === "object" && "text" in block) {
+          const t = block.text;
+          if (typeof t === "string") return { is_error: true, error_message: t };
+        }
+      }
+    }
+    if (typeof r.message === "string") return { is_error: true, error_message: r.message };
+    return { is_error: true };
+  }
+  if (typeof r.error === "string" && r.error.trim() !== "") {
+    return { is_error: true, error_message: r.error };
+  }
+  if (r.interrupted === true) {
+    return { is_error: true, error_message: "Interrupted" };
+  }
+  return { is_error: false };
+}
 function mapHookPayload(hookName, payload, augment) {
   const base = {
     session_id: payload.session_id,
@@ -209,7 +238,8 @@ function mapHookPayload(hookName, payload, augment) {
         tool_use_id: payload.tool_use_id
       };
       break;
-    case "PostToolUse":
+    case "PostToolUse": {
+      const err = inspectToolResponse(payload.tool_response);
       candidate = {
         ...base,
         type: "tool_call",
@@ -217,9 +247,12 @@ function mapHookPayload(hookName, payload, augment) {
         tool_input: payload.tool_input,
         tool_response: payload.tool_response,
         tool_use_id: payload.tool_use_id,
-        duration_ms: payload.duration_ms
+        duration_ms: payload.duration_ms,
+        is_error: err.is_error,
+        error_message: err.error_message
       };
       break;
+    }
     case "Stop":
       candidate = {
         ...base,
@@ -474,6 +507,233 @@ async function bufferMtimeMs(sessionId) {
   }
 }
 
+// src/lib/transcript.ts
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+function asInt(x) {
+  if (typeof x === "number" && Number.isFinite(x) && x >= 0) return Math.trunc(x);
+  return 0;
+}
+function extractAssistantText(content) {
+  if (!Array.isArray(content)) return void 0;
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && "type" in block) {
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+    }
+  }
+  const joined = parts.join("\n").trim();
+  return joined === "" ? void 0 : joined;
+}
+async function readNewAssistantTurns(sessionId, transcriptPath) {
+  const seen = await readCursor(sessionId);
+  let raw;
+  try {
+    raw = await readFile5(transcriptPath, "utf8");
+  } catch {
+    return { turns: [], seen };
+  }
+  const turns = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (parsed.type !== "assistant") continue;
+    const uuid = typeof parsed.uuid === "string" ? parsed.uuid : "";
+    if (uuid === "" || seen.has(uuid)) continue;
+    const msg = parsed.message ?? {};
+    const model = typeof msg.model === "string" ? msg.model : "";
+    if (model === "" || model === "<synthetic>") continue;
+    const usage = msg.usage ?? {};
+    turns.push({
+      message_uuid: uuid,
+      model,
+      input_tokens: asInt(usage.input_tokens),
+      output_tokens: asInt(usage.output_tokens),
+      cache_read_tokens: asInt(usage.cache_read_input_tokens),
+      cache_creation_tokens: asInt(usage.cache_creation_input_tokens),
+      text: extractAssistantText(msg.content)
+    });
+  }
+  return { turns, seen };
+}
+var CURSOR_KEEP = 200;
+async function readCursor(sessionId) {
+  try {
+    const raw = await readFile5(paths.transcriptCursorFile(sessionId), "utf8");
+    return new Set(
+      raw.split("\n").map((s) => s.trim()).filter((s) => s !== "")
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function persistCursor(sessionId, seen, newlyEmitted) {
+  for (const u of newlyEmitted) seen.add(u);
+  const file = paths.transcriptCursorFile(sessionId);
+  await mkdir5(dirname5(file), { recursive: true });
+  const arr = [...seen];
+  const trimmed = arr.length > CURSOR_KEEP ? arr.slice(arr.length - CURSOR_KEEP) : arr;
+  await writeFile5(file, trimmed.join("\n") + "\n");
+}
+
+// src/lib/subagent-transcript.ts
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+function asInt2(x) {
+  if (typeof x === "number" && Number.isFinite(x) && x >= 0) return Math.trunc(x);
+  return 0;
+}
+function textFromBlocks(content) {
+  if (!Array.isArray(content)) return typeof content === "string" ? content : void 0;
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && "type" in block) {
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+    }
+  }
+  const joined = parts.join("\n").trim();
+  return joined === "" ? void 0 : joined;
+}
+function summarizeToolResult(content) {
+  if (!Array.isArray(content)) {
+    if (typeof content === "string") return { is_error: false };
+    return { is_error: false };
+  }
+  let isError = false;
+  const texts = [];
+  for (const block of content) {
+    if (block && typeof block === "object") {
+      const b = block;
+      if (b.is_error === true) isError = true;
+      if (typeof b.text === "string") texts.push(b.text);
+    }
+  }
+  if (isError && texts.length > 0) return { is_error: true, error_message: texts.join("\n").slice(0, 500) };
+  if (isError) return { is_error: true };
+  return { is_error: false };
+}
+async function readNewSubagentEvents(parentSessionId, agentToolUseId, transcriptPath) {
+  const seen = await readCursor2(parentSessionId, agentToolUseId);
+  let raw;
+  try {
+    raw = await readFile6(transcriptPath, "utf8");
+  } catch {
+    return { emits: [], seen };
+  }
+  const emits = [];
+  const toolNameByUseId = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const uuid = typeof parsed.uuid === "string" ? parsed.uuid : "";
+    if (uuid === "" || seen.has(uuid)) continue;
+    const msg = parsed.message ?? {};
+    if (parsed.type === "user") {
+      const content = msg.content;
+      const hasToolResults = Array.isArray(content) && content.some(
+        (b) => b && typeof b === "object" && b.type === "tool_result"
+      );
+      if (hasToolResults) {
+        for (const block of content) {
+          if (!block || typeof block !== "object") continue;
+          const b = block;
+          if (b.type !== "tool_result") continue;
+          const tuid = typeof b.tool_use_id === "string" ? b.tool_use_id : "";
+          if (tuid === "") continue;
+          const { is_error, error_message } = summarizeToolResult(b.content);
+          emits.push({
+            kind: "tool_call",
+            uuid: `${uuid}:${tuid}`,
+            tool_use_id: tuid,
+            tool_name: toolNameByUseId.get(tuid) ?? "unknown",
+            tool_response: b.content,
+            is_error,
+            error_message
+          });
+        }
+      } else {
+        const text = textFromBlocks(content);
+        if (text !== void 0) {
+          emits.push({ kind: "user_prompt", uuid, prompt: text });
+        }
+      }
+      continue;
+    }
+    if (parsed.type === "assistant") {
+      const model = typeof msg.model === "string" ? msg.model : "";
+      if (model === "" || model === "<synthetic>") continue;
+      const usage = msg.usage ?? {};
+      emits.push({
+        kind: "assistant_turn",
+        uuid,
+        message_uuid: uuid,
+        model,
+        input_tokens: asInt2(usage.input_tokens),
+        output_tokens: asInt2(usage.output_tokens),
+        cache_read_tokens: asInt2(usage.cache_read_input_tokens),
+        cache_creation_tokens: asInt2(usage.cache_creation_input_tokens),
+        text: textFromBlocks(msg.content)
+      });
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (!block || typeof block !== "object") continue;
+          const b = block;
+          if (b.type !== "tool_use") continue;
+          const tuid = typeof b.id === "string" ? b.id : "";
+          const tname = typeof b.name === "string" ? b.name : "";
+          if (tuid === "" || tname === "") continue;
+          toolNameByUseId.set(tuid, tname);
+          emits.push({
+            kind: "tool_attempt",
+            uuid: `${uuid}:${tuid}`,
+            tool_use_id: tuid,
+            tool_name: tname,
+            tool_input: b.input
+          });
+        }
+      }
+      continue;
+    }
+  }
+  return { emits, seen };
+}
+var CURSOR_KEEP2 = 500;
+async function readCursor2(parentSessionId, agentToolUseId) {
+  try {
+    const raw = await readFile6(cursorFile(parentSessionId, agentToolUseId), "utf8");
+    return new Set(
+      raw.split("\n").map((s) => s.trim()).filter((s) => s !== "")
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function cursorFile(parentSessionId, agentToolUseId) {
+  return `${paths.transcriptDir}/subagent-${parentSessionId}-${agentToolUseId}`;
+}
+async function persistSubagentCursor(parentSessionId, agentToolUseId, seen, newlyEmitted) {
+  for (const u of newlyEmitted) seen.add(u);
+  const file = cursorFile(parentSessionId, agentToolUseId);
+  await mkdir6(dirname6(file), { recursive: true });
+  const arr = [...seen];
+  const trimmed = arr.length > CURSOR_KEEP2 ? arr.slice(arr.length - CURSOR_KEEP2) : arr;
+  await writeFile6(file, trimmed.join("\n") + "\n");
+}
+
 // src/commands/push.ts
 async function readStdin() {
   if (process.stdin.isTTY) return "";
@@ -526,6 +786,113 @@ async function pushCommand(opts) {
       return 0;
     }
     await appendEvent(sessionId, result.event);
+    if (opts.event === "PostToolUse" || opts.event === "Stop" || opts.event === "SubagentStop") {
+      const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : "";
+      if (transcriptPath !== "") {
+        try {
+          const { turns, seen } = await readNewAssistantTurns(sessionId, transcriptPath);
+          const newlyEmitted = [];
+          for (const t of turns) {
+            const seq = await nextSequence(sessionId);
+            const ev = {
+              type: "assistant_turn",
+              session_id: sessionId,
+              transcript_path: transcriptPath,
+              cwd: typeof payload.cwd === "string" ? payload.cwd : "",
+              hook_event_name: opts.event,
+              permission_mode: typeof payload.permission_mode === "string" ? payload.permission_mode : void 0,
+              wall_ts: (/* @__PURE__ */ new Date()).toISOString(),
+              sequence: seq,
+              message_uuid: t.message_uuid,
+              model: t.model,
+              input_tokens: t.input_tokens,
+              output_tokens: t.output_tokens,
+              cache_read_tokens: t.cache_read_tokens,
+              cache_creation_tokens: t.cache_creation_tokens,
+              text: t.text
+            };
+            await appendEvent(sessionId, ev);
+            newlyEmitted.push(t.message_uuid);
+          }
+          if (newlyEmitted.length > 0) {
+            await persistCursor(sessionId, seen, newlyEmitted);
+          }
+        } catch (err) {
+          process.stderr.write(`runtape: transcript scan failed: ${err instanceof Error ? err.message : String(err)}
+`);
+        }
+      }
+    }
+    if (opts.event === "SubagentStop") {
+      const subTranscript = typeof payload.agent_transcript_path === "string" ? payload.agent_transcript_path : "";
+      const agentToolUseId = typeof payload.agent_id === "string" ? payload.agent_id : "";
+      if (subTranscript !== "" && agentToolUseId !== "") {
+        try {
+          const { emits, seen } = await readNewSubagentEvents(sessionId, agentToolUseId, subTranscript);
+          const newlyEmitted = [];
+          const cwd = typeof payload.cwd === "string" ? payload.cwd : "";
+          for (const e of emits) {
+            const seq = await nextSequence(sessionId);
+            const baseEnvelope = {
+              session_id: sessionId,
+              transcript_path: subTranscript,
+              cwd,
+              hook_event_name: opts.event,
+              permission_mode: typeof payload.permission_mode === "string" ? payload.permission_mode : void 0,
+              wall_ts: (/* @__PURE__ */ new Date()).toISOString(),
+              sequence: seq,
+              agent_tool_use_id: agentToolUseId
+            };
+            let ev = null;
+            if (e.kind === "user_prompt") {
+              ev = { ...baseEnvelope, type: "user_prompt", prompt: e.prompt };
+            } else if (e.kind === "assistant_turn") {
+              ev = {
+                ...baseEnvelope,
+                type: "assistant_turn",
+                message_uuid: e.message_uuid,
+                model: e.model,
+                input_tokens: e.input_tokens,
+                output_tokens: e.output_tokens,
+                cache_read_tokens: e.cache_read_tokens,
+                cache_creation_tokens: e.cache_creation_tokens,
+                text: e.text
+              };
+            } else if (e.kind === "tool_attempt") {
+              ev = {
+                ...baseEnvelope,
+                type: "tool_attempt",
+                tool_name: e.tool_name,
+                tool_input: e.tool_input,
+                tool_use_id: e.tool_use_id
+              };
+            } else if (e.kind === "tool_call") {
+              ev = {
+                ...baseEnvelope,
+                type: "tool_call",
+                tool_name: e.tool_name,
+                tool_input: null,
+                tool_response: e.tool_response,
+                tool_use_id: e.tool_use_id,
+                duration_ms: 0,
+                is_error: e.is_error,
+                error_message: e.error_message
+              };
+            }
+            if (ev) {
+              await appendEvent(sessionId, ev);
+              newlyEmitted.push(e.uuid);
+            }
+          }
+          if (newlyEmitted.length > 0) {
+            await persistSubagentCursor(sessionId, agentToolUseId, seen, newlyEmitted);
+          }
+        } catch (err) {
+          process.stderr.write(`runtape: subagent transcript scan failed: ${err instanceof Error ? err.message : String(err)}
+`);
+        }
+      }
+    }
     spawnFlusher(resolveCliBinPath());
     return 0;
   } catch (err) {
@@ -536,10 +903,10 @@ async function pushCommand(opts) {
 }
 
 // src/commands/status.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 async function readFlusherPid() {
   try {
-    const raw = await readFile5(paths.flusherPid, "utf8");
+    const raw = await readFile7(paths.flusherPid, "utf8");
     const n = Number.parseInt(raw.trim(), 10);
     return Number.isFinite(n) ? n : null;
   } catch (err) {
@@ -639,7 +1006,8 @@ async function setupCommand(opts) {
   const rl = createInterface3({ input: input3, output: output3 });
   try {
     process.stdout.write("\nRuntape setup\n");
-    process.stdout.write("Let's get your Claude Code runs captured.\n\n");
+    process.stdout.write("Let's get your Claude Code runs captured.\n");
+    process.stdout.write("(Press Enter at any prompt to accept the default shown in [brackets].)\n\n");
     const existing = await readConfig();
     if (existing) {
       process.stdout.write(`Already logged in to ${existing.server_url}
@@ -655,7 +1023,7 @@ async function setupCommand(opts) {
     const suggestedUrl = defaultServerUrl();
     process.stdout.write(`Step 1/3 \u2014 Backend
 `);
-    const urlInput = (await rl.question(`Server URL [${suggestedUrl}]: `)).trim();
+    const urlInput = (await rl.question(`Server URL [${suggestedUrl}] (Enter to use this): `)).trim();
     const serverUrl = urlInput === "" ? suggestedUrl : urlInput;
     const dashboardUrl = `${serverUrl.replace(/\/$/, "")}/dashboard`;
     process.stdout.write(`
@@ -726,15 +1094,15 @@ Step 3/3 \u2014 Claude Code hooks
 }
 
 // src/lib/flusher.ts
-import { appendFile as appendFile2, mkdir as mkdir5, readFile as readFile6, unlink as unlink3, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname5 } from "path";
+import { appendFile as appendFile2, mkdir as mkdir7, readFile as readFile8, unlink as unlink3, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname7 } from "path";
 var POLL_INTERVAL_MS = 1500;
 var IDLE_EXIT_MS = 3e4;
 var BATCH_MAX = 100;
 var BACKOFF_STEPS_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 32e3, 6e4];
 async function log(line) {
   try {
-    await mkdir5(dirname5(paths.flusherLog), { recursive: true });
+    await mkdir7(dirname7(paths.flusherLog), { recursive: true });
     await appendFile2(paths.flusherLog, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `);
   } catch {
@@ -751,9 +1119,9 @@ async function isProcessAlive(pid) {
   }
 }
 async function acquirePidLock() {
-  await mkdir5(dirname5(paths.flusherPid), { recursive: true });
+  await mkdir7(dirname7(paths.flusherPid), { recursive: true });
   try {
-    const existing = await readFile6(paths.flusherPid, "utf8");
+    const existing = await readFile8(paths.flusherPid, "utf8");
     const pid = Number.parseInt(existing.trim(), 10);
     if (Number.isFinite(pid) && await isProcessAlive(pid)) {
       return false;
@@ -761,7 +1129,7 @@ async function acquirePidLock() {
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
-  await writeFile5(paths.flusherPid, String(process.pid));
+  await writeFile7(paths.flusherPid, String(process.pid));
   return true;
 }
 async function releasePidLock() {
@@ -846,7 +1214,7 @@ async function runFlusher() {
 }
 
 // src/index.ts
-var pkgPath = join2(dirname6(fileURLToPath2(import.meta.url)), "..", "package.json");
+var pkgPath = join2(dirname8(fileURLToPath2(import.meta.url)), "..", "package.json");
 var PKG_VERSION = JSON.parse(readFileSync(pkgPath, "utf8")).version;
 if (process.argv.includes("--internal-flusher")) {
   void runFlusher().then(