@taewooopark/agent-blackbox 0.42.0

package/dist/cli.js

@@ -0,0 +1,2135 @@
+#!/usr/bin/env node
+
+// packages/core/src/events.ts
+var traceHosts = [
+  "opencode",
+  "pi",
+  "codex",
+  "claude-code",
+  "hermes",
+  "custom"
+];
+var traceEventKinds = [
+  "session_created",
+  "session_updated",
+  "session_idle",
+  "session_error",
+  "agent_start",
+  "agent_end",
+  "turn_start",
+  "turn_end",
+  "message",
+  "tool_call",
+  "tool_result",
+  "file_read",
+  "file_edit",
+  "file_created",
+  "file_deleted",
+  "search",
+  "bash",
+  "permission_asked",
+  "permission_replied",
+  "todo_updated",
+  "subagent_spawned",
+  "decision_extracted",
+  "blocker_detected",
+  "handoff_generated",
+  "git_status",
+  "git_commit",
+  "git_push",
+  "context_compacted",
+  "command_run",
+  "agent_switched",
+  "model_switched",
+  "host_event"
+];
+var dataSensitivities = [
+  "public",
+  "internal",
+  "private",
+  "secret",
+  "student_sensitive"
+];
+function validateTraceEvent(event) {
+  const errors = [];
+  if (!isRecord(event)) {
+    return { ok: false, errors: ["event must be an object"] };
+  }
+  requireString(event, "id", errors);
+  requireString(event, "ts", errors);
+  requireNumber(event, "seq", errors);
+  requireEnum(event, "host", traceHosts, errors);
+  requireString(event, "runId", errors);
+  requireString(event, "sessionId", errors);
+  requireEnum(event, "kind", traceEventKinds, errors);
+  requireEnum(event, "sensitivity", dataSensitivities, errors);
+  if (!isRecord(event.payload)) {
+    errors.push("payload must be an object");
+  }
+  if (!isRecord(event.redaction)) {
+    errors.push("redaction must be an object");
+  }
+  if (!isRecord(event.evidence)) {
+    errors.push("evidence must be an object");
+  }
+  if (typeof event.ts === "string" && Number.isNaN(Date.parse(event.ts))) {
+    errors.push("ts must be an ISO-compatible timestamp");
+  }
+  if (typeof event.seq === "number" && (!Number.isInteger(event.seq) || event.seq < 1)) {
+    errors.push("seq must be a positive integer");
+  }
+  return { ok: errors.length === 0, errors };
+}
+function assertTraceEvent(event) {
+  const result = validateTraceEvent(event);
+  if (!result.ok) {
+    throw new Error(`Invalid trace event: ${result.errors.join("; ")}`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString(value, key, errors) {
+  if (typeof value[key] !== "string" || value[key] === "") {
+    errors.push(`${key} must be a non-empty string`);
+  }
+}
+function requireNumber(value, key, errors) {
+  if (typeof value[key] !== "number") {
+    errors.push(`${key} must be a number`);
+  }
+}
+function requireEnum(value, key, allowed, errors) {
+  if (typeof value[key] !== "string" || !allowed.includes(value[key])) {
+    errors.push(`${key} must be one of ${allowed.join(", ")}`);
+  }
+}
+
+// packages/core/src/graph.ts
+function materializeWorkflowGraph(events) {
+  const sorted = sortEvents(events);
+  const runId = sorted[0]?.runId ?? "empty-run";
+  const graph = {
+    runId,
+    nodes: /* @__PURE__ */ new Map(),
+    edges: /* @__PURE__ */ new Map(),
+    appliedEventIds: []
+  };
+  ensureNode(graph, {
+    id: runNodeId(runId),
+    type: "RUN",
+    label: runId,
+    status: sorted.length > 0 ? "ACTIVE" : "UNKNOWN",
+    at: sorted[0]?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    ...sorted[0]?.id ? { eventId: sorted[0].id } : {},
+    data: { runId }
+  });
+  for (const event of sorted) {
+    applyTraceEvent(graph, event);
+  }
+  return freezeGraph(graph);
+}
+function replayWorkflowGraphAtSeq(events, seq) {
+  return materializeWorkflowGraph(events.filter((event) => event.seq <= seq));
+}
+function replayWorkflowGraphAtTime(events, at) {
+  const atTime = new Date(at).getTime();
+  return materializeWorkflowGraph(events.filter((event) => new Date(event.ts).getTime() <= atTime));
+}
+function applyTraceEvent(graph, event) {
+  graph.appliedEventIds.push(event.id);
+  ensureSession(graph, event);
+  if (event.agentId) {
+    ensureAgent(graph, event);
+  }
+  if (event.turnId) {
+    ensureTurn(graph, event);
+  }
+  switch (event.kind) {
+    case "session_created":
+    case "session_updated":
+      updateNodeStatus(graph, sessionNodeId(event.sessionId), "ACTIVE", event);
+      break;
+    case "session_idle":
+      updateNodeStatus(graph, sessionNodeId(event.sessionId), "SUCCEEDED", event);
+      break;
+    case "session_error":
+      updateNodeStatus(graph, sessionNodeId(event.sessionId), "FAILED", event);
+      createEventNode(graph, event, "ERROR", event.summary ?? "Session error", "FAILED");
+      connectScope(graph, event, eventNodeId(event), "PRODUCES");
+      break;
+    case "agent_start":
+      if (event.agentId) {
+        updateNodeStatus(graph, agentNodeId(event.agentId), "ACTIVE", event);
+      }
+      break;
+    case "agent_end":
+      if (event.agentId) {
+        updateNodeStatus(graph, agentNodeId(event.agentId), "SUCCEEDED", event);
+      }
+      break;
+    case "turn_start":
+      if (event.turnId) {
+        updateNodeStatus(graph, turnNodeId(event.turnId), "ACTIVE", event);
+      }
+      break;
+    case "turn_end":
+      if (event.turnId) {
+        updateNodeStatus(graph, turnNodeId(event.turnId), "SUCCEEDED", event);
+      }
+      break;
+    case "message":
+      createEventNode(graph, event, "MESSAGE", event.summary ?? messageLabel(event), "SUCCEEDED");
+      connectScope(graph, event, eventNodeId(event), event.evidence.claimedByModel ? "CLAIMS" : "CONTAINS");
+      break;
+    case "tool_call":
+      createEventNode(graph, event, "TOOL_CALL", event.summary ?? toolLabel(event), "ACTIVE");
+      connectScope(graph, event, eventNodeId(event), "CALLS");
+      break;
+    case "tool_result":
+      createEventNode(graph, event, "TOOL_CALL", event.summary ?? "Tool result", resultStatus(event));
+      connectScope(graph, event, eventNodeId(event), "OBSERVED_AS");
+      break;
+    case "file_read":
+    case "file_edit":
+    case "file_created":
+    case "file_deleted":
+      createFileActivity(graph, event);
+      break;
+    case "bash":
+      createEventNode(graph, event, "COMMAND", event.summary ?? commandLabel(event), resultStatus(event));
+      connectScope(graph, event, eventNodeId(event), "EXECUTES");
+      break;
+    case "search":
+      createEventNode(graph, event, "SEARCH", event.summary ?? searchLabel(event), "SUCCEEDED");
+      connectScope(graph, event, eventNodeId(event), "SEARCHES");
+      break;
+    case "todo_updated":
+      createEventNode(graph, event, "TODO", event.summary ?? "Todo update", "ACTIVE");
+      connectScope(graph, event, eventNodeId(event), "UPDATES");
+      break;
+    case "permission_asked":
+    case "permission_replied":
+      createEventNode(graph, event, "PERMISSION_GATE", event.summary ?? "Permission gate", "NEEDS_APPROVAL");
+      connectScope(graph, event, eventNodeId(event), "BLOCKS");
+      break;
+    case "decision_extracted":
+      createDecision(graph, event);
+      break;
+    case "blocker_detected":
+      createEventNode(graph, event, "BLOCKER", event.summary ?? "Blocker", "BLOCKED");
+      connectScope(graph, event, eventNodeId(event), "BLOCKS");
+      break;
+    case "handoff_generated":
+      createEventNode(graph, event, "HANDOFF", event.summary ?? "Handoff", "SUCCEEDED");
+      connectScope(graph, event, eventNodeId(event), "PRODUCES");
+      break;
+    case "subagent_spawned":
+      createEventNode(graph, event, "AGENT", event.summary ?? "Subagent", "ACTIVE");
+      connectScope(graph, event, eventNodeId(event), "SPAWNS");
+      break;
+    case "git_status":
+    case "git_commit":
+    case "git_push":
+      createEventNode(graph, event, "ARTIFACT", event.summary ?? event.kind, resultStatus(event));
+      connectScope(graph, event, eventNodeId(event), "PRODUCES");
+      break;
+    default:
+      createEventNode(graph, event, "ARTIFACT", event.summary ?? event.kind, "UNKNOWN");
+      connectScope(graph, event, eventNodeId(event), "CONTAINS");
+  }
+}
+function ensureSession(graph, event) {
+  const sessionId = sessionNodeId(event.sessionId);
+  ensureNode(graph, {
+    id: sessionId,
+    type: "SESSION",
+    label: event.sessionId,
+    status: "ACTIVE",
+    at: event.ts,
+    eventId: event.id,
+    data: { sessionId: event.sessionId, parentSessionId: event.parentSessionId ?? null }
+  });
+  ensureEdge(graph, {
+    from: runNodeId(event.runId),
+    to: sessionId,
+    type: "CONTAINS",
+    at: event.ts,
+    eventId: event.id
+  });
+}
+function ensureAgent(graph, event) {
+  if (!event.agentId) {
+    return;
+  }
+  const id = agentNodeId(event.agentId);
+  ensureNode(graph, {
+    id,
+    type: "AGENT",
+    label: event.agentId,
+    status: "ACTIVE",
+    at: event.ts,
+    eventId: event.id,
+    data: { agentId: event.agentId, agentRole: event.agentRole ?? "unknown" }
+  });
+  ensureEdge(graph, {
+    from: sessionNodeId(event.sessionId),
+    to: id,
+    type: event.agentRole === "subagent" ? "SPAWNS" : "CONTAINS",
+    at: event.ts,
+    eventId: event.id
+  });
+}
+function ensureTurn(graph, event) {
+  if (!event.turnId) {
+    return;
+  }
+  const id = turnNodeId(event.turnId);
+  ensureNode(graph, {
+    id,
+    type: "TURN",
+    label: event.turnId,
+    status: "ACTIVE",
+    at: event.ts,
+    eventId: event.id,
+    data: { turnId: event.turnId }
+  });
+  ensureEdge(graph, {
+    from: event.agentId ? agentNodeId(event.agentId) : sessionNodeId(event.sessionId),
+    to: id,
+    type: "CONTAINS",
+    at: event.ts,
+    eventId: event.id
+  });
+}
+function createEventNode(graph, event, type, label, status) {
+  ensureNode(graph, {
+    id: eventNodeId(event),
+    type,
+    label,
+    status,
+    at: event.ts,
+    eventId: event.id,
+    data: { eventKind: event.kind, ...event.payload }
+  });
+}
+function createFileActivity(graph, event) {
+  const path = filePathPayload(event) ?? "unknown-file";
+  const fileId = fileNodeId(path);
+  ensureNode(graph, {
+    id: fileId,
+    type: "FILE",
+    label: path,
+    status: event.kind === "file_deleted" ? "REVERTED" : "ACTIVE",
+    at: event.ts,
+    eventId: event.id,
+    data: { path }
+  });
+  const edgeType = fileEdgeType(event.kind);
+  connectScope(graph, event, fileId, edgeType);
+}
+function createDecision(graph, event) {
+  const label = stringPayload(event, "statement") ?? event.summary ?? "Decision";
+  const decisionId = eventNodeId(event);
+  createEventNode(graph, event, "DECISION", label, "SUCCEEDED");
+  connectScope(graph, event, decisionId, "DECIDES");
+  const evidenceIds = arrayPayload(event, "evidenceEventIds");
+  for (const evidenceEventId of evidenceIds) {
+    ensureEdge(graph, {
+      from: eventNodeIdFromEventId(evidenceEventId),
+      to: decisionId,
+      type: "SUPPORTS_DECISION",
+      at: event.ts,
+      eventId: event.id,
+      inferred: true,
+      confidence: numberPayload(event, "confidence") ?? 0.5
+    });
+  }
+}
+function connectScope(graph, event, targetNodeId, edgeType) {
+  const sourceId = event.turnId ? turnNodeId(event.turnId) : event.agentId ? agentNodeId(event.agentId) : sessionNodeId(event.sessionId);
+  ensureEdge(graph, {
+    from: sourceId,
+    to: targetNodeId,
+    type: edgeType,
+    at: event.ts,
+    eventId: event.id
+  });
+}
+function ensureNode(graph, input) {
+  const existing = graph.nodes.get(input.id);
+  if (existing) {
+    existing.updatedAt = input.at;
+    existing.status = input.status;
+    existing.data = { ...existing.data, ...input.data ?? {} };
+    if (input.eventId && !existing.eventIds.includes(input.eventId)) {
+      existing.eventIds.push(input.eventId);
+    }
+    return;
+  }
+  graph.nodes.set(input.id, {
+    id: input.id,
+    type: input.type,
+    label: input.label,
+    status: input.status,
+    createdAt: input.at,
+    updatedAt: input.at,
+    eventIds: input.eventId ? [input.eventId] : [],
+    data: input.data ?? {}
+  });
+}
+function updateNodeStatus(graph, nodeId, status, event) {
+  const node = graph.nodes.get(nodeId);
+  if (!node) {
+    return;
+  }
+  node.status = status;
+  node.updatedAt = event.ts;
+  if (!node.eventIds.includes(event.id)) {
+    node.eventIds.push(event.id);
+  }
+}
+function ensureEdge(graph, input) {
+  const id = workflowEdgeId(input.from, input.to, input.type);
+  const existing = graph.edges.get(id);
+  if (existing) {
+    existing.updatedAt = input.at;
+    if (!existing.eventIds.includes(input.eventId)) {
+      existing.eventIds.push(input.eventId);
+    }
+    return;
+  }
+  graph.edges.set(id, {
+    id,
+    from: input.from,
+    to: input.to,
+    type: input.type,
+    ...input.label ? { label: input.label } : {},
+    createdAt: input.at,
+    updatedAt: input.at,
+    eventIds: [input.eventId],
+    inferred: input.inferred ?? false,
+    confidence: input.confidence ?? 1
+  });
+}
+function freezeGraph(graph) {
+  return {
+    runId: graph.runId,
+    nodes: [...graph.nodes.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    edges: [...graph.edges.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    appliedEventIds: [...graph.appliedEventIds]
+  };
+}
+function sortEvents(events) {
+  return [...events].sort((a, b) => a.seq - b.seq || a.ts.localeCompare(b.ts));
+}
+function resultStatus(event) {
+  const exitCode = numberPayload(event, "exitCode");
+  if (exitCode !== void 0) {
+    return exitCode === 0 ? "SUCCEEDED" : "FAILED";
+  }
+  if (event.payload.error === true || typeof event.payload.error === "string") {
+    return "FAILED";
+  }
+  return "SUCCEEDED";
+}
+function fileEdgeType(kind) {
+  if (kind === "file_read") return "READS";
+  if (kind === "file_edit") return "EDITS";
+  if (kind === "file_created") return "CREATES";
+  if (kind === "file_deleted") return "DELETES";
+  return "UPDATES";
+}
+function messageLabel(event) {
+  return stringPayload(event, "role") ? `Message: ${stringPayload(event, "role")}` : "Message";
+}
+function toolLabel(event) {
+  return stringPayload(event, "tool") ?? stringPayload(event, "name") ?? "Tool call";
+}
+function commandLabel(event) {
+  return stringPayload(event, "command") ?? "Command";
+}
+function searchLabel(event) {
+  return stringPayload(event, "query") ?? "Search";
+}
+function stringPayload(event, key) {
+  const value = event.payload[key];
+  return typeof value === "string" ? value : void 0;
+}
+function stringPayloadPath(event, paths) {
+  for (const path of paths) {
+    const value = payloadPath(event.payload, path);
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function filePathPayload(event) {
+  return stringPayloadPath(event, [
+    "path",
+    "file",
+    "properties.file",
+    "properties.path",
+    "output.metadata.path",
+    "input.args.filePath",
+    "input.args.path"
+  ]);
+}
+function payloadPath(value, path) {
+  let current = value;
+  for (const part of path.split(".")) {
+    if (!isRecord2(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function numberPayload(event, key) {
+  const value = event.payload[key];
+  return typeof value === "number" ? value : void 0;
+}
+function arrayPayload(event, key) {
+  const value = event.payload[key];
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function runNodeId(runId) {
+  return `run:${stablePart(runId)}`;
+}
+function sessionNodeId(sessionId) {
+  return `session:${stablePart(sessionId)}`;
+}
+function agentNodeId(agentId) {
+  return `agent:${stablePart(agentId)}`;
+}
+function turnNodeId(turnId) {
+  return `turn:${stablePart(turnId)}`;
+}
+function fileNodeId(path) {
+  return `file:${stablePart(path)}`;
+}
+function eventNodeId(event) {
+  return eventNodeIdFromEventId(event.id);
+}
+function eventNodeIdFromEventId(eventId) {
+  return `event:${stablePart(eventId)}`;
+}
+function workflowEdgeId(from, to, type) {
+  return `edge:${type}:${stablePart(from)}:${stablePart(to)}`;
+}
+function stablePart(value) {
+  return value.replace(/[^a-zA-Z0-9_.:-]/g, "_");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// packages/core/src/audit.ts
+var claimRules = [
+  {
+    name: "tests-run",
+    pattern: /\b(?:ran|run|running|executed)\s+(?:the\s+)?(?:tests?|test suite|checks?)\b/i,
+    verifier: (events) => events.filter((event) => event.kind === "bash" && stringPayload2(event, "command")?.match(/\b(test|check|vitest|pytest|cargo test|npm test)\b/i)).map((event) => event.id),
+    severity: "warning"
+  },
+  {
+    name: "file-updated",
+    pattern: /\b(?:updated|edited|patched|changed|modified)\s+(?:the\s+)?(?:file|code|implementation|readme|docs?)\b/i,
+    verifier: (events) => events.filter((event) => event.kind === "file_edit").map((event) => event.id),
+    severity: "warning"
+  },
+  {
+    name: "committed",
+    pattern: /\b(?:committed|created a commit|made a commit)\b/i,
+    verifier: (events) => events.filter((event) => event.kind === "git_commit").map((event) => event.id),
+    severity: "risk"
+  }
+];
+function evaluatePromiseChecks(events) {
+  const messageEvents = events.filter((event) => event.kind === "message" && event.evidence.claimedByModel);
+  const checks = [];
+  for (const message of messageEvents) {
+    const text = stringPayload2(message, "text") ?? stringPayload2(message, "content") ?? "";
+    for (const rule of claimRules) {
+      if (!rule.pattern.test(text)) {
+        continue;
+      }
+      const evidenceEventIds = rule.verifier(events);
+      checks.push({
+        claim: `${rule.name}: ${shorten(text)}`,
+        status: evidenceEventIds.length > 0 ? "verified" : "unverified",
+        evidenceEventIds,
+        severity: evidenceEventIds.length > 0 ? "info" : rule.severity
+      });
+    }
+  }
+  return checks;
+}
+function generateHandoffMarkdown(graph, checks = []) {
+  const files = graph.nodes.filter((node) => node.type === "FILE");
+  const decisions = graph.nodes.filter((node) => node.type === "DECISION");
+  const failures = graph.nodes.filter((node) => node.status === "FAILED");
+  const blockers = graph.nodes.filter((node) => node.type === "BLOCKER" || node.status === "BLOCKED");
+  const commands = graph.nodes.filter((node) => node.type === "COMMAND");
+  return [
+    `# Agent-Blackbox Handoff`,
+    ``,
+    `## Current Objective`,
+    `Run: ${graph.runId}`,
+    ``,
+    `## What Has Been Observed`,
+    `- Events applied: ${graph.appliedEventIds.length}`,
+    `- Nodes: ${graph.nodes.length}`,
+    `- Edges: ${graph.edges.length}`,
+    ``,
+    `## Files In Play`,
+    renderNodeList(files),
+    ``,
+    `## Decisions`,
+    renderNodeList(decisions),
+    ``,
+    `## Commands / Verification`,
+    renderNodeList(commands),
+    ``,
+    `## Failed Attempts`,
+    renderNodeList(failures),
+    ``,
+    `## Blockers / Approval Needed`,
+    renderNodeList(blockers),
+    ``,
+    `## Promise Checks`,
+    checks.length === 0 ? `- No model claims matched the built-in promise-check rules.` : checks.map((check) => `- ${check.status.toUpperCase()}: ${check.claim} (${check.evidenceEventIds.join(", ") || "no evidence"})`).join("\n"),
+    ``,
+    `## Next Safe Action`,
+    blockers.length > 0 ? `Resolve or approve the blocker before continuing.` : failures.length > 0 ? `Inspect the latest failed command or error node before editing again.` : `Continue from the latest decision or verification node.`
+  ].join("\n");
+}
+function renderNodeList(nodes) {
+  if (nodes.length === 0) {
+    return "- None recorded.";
+  }
+  return nodes.map((node) => `- ${node.label} [${node.status}] events=${node.eventIds.join(",") || "none"}`).join("\n");
+}
+function stringPayload2(event, key) {
+  const value = event.payload[key];
+  return typeof value === "string" ? value : void 0;
+}
+function shorten(value) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
+}
+
+// packages/core/src/efficiency.ts
+function buildDeterministicSuggestions(report) {
+  const suggestions = [];
+  for (const metric of report.metrics) {
+    if (metric.status === "good") continue;
+    const action = deterministicActionFor(metric);
+    if (!action) continue;
+    suggestions.push({
+      metricId: metric.id,
+      severity: metric.status,
+      title: metric.label,
+      action,
+      source: "deterministic"
+    });
+  }
+  return suggestions;
+}
+function deterministicActionFor(metric) {
+  const reclaim = metric.reclaimableTokens ? ` (~${formatTokens(metric.reclaimableTokens)} reclaimable)` : "";
+  const worst = metric.offenders && metric.offenders.length > 0 ? metric.offenders.join(", ") : "";
+  switch (metric.id) {
+    case "context-pressure":
+      return `Peak input hit ${metric.display}. Compact: summarise resolved turns into a short note of decisions + open bugs and start a fresh window, clear raw tool outputs you've already acted on, and push deep exploration into a sub-agent that returns only a ~1-2k-token summary.`;
+    case "cache-hit":
+      return `Only ${metric.display} was cache-served, and cached tokens are ~10\xD7 cheaper. Keep the prompt prefix byte-stable (no timestamps or per-run data in the system prompt), append new turns instead of editing old ones, and mask unused tools rather than adding/removing them \u2014 any change voids the cache from that point on.`;
+    case "redundant-reads":
+      return `${worst ? `${worst} were re-read` : "Files were re-read"}${reclaim}. Read each file once and keep it in working memory or a notes file; after an edit, re-read only the changed line range, not the whole file.`;
+    case "read-amplification":
+      return `Read ${metric.display} more text than was edited${worst ? ` (${worst} dominated)` : ""}. Locate with grep/symbol search first, then read only the relevant line range; load a repo map instead of whole files up front.`;
+    case "large-injections":
+      return `A single output added ${metric.display}${worst ? ` (${worst})` : ""}. Scope it \u2014 narrow paths, add a max-count/head limit, or pipe through a summary \u2014 or have a sub-agent absorb it and return just the distilled result.`;
+    case "retry-waste":
+      return `${worst ? `${worst} was re-run after failing` : "Failing commands were re-run"}${reclaim}. Read the first failure's stderr and fix the root cause before retrying once; keep the failed attempt in context so the model doesn't repeat it.`;
+    case "yield-density":
+      return `A lot of context produced few concrete changes (${metric.display}). Split into smaller verifiable steps, recite the current goal/todo each step to keep it in recent tokens (models under-use the middle of long contexts), and offload exploration to a sub-agent.`;
+    case "tool-overhead":
+      return `Many tool calls per outcome (${metric.display}). Batch related edits into one change, drop exploratory calls that don't lead to an edit, and trim to a minimal non-overlapping tool set.`;
+    default:
+      return metric.detail;
+  }
+}
+var CHARS_PER_TOKEN = 4;
+var estimateTokens = (chars) => Math.round(chars / CHARS_PER_TOKEN);
+var baseName = (path) => path.split(/[\\/]/).filter(Boolean).pop() ?? path;
+var commandVerb = (command) => command.trim().split(/\s+/)[0] || command;
+function computeEfficiencyReport(events) {
+  let finalSnapshot;
+  let peakInput = 0;
+  let hasRealTokens = false;
+  for (const event of events) {
+    const snap = readTokenSnapshot(event);
+    if (!snap) continue;
+    hasRealTokens = true;
+    finalSnapshot = snap;
+    peakInput = Math.max(peakInput, snap.input);
+  }
+  const reads = [];
+  const edits = [];
+  const injections = [];
+  const bashRuns = [];
+  for (const event of events) {
+    if (event.kind === "file_read") {
+      const chars = numberAt(event, "chars");
+      if (chars) reads.push({ path: stringAt(event, "path") ?? event.id, tokens: estimateTokens(chars), id: event.id });
+    } else if (event.kind === "file_edit" || event.kind === "file_created") {
+      const chars = numberAt(event, "chars");
+      if (chars) edits.push({ path: stringAt(event, "path") ?? event.id, tokens: estimateTokens(chars), id: event.id });
+    } else if (event.kind === "bash") {
+      const chars = numberAt(event, "outputChars") ?? 0;
+      const tokens = estimateTokens(chars);
+      bashRuns.push({ command: stringAt(event, "command") ?? "", exitCode: numberAt(event, "exitCode"), tokens, id: event.id });
+      if (tokens > 0) injections.push({ label: stringAt(event, "command") ?? "command", tokens, id: event.id });
+    } else if (event.kind === "tool_result") {
+      const chars = numberAt(event, "outputChars");
+      if (chars) {
+        const label = stringAt(event, "skill") ?? stringAt(event, "tool") ?? "tool";
+        injections.push({ label, tokens: estimateTokens(chars), id: event.id });
+      }
+    }
+  }
+  const totalReadTokens = reads.reduce((sum, r) => sum + r.tokens, 0);
+  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 peak = hasRealTokens ? peakInput : totalInputTokens;
+  const metrics = [];
+  {
+    const { score, status } = lowerIsBetter(peak, 1e5, 18e4);
+    metrics.push({
+      weight: 1.5,
+      metric: {
+        id: "context-pressure",
+        label: "Context pressure",
+        value: peak,
+        unit: "tokens",
+        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.`,
+        evidenceEventIds: []
+      }
+    });
+  }
+  {
+    const cacheRead = finalSnapshot?.cacheRead ?? 0;
+    const fresh = finalSnapshot?.input ?? 0;
+    const denom = cacheRead + fresh;
+    const hasCacheTelemetry = hasRealTokens && (cacheRead > 0 || (finalSnapshot?.cacheWrite ?? 0) > 0);
+    const ratio = denom > 0 ? cacheRead / denom : 0;
+    if (hasCacheTelemetry) {
+      const { score, status } = higherIsBetter(ratio, 0.6, 0.3);
+      metrics.push({
+        weight: 1,
+        metric: {
+          id: "cache-hit",
+          label: "Cache hit ratio",
+          value: ratio,
+          unit: "%",
+          display: `${Math.round(ratio * 100)}%`,
+          score,
+          status,
+          detail: status === "good" ? "Most of the prompt was served from cache." : "Low prompt-cache reuse \u2014 stabilise the prompt prefix so more context is cached.",
+          evidenceEventIds: []
+        }
+      });
+    } else {
+      metrics.push({
+        weight: 0,
+        metric: {
+          id: "cache-hit",
+          label: "Cache hit ratio",
+          value: 0,
+          unit: "%",
+          display: "n/a",
+          score: 100,
+          status: "good",
+          detail: "This model reported no cache telemetry.",
+          evidenceEventIds: []
+        }
+      });
+    }
+  }
+  {
+    const byPath = /* @__PURE__ */ new Map();
+    for (const r of reads) {
+      const list = byPath.get(r.path) ?? [];
+      list.push({ tokens: r.tokens, id: r.id });
+      byPath.set(r.path, list);
+    }
+    let reclaimable = 0;
+    const evidence = [];
+    let reReadPaths = 0;
+    const offenders = [];
+    for (const [path, list] of byPath.entries()) {
+      if (list.length > 1) {
+        reReadPaths += 1;
+        let extraTokens = 0;
+        for (const extra of list.slice(1)) {
+          reclaimable += extra.tokens;
+          extraTokens += extra.tokens;
+          evidence.push(extra.id);
+        }
+        offenders.push({ label: `${baseName(path)} \xD7${list.length}`, reclaim: extraTokens });
+      }
+    }
+    const reReadOffenders = offenders.sort((a, b) => b.reclaim - a.reclaim).slice(0, 3).map((o) => o.label);
+    let { score, status } = lowerIsBetter(reReadPaths, 0, 2);
+    if (reclaimable >= 1e4 && status !== "bad") {
+      status = "bad";
+      score = Math.min(score, 30);
+    }
+    metrics.push({
+      weight: 2,
+      metric: {
+        id: "redundant-reads",
+        label: "Redundant re-reads",
+        value: reReadPaths,
+        unit: "count",
+        display: reReadPaths === 0 ? "none" : `${reReadPaths} ${reReadPaths === 1 ? "file" : "files"}`,
+        score,
+        status,
+        detail: reReadPaths === 0 ? "No file was read more than once." : `${reReadPaths} file(s) were read again \u2014 about ${formatTokens(reclaimable)} of context was reloaded.`,
+        evidenceEventIds: evidence,
+        reclaimableTokens: reclaimable,
+        ...reReadOffenders.length > 0 ? { offenders: reReadOffenders } : {}
+      }
+    });
+  }
+  if (edits.length > 0 && totalReadTokens > 0) {
+    const ratio = totalReadTokens / Math.max(totalEditTokens, 1);
+    const { score, status } = lowerIsBetter(ratio, 40, 120);
+    const readByPath = /* @__PURE__ */ new Map();
+    for (const r of reads) readByPath.set(r.path, (readByPath.get(r.path) ?? 0) + r.tokens);
+    const topReaders = [...readByPath.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([path, tokens]) => `${baseName(path)} ~${formatTokens(tokens)}`);
+    metrics.push({
+      weight: 2,
+      metric: {
+        id: "read-amplification",
+        label: "Read amplification",
+        value: ratio,
+        unit: "x",
+        display: `${ratio.toFixed(ratio >= 10 ? 0 : 1)}\xD7`,
+        score,
+        status,
+        detail: status === "good" ? "Reads were roughly proportional to the edits made." : `Read ${formatTokens(totalReadTokens)} to write ${formatTokens(totalEditTokens)} \u2014 pull in less, use ranged reads.`,
+        evidenceEventIds: reads.slice(0, 5).map((r) => r.id),
+        ...status !== "good" && topReaders.length > 0 ? { offenders: topReaders } : {}
+      }
+    });
+  }
+  {
+    const sorted = [...injections].sort((a, b) => b.tokens - a.tokens);
+    const biggest = sorted[0]?.tokens ?? 0;
+    const over5k = sorted.filter((i) => i.tokens >= 5e3);
+    const { score, status } = lowerIsBetter(biggest, 5e3, 15e3);
+    const injectionOffenders = over5k.slice(0, 3).map((i) => `${commandVerb(i.label)} ~${formatTokens(i.tokens)}`);
+    metrics.push({
+      weight: 1.5,
+      metric: {
+        id: "large-injections",
+        label: "Large context injections",
+        value: biggest,
+        unit: "tokens",
+        display: biggest >= 2e3 ? formatTokens(biggest) : "none",
+        score,
+        status,
+        detail: over5k.length === 0 ? "No single tool output flooded the context." : `${over5k.length} output(s) added 5k+ tokens (largest ${formatTokens(biggest)}) \u2014 scope greps/reads or summarise.`,
+        evidenceEventIds: over5k.map((i) => i.id),
+        ...injectionOffenders.length > 0 ? { offenders: injectionOffenders } : {}
+      }
+    });
+  }
+  {
+    const byCommand = /* @__PURE__ */ new Map();
+    for (const b of bashRuns) {
+      if (!b.command) continue;
+      const list = byCommand.get(b.command) ?? [];
+      list.push({ exitCode: b.exitCode, tokens: b.tokens, id: b.id });
+      byCommand.set(b.command, list);
+    }
+    let wasted = 0;
+    let retries = 0;
+    const evidence = [];
+    const offenders = [];
+    for (const [command, list] of byCommand.entries()) {
+      if (list.length <= 1) continue;
+      retries += list.length - 1;
+      for (const attempt of list) {
+        if (attempt.exitCode !== 0) {
+          wasted += attempt.tokens;
+          evidence.push(attempt.id);
+        }
+      }
+      offenders.push({ label: `${commandVerb(command)} \xD7${list.length}`, runs: list.length });
+    }
+    const retryOffenders = offenders.sort((a, b) => b.runs - a.runs).slice(0, 3).map((o) => o.label);
+    const { score, status } = lowerIsBetter(retries, 0, 2);
+    metrics.push({
+      weight: 2,
+      metric: {
+        id: "retry-waste",
+        label: "Retry waste",
+        value: retries,
+        unit: "count",
+        display: retries === 0 ? "none" : `${retries}`,
+        score,
+        status,
+        detail: retries === 0 ? "No command was re-run after failing." : `${retries} re-run(s) of failing commands burned about ${formatTokens(wasted)}.`,
+        evidenceEventIds: evidence,
+        reclaimableTokens: wasted,
+        ...retryOffenders.length > 0 ? { offenders: retryOffenders } : {}
+      }
+    });
+  }
+  if (totalInputTokens > 0) {
+    const outcomes = editedPaths.size + okCommands;
+    const density = outcomes / (totalInputTokens / 1e3);
+    const { score, status } = higherIsBetter(density, 0.05, 0.02);
+    metrics.push({
+      weight: 1,
+      metric: {
+        id: "yield-density",
+        label: "Yield density",
+        value: density,
+        unit: "ratio",
+        display: `${density.toFixed(3)}/k`,
+        score,
+        status,
+        detail: status === "good" ? "The run turned tokens into concrete changes efficiently." : `${outcomes} outcome(s) across ${formatTokens(totalInputTokens)} \u2014 a lot of context for little change.`,
+        evidenceEventIds: []
+      }
+    });
+  }
+  {
+    const toolCalls = events.filter((e) => e.kind === "tool_call").length;
+    const outcomes = Math.max(1, reads.length + edits.length + bashRuns.length);
+    const ratio = toolCalls / outcomes;
+    const { score, status } = lowerIsBetter(ratio, 2, 4);
+    metrics.push({
+      weight: 0.5,
+      metric: {
+        id: "tool-overhead",
+        label: "Tool overhead",
+        value: ratio,
+        unit: "ratio",
+        display: `${ratio.toFixed(1)}\xD7`,
+        score,
+        status,
+        detail: status === "good" ? "Tool calls translated into work without much churn." : "Many tool calls relative to concrete outcomes.",
+        evidenceEventIds: []
+      }
+    });
+  }
+  const weighted = metrics.filter((m) => m.weight > 0);
+  const overallScore = weighted.length > 0 ? Math.round(weighted.reduce((s, m) => s + m.metric.score * m.weight, 0) / weighted.reduce((s, m) => s + m.weight, 0)) : 100;
+  const reclaimableTokens = metrics.reduce((s, m) => s + (m.metric.reclaimableTokens ?? 0), 0);
+  return {
+    overallScore,
+    status: overallScore >= 75 ? "good" : overallScore >= 50 ? "warn" : "bad",
+    headline: buildHeadline(totalInputTokens, finalSnapshot, reclaimableTokens, hasRealTokens),
+    totalInputTokens,
+    reclaimableTokens,
+    estimated: !hasRealTokens,
+    metrics: metrics.map((m) => m.metric)
+  };
+}
+function buildHeadline(totalInput, snap, reclaimable, hasRealTokens) {
+  const parts = [];
+  if (totalInput > 0) parts.push(`${hasRealTokens ? "" : "~"}${formatTokens(totalInput)} input`);
+  if (snap && (snap.cacheRead > 0 || snap.cacheWrite > 0)) {
+    const denom = snap.cacheRead + snap.input;
+    if (denom > 0) parts.push(`cache ${Math.round(snap.cacheRead / denom * 100)}%`);
+  }
+  if (reclaimable > 0) parts.push(`~${formatTokens(reclaimable)} reclaimable`);
+  return parts.join(" \xB7 ");
+}
+function lowerIsBetter(value, warnAt, badAt) {
+  if (value <= warnAt) return { score: Math.round(lerp(value, 0, warnAt, 100, 80)), status: "good" };
+  if (value <= badAt) return { score: Math.round(lerp(value, warnAt, badAt, 80, 40)), status: "warn" };
+  return { score: Math.max(0, Math.round(lerp(value, badAt, badAt * 2, 40, 0))), status: "bad" };
+}
+function higherIsBetter(value, goodAt, badAt) {
+  if (value >= goodAt) return { score: Math.min(100, Math.round(lerp(value, goodAt, goodAt * 1.5, 80, 100))), status: "good" };
+  if (value >= badAt) return { score: Math.round(lerp(value, badAt, goodAt, 40, 80)), status: "warn" };
+  return { score: Math.max(0, Math.round(lerp(value, 0, badAt, 0, 40))), status: "bad" };
+}
+function lerp(value, inMin, inMax, outMin, outMax) {
+  if (inMax === inMin) return outMin;
+  const t = Math.max(0, Math.min(1, (value - inMin) / (inMax - inMin)));
+  return outMin + t * (outMax - outMin);
+}
+function numberAt(event, key) {
+  const value = event.payload[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringAt(event, key) {
+  const value = event.payload[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readTokenSnapshot(event) {
+  const present = deepNumber(event.payload, "properties.info.tokens") !== void 0 || deepNumber(event.payload, "properties.tokens") !== void 0 || deepNumber(event.payload, "tokens") !== void 0 || isRecordAtPath(event.payload, "properties.info.tokens") || isRecordAtPath(event.payload, "properties.tokens") || isRecordAtPath(event.payload, "tokens");
+  if (!present) return void 0;
+  return {
+    input: deepNumber(event.payload, ["properties.info.tokens.input", "properties.tokens.input", "tokens.input"]) ?? 0,
+    output: deepNumber(event.payload, ["properties.info.tokens.output", "properties.tokens.output", "tokens.output"]) ?? 0,
+    reasoning: deepNumber(event.payload, ["properties.info.tokens.reasoning", "properties.tokens.reasoning", "tokens.reasoning"]) ?? 0,
+    cacheRead: deepNumber(event.payload, [
+      "properties.info.tokens.cache.read",
+      "properties.tokens.cache.read",
+      "tokens.cache.read",
+      "properties.info.tokens.cacheRead",
+      "tokens.cacheRead"
+    ]) ?? 0,
+    cacheWrite: deepNumber(event.payload, [
+      "properties.info.tokens.cache.write",
+      "properties.tokens.cache.write",
+      "tokens.cache.write",
+      "properties.info.tokens.cacheWrite",
+      "tokens.cacheWrite"
+    ]) ?? 0
+  };
+}
+function deepNumber(payload, path) {
+  const paths = Array.isArray(path) ? path : [path];
+  for (const p of paths) {
+    const value = walk(payload, p);
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function isRecordAtPath(payload, path) {
+  const value = walk(payload, path);
+  return typeof value === "object" && value !== null;
+}
+function walk(payload, path) {
+  let current = payload;
+  for (const part of path.split(".")) {
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function formatTokens(value) {
+  if (value >= 1e3) {
+    const k = value / 1e3;
+    return `${k >= 10 ? Math.round(k) : k.toFixed(1)}k`;
+  }
+  return `${Math.round(value)}`;
+}
+
+// packages/core/src/efficiencyMemory.ts
+var EFFICIENCY_MEMORY_START = "<!-- agent-blackbox:efficiency:start -->";
+var EFFICIENCY_MEMORY_END = "<!-- agent-blackbox:efficiency:end -->";
+var offenderLabel = (offender) => offender.split(/\s+/)[0] ?? offender;
+var dedupe = (xs) => [...new Set(xs.filter(Boolean))];
+function buildEfficiencyMemory(report, options = {}) {
+  const flagged = new Map(report.metrics.filter((m) => m.status !== "good").map((m) => [m.id, m]));
+  const offendersOf = (id) => (flagged.get(id)?.offenders ?? []).map(offenderLabel);
+  const lines = [];
+  const commands = dedupe(options.verifiedCommands ?? []).slice(0, 4);
+  if (commands.length > 0) {
+    lines.push(`- **Reuse these verified commands** (don't rediscover): ${commands.map((c) => `\`${c}\``).join(", ")}`);
+  }
+  const reread = dedupe([...offendersOf("redundant-reads"), ...offendersOf("read-amplification")]).slice(0, 6);
+  if (reread.length > 0) {
+    lines.push(
+      `- **Read these once, then reuse** \u2014 re-read only the changed line range after an edit, never the whole file: ${reread.join(", ")}`
+    );
+  }
+  const injections = dedupe(offendersOf("large-injections")).slice(0, 4);
+  if (injections.length > 0) {
+    lines.push(
+      `- **Scope these large outputs** (narrow paths, \`max-count\`/\`head\`, or summarise): ${injections.join(", ")}`
+    );
+  }
+  const retries = dedupe(offendersOf("retry-waste")).slice(0, 4);
+  if (retries.length > 0) {
+    lines.push(`- **Fix the root cause before re-running** (read the first failure's stderr): ${retries.join(", ")}`);
+  }
+  if (flagged.has("context-pressure")) {
+    lines.push(
+      "- **Keep the window lean**: compact resolved turns into a short decisions + open-bugs note, and delegate deep exploration to a sub-agent that returns a brief summary."
+    );
+  }
+  if (flagged.has("cache-hit")) {
+    lines.push(
+      "- **Protect the prompt cache**: keep the prefix byte-stable (no timestamps/volatile data) and append turns instead of editing earlier ones."
+    );
+  }
+  if (flagged.has("tool-overhead")) {
+    lines.push("- **Batch related edits** into one change; skip exploratory tool calls that don't lead to an edit.");
+  }
+  if (lines.length === 0) return null;
+  return [
+    EFFICIENCY_MEMORY_START,
+    "## Context-efficiency notes",
+    "<!-- Auto-generated by Agent-Blackbox from the last run. Put your own notes ABOVE this block; everything between these markers is regenerated. -->",
+    "",
+    ...lines,
+    EFFICIENCY_MEMORY_END
+  ].join("\n");
+}
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var managedBlockRegExp = () => new RegExp(`${escapeRegExp(EFFICIENCY_MEMORY_START)}[\\s\\S]*?${escapeRegExp(EFFICIENCY_MEMORY_END)}`);
+function hasManagedBlock(content) {
+  return managedBlockRegExp().test(content);
+}
+function upsertManagedBlock(content, block) {
+  if (hasManagedBlock(content)) {
+    return content.replace(managedBlockRegExp(), block);
+  }
+  const base = content.trimEnd();
+  return base.length === 0 ? `${block}
+` : `${base}
+
+${block}
+`;
+}
+function removeManagedBlock(content) {
+  if (!hasManagedBlock(content)) return content;
+  const stripped = content.replace(managedBlockRegExp(), "").replace(/\n{3,}/g, "\n\n").trimEnd();
+  return stripped.length === 0 ? "" : `${stripped}
+`;
+}
+
+// apps/daemon/dist/cli.js
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname as dirname3, resolve } from "node:path";
+
+// apps/daemon/dist/dashboardServer.js
+import { createReadStream } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { createServer } from "node:http";
+import { extname, join, normalize } from "node:path";
+var mimeTypes = {
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+async function startDashboardServer(options) {
+  const indexPath = join(options.distDir, "index.html");
+  let indexHtml;
+  try {
+    indexHtml = await readFile(indexPath, "utf8");
+  } catch {
+    throw new Error(`Dashboard build not found at ${options.distDir}. Run "npm run build" first.`);
+  }
+  const injected = indexHtml.replace("</head>", `  <script>window.AGENT_BLACKBOX_DAEMON_URL=${JSON.stringify(options.daemonUrl)};</script>
+  </head>`);
+  const server = createServer((request, response) => {
+    const rawPath = decodeURIComponent((request.url ?? "/").split("?")[0] ?? "/");
+    if (rawPath === "/" || rawPath === "/index.html") {
+      response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      response.end(injected);
+      return;
+    }
+    const safePath = normalize(rawPath).replace(/^(\.\.[/\\])+/, "");
+    const filePath = join(options.distDir, safePath);
+    if (!filePath.startsWith(options.distDir)) {
+      response.writeHead(403);
+      response.end("Forbidden");
+      return;
+    }
+    void stat(filePath).then((stats) => {
+      if (!stats.isFile()) {
+        throw new Error("not a file");
+      }
+      response.writeHead(200, { "content-type": mimeTypes[extname(filePath)] ?? "application/octet-stream" });
+      createReadStream(filePath).pipe(response);
+    }).catch(() => {
+      response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      response.end(injected);
+    });
+  });
+  const port = options.port ?? 5173;
+  await new Promise((resolve2) => {
+    server.listen(port, "127.0.0.1", resolve2);
+  });
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : port;
+  return {
+    server,
+    port: actualPort,
+    close: () => new Promise((resolve2, reject) => {
+      server.close((error) => error ? reject(error) : resolve2());
+    })
+  };
+}
+
+// packages/storage/src/ndjson.ts
+import { appendFile, mkdir, readFile as readFile2 } from "node:fs/promises";
+import { dirname } from "node:path";
+function serializeTraceEvent(event) {
+  assertTraceEvent(event);
+  return `${JSON.stringify(event)}
+`;
+}
+function parseTraceEventLine(line) {
+  const parsed = JSON.parse(line);
+  assertTraceEvent(parsed);
+  return parsed;
+}
+function parseTraceEvents(input) {
+  return input.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => parseTraceEventLine(line));
+}
+async function appendTraceEvent(filePath, event) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await appendFile(filePath, serializeTraceEvent(event), "utf8");
+}
+async function readTraceEvents(filePath) {
+  const input = await readFile2(filePath, "utf8");
+  return parseTraceEvents(input);
+}
+
+// apps/daemon/dist/server.js
+import { createServer as createServer2 } from "node:http";
+import { join as join2 } from "node:path";
+import { WebSocket, WebSocketServer } from "ws";
+
+// apps/daemon/dist/suggestionProvider.js
+import { spawn } from "node:child_process";
+var TIMEOUT_MS = 45e3;
+var SYSTEM_PROMPT = `You optimize the context-window economy of AI coding-agent runs. The agent has tools: file read/edit, bash, grep/glob, sub-agents, and prompt caching. You receive a JSON digest of the run's FLAGGED metrics (each: id, value, display, status, detail, reclaimableTokens, offenders). Return ONE concrete fix per flagged metric that the operator can apply on the next run.
+
+# Every action MUST
+- Ground in this run's numbers: cite the metric's display/reclaimable, and name the offenders verbatim when present (e.g. "config.json \xD75").
+- Name a concrete mechanism or tool \u2014 not a goal. "Reduce context" is banned; "after an edit, re-read only the changed line range instead of the whole file" is right.
+- State the expected effect (fewer tokens / cache hits / fewer steps).
+- Be one or two sentences. Do not restate the metric or give generic advice.
+
+# Fix playbook (match the flagged id)
+- context-pressure: compact resolved turns into a short decisions+open-bugs note and start a fresh window; clear raw tool outputs already acted on; move exploration into a sub-agent that returns a ~1-2k-token summary; keep file paths as references, not full contents.
+- cache-hit: cached tokens are ~10x cheaper \u2014 keep the prompt prefix byte-stable (no timestamps/per-run data in the system prompt), append-only (never edit earlier turns), deterministic JSON key order, and mask unused tools instead of adding/removing them mid-run (any change voids the cache downstream).
+- redundant-reads: read each file once and hold it in working memory or a notes file; after an edit re-read only the changed line range, never the whole file again.
+- read-amplification: locate with grep/symbol search, then read only the relevant line range; pre-load a repo map/metadata and fetch on demand instead of whole files.
+- large-injections: scope the command (narrow paths, max-count/head) or pipe it through a summary; or have a sub-agent absorb the big output and return only the distilled result.
+- retry-waste: don't re-run blindly \u2014 read the first failure's stderr, fix the root cause, retry once; keep the failed attempt in context so the model doesn't repeat it.
+- yield-density: split into smaller verifiable steps; recite the goal/todo each step to keep it in recent tokens (models under-use the middle of long contexts); offload exploration to a sub-agent to keep the main thread lean.
+- tool-overhead: batch related edits into one change, drop exploratory calls that don't lead to an edit, and trim to a minimal non-overlapping tool set.
+
+# Contrast (do this)
+metricId "redundant-reads", reclaimableTokens ~12000, offenders ["calculator.js \xD74"]:
+- BAD: "Avoid reading files multiple times to save context."
+- GOOD: "calculator.js was read 4\xD7 (~12k reclaimable) \u2014 read it once and cache it, then after each edit re-read only the changed line range instead of the whole file."
+
+# Output
+Respond with ONLY this JSON, one entry per flagged metric, nothing else:
+{"suggestions":[{"metricId":"<id>","title":"<=6 words","action":"<specific fix grounded in this run's numbers/offenders>"}]}`;
+function buildDigest(report) {
+  return {
+    overallScore: report.overallScore,
+    headline: report.headline,
+    totalInputTokens: report.totalInputTokens,
+    estimated: report.estimated,
+    metrics: report.metrics.filter((m) => m.status !== "good").map((m) => ({
+      id: m.id,
+      label: m.label,
+      status: m.status,
+      value: Number(m.value.toFixed(3)),
+      display: m.display,
+      detail: m.detail,
+      ...m.reclaimableTokens ? { reclaimableTokens: m.reclaimableTokens } : {},
+      ...m.offenders && m.offenders.length > 0 ? { offenders: m.offenders } : {}
+    }))
+  };
+}
+var FREE_POOL = [
+  { provider: "opencode", model: "opencode/deepseek-v4-flash-free" },
+  { provider: "opencode", model: "opencode/north-mini-code-free" },
+  { provider: "ollama", model: "qwen3-coder:480b-cloud" },
+  { provider: "opencode", model: "opencode/mimo-v2.5-free" },
+  { provider: "ollama", model: "gpt-oss:120b-cloud" },
+  { provider: "ollama", model: "llama3.1:8b" }
+];
+var FREE_COOLDOWN_MS = 10 * 6e4;
+var freeCursor = 0;
+var freeCooldownUntil = /* @__PURE__ */ new Map();
+function orderFreePool(pool, cooldownUntil, cursor, now) {
+  const fresh = pool.filter((entry) => (cooldownUntil.get(entry.model) ?? 0) <= now);
+  const list = fresh.length > 0 ? fresh : pool;
+  const start = (cursor % list.length + list.length) % list.length;
+  return [...list.slice(start), ...list.slice(0, start)];
+}
+function isQuotaError(error) {
+  const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+  return message.includes("429") || message.includes("usage limit") || message.includes("rate limit") || message.includes("too many requests") || message.includes("quota");
+}
+async function generateSuggestions(report, config) {
+  const deterministic = buildDeterministicSuggestions(report);
+  if (config.mode === "off" || deterministic.length === 0) {
+    return { suggestions: deterministic, provider: "deterministic" };
+  }
+  const digest = buildDigest(report);
+  if ((config.mode === "auto" || config.mode === "free") && !config.model) {
+    const order2 = orderFreePool(FREE_POOL, freeCooldownUntil, freeCursor, Date.now());
+    freeCursor += 1;
+    for (const entry of order2) {
+      try {
+        const llm = await callProvider(entry.provider, digest, { ...config, model: entry.model });
+        const validated = validateSuggestions(llm, report);
+        if (validated.length > 0) {
+          return { suggestions: mergeSuggestions(deterministic, validated), provider: entry.model };
+        }
+      } catch (error) {
+        if (isQuotaError(error))
+          freeCooldownUntil.set(entry.model, Date.now() + FREE_COOLDOWN_MS);
+      }
+    }
+    return { suggestions: deterministic, provider: "deterministic" };
+  }
+  const order = config.mode === "auto" || config.mode === "free" ? ["ollama"] : [config.mode];
+  for (const provider of order) {
+    try {
+      const llm = await callProvider(provider, digest, config);
+      const validated = validateSuggestions(llm, report);
+      if (validated.length > 0) {
+        return { suggestions: mergeSuggestions(deterministic, validated), provider };
+      }
+    } catch {
+    }
+  }
+  return { suggestions: deterministic, provider: "deterministic" };
+}
+async function callProvider(provider, digest, config) {
+  if (provider === "ollama")
+    return callOllama(digest, config);
+  if (provider === "openai-compat")
+    return callOpenAICompat(digest, config);
+  return callOpenCode(digest, config);
+}
+async function callOllama(digest, config) {
+  const baseUrl = config.baseUrl ?? "http://127.0.0.1:11434";
+  const model = config.model ?? "llama3.1";
+  const response = await fetchJson(`${baseUrl}/api/chat`, {
+    model,
+    stream: false,
+    format: "json",
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: JSON.stringify(digest) }
+    ]
+  });
+  const err = response?.error;
+  if (err)
+    throw new Error(typeof err === "string" ? err : JSON.stringify(err));
+  const content = response?.message?.content;
+  return content ? JSON.parse(content) : void 0;
+}
+async function callOpenAICompat(digest, config) {
+  if (!config.baseUrl)
+    throw new Error("openai-compat needs --suggest-base-url");
+  const model = config.model ?? "local-model";
+  const apiKey = process.env.AGENT_BLACKBOX_SUGGEST_KEY;
+  const response = await fetchJson(`${config.baseUrl.replace(/\/$/, "")}/v1/chat/completions`, {
+    model,
+    stream: false,
+    response_format: { type: "json_object" },
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: JSON.stringify(digest) }
+    ]
+  }, apiKey ? { authorization: `Bearer ${apiKey}` } : {});
+  const content = response?.choices?.[0]?.message?.content;
+  return content ? JSON.parse(content) : void 0;
+}
+async function callOpenCode(digest, config) {
+  const model = config.model ?? "opencode/deepseek-v4-flash-free";
+  const prompt = `${SYSTEM_PROMPT}
+
+Metrics:
+${JSON.stringify(digest)}
+
+Output ONLY the JSON object, nothing else.`;
+  const stdout = await runCommand("opencode", ["run", "--model", model, prompt]);
+  return extractJsonObject(stdout);
+}
+function mergeSuggestions(deterministic, llm) {
+  const llmByMetric = new Map(llm.map((s) => [s.metricId, s]));
+  return deterministic.map((d) => llmByMetric.get(d.metricId) ?? d);
+}
+function validateSuggestions(raw, report) {
+  const list = Array.isArray(raw) ? raw : Array.isArray(raw?.suggestions) ? raw.suggestions : [];
+  const statusByMetric = new Map(report.metrics.map((m) => [m.id, m.status]));
+  const out = [];
+  for (const item of list) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const metricId = item.metricId;
+    const action = item.action;
+    const title = item.title;
+    if (typeof metricId !== "string" || typeof action !== "string" || action.trim().length < 8)
+      continue;
+    const status = statusByMetric.get(metricId);
+    if (status !== "warn" && status !== "bad")
+      continue;
+    out.push({
+      metricId,
+      severity: status,
+      title: typeof title === "string" && title.length > 0 ? title : metricId,
+      action: action.trim().slice(0, 400),
+      source: "llm"
+    });
+  }
+  return out;
+}
+async function fetchJson(url, body, extraHeaders = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...extraHeaders },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    if (!response.ok)
+      throw new Error(`${url} -> ${response.status}`);
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function runCommand(command, args2) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args2, { stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error("opencode timed out"));
+    }, TIMEOUT_MS);
+    child.stdout.on("data", (chunk) => {
+      out += chunk.toString();
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0)
+        resolve2(out);
+      else
+        reject(new Error(`opencode exited ${code}`));
+    });
+  });
+}
+function extractJsonObject(text) {
+  const start = text.indexOf("{");
+  if (start === -1)
+    return void 0;
+  let depth = 0;
+  for (let i = start; i < text.length; i += 1) {
+    if (text[i] === "{")
+      depth += 1;
+    else if (text[i] === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        try {
+          return JSON.parse(text.slice(start, i + 1));
+        } catch {
+          return void 0;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+
+// apps/daemon/dist/server.js
+async function startTraceDaemon(options) {
+  const eventsFile = options.eventsFile ?? join2(options.projectDir, ".agent-blackbox", "events.ndjson");
+  const suggestConfig = options.suggest ?? { mode: "auto" };
+  const clients = /* @__PURE__ */ new Set();
+  const server = createServer2((request, response) => {
+    void handleRequest(request, response, eventsFile, clients, suggestConfig);
+  });
+  const streamServer = new WebSocketServer({ noServer: true });
+  server.on("upgrade", (request, socket, head) => {
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== "/stream") {
+      socket.destroy();
+      return;
+    }
+    streamServer.handleUpgrade(request, socket, head, (client) => {
+      clients.add(client);
+      client.on("close", () => {
+        clients.delete(client);
+      });
+      void sendSnapshot(client, eventsFile);
+    });
+  });
+  const port = options.port ?? 47831;
+  await new Promise((resolve2) => {
+    server.listen(port, "127.0.0.1", resolve2);
+  });
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : port;
+  return {
+    server,
+    port: actualPort,
+    eventsFile,
+    close: () => new Promise((resolve2, reject) => {
+      server.close((error) => {
+        streamServer.close();
+        if (error) {
+          reject(error);
+        } else {
+          resolve2();
+        }
+      });
+    })
+  };
+}
+async function loadTraceEvents(eventsFile) {
+  try {
+    return await readTraceEvents(eventsFile);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function buildReplaySummary(eventsFile) {
+  const events = await loadTraceEvents(eventsFile);
+  const graph = materializeWorkflowGraph(events);
+  return {
+    events: events.length,
+    nodes: graph.nodes.length,
+    edges: graph.edges.length,
+    runId: graph.runId
+  };
+}
+async function buildTraceSnapshot(eventsFile, replay = {}) {
+  const events = await loadTraceEvents(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));
+  const checks = evaluatePromiseChecks(visibleEvents);
+  const efficiency = computeEfficiencyReport(visibleEvents);
+  const handoffMarkdown = generateHandoffMarkdown(graph, checks);
+  return {
+    events,
+    graph,
+    checks,
+    efficiency,
+    handoffMarkdown,
+    replay: {
+      mode: replay.seq !== void 0 ? "seq" : replay.at !== void 0 ? "time" : "live",
+      ...replay.seq !== void 0 ? { seq: replay.seq } : {},
+      ...replay.at !== void 0 ? { at: replay.at } : {}
+    }
+  };
+}
+async function handleRequest(request, response, eventsFile, clients, suggestConfig) {
+  try {
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    const replay = parseReplayQuery(url);
+    if (request.method === "OPTIONS") {
+      sendEmpty(response, 204);
+      return;
+    }
+    if (request.method === "GET" && url.pathname === "/health") {
+      sendJson(response, 200, { ok: true, data: { status: "ok", eventsFile } });
+      return;
+    }
+    if (request.method === "GET" && url.pathname === "/events") {
+      sendJson(response, 200, { ok: true, data: await loadTraceEvents(eventsFile) });
+      return;
+    }
+    if (request.method === "GET" && url.pathname === "/graph") {
+      sendJson(response, 200, { ok: true, data: (await buildTraceSnapshot(eventsFile, replay)).graph });
+      return;
+    }
+    if (request.method === "GET" && url.pathname === "/snapshot") {
+      sendJson(response, 200, { ok: true, data: await buildTraceSnapshot(eventsFile, replay) });
+      return;
+    }
+    if (request.method === "GET" && url.pathname === "/efficiency") {
+      sendJson(response, 200, { ok: true, data: (await buildTraceSnapshot(eventsFile, replay)).efficiency });
+      return;
+    }
+    if (request.method === "GET" && url.pathname === "/audit") {
+      sendJson(response, 200, { ok: true, data: (await buildTraceSnapshot(eventsFile, replay)).checks });
+      return;
+    }
+    if (request.method === "GET" && url.pathname === "/handoff") {
+      sendJson(response, 200, {
+        ok: true,
+        data: { markdown: (await buildTraceSnapshot(eventsFile, replay)).handoffMarkdown }
+      });
+      return;
+    }
+    if (url.pathname === "/suggest" && (request.method === "POST" || request.method === "GET")) {
+      const body = request.method === "POST" ? await readJsonBody(request) : {};
+      const report = body.report && Array.isArray(body.report.metrics) ? body.report : (await buildTraceSnapshot(eventsFile, replay)).efficiency;
+      const result = await generateSuggestions(report, suggestConfig);
+      sendJson(response, 200, { ok: true, data: result });
+      return;
+    }
+    if (request.method === "POST" && url.pathname === "/events") {
+      const body = await readJsonBody(request);
+      const validation = validateTraceEvent(body);
+      if (!validation.ok) {
+        sendJson(response, 400, {
+          ok: false,
+          error: { message: "Invalid TraceEvent", details: validation.errors }
+        });
+        return;
+      }
+      await appendTraceEvent(eventsFile, body);
+      void broadcastSnapshot(clients, eventsFile);
+      sendJson(response, 202, { ok: true, data: { accepted: true, id: body.id } });
+      return;
+    }
+    sendJson(response, 404, { ok: false, error: { message: "Not found" } });
+  } catch (error) {
+    sendJson(response, error instanceof BadRequestError ? 400 : 500, {
+      ok: false,
+      error: { message: error instanceof Error ? error.message : String(error) }
+    });
+  }
+}
+async function broadcastSnapshot(clients, eventsFile) {
+  if (clients.size === 0) {
+    return;
+  }
+  await Promise.allSettled([...clients].map((client) => sendSnapshot(client, eventsFile)));
+}
+async function sendSnapshot(client, eventsFile) {
+  if (client.readyState !== WebSocket.OPEN) {
+    return;
+  }
+  try {
+    client.send(JSON.stringify({ type: "snapshot", data: await buildTraceSnapshot(eventsFile) }));
+  } catch (error) {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(JSON.stringify({
+        type: "error",
+        error: { message: error instanceof Error ? error.message : String(error) }
+      }));
+    }
+  }
+}
+async function readJsonBody(request) {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const raw = Buffer.concat(chunks).toString("utf8");
+  return raw.length > 0 ? JSON.parse(raw) : {};
+}
+function sendJson(response, statusCode, payload) {
+  response.writeHead(statusCode, {
+    "access-control-allow-headers": "content-type",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-origin": "*",
+    "content-type": "application/json; charset=utf-8"
+  });
+  response.end(JSON.stringify(payload));
+}
+function sendEmpty(response, statusCode) {
+  response.writeHead(statusCode, {
+    "access-control-allow-headers": "content-type",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-origin": "*"
+  });
+  response.end();
+}
+function parseReplayQuery(url) {
+  const seq = url.searchParams.get("seq");
+  if (seq !== null && seq !== "") {
+    const parsed = Number(seq);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+      throw new BadRequestError("seq must be a non-negative integer");
+    }
+    return { seq: parsed };
+  }
+  const at = url.searchParams.get("at");
+  if (at !== null && at !== "") {
+    if (Number.isNaN(Date.parse(at))) {
+      throw new BadRequestError("at must be an ISO-compatible timestamp");
+    }
+    return { at };
+  }
+  return {};
+}
+var BadRequestError = class extends Error {
+};
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// apps/daemon/dist/initOpenCode.js
+import { mkdir as mkdir2, readFile as readFile3, writeFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var defaultAdapterPackage = "@agent-blackbox/opencode-adapter";
+var defaultDaemonUrl = "http://127.0.0.1:47831";
+async function initOpenCodeProject(options) {
+  const adapterPackage = options.adapterPackage ?? defaultAdapterPackage;
+  const adapterImport = inferAdapterImport(adapterPackage);
+  const daemonUrl = options.daemonUrl ?? defaultDaemonUrl;
+  const opencodeDir = join3(options.projectDir, ".opencode");
+  const pluginsDir = join3(opencodeDir, "plugins");
+  const pluginPath = join3(pluginsDir, "agent-blackbox.ts");
+  const packageJsonPath = join3(opencodeDir, "package.json");
+  await mkdir2(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 readFile3(options.pluginBundlePath, "utf8");
+    const inlined = bundle.replaceAll("__ABB_DAEMON_URL__", daemonUrl);
+    await writeFile(pluginPath, inlined, "utf8");
+    return { pluginPath, packageJsonPath, adapterPackage, adapterImport };
+  }
+  await writeFile(pluginPath, renderOpenCodePlugin({ adapterImport, daemonUrl, optimize: options.optimize ?? false }), "utf8");
+  await writePackageJson(packageJsonPath, adapterPackage, adapterImport);
+  return {
+    pluginPath,
+    packageJsonPath,
+    adapterPackage,
+    adapterImport
+  };
+}
+function renderOpenCodePlugin(options) {
+  return `import { createOpenCodePlugin } from "${options.adapterImport}";
+
+export const AgentBlackbox = createOpenCodePlugin({
+  daemonUrl: process.env.AGENT_BLACKBOX_DAEMON_URL ?? "${options.daemonUrl}"${options.optimize ? ",\n  optimize: true" : ""}
+});
+`;
+}
+async function writePackageJson(packageJsonPath, adapterPackage, adapterImport) {
+  const existing = await readPackageJson(packageJsonPath);
+  const dependencies = {
+    ...existing.dependencies ?? {},
+    [adapterImport]: adapterPackage
+  };
+  await writeFile(packageJsonPath, `${JSON.stringify({ ...existing, dependencies }, null, 2)}
+`, "utf8");
+}
+function inferAdapterImport(adapterPackage) {
+  if (adapterPackage.startsWith("file:") || adapterPackage.startsWith("/") || adapterPackage.startsWith("./") || adapterPackage.startsWith("../")) {
+    return defaultAdapterPackage;
+  }
+  return adapterPackage;
+}
+async function readPackageJson(packageJsonPath) {
+  try {
+    return JSON.parse(await readFile3(packageJsonPath, "utf8"));
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+async function pathExists(path) {
+  try {
+    await readFile3(path, "utf8");
+    return true;
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// apps/daemon/dist/index.js
+var AGENT_BLACKBOX_DAEMON_VERSION = "0.1.0";
+function describeDaemon() {
+  return "Agent-Blackbox daemon: local ingest, replay, and dashboard bridge.";
+}
+
+// apps/daemon/dist/optimize.js
+import { mkdir as mkdir3, readFile as readFile4, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join4 } from "node:path";
+var flaggedIds = (report) => report.metrics.filter((m) => m.status !== "good").map((m) => m.id);
+var joinIds = (ids) => ids.join(", ");
+var REVERT_MARGIN = 3;
+async function runOptimize(options) {
+  const eventsFile = join4(options.projectDir, ".agent-blackbox", "events.ndjson");
+  const agentsMdPath = join4(options.projectDir, "AGENTS.md");
+  const statePath = join4(options.projectDir, ".agent-blackbox", "optimization.json");
+  const events = await loadTraceEvents(eventsFile);
+  const { runId, events: runEvents } = latestRun(events);
+  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;
+  if (options.mode === "revert") {
+    return revert(agentsMdPath, statePath, score);
+  }
+  const block = report ? buildEfficiencyMemory(report, { verifiedCommands: verifiedCommands(runEvents) }) : null;
+  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.",
+      score,
+      baselineScore: null,
+      reclaimableTokens: report?.reclaimableTokens,
+      block,
+      agentsMdPath,
+      changed: false
+    };
+  }
+  if (options.mode === "apply") {
+    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);
+    await writeFile2(agentsMdPath, next, "utf8");
+    await writeState(statePath, {
+      runId: runId ?? "",
+      baselineScore: score,
+      baselineLatestTs: latestTs,
+      baselineFlagged: flaggedIds(report),
+      fileExisted: prior !== null,
+      appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    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.`,
+      score,
+      baselineScore: score,
+      reclaimableTokens: report.reclaimableTokens,
+      block,
+      agentsMdPath,
+      changed: prior !== next
+    };
+  }
+  const state = await readState(statePath);
+  if (!state) {
+    return { mode: "check", action: "Nothing applied yet \u2014 run `optimize --apply` first.", score, baselineScore: null, block: null, agentsMdPath, changed: false };
+  }
+  if (runId === null) {
+    return { mode: "check", action: "No runs recorded yet.", score, baselineScore: state.baselineScore, block: null, agentsMdPath, changed: false };
+  }
+  if (latestTs <= state.baselineLatestTs) {
+    return {
+      mode: "check",
+      action: "No new run since apply. Run your agent with the memory in place, then re-check.",
+      score,
+      baselineScore: state.baselineScore,
+      block: null,
+      agentsMdPath,
+      changed: false
+    };
+  }
+  const delta = (score ?? 0) - state.baselineScore;
+  const nowFlagged = report ? flaggedIds(report) : [];
+  const baseFlagged = state.baselineFlagged ?? [];
+  const cleared = baseFlagged.filter((id) => !nowFlagged.includes(id));
+  const appeared = nowFlagged.filter((id) => !baseFlagged.includes(id));
+  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);
+    await rm(statePath, { force: true });
+    return {
+      mode: "check",
+      action: `Score dropped ${state.baselineScore} \u2192 ${score ?? "?"} (\u0394${delta})${diffSuffix} on the new run \u2014 rolled the memory back.`,
+      score,
+      baselineScore: state.baselineScore,
+      block: null,
+      agentsMdPath,
+      changed
+    };
+  }
+  return {
+    mode: "check",
+    action: `Score ${state.baselineScore} \u2192 ${score ?? "?"} (\u0394${delta >= 0 ? "+" : ""}${delta})${diffSuffix} \u2014 kept the memory.`,
+    score,
+    baselineScore: state.baselineScore,
+    block: null,
+    agentsMdPath,
+    changed: false
+  };
+}
+async function revert(agentsMdPath, statePath, score) {
+  const state = await readState(statePath);
+  const changed = await restore(agentsMdPath, 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.",
+    score,
+    baselineScore: state ? state.baselineScore : null,
+    block: null,
+    agentsMdPath,
+    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 true;
+  }
+  await writeFile2(agentsMdPath, next, "utf8");
+  return true;
+}
+function latestRun(events) {
+  let latest;
+  for (const e of events)
+    if (!latest || e.ts > latest.ts)
+      latest = e;
+  if (!latest)
+    return { runId: null, events: [] };
+  const runId = latest.runId;
+  return { runId, events: events.filter((e) => e.runId === runId) };
+}
+var NAV_VERBS = /* @__PURE__ */ new Set([
+  "ls",
+  "pwd",
+  "cat",
+  "find",
+  "grep",
+  "rg",
+  "fd",
+  "head",
+  "tail",
+  "echo",
+  "which",
+  "env",
+  "cd",
+  "tree",
+  "stat",
+  "wc",
+  "sort",
+  "uniq",
+  "clear",
+  "sleep",
+  "true",
+  "false"
+]);
+function verifiedCommands(events) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (e.kind !== "bash")
+      continue;
+    const payload = e.payload;
+    if (!payload || payload.exitCode !== 0)
+      continue;
+    const command = typeof payload.command === "string" ? payload.command.trim() : "";
+    if (!command || seen.has(command))
+      continue;
+    const verb = command.split(/\s+/)[0] ?? "";
+    if (NAV_VERBS.has(verb))
+      continue;
+    seen.add(command);
+    out.push(command);
+  }
+  return out;
+}
+async function readMaybe(path) {
+  try {
+    return await readFile4(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+async function readState(path) {
+  const raw = await readMaybe(path);
+  if (!raw)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeState(path, state) {
+  await mkdir3(dirname2(path), { recursive: true });
+  await writeFile2(path, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+
+// apps/daemon/dist/cli.js
+var args = process.argv.slice(2);
+var cliDir = dirname3(fileURLToPath(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")]);
+void main(args);
+async function main(argv) {
+  if (argv.includes("--version") || argv.includes("-v")) {
+    console.log(AGENT_BLACKBOX_DAEMON_VERSION);
+    return;
+  }
+  const command = argv[0] ?? "help";
+  if (command === "daemon") {
+    const projectDir = readFlag(argv, "--project") ?? process.cwd();
+    const port = Number(readFlag(argv, "--port") ?? "47831");
+    const daemon = await startTraceDaemon({ projectDir, port });
+    console.log(`Agent-Blackbox daemon listening on http://127.0.0.1:${daemon.port}`);
+    console.log(`Trace file: ${daemon.eventsFile}`);
+    return;
+  }
+  if (command === "up") {
+    const projectDir = resolve(readFlag(argv, "--project") ?? process.cwd());
+    const port = Number(readFlag(argv, "--port") ?? "47831");
+    const uiPort = Number(readFlag(argv, "--ui-port") ?? "5173");
+    const daemonUrl = `http://127.0.0.1:${port}`;
+    const adapterPackage = readFlag(argv, "--adapter-package") ?? `file:${resolve(repoRoot, "packages/opencode-adapter")}`;
+    const suggest = readSuggestConfig(argv);
+    try {
+      const result = await initOpenCodeProject({
+        projectDir,
+        daemonUrl,
+        adapterPackage,
+        force: false,
+        optimize: argv.includes("--optimize"),
+        ...pluginBundlePath ? { pluginBundlePath } : {}
+      });
+      console.log(`\u2713 OpenCode recorder plugin installed: ${result.pluginPath}`);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("already exists")) {
+        console.log("\u2713 OpenCode recorder plugin already present");
+      } else {
+        throw error;
+      }
+    }
+    const daemon = await startTraceDaemon({ projectDir, port, suggest });
+    const ui = await startDashboardServer({ distDir: dashboardDistDir, port: uiPort, daemonUrl });
+    const dashboardUrl = `http://127.0.0.1:${ui.port}`;
+    console.log("");
+    console.log(`\u2713 Agent-Blackbox is up for ${projectDir}`);
+    console.log(`  Dashboard:  ${dashboardUrl}`);
+    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(dashboardUrl);
+    console.log("Now run your agent in that project, e.g.:");
+    console.log(`  AGENT_BLACKBOX_DAEMON_URL=${daemonUrl} opencode run --dir ${projectDir} "Read the code, run tests, summarize."`);
+    console.log("");
+    console.log("Press Ctrl+C to stop.");
+    return;
+  }
+  if (command === "replay") {
+    const eventsFile = argv[1];
+    if (!eventsFile) {
+      throw new Error("Usage: agent-blackbox replay <events.ndjson>");
+    }
+    console.log(JSON.stringify(await buildReplaySummary(eventsFile), null, 2));
+    return;
+  }
+  if (command === "handoff") {
+    const eventsFile = argv[1];
+    if (!eventsFile) {
+      throw new Error("Usage: agent-blackbox handoff <events.ndjson>");
+    }
+    const events = await loadTraceEvents(eventsFile);
+    console.log(generateHandoffMarkdown(materializeWorkflowGraph(events), evaluatePromiseChecks(events)));
+    return;
+  }
+  if (command === "init-opencode") {
+    const projectDir = readFlag(argv, "--project") ?? process.cwd();
+    const daemonUrl = readFlag(argv, "--daemon-url");
+    const adapterPackage = readFlag(argv, "--adapter-package");
+    const result = await initOpenCodeProject({
+      projectDir,
+      ...daemonUrl ? { daemonUrl } : {},
+      ...adapterPackage ? { adapterPackage } : {},
+      force: argv.includes("--force"),
+      optimize: argv.includes("--optimize"),
+      ...pluginBundlePath ? { pluginBundlePath } : {}
+    });
+    console.log(`OpenCode plugin written: ${result.pluginPath}`);
+    console.log(`OpenCode package config written: ${result.packageJsonPath}`);
+    return;
+  }
+  if (command === "optimize") {
+    const projectDir = resolve(readFlag(argv, "--project") ?? process.cwd());
+    const mode = argv.includes("--apply") ? "apply" : argv.includes("--check") ? "check" : argv.includes("--revert") ? "revert" : "preview";
+    const result = await runOptimize({ projectDir, mode });
+    console.log(`Agent-Blackbox optimize (${result.mode}) \u2014 ${result.agentsMdPath}`);
+    if (result.score !== null)
+      console.log(`  Latest run score: ${result.score}${result.baselineScore !== null ? ` (baseline ${result.baselineScore})` : ""}`);
+    if (result.reclaimableTokens && result.reclaimableTokens > 0)
+      console.log(`  Reclaimable waste this run: ~${result.reclaimableTokens} tokens`);
+    console.log(`  ${result.action}`);
+    if (result.block) {
+      console.log("");
+      console.log(result.block);
+    }
+    if (mode === "check")
+      console.log("\nNote: scores compare different runs, so this is a heuristic \u2014 auto-revert only fires on a clear drop.");
+    return;
+  }
+  printHelp();
+}
+function printHelp() {
+  console.log(describeDaemon());
+  console.log("");
+  console.log("Usage:");
+  console.log("  agent-blackbox up [--project <dir>] [--port <port>] [--ui-port <port>]   # plugin + daemon + dashboard, one command");
+  console.log("       [--suggest auto|free|off|ollama|opencode|openai-compat] [--suggest-model <id>] [--suggest-base-url <url>] [--optimize] [--no-open]");
+  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");
+  console.log("  agent-blackbox handoff <events.ndjson>");
+  console.log("  agent-blackbox replay <events.ndjson>");
+  console.log("  agent-blackbox --version");
+}
+function openInBrowser(url) {
+  const platform = process.platform;
+  const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args2 = platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    spawn2(command, args2, { stdio: "ignore", detached: true }).unref();
+  } catch {
+  }
+}
+function readFlag(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index < 0) {
+    return void 0;
+  }
+  return argv[index + 1];
+}
+function readSuggestConfig(argv) {
+  const modes = ["auto", "off", "free", "ollama", "opencode", "openai-compat"];
+  const raw = readFlag(argv, "--suggest") ?? process.env.AGENT_BLACKBOX_SUGGEST ?? "auto";
+  const mode = modes.includes(raw) ? raw : "auto";
+  const model = readFlag(argv, "--suggest-model") ?? process.env.AGENT_BLACKBOX_SUGGEST_MODEL;
+  const baseUrl = readFlag(argv, "--suggest-base-url") ?? process.env.AGENT_BLACKBOX_SUGGEST_BASE_URL;
+  return { mode, ...model ? { model } : {}, ...baseUrl ? { baseUrl } : {} };
+}