@taewooopark/agent-blackbox 0.46.4 → 0.47.0

package/dist/cli.js

@@ -1,5 +1,10 @@
 #!/usr/bin/env node
 
+// packages/core/src/json.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // packages/core/src/events.ts
 var traceHosts = [
   "opencode",
@@ -9,6 +14,7 @@ var traceHosts = [
   "hermes",
   "custom"
 ];
+var agentRoles = ["primary", "subagent", "system", "unknown"];
 var traceEventKinds = [
   "session_created",
   "session_updated",
@@ -50,6 +56,55 @@ var dataSensitivities = [
   "secret",
   "student_sensitive"
 ];
+var observedKinds = /* @__PURE__ */ new Set([
+  "tool_call",
+  "tool_result",
+  "file_read",
+  "file_edit",
+  "file_created",
+  "file_deleted",
+  "search",
+  "bash",
+  "permission_asked",
+  "permission_replied",
+  "todo_updated",
+  "git_status",
+  "git_commit",
+  "git_push"
+]);
+var claimKinds = /* @__PURE__ */ new Set(["message", "decision_extracted", "handoff_generated"]);
+function createTraceEvent(seq, input) {
+  const id = makeTraceEventId(input.runId, seq);
+  const evidence = inferEvidence(input.kind, input.evidence);
+  return {
+    id,
+    ts: input.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    seq,
+    host: input.host,
+    runId: input.runId,
+    sessionId: input.sessionId,
+    ...input.parentSessionId ? { parentSessionId: input.parentSessionId } : {},
+    ...input.cwd ? { cwd: input.cwd } : {},
+    ...input.agentId ? { agentId: input.agentId } : {},
+    ...input.agentRole ? { agentRole: input.agentRole } : {},
+    ...input.agentLabel ? { agentLabel: input.agentLabel } : {},
+    ...input.turnId ? { turnId: input.turnId } : {},
+    kind: input.kind,
+    ...input.summary ? { summary: input.summary } : {},
+    payload: input.payload ?? {},
+    sensitivity: input.sensitivity ?? "private",
+    redaction: {
+      rawStored: input.redaction?.rawStored ?? false,
+      rulesApplied: input.redaction?.rulesApplied ?? [],
+      truncated: input.redaction?.truncated ?? false
+    },
+    evidence
+  };
+}
+function makeTraceEventId(runId, seq) {
+  const safeRunId = runId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `evt_${safeRunId}_${String(seq).padStart(6, "0")}`;
+}
 function validateTraceEvent(event) {
   const errors = [];
   if (!isRecord(event)) {
@@ -64,6 +119,12 @@ function validateTraceEvent(event) {
   if (event.cwd !== void 0 && typeof event.cwd !== "string") {
     errors.push("cwd must be a string when present");
   }
+  optionalEnum(event, "agentRole", agentRoles, errors);
+  optionalString(event, "agentId", errors);
+  optionalString(event, "agentLabel", errors);
+  optionalString(event, "parentSessionId", errors);
+  optionalString(event, "turnId", errors);
+  optionalString(event, "summary", errors);
   requireEnum(event, "kind", traceEventKinds, errors);
   requireEnum(event, "sensitivity", dataSensitivities, errors);
   if (!isRecord(event.payload)) {
@@ -89,6 +150,12 @@ function assertTraceEvent(event) {
     throw new Error(`Invalid trace event: ${result.errors.join("; ")}`);
   }
 }
+function inferEvidence(kind, override) {
+  return {
+    observed: override?.observed ?? observedKinds.has(kind),
+    claimedByModel: override?.claimedByModel ?? claimKinds.has(kind)
+  };
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -107,6 +174,99 @@ function requireEnum(value, key, allowed, errors) {
     errors.push(`${key} must be one of ${allowed.join(", ")}`);
   }
 }
+function optionalString(value, key, errors) {
+  if (value[key] !== void 0 && typeof value[key] !== "string") {
+    errors.push(`${key} must be a string when present`);
+  }
+}
+function optionalEnum(value, key, allowed, errors) {
+  if (value[key] !== void 0 && (typeof value[key] !== "string" || !allowed.includes(value[key]))) {
+    errors.push(`${key} must be one of ${allowed.join(", ")} when present`);
+  }
+}
+
+// packages/core/src/redaction.ts
+var defaultRedactionRules = [
+  {
+    name: "github-token",
+    pattern: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b/g,
+    replacement: "[REDACTED_GITHUB_TOKEN]"
+  },
+  {
+    name: "anthropic-key",
+    pattern: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g,
+    replacement: "[REDACTED_ANTHROPIC_KEY]"
+  },
+  {
+    name: "openai-key",
+    pattern: /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+    replacement: "[REDACTED_OPENAI_KEY]"
+  },
+  {
+    name: "private-key",
+    // Tempered quantifier: the body cannot cross another BEGIN marker. Without it, a
+    // lone BEGIN with no END forces a scan to end-of-string from every BEGIN — O(n²)
+    // backtracking on untrusted tool output peppered with BEGIN markers (slow-path DoS).
+    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----(?:(?!-----BEGIN )[\s\S])*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    replacement: "[REDACTED_PRIVATE_KEY]"
+  }
+];
+function redactJsonObject(payload, options = {}) {
+  return redactJsonValue(payload, options);
+}
+function redactJsonValue(value, options = {}) {
+  const rules = [...defaultRedactionRules, ...options.extraRules ?? []];
+  const applied = /* @__PURE__ */ new Set();
+  let truncated = false;
+  const maxStringLength = options.maxStringLength ?? 4e3;
+  const visit = (current) => {
+    if (typeof current === "string") {
+      let next = current;
+      if (options.projectDir) {
+        next = replaceLiteral(next, options.projectDir, "$PROJECT", "project-dir", applied);
+      }
+      if (options.homeDir) {
+        next = replaceLiteral(next, options.homeDir, "~", "home-dir", applied);
+      }
+      for (const rule of rules) {
+        if (rule.pattern.test(next)) {
+          applied.add(rule.name);
+          next = next.replace(rule.pattern, rule.replacement);
+        }
+        rule.pattern.lastIndex = 0;
+      }
+      if (next.length > maxStringLength) {
+        truncated = true;
+        applied.add("truncate-string");
+        return `${next.slice(0, maxStringLength)}...[TRUNCATED ${next.length - maxStringLength} chars]`;
+      }
+      return next;
+    }
+    if (Array.isArray(current)) {
+      return current.map((item) => visit(item));
+    }
+    if (isJsonObject(current)) {
+      const next = {};
+      for (const [key, nested] of Object.entries(current)) {
+        next[key] = visit(nested);
+      }
+      return next;
+    }
+    return current;
+  };
+  return {
+    value: visit(value),
+    rulesApplied: [...applied].sort(),
+    truncated
+  };
+}
+function replaceLiteral(value, search, replacement, ruleName, applied) {
+  if (!search || !value.includes(search)) {
+    return value;
+  }
+  applied.add(ruleName);
+  return value.split(search).join(replacement);
+}
 
 // packages/core/src/graph.ts
 function materializeWorkflowGraph(events) {
@@ -273,13 +433,23 @@ function ensureAgent(graph, event) {
   ensureNode(graph, {
     id,
     type: "AGENT",
+    // Identity stays the agentId (the dashboard matches lanes by it). A readable
+    // display name rides in data.agentName, kept separate so matching never breaks.
     label: event.agentId,
     status: "ACTIVE",
     at: event.ts,
     eventId: event.id,
-    data: { agentId: event.agentId, agentRole: event.agentRole ?? "unknown" },
+    data: {
+      agentId: event.agentId,
+      agentRole: event.agentRole ?? "unknown",
+      ...event.agentLabel ? { agentName: event.agentLabel } : {}
+    },
     keepStatusIfExists: true
   });
+  if (event.agentLabel) {
+    const node = graph.nodes.get(id);
+    if (node && !node.data.agentName) node.data.agentName = event.agentLabel;
+  }
   ensureEdge(graph, {
     from: sessionNodeId(event.sessionId),
     to: id,
@@ -714,7 +884,8 @@ function computeEfficiencyReport(events) {
   const totalEditTokens = edits.reduce((sum, e) => sum + e.tokens, 0);
   const editedPaths = new Set(edits.map((e) => e.path));
   const okCommands = bashRuns.filter((b) => b.exitCode === 0).length;
-  const totalInputTokens = hasRealTokens ? finalSnapshot.input : estimateTokens(reads.reduce((s, r) => s + r.tokens * CHARS_PER_TOKEN, 0) + injections.reduce((s, i) => s + i.tokens * CHARS_PER_TOKEN, 0));
+  const injectionTokens = injections.reduce((s, i) => s + i.tokens, 0);
+  const totalInputTokens = hasRealTokens ? finalSnapshot.input : totalReadTokens + totalEditTokens + injectionTokens;
   const peak = hasRealTokens ? peakInput : totalInputTokens;
   const metrics = [];
   {
@@ -729,7 +900,11 @@ function computeEfficiencyReport(events) {
         display: formatTokens(peak),
         score,
         status,
-        detail: status === "good" ? "The context window stayed comfortably sized." : `Peak input reached ${formatTokens(peak)} \u2014 large prompts cost latency and money on every turn.`,
+        detail: status === "good" ? "The context window stayed comfortably sized." : hasRealTokens ? `Peak input reached ${formatTokens(peak)} \u2014 large prompts cost latency and money on every turn.` : (
+          // No real token telemetry: this is total input pulled in over the run (we can't
+          // measure peak window occupancy), so don't claim a measured peak.
+          `About ${formatTokens(peak)} of input flowed through the context \u2014 large prompts cost latency and money on every turn.`
+        ),
         evidenceEventIds: []
       }
     });
@@ -879,7 +1054,7 @@ function computeEfficiencyReport(events) {
       if (list.length <= 1) continue;
       retries += list.length - 1;
       for (const attempt of list) {
-        if (attempt.exitCode !== 0) {
+        if (attempt.exitCode !== void 0 && attempt.exitCode !== 0) {
           wasted += attempt.tokens;
           evidence.push(attempt.id);
         }
@@ -1117,18 +1292,614 @@ function removeManagedBlock(content) {
 `;
 }
 
+// packages/claude-code-adapter/dist/normalize.js
+var READ_TOOLS = /* @__PURE__ */ new Set(["read"]);
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["edit", "multiedit", "applypatch", "apply_patch", "notebookedit"]);
+var WRITE_TOOLS = /* @__PURE__ */ new Set(["write"]);
+var BASH_TOOLS = /* @__PURE__ */ new Set(["bash", "shell"]);
+var SEARCH_TOOLS = /* @__PURE__ */ new Set(["grep", "glob", "ls", "websearch"]);
+var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["task", "agent"]);
+var TODO_TOOLS = /* @__PURE__ */ new Set(["todowrite", "taskcreate", "taskupdate", "taskstop"]);
+var WORKFLOW_TOOLS = /* @__PURE__ */ new Set(["workflow"]);
+var COMMAND_TOOLS = /* @__PURE__ */ new Set(["skill"]);
+var TEAM_TOOLS = /* @__PURE__ */ new Set(["sendmessage", "teamcreate", "teamdelete", "remotetrigger", "pushnotification"]);
+function createClaudeNormalizer(ctx) {
+  const toolUses = /* @__PURE__ */ new Map();
+  let lastModel;
+  const consume = (rawLine) => {
+    const line = asRecord(rawLine);
+    switch (readString(line, ["type"])) {
+      case "assistant":
+        return consumeAssistant(line, ctx, toolUses, (m) => lastModel = m, () => lastModel);
+      case "user":
+        return consumeUser(line, ctx, toolUses);
+      case "system":
+        return consumeSystem(line, ctx);
+      default:
+        return [];
+    }
+  };
+  return { consume };
+}
+function consumeAssistant(line, ctx, toolUses, setModel, getModel) {
+  const events = [];
+  const msg = asRecord(line.message);
+  const model = readString(msg, ["model"]);
+  const usage = asRecord(msg.usage);
+  if (Object.keys(usage).length > 0) {
+    const inputTokens = num(usage.input_tokens) + num(usage.cache_read_input_tokens) + num(usage.cache_creation_input_tokens);
+    events.push(mkInput(line, ctx, {
+      kind: "message",
+      summary: "assistant turn",
+      payload: {
+        role: "assistant",
+        ...model ? { model } : {},
+        tokens: {
+          input: inputTokens,
+          output: num(usage.output_tokens),
+          cache: { read: num(usage.cache_read_input_tokens), write: num(usage.cache_creation_input_tokens) }
+        }
+      }
+    }));
+  }
+  if (model && model !== "<synthetic>" && model !== getModel()) {
+    if (getModel())
+      events.push(mkInput(line, ctx, { kind: "model_switched", summary: `Model \u2192 ${model}`, payload: { model } }));
+    setModel(model);
+  }
+  for (const block of asArray(msg.content)) {
+    const b = asRecord(block);
+    if (readString(b, ["type"]) !== "tool_use")
+      continue;
+    const id = readString(b, ["id"]);
+    const name = readString(b, ["name"]) ?? "unknown-tool";
+    const input = asJsonObject(b.input);
+    if (id)
+      toolUses.set(id, { name, input });
+    events.push(mkInput(line, ctx, {
+      kind: "tool_call",
+      summary: `tool.call:${prettyTool(name)}`,
+      payload: { tool: name, ...id ? { callID: id } : {} }
+    }));
+  }
+  return events;
+}
+function consumeUser(line, ctx, toolUses) {
+  const events = [];
+  const msg = asRecord(line.message);
+  if (ctx.agent && !ctx.agent.label) {
+    const task = extractText(msg.content);
+    if (task)
+      ctx.agent.label = shortLabel(task);
+  }
+  const promptSource = readString(line, ["promptSource"]);
+  const isMeta = line.isMeta === true;
+  if (!isMeta && (promptSource === "typed" || promptSource === "queued")) {
+    const text = extractText(msg.content);
+    if (text)
+      events.push(mkInput(line, ctx, { kind: "message", summary: "user prompt", payload: { role: "user", text } }));
+  }
+  const toolUseResult = line.toolUseResult;
+  for (const block of asArray(msg.content)) {
+    const b = asRecord(block);
+    if (readString(b, ["type"]) !== "tool_result")
+      continue;
+    const id = readString(b, ["tool_use_id"]);
+    const call = id ? toolUses.get(id) : void 0;
+    if (!call)
+      continue;
+    const observed = deriveObserved(call.name, call.input, b, toolUseResult, line, ctx);
+    if (observed)
+      events.push(observed);
+  }
+  return events;
+}
+function consumeSystem(line, ctx) {
+  const subtype = readString(line, ["subtype"]);
+  if (subtype === "compact_boundary") {
+    return [mkInput(line, ctx, { kind: "context_compacted", summary: "Context compacted", payload: {} })];
+  }
+  if (subtype === "api_error") {
+    return [mkInput(line, ctx, { kind: "host_event", summary: "API error", payload: { event: "api_error", ...readString(line, ["level"]) ? { level: readString(line, ["level"]) } : {} } })];
+  }
+  if (subtype === "local_command") {
+    return [mkInput(line, ctx, { kind: "command_run", summary: "Local command", payload: { event: "local_command" } })];
+  }
+  if (subtype === "stop_hook_summary") {
+    const prevented = line.preventedContinuation === true;
+    const errors = asArray(line.hookErrors);
+    if (prevented || errors.length > 0) {
+      return [
+        mkInput(line, ctx, {
+          kind: "host_event",
+          summary: prevented ? "Hook blocked continuation" : "Hook error",
+          payload: { event: "hook", preventedContinuation: prevented, hookErrors: errors.length }
+        })
+      ];
+    }
+  }
+  return [];
+}
+function deriveObserved(name, input, resultBlock, toolUseResult, line, ctx) {
+  const lname = name.toLowerCase();
+  const tur = asRecord(toolUseResult);
+  const isError = resultBlock.is_error === true;
+  if (READ_TOOLS.has(lname)) {
+    const fileRec = asRecord(tur.file);
+    const path = readString(fileRec, ["filePath"]) ?? readString(input, ["file_path", "path"]);
+    const image = imageReadChars(tur, fileRec, resultBlock);
+    const chars = strlen(fileRec.content) ?? measureResultText(resultBlock) ?? image;
+    return mkInput(line, ctx, {
+      kind: "file_read",
+      summary: path ? `Read ${path}` : "Read file",
+      payload: {
+        ...path ? { path } : {},
+        ...chars !== void 0 ? { chars } : {},
+        ...image !== void 0 ? { image: true } : {}
+      }
+    });
+  }
+  if (EDIT_TOOLS.has(lname)) {
+    const path = readString(tur, ["filePath"]) ?? readString(input, ["file_path", "path"]);
+    const chars = strlen(tur.newString) ?? strlen(input.new_string) ?? measureResultText(resultBlock);
+    return mkInput(line, ctx, {
+      kind: "file_edit",
+      summary: path ? `Edited ${path}` : "Edited file",
+      payload: { ...path ? { path } : {}, ...chars !== void 0 ? { chars } : {} }
+    });
+  }
+  if (WRITE_TOOLS.has(lname)) {
+    const path = readString(tur, ["filePath"]) ?? readString(input, ["file_path", "path"]);
+    const chars = strlen(tur.content) ?? strlen(input.content) ?? measureResultText(resultBlock);
+    return mkInput(line, ctx, {
+      kind: "file_created",
+      summary: path ? `Created ${path}` : "Created file",
+      payload: { ...path ? { path } : {}, ...chars !== void 0 ? { chars } : {} }
+    });
+  }
+  if (BASH_TOOLS.has(lname)) {
+    const command = readString(input, ["command"]);
+    const outputChars2 = (strlen(tur.stdout) ?? 0) + (strlen(tur.stderr) ?? 0) || measureResultText(resultBlock) || 0;
+    const git = command ? gitKind(command) : void 0;
+    if (git) {
+      return mkInput(line, ctx, {
+        kind: git.kind,
+        summary: isError ? `${git.label} (failed)` : git.label,
+        payload: { ...command ? { command } : {}, exitCode: isError ? 1 : 0, outputChars: outputChars2 }
+      });
+    }
+    return mkInput(line, ctx, {
+      kind: "bash",
+      summary: command ? `Ran ${command}` : "Ran shell command",
+      payload: {
+        ...command ? { command } : {},
+        exitCode: isError ? 1 : 0,
+        outputChars: outputChars2,
+        ...readString(input, ["description"]) ? { description: readString(input, ["description"]) } : {}
+      }
+    });
+  }
+  if (SEARCH_TOOLS.has(lname)) {
+    const query = readString(input, ["pattern", "query", "glob", "path"]);
+    return mkInput(line, ctx, {
+      kind: "search",
+      summary: query ? `Searched ${query}` : "Searched",
+      payload: { ...query ? { query } : {} }
+    });
+  }
+  if (SUBAGENT_TOOLS.has(lname)) {
+    const label = readString(input, ["subagent_type", "description"]) ?? "subagent";
+    const agentId = readString(tur, ["agentId"]) ?? label;
+    const ev = mkInput(line, ctx, {
+      kind: "subagent_spawned",
+      summary: `Delegated to ${label}`,
+      payload: {
+        agent: label,
+        agentId,
+        ...readString(input, ["description"]) ? { description: readString(input, ["description"]) } : {},
+        ...shorten2(readString(input, ["prompt"]), 600) ? { prompt: shorten2(readString(input, ["prompt"]), 600) } : {}
+      }
+    });
+    ev.agentId = agentId;
+    ev.agentRole = "subagent";
+    ev.agentLabel = label;
+    return ev;
+  }
+  if (WORKFLOW_TOOLS.has(lname)) {
+    const wfName = readString(tur, ["workflowName"]) ?? "workflow";
+    const wfRun = readString(tur, ["runId"]);
+    const ev = mkInput(line, ctx, {
+      kind: "subagent_spawned",
+      summary: `Ran workflow ${wfName}`,
+      payload: {
+        agent: `workflow:${wfName}`,
+        ...wfRun ? { agentId: wfRun } : {},
+        ...readString(tur, ["summary"]) ? { description: readString(tur, ["summary"]) } : {}
+      }
+    });
+    ev.agentId = wfRun ?? `workflow:${wfName}`;
+    ev.agentRole = "subagent";
+    ev.agentLabel = `workflow:${wfName}`;
+    return ev;
+  }
+  if (COMMAND_TOOLS.has(lname)) {
+    const cmd = readString(input, ["skill", "command"]) ?? readString(tur, ["commandName"]) ?? "command";
+    return mkInput(line, ctx, { kind: "command_run", summary: `/${cmd}`, payload: { command: cmd } });
+  }
+  if (TEAM_TOOLS.has(lname)) {
+    return mkInput(line, ctx, { kind: "host_event", summary: `Team: ${name}`, payload: { tool: name, event: "team" } });
+  }
+  if (TODO_TOOLS.has(lname)) {
+    return mkInput(line, ctx, { kind: "todo_updated", summary: "Updated todos", payload: {} });
+  }
+  const outputChars = measureResultText(resultBlock) ?? strlen(tur.result) ?? strlen(tur.text);
+  return mkInput(line, ctx, {
+    kind: "tool_result",
+    summary: `Used ${prettyTool(name)}`,
+    payload: { tool: name, ...outputChars !== void 0 ? { outputChars } : {} }
+  });
+}
+function mkInput(line, ctx, partial) {
+  const redactOpts = {
+    ...ctx.homeDir ? { homeDir: ctx.homeDir } : {},
+    ...ctx.projectDir ? { projectDir: ctx.projectDir } : {},
+    maxStringLength: 4e3
+  };
+  const redacted = redactJsonObject(sanitize(partial.payload), redactOpts);
+  const summary = redactJsonValue(partial.summary, redactOpts).value;
+  const sessionId = readString(line, ["sessionId"]) ?? ctx.defaultSessionId;
+  const ts = readString(line, ["timestamp"]);
+  const cwd = readString(line, ["cwd"]);
+  const input = {
+    host: "claude-code",
+    runId: sessionId,
+    sessionId,
+    kind: partial.kind,
+    summary,
+    payload: redacted.value,
+    redaction: { rawStored: ctx.rawStored ?? false, rulesApplied: redacted.rulesApplied, truncated: redacted.truncated }
+  };
+  if (ts)
+    input.ts = ts;
+  if (cwd)
+    input.cwd = cwd;
+  if (ctx.agent) {
+    input.agentId = ctx.agent.agentId;
+    input.agentRole = "subagent";
+    if (ctx.agent.label)
+      input.agentLabel = redactJsonValue(ctx.agent.label, redactOpts).value;
+  }
+  return input;
+}
+function extractText(content) {
+  if (typeof content === "string")
+    return content.trim() || void 0;
+  if (Array.isArray(content)) {
+    const text = content.map((b) => isRecord3(b) && readString(b, ["type"]) === "text" ? readString(b, ["text"]) : void 0).filter((t) => Boolean(t)).join("\n").trim();
+    return text || void 0;
+  }
+  return void 0;
+}
+function measureResultText(resultBlock) {
+  const content = resultBlock.content;
+  if (typeof content === "string")
+    return content.length;
+  if (Array.isArray(content)) {
+    let total = 0;
+    for (const b of content) {
+      const t = isRecord3(b) ? readString(b, ["text"]) : void 0;
+      if (t)
+        total += t.length;
+    }
+    return total || void 0;
+  }
+  return void 0;
+}
+function strlen(v) {
+  return typeof v === "string" ? v.length : void 0;
+}
+function imageReadChars(tur, fileRec, resultBlock) {
+  const isImage = readString(tur, ["type"]) === "image" || typeof fileRec.base64 === "string" || blockHasImage(resultBlock);
+  if (!isImage)
+    return void 0;
+  const dims = asRecord(fileRec.dimensions);
+  const w = readNumber(dims, ["width"]);
+  const h = readNumber(dims, ["height"]);
+  if (w !== void 0 && h !== void 0 && w > 0 && h > 0)
+    return Math.round(w * h / 750) * 4;
+  return 6e3;
+}
+function blockHasImage(resultBlock) {
+  const content = resultBlock.content;
+  return Array.isArray(content) && content.some((b) => isRecord3(b) && readString(b, ["type"]) === "image");
+}
+function readNumber(record, keys) {
+  for (const key of keys) {
+    const value = readPath(record, key);
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+  }
+  return void 0;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function shorten2(v, max) {
+  if (v === void 0)
+    return void 0;
+  return v.length <= max ? v : `${v.slice(0, max)}...`;
+}
+function shortLabel(text) {
+  const firstLine = (text.split("\n").find((l) => l.trim().length > 0) ?? text).trim();
+  return firstLine.length > 48 ? `${firstLine.slice(0, 47)}\u2026` : firstLine;
+}
+function gitKind(command) {
+  if (/\bgit\s+push\b/.test(command))
+    return { kind: "git_push", label: "Pushed changes" };
+  if (/\bgit\s+commit\b/.test(command))
+    return { kind: "git_commit", label: "Recorded a commit" };
+  return void 0;
+}
+function prettyTool(name) {
+  if (!name.startsWith("mcp__"))
+    return name;
+  const rest = name.slice("mcp__".length);
+  const sep = rest.indexOf("__");
+  return sep < 0 ? rest : `${rest.slice(0, sep)}: ${rest.slice(sep + 2)}`;
+}
+function readString(record, keys) {
+  for (const key of keys) {
+    const value = readPath(record, key);
+    if (typeof value === "string" && value.length > 0)
+      return value;
+  }
+  return void 0;
+}
+function readPath(record, path) {
+  const parts = path.split(".");
+  let current = record;
+  for (const part of parts) {
+    if (!isRecord3(current))
+      return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asRecord(value) {
+  return isRecord3(value) ? value : {};
+}
+function asJsonObject(value) {
+  return isRecord3(value) ? sanitize(value) : {};
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sanitize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  return sanitizeValue(value, seen);
+}
+function sanitizeValue(value, seen) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value !== "object")
+    return String(value);
+  if (seen.has(value))
+    return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const out2 = value.map((v) => sanitizeValue(v, seen));
+    seen.delete(value);
+    return out2;
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v === "undefined" || typeof v === "function" || typeof v === "symbol")
+      continue;
+    out[k] = sanitizeValue(v, seen);
+  }
+  seen.delete(value);
+  return out;
+}
+
+// packages/claude-code-adapter/dist/tailer.js
+import { open, readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+function defaultProjectsDir(homeDir = homedir()) {
+  const override = process.env.CLAUDE_CONFIG_DIR;
+  return override && override.length > 0 ? join(override, "projects") : join(homeDir, ".claude", "projects");
+}
+async function startClaudeCodeTailer(sink, options = {}) {
+  const homeDir = options.homeDir ?? homedir();
+  const projectsDir = options.projectsDir ?? defaultProjectsDir(homeDir);
+  const pollMs = options.pollMs ?? 700;
+  const backfillCutoff = Date.now() - (options.backfillDays ?? 2) * 24 * 60 * 60 * 1e3;
+  const files = /* @__PURE__ */ new Map();
+  const seqByRun = /* @__PURE__ */ new Map();
+  const nextSeq = (runId) => {
+    const n = (seqByRun.get(runId) ?? 0) + 1;
+    seqByRun.set(runId, n);
+    return n;
+  };
+  const contextForFile = (filePath) => {
+    const base = basename(filePath).replace(/\.jsonl$/, "");
+    const common = {
+      defaultSessionId: base,
+      homeDir,
+      ...options.rawStored !== void 0 ? { rawStored: options.rawStored } : {}
+    };
+    return base.startsWith("agent-") ? { ...common, agent: { agentId: base.slice("agent-".length) } } : common;
+  };
+  const ensureFile = (filePath) => {
+    let state = files.get(filePath);
+    if (!state) {
+      state = { offset: 0, buffer: "", normalizer: createClaudeNormalizer(contextForFile(filePath)) };
+      files.set(filePath, state);
+    }
+    return state;
+  };
+  const drainFile = async (filePath) => {
+    let size;
+    try {
+      size = (await stat(filePath)).size;
+    } catch {
+      return;
+    }
+    const state = ensureFile(filePath);
+    if (size < state.offset) {
+      state.offset = 0;
+      state.buffer = "";
+    }
+    if (size <= state.offset)
+      return;
+    const fh = await open(filePath, "r");
+    try {
+      const length = size - state.offset;
+      const buf = Buffer.alloc(length);
+      await fh.read(buf, 0, length, state.offset);
+      state.offset = size;
+      state.buffer += buf.toString("utf8");
+    } finally {
+      await fh.close();
+    }
+    const lines = state.buffer.split("\n");
+    state.buffer = lines.pop() ?? "";
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (!line)
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const events = state.normalizer.consume(parsed);
+      for (const input of events)
+        await emit(sink, input, nextSeq);
+    }
+  };
+  const listTranscripts = async () => {
+    let entries;
+    try {
+      entries = await readdir(projectsDir, { recursive: true });
+    } catch {
+      return [];
+    }
+    return entries.filter((e) => e.endsWith(".jsonl")).map((e) => join(projectsDir, e));
+  };
+  const initial = await listTranscripts();
+  const recent = [];
+  for (const f of initial) {
+    try {
+      if ((await stat(f)).mtimeMs >= backfillCutoff)
+        recent.push(f);
+    } catch {
+    }
+  }
+  recent.sort((a, b) => Number(basename(a).startsWith("agent-")) - Number(basename(b).startsWith("agent-")));
+  for (const f of recent)
+    await drainFile(f);
+  let running = true;
+  const tick = async () => {
+    if (!running)
+      return;
+    const all = await listTranscripts();
+    all.sort((a, b) => Number(basename(a).startsWith("agent-")) - Number(basename(b).startsWith("agent-")));
+    for (const f of all) {
+      try {
+        await drainFile(f);
+      } catch {
+      }
+    }
+  };
+  const timer = setInterval(() => void tick(), pollMs);
+  if (typeof timer.unref === "function")
+    timer.unref();
+  return {
+    projectsDir,
+    stop: () => {
+      running = false;
+      clearInterval(timer);
+    }
+  };
+}
+async function emit(sink, input, nextSeq) {
+  const event = createTraceEvent(nextSeq(input.runId), input);
+  await sink.write(event);
+}
+
+// packages/claude-code-adapter/dist/hooks.js
+var ABB_HOOK_MARKER = "agent-blackbox-hook";
+function abbHookSpecs() {
+  return [
+    { event: "PreToolUse", matcher: "Read|Edit|MultiEdit|Write|Bash" },
+    { event: "PostToolUse", matcher: "Read|Edit|MultiEdit|Write|Bash" },
+    { event: "UserPromptSubmit" },
+    { event: "PreCompact" },
+    { event: "SessionEnd" }
+  ];
+}
+function isAbbGroup(group) {
+  return isRecord4(group) && Array.isArray(group.hooks) && group.hooks.some((h) => isRecord4(h) && typeof h.command === "string" && h.command.includes(ABB_HOOK_MARKER));
+}
+function mergeAbbHooks(settings, invocation) {
+  const next = { ...settings };
+  const hooks = isRecord4(settings.hooks) ? { ...settings.hooks } : {};
+  for (const spec of abbHookSpecs()) {
+    const current = hooks[spec.event];
+    const kept = (Array.isArray(current) ? current : []).filter((g) => !isAbbGroup(g));
+    kept.push({
+      ...spec.matcher ? { matcher: spec.matcher } : {},
+      hooks: [{ type: "command", command: `${invocation} ${spec.event} ${ABB_HOOK_MARKER}` }]
+    });
+    hooks[spec.event] = kept;
+  }
+  next.hooks = hooks;
+  return next;
+}
+function removeAbbHooks(settings) {
+  if (!isRecord4(settings.hooks))
+    return settings;
+  const next = { ...settings };
+  const hooks = {};
+  for (const [event, groups] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(groups))
+      continue;
+    const kept = groups.filter((g) => !isAbbGroup(g));
+    if (kept.length > 0)
+      hooks[event] = kept;
+  }
+  if (Object.keys(hooks).length > 0)
+    next.hooks = hooks;
+  else
+    delete next.hooks;
+  return next;
+}
+function hasAbbHooks(settings) {
+  if (!isRecord4(settings.hooks))
+    return false;
+  return Object.values(settings.hooks).some((groups) => Array.isArray(groups) && groups.some(isAbbGroup));
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // apps/daemon/dist/cli.js
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname5, join as join6, resolve } from "node:path";
+import { dirname as dirname6, join as join8, resolve } from "node:path";
 
 // apps/daemon/dist/dashboardServer.js
 import { createReadStream } from "node:fs";
-import { readFile, stat } from "node:fs/promises";
+import { readFile, stat as stat2 } from "node:fs/promises";
 import { createServer } from "node:http";
-import { extname, join, normalize } from "node:path";
+import { extname, join as join2, normalize } from "node:path";
 var mimeTypes = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -1142,7 +1913,7 @@ var mimeTypes = {
   ".woff2": "font/woff2"
 };
 async function startDashboardServer(options) {
-  const indexPath = join(options.distDir, "index.html");
+  const indexPath = join2(options.distDir, "index.html");
   let indexHtml;
   try {
     indexHtml = await readFile(indexPath, "utf8");
@@ -1166,13 +1937,13 @@ async function startDashboardServer(options) {
       return;
     }
     const safePath = normalize(rawPath).replace(/^(\.\.[/\\])+/, "");
-    const filePath = join(options.distDir, safePath);
+    const filePath = join2(options.distDir, safePath);
     if (!filePath.startsWith(options.distDir)) {
       response.writeHead(403);
       response.end("Forbidden");
       return;
     }
-    void stat(filePath).then((stats) => {
+    void stat2(filePath).then((stats) => {
       if (!stats.isFile()) {
         throw new Error("not a file");
       }
@@ -1206,7 +1977,7 @@ async function startDashboardServer(options) {
 
 // apps/daemon/dist/index.js
 import { readFileSync } from "node:fs";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname4, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/storage/src/ndjson.ts
@@ -1263,13 +2034,17 @@ async function readTraceEvents(filePath) {
 }
 
 // apps/daemon/dist/server.js
+import { readFile as readFile4 } from "node:fs/promises";
 import { createServer as createServer2 } from "node:http";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import { WebSocket, WebSocketServer } from "ws";
 
 // apps/daemon/dist/optimize.js
-import { mkdir as mkdir2, readFile as readFile3, rm, writeFile } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute, join as join2 } from "node:path";
+import { mkdir as mkdir2, readFile as readFile3, rename, rm, writeFile } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join3 } from "node:path";
+function memoryFileFor(host) {
+  return host === "claude-code" ? "CLAUDE.md" : "AGENTS.md";
+}
 var flaggedIds = (report) => report.metrics.filter((m) => m.status !== "good").map((m) => m.id);
 var joinIds = (ids) => ids.join(", ");
 var REVERT_MARGIN = 3;
@@ -1279,13 +2054,15 @@ async function runOptimize(options) {
   return { ...result, applied: content !== null && hasManagedBlock(content) };
 }
 async function computeOptimize(options) {
-  const eventsFile = options.eventsFile ?? join2(options.projectDir, ".agent-blackbox", "events.ndjson");
+  const eventsFile = options.eventsFile ?? join3(options.projectDir, ".agent-blackbox", "events.ndjson");
   const events = await loadTraceEvents(eventsFile);
   const { runId, events: runEvents } = latestRun(events);
   const runCwd = runEvents.find((e) => typeof e.cwd === "string" && e.cwd.length > 0)?.cwd;
   const targetDir = runCwd && isAbsolute(runCwd) ? runCwd : options.projectDir;
-  const agentsMdPath = join2(targetDir, "AGENTS.md");
-  const statePath = join2(targetDir, ".agent-blackbox", "optimization.json");
+  const runHost = runEvents.find((e) => typeof e.host === "string")?.host;
+  const memoryFileName = memoryFileFor(runHost);
+  const agentsMdPath = join3(targetDir, memoryFileName);
+  const statePath = join3(targetDir, ".agent-blackbox", "optimization.json");
   const latestTs = runEvents.reduce((max, e) => e.ts > max ? e.ts : max, "");
   const report = runEvents.length > 0 ? computeEfficiencyReport(runEvents) : null;
   const score = report ? report.overallScore : null;
@@ -1296,7 +2073,7 @@ async function computeOptimize(options) {
   if (options.mode === "preview") {
     return {
       mode: "preview",
-      action: block ? "Preview only \u2014 re-run with --apply to write this to AGENTS.md." : "This run is clean \u2014 nothing worth pinning.",
+      action: block ? `Preview only \u2014 re-run with --apply to write this to ${memoryFileName}.` : "This run is clean \u2014 nothing worth pinning.",
       score,
       baselineScore: null,
       reclaimableTokens: report?.reclaimableTokens,
@@ -1309,22 +2086,26 @@ async function computeOptimize(options) {
     if (!block || !report || score === null || runId === null) {
       return { mode: "apply", action: "This run is clean \u2014 nothing to apply.", score, baselineScore: null, block: null, agentsMdPath, changed: false };
     }
-    const prior = await readMaybe(agentsMdPath);
-    const next = upsertManagedBlock(prior ?? "", block);
-    if (prior === null || next !== prior) {
-      await writeFile(agentsMdPath, next, "utf8");
-      await writeState(statePath, {
-        runId: runId ?? "",
-        baselineScore: score,
-        baselineLatestTs: latestTs,
-        baselineFlagged: flaggedIds(report),
-        fileExisted: prior !== null,
-        appliedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
+    const { prior, next } = await serializeWrite(agentsMdPath, async () => {
+      const prior2 = await readMaybe(agentsMdPath);
+      const next2 = upsertManagedBlock(prior2 ?? "", block);
+      if (prior2 === null || next2 !== prior2) {
+        await writeFileAtomic(agentsMdPath, next2);
+        await writeState(statePath, {
+          runId: runId ?? "",
+          baselineScore: score,
+          baselineLatestTs: latestTs,
+          baselineFlagged: flaggedIds(report),
+          fileExisted: prior2 !== null,
+          appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          memoryFile: memoryFileName
+        });
+      }
+      return { prior: prior2, next: next2 };
+    });
     return {
       mode: "apply",
-      action: `Wrote efficiency memory to AGENTS.md \u2014 targets ~${report.reclaimableTokens} reclaimable tokens on similar future runs (no re-run needed). Optional: re-run the same task + \`optimize --check\` to benchmark the gain.`,
+      action: `Wrote efficiency memory to ${memoryFileName} \u2014 targets ~${report.reclaimableTokens} reclaimable tokens on similar future runs (no re-run needed). Optional: re-run the same task + \`optimize --check\` to benchmark the gain.`,
       score,
       baselineScore: score,
       reclaimableTokens: report.reclaimableTokens,
@@ -1359,7 +2140,8 @@ async function computeOptimize(options) {
   const metricDiff = [cleared.length ? `cleared ${joinIds(cleared)}` : "", appeared.length ? `new ${joinIds(appeared)}` : ""].filter(Boolean).join("; ");
   const diffSuffix = metricDiff ? ` [${metricDiff}]` : "";
   if (delta < -REVERT_MARGIN) {
-    const changed = await restore(agentsMdPath, state.fileExisted);
+    const appliedPath = state.memoryFile ? join3(targetDir, state.memoryFile) : agentsMdPath;
+    const changed = await restore(appliedPath, state.fileExisted);
     await rm(statePath, { force: true });
     return {
       mode: "check",
@@ -1383,32 +2165,35 @@ async function computeOptimize(options) {
 }
 async function revert(agentsMdPath, statePath, score) {
   const state = await readState(statePath);
-  const changed = await restore(agentsMdPath, state ? state.fileExisted : true);
+  const path = state?.memoryFile ? join3(dirname2(agentsMdPath), state.memoryFile) : agentsMdPath;
+  const changed = await restore(path, state ? state.fileExisted : true);
   if (state)
     await rm(statePath, { force: true });
   return {
     mode: "revert",
-    action: changed ? "Removed the managed efficiency block from AGENTS.md." : "Nothing to revert.",
+    action: changed ? `Removed the managed efficiency block from ${basename2(path)}.` : "Nothing to revert.",
     score,
     baselineScore: state ? state.baselineScore : null,
     block: null,
-    agentsMdPath,
+    agentsMdPath: path,
     changed
   };
 }
 async function restore(agentsMdPath, fileExisted) {
-  const current = await readMaybe(agentsMdPath);
-  if (current === null)
-    return false;
-  const next = removeManagedBlock(current);
-  if (next === current)
-    return false;
-  if (next.trim() === "" && !fileExisted) {
-    await rm(agentsMdPath, { force: true });
+  return serializeWrite(agentsMdPath, async () => {
+    const current = await readMaybe(agentsMdPath);
+    if (current === null)
+      return false;
+    const next = removeManagedBlock(current);
+    if (next === current)
+      return false;
+    if (next.trim() === "" && !fileExisted) {
+      await rm(agentsMdPath, { force: true });
+      return true;
+    }
+    await writeFileAtomic(agentsMdPath, next);
     return true;
-  }
-  await writeFile(agentsMdPath, next, "utf8");
-  return true;
+  });
 }
 function latestRun(events) {
   let latest;
@@ -1484,9 +2269,21 @@ async function readState(path) {
   }
 }
 async function writeState(path, state) {
+  await writeFileAtomic(path, `${JSON.stringify(state, null, 2)}
+`);
+}
+async function writeFileAtomic(path, content) {
   await mkdir2(dirname2(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(state, null, 2)}
-`, "utf8");
+  const tmp = `${path}.${process.pid}.tmp`;
+  await writeFile(tmp, content, "utf8");
+  await rename(tmp, path);
+}
+var writeChains2 = /* @__PURE__ */ new Map();
+function serializeWrite(key, run) {
+  const prev = writeChains2.get(key) ?? Promise.resolve();
+  const result = prev.then(run, run);
+  writeChains2.set(key, result.then(() => void 0, () => void 0));
+  return result;
 }
 
 // apps/daemon/dist/suggestionProvider.js
@@ -1759,11 +2556,12 @@ function extractJsonObject(text) {
 
 // apps/daemon/dist/server.js
 async function startTraceDaemon(options) {
-  const eventsFile = options.eventsFile ?? join3(options.projectDir, ".agent-blackbox", "events.ndjson");
+  const eventsFile = options.eventsFile ?? join4(options.projectDir, ".agent-blackbox", "events.ndjson");
   const suggestConfig = options.suggest ?? { mode: "auto" };
   const clients = /* @__PURE__ */ new Set();
+  const scheduleBroadcast = makeBroadcastScheduler(clients, eventsFile);
   const server = createServer2((request, response) => {
-    void handleRequest(request, response, eventsFile, clients, suggestConfig, options.projectDir);
+    void handleRequest(request, response, eventsFile, clients, suggestConfig, options.projectDir, scheduleBroadcast);
   });
   const streamServer = new WebSocketServer({ noServer: true });
   server.on("upgrade", (request, socket, head) => {
@@ -1774,8 +2572,11 @@ async function startTraceDaemon(options) {
     }
     streamServer.handleUpgrade(request, socket, head, (client) => {
       clients.add(client);
-      client.on("close", () => {
-        clients.delete(client);
+      const drop = () => clients.delete(client);
+      client.on("close", drop);
+      client.on("error", () => {
+        drop();
+        client.terminate();
       });
       void sendSnapshot(client, eventsFile);
     });
@@ -1794,6 +2595,12 @@ async function startTraceDaemon(options) {
     server,
     port: actualPort,
     eventsFile,
+    ingest: async (event) => {
+      if (!validateTraceEvent(event).ok)
+        return;
+      await appendTraceEvent(eventsFile, event);
+      scheduleBroadcast();
+    },
     close: () => new Promise((resolve2, reject) => {
       for (const client of clients) {
         client.terminate();
@@ -1820,6 +2627,26 @@ async function loadTraceEvents(eventsFile) {
     throw error;
   }
 }
+var SNAPSHOT_EVENT_CAP = 3e4;
+async function loadRecentTraceEvents(eventsFile, cap = SNAPSHOT_EVENT_CAP) {
+  let text;
+  try {
+    text = await readFile4(eventsFile, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  const lines = text.split("\n");
+  let kept = 0;
+  let start = lines.length;
+  while (start > 0 && kept < cap) {
+    start -= 1;
+    if (lines[start].trim().length > 0)
+      kept += 1;
+  }
+  return parseTraceEvents(lines.slice(start).join("\n"));
+}
 async function buildReplaySummary(eventsFile) {
   const events = await loadTraceEvents(eventsFile);
   const graph = materializeWorkflowGraph(events);
@@ -1831,7 +2658,7 @@ async function buildReplaySummary(eventsFile) {
   };
 }
 async function buildTraceSnapshot(eventsFile, replay = {}) {
-  const events = await loadTraceEvents(eventsFile);
+  const events = await loadRecentTraceEvents(eventsFile);
   const graph = replay.seq !== void 0 ? replayWorkflowGraphAtSeq(events, replay.seq) : replay.at !== void 0 ? replayWorkflowGraphAtTime(events, replay.at) : materializeWorkflowGraph(events);
   const replayedEvents = new Set(graph.appliedEventIds);
   const visibleEvents = events.filter((event) => replayedEvents.has(event.id));
@@ -1851,7 +2678,7 @@ async function buildTraceSnapshot(eventsFile, replay = {}) {
     }
   };
 }
-async function handleRequest(request, response, eventsFile, clients, suggestConfig, projectDir) {
+async function handleRequest(request, response, eventsFile, clients, suggestConfig, projectDir, scheduleBroadcast) {
   try {
     applyCors(request, response);
     const url = new URL(request.url ?? "/", "http://127.0.0.1");
@@ -1928,7 +2755,7 @@ async function handleRequest(request, response, eventsFile, clients, suggestConf
         return;
       }
       await appendTraceEvent(eventsFile, body);
-      void broadcastSnapshot(clients, eventsFile);
+      scheduleBroadcast();
       sendJson(response, 202, { ok: true, data: { accepted: true, id: body.id } });
       return;
     }
@@ -1946,6 +2773,19 @@ async function broadcastSnapshot(clients, eventsFile) {
   }
   await Promise.allSettled([...clients].map((client) => sendSnapshot(client, eventsFile)));
 }
+function makeBroadcastScheduler(clients, eventsFile, delayMs = 150) {
+  let timer = null;
+  return () => {
+    if (timer)
+      return;
+    timer = setTimeout(() => {
+      timer = null;
+      void broadcastSnapshot(clients, eventsFile);
+    }, delayMs);
+    if (typeof timer.unref === "function")
+      timer.unref();
+  };
+}
 async function sendSnapshot(client, eventsFile) {
   if (client.readyState !== WebSocket.OPEN) {
     return;
@@ -2038,24 +2878,24 @@ function isNodeError(error) {
 }
 
 // apps/daemon/dist/initOpenCode.js
-import { mkdir as mkdir3, readFile as readFile4, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile5, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, join as join5 } from "node:path";
 var defaultAdapterPackage = "@agent-blackbox/opencode-adapter";
 var defaultDaemonUrl = "http://127.0.0.1:47831";
 function globalOpenCodeDir() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  return xdg && xdg.length > 0 ? join4(xdg, "opencode") : join4(homedir(), ".config", "opencode");
+  return xdg && xdg.length > 0 ? join5(xdg, "opencode") : join5(homedir2(), ".config", "opencode");
 }
 function globalRecorderPath() {
-  return join4(globalOpenCodeDir(), "plugins", "agent-blackbox.js");
+  return join5(globalOpenCodeDir(), "plugins", "agent-blackbox.js");
 }
 async function installGlobalRecorder(options) {
   if (!await pathExists(options.pluginBundlePath)) {
     throw new Error("Self-contained recorder bundle not found. Use the published npx package, or build it from source with `npm run build:cli`.");
   }
   const pluginPath = globalRecorderPath();
-  const bundle = (await readFile4(options.pluginBundlePath, "utf8")).replaceAll("__ABB_DAEMON_URL__", options.daemonUrl);
+  const bundle = (await readFile5(options.pluginBundlePath, "utf8")).replaceAll("__ABB_DAEMON_URL__", options.daemonUrl);
   await mkdir3(dirname3(pluginPath), { recursive: true });
   await writeFile2(pluginPath, bundle, "utf8");
   return { pluginPath };
@@ -2075,16 +2915,16 @@ async function initOpenCodeProject(options) {
   const adapterPackage = options.adapterPackage ?? defaultAdapterPackage;
   const adapterImport = inferAdapterImport(adapterPackage);
   const daemonUrl = options.daemonUrl ?? defaultDaemonUrl;
-  const opencodeDir = join4(options.projectDir, ".opencode");
-  const pluginsDir = join4(opencodeDir, "plugins");
-  const pluginPath = join4(pluginsDir, "agent-blackbox.ts");
-  const packageJsonPath = join4(opencodeDir, "package.json");
+  const opencodeDir = join5(options.projectDir, ".opencode");
+  const pluginsDir = join5(opencodeDir, "plugins");
+  const pluginPath = join5(pluginsDir, "agent-blackbox.ts");
+  const packageJsonPath = join5(opencodeDir, "package.json");
   await mkdir3(pluginsDir, { recursive: true });
   if (!options.force && await pathExists(pluginPath)) {
     throw new Error(`${pluginPath} already exists. Re-run with --force to overwrite it.`);
   }
   if (options.pluginBundlePath && await pathExists(options.pluginBundlePath)) {
-    const bundle = await readFile4(options.pluginBundlePath, "utf8");
+    const bundle = await readFile5(options.pluginBundlePath, "utf8");
     const inlined = bundle.replaceAll("__ABB_DAEMON_URL__", daemonUrl);
     await writeFile2(pluginPath, inlined, "utf8");
     return { pluginPath, packageJsonPath, adapterPackage, adapterImport };
@@ -2123,7 +2963,7 @@ function inferAdapterImport(adapterPackage) {
 }
 async function readPackageJson(packageJsonPath) {
   try {
-    return JSON.parse(await readFile4(packageJsonPath, "utf8"));
+    return JSON.parse(await readFile5(packageJsonPath, "utf8"));
   } catch (error) {
     if (isNodeError2(error) && error.code === "ENOENT") {
       return {};
@@ -2133,7 +2973,7 @@ async function readPackageJson(packageJsonPath) {
 }
 async function pathExists(path) {
   try {
-    await readFile4(path, "utf8");
+    await readFile5(path, "utf8");
     return true;
   } catch (error) {
     if (isNodeError2(error) && error.code === "ENOENT") {
@@ -2151,7 +2991,7 @@ function resolvePackageVersion() {
   let dir = dirname4(fileURLToPath(import.meta.url));
   for (let i = 0; i < 6; i += 1) {
     try {
-      const pkg = JSON.parse(readFileSync(join5(dir, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync(join6(dir, "package.json"), "utf8"));
       if (typeof pkg.version === "string" && pkg.version.length > 0)
         return pkg.version;
     } catch {
@@ -2168,16 +3008,69 @@ function describeDaemon() {
   return "Agent-Blackbox daemon: local ingest, replay, and dashboard bridge.";
 }
 
+// apps/daemon/dist/initClaudeHooks.js
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname5, join as join7 } from "node:path";
+function globalClaudeDir() {
+  const override = process.env.CLAUDE_CONFIG_DIR;
+  return override && override.length > 0 ? override : join7(homedir3(), ".claude");
+}
+function claudeSettingsPath() {
+  return join7(globalClaudeDir(), "settings.json");
+}
+async function installClaudeCodeHooks(options) {
+  const settingsPath = claudeSettingsPath();
+  const settings = await readSettings(settingsPath);
+  const next = mergeAbbHooks(settings, `node ${options.hookEntryPath}`);
+  await mkdir4(dirname5(settingsPath), { recursive: true });
+  await writeFile3(settingsPath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  return { settingsPath };
+}
+async function uninstallClaudeCodeHooks() {
+  const settingsPath = claudeSettingsPath();
+  let settings;
+  try {
+    settings = JSON.parse(await readFile6(settingsPath, "utf8"));
+  } catch (error) {
+    if (isNotFound(error))
+      return { settingsPath, removed: false };
+    throw error;
+  }
+  if (!hasAbbHooks(settings))
+    return { settingsPath, removed: false };
+  await writeFile3(settingsPath, `${JSON.stringify(removeAbbHooks(settings), null, 2)}
+`, "utf8");
+  return { settingsPath, removed: true };
+}
+async function readSettings(path) {
+  try {
+    return JSON.parse(await readFile6(path, "utf8"));
+  } catch (error) {
+    if (isNotFound(error))
+      return {};
+    throw new Error(`Refusing to edit ${path}: it isn't valid JSON (${error instanceof Error ? error.message : String(error)}).`);
+  }
+}
+function isNotFound(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
 // apps/daemon/dist/cli.js
 var args = process.argv.slice(2);
-var cliDir = dirname5(fileURLToPath2(import.meta.url));
+var cliDir = dirname6(fileURLToPath2(import.meta.url));
 var repoRoot = resolve(cliDir, "../../..");
 var firstExisting = (paths) => paths.find((p) => existsSync(p));
 var dashboardDistDir = firstExisting([resolve(cliDir, "dashboard"), resolve(repoRoot, "apps/dashboard/dist")]) ?? resolve(repoRoot, "apps/dashboard/dist");
 var pluginBundlePath = firstExisting([resolve(cliDir, "agent-blackbox.plugin.mjs")]);
+var hookEntryPath = firstExisting([
+  resolve(cliDir, "agent-blackbox-hook.mjs"),
+  resolve(repoRoot, "packages/claude-code-adapter/dist/hook-entry.js")
+]);
 function globalDataDir() {
   const xdg = process.env.XDG_DATA_HOME;
-  return xdg && xdg.length > 0 ? join6(xdg, "agent-blackbox") : join6(homedir2(), ".local", "share", "agent-blackbox");
+  return xdg && xdg.length > 0 ? join8(xdg, "agent-blackbox") : join8(homedir4(), ".local", "share", "agent-blackbox");
 }
 void main(args).catch((error) => {
   console.error(error instanceof Error ? error.message : String(error));
@@ -2206,26 +3099,50 @@ async function main(argv) {
     const suggest = readSuggestConfig(argv);
     let daemon;
     if (global) {
-      if (!pluginBundlePath) {
-        throw new Error("Global install needs the self-contained recorder bundle. Use the published npx package, or `npm run build:cli` then `node packages/cli/dist/cli.js up`.\n(Or scope to one project with: agent-blackbox up --project <dir>.)");
-      }
-      const { pluginPath } = await installGlobalRecorder({ daemonUrl, pluginBundlePath });
+      const host = readHost(argv);
       const dataDir = globalDataDir();
-      const eventsFile = join6(dataDir, "events.ndjson");
+      const eventsFile = join8(dataDir, "events.ndjson");
       daemon = await startTraceDaemon({ projectDir: dataDir, port, eventsFile, suggest });
+      const recorders = [];
+      if (host === "opencode" || host === "all") {
+        if (!pluginBundlePath) {
+          throw new Error("The OpenCode recorder needs the self-contained bundle. Use the published npx package, or `npm run build:cli` then `node packages/cli/dist/cli.js up`.\n(Claude Code needs no bundle \u2014 try: agent-blackbox up --host claude-code.)");
+        }
+        const { pluginPath } = await installGlobalRecorder({ daemonUrl, pluginBundlePath });
+        recorders.push(`OpenCode recorder installed \u2192 ${pluginPath}`);
+      }
+      if (host === "claude-code" || host === "all") {
+        const tailer = await startClaudeCodeTailer({ write: (event) => daemon.ingest(event) });
+        recorders.push(`Claude Code transcripts tailed \u2190 ${tailer.projectsDir} (no install)`);
+        if (argv.includes("--optimize")) {
+          if (hookEntryPath) {
+            const { settingsPath } = await installClaudeCodeHooks({ hookEntryPath });
+            recorders.push(`Claude Code in-run actuator installed \u2192 ${settingsPath} (read-dedup + working-set)`);
+          } else {
+            recorders.push("Claude Code actuator needs the built hook \u2014 run `npm run build` first (recording only for now).");
+          }
+        }
+      }
+      if (host === "codex") {
+        recorders.push("Codex recorder isn't built yet (see local-planning/). Use --host opencode|claude-code|all.");
+      }
       const ui2 = await startDashboardServer({ distDir: dashboardDistDir, port: uiPort, daemonUrl });
       const dashboardUrl2 = `http://127.0.0.1:${ui2.port}`;
-      console.log(`\u2713 Global OpenCode recorder installed: ${pluginPath}`);
-      console.log(`\u2713 Agent-Blackbox is up (recording all OpenCode sessions)`);
+      for (const line of recorders)
+        console.log(`\u2713 ${line}`);
+      console.log(`\u2713 Agent-Blackbox is up (host: ${host})`);
       console.log(`  Dashboard:  ${dashboardUrl2}`);
       console.log(`  Daemon API: ${daemonUrl}  (trace: ${daemon.eventsFile})`);
       console.log(`  Suggestions: ${suggest.mode}${suggest.model ? ` (${suggest.model})` : ""}`);
       console.log("");
       if (!argv.includes("--no-open"))
         openInBrowser(dashboardUrl2);
-      console.log("Now use OpenCode however you already do \u2014 the dashboard fills in live:");
-      console.log("  opencode                 # in any folder (terminal), or");
-      console.log("  the OpenCode desktop app # open any project");
+      if (host === "claude-code" || host === "all") {
+        console.log("Now use Claude Code however you already do \u2014 the map fills in live as it writes transcripts.");
+      }
+      if (host === "opencode" || host === "all") {
+        console.log("Now use OpenCode however you already do (terminal or the desktop app) \u2014 the map fills in live.");
+      }
       console.log("");
       console.log("Stop recording any time with:  agent-blackbox uninstall");
       console.log("Press Ctrl+C to stop the daemon + dashboard.");
@@ -2283,6 +3200,24 @@ async function main(argv) {
   if (command === "uninstall") {
     const { pluginPath, removed } = await uninstallGlobalRecorder();
     console.log(removed ? `\u2713 Removed global OpenCode recorder: ${pluginPath}` : `Nothing to remove \u2014 ${pluginPath} is not present.`);
+    const hooks = await uninstallClaudeCodeHooks();
+    if (hooks.removed)
+      console.log(`\u2713 Removed Claude Code actuator hooks: ${hooks.settingsPath}`);
+    return;
+  }
+  if (command === "install-hooks") {
+    if (!hookEntryPath) {
+      throw new Error("Built hook not found. Run `npm run build` first, or use the published npx package.");
+    }
+    const { settingsPath } = await installClaudeCodeHooks({ hookEntryPath });
+    console.log(`\u2713 Claude Code in-run actuator installed: ${settingsPath}`);
+    console.log("  New sessions get PreToolUse read-dedup (skip re-reading unchanged files) + a UserPromptSubmit working-set reminder.");
+    console.log("  Remove with: agent-blackbox uninstall-hooks");
+    return;
+  }
+  if (command === "uninstall-hooks") {
+    const { settingsPath, removed } = await uninstallClaudeCodeHooks();
+    console.log(removed ? `\u2713 Removed Claude Code actuator hooks: ${settingsPath}` : `Nothing to remove \u2014 no Agent-Blackbox hooks in ${settingsPath}.`);
     return;
   }
   if (command === "replay") {
@@ -2343,10 +3278,14 @@ function printHelp() {
   console.log("");
   console.log("Usage:");
   console.log("  agent-blackbox up                       # GLOBAL: record every OpenCode session (any folder / the app) + daemon + dashboard");
+  console.log("  agent-blackbox up --host claude-code     # record Claude Code instead \u2014 no install, tails transcripts (also: opencode | codex | all)");
   console.log("  agent-blackbox up --project <dir>        # scope the recorder to one project instead");
   console.log("       [--port <port>] [--ui-port <port>] [--suggest auto|free|off|ollama|opencode|openai-compat] [--suggest-model <id>] [--optimize] [--no-open]");
+  console.log("       [--optimize]  with --host claude-code: also install the in-run actuator (read-dedup + working-set hooks)");
   console.log("  agent-blackbox install [--port <port>]   # install the global recorder only (no daemon)");
-  console.log("  agent-blackbox uninstall                 # remove the global recorder");
+  console.log("  agent-blackbox install-hooks             # install the Claude Code in-run actuator hooks (opt-in)");
+  console.log("  agent-blackbox uninstall-hooks           # remove the Claude Code actuator hooks");
+  console.log("  agent-blackbox uninstall                 # remove the global recorder (+ Claude Code hooks)");
   console.log("  agent-blackbox daemon [--project <dir>] [--port <port>]");
   console.log("  agent-blackbox init-opencode [--project <dir>] [--daemon-url <url>] [--adapter-package <specifier>] [--force] [--optimize]");
   console.log("  agent-blackbox optimize [--project <dir>] [--apply | --check | --revert]   # write/measure/rollback AGENTS.md efficiency memory");
@@ -2377,6 +3316,11 @@ function portArg(raw, fallback) {
   const n = Number(raw);
   return Number.isInteger(n) && n >= 0 && n <= 65535 ? n : fallback;
 }
+function readHost(argv) {
+  const allowed = ["opencode", "claude-code", "codex", "all"];
+  const raw = readFlag(argv, "--host") ?? process.env.AGENT_BLACKBOX_HOST ?? "opencode";
+  return allowed.includes(raw) ? raw : "opencode";
+}
 function readSuggestConfig(argv) {
   const modes = ["auto", "off", "free", "ollama", "opencode", "openai-compat"];
   const raw = readFlag(argv, "--suggest") ?? process.env.AGENT_BLACKBOX_SUGGEST ?? "auto";