@bluecopa/harness 0.0.0-snapshot.137

package/dist/arc/index.js

@@ -0,0 +1,2863 @@
+import { tool, generateText, stepCountIs, streamText } from 'ai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { z } from 'zod';
+import { randomUUID } from 'crypto';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+// src/arc/loop.ts
+
+// src/agent/types.ts
+function getTextContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter(
+    (p) => p.type === "text"
+  ).map((p) => p.text).join("\n");
+}
+
+// src/arc/message-convert.ts
+function toModelMessages(messages) {
+  const out = [];
+  let seenNonSystem = false;
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      const text = typeof msg.content === "string" ? msg.content : getTextContent(msg.content);
+      if (seenNonSystem) {
+        out.push({ role: "user", content: `[System] ${text}` });
+      } else {
+        out.push({ role: "system", content: text });
+      }
+      continue;
+    }
+    seenNonSystem = true;
+    if (msg.role === "user") {
+      out.push({ role: "user", content: msg.content });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const textContent = typeof msg.content === "string" ? msg.content : getTextContent(msg.content);
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        const parts = [];
+        if (textContent) {
+          parts.push({ type: "text", text: textContent });
+        }
+        for (const tc of msg.toolCalls) {
+          const part = {
+            type: "tool-call",
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            input: tc.args
+          };
+          if (tc.providerMetadata) {
+            part.providerOptions = tc.providerMetadata;
+          }
+          parts.push(part);
+        }
+        const assistantMsg = { role: "assistant", content: parts };
+        if (msg.providerMetadata) {
+          assistantMsg.providerOptions = msg.providerMetadata;
+        }
+        out.push(assistantMsg);
+      } else {
+        out.push({ role: "assistant", content: textContent });
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      if (msg.toolResults && msg.toolResults.length > 0) {
+        const parts = msg.toolResults.map((tr) => ({
+          type: "tool-result",
+          toolCallId: tr.toolCallId,
+          toolName: tr.toolName,
+          output: tr.isError ? { type: "error-text", value: tr.result } : { type: "text", value: tr.result }
+        }));
+        out.push({ role: "tool", content: parts });
+      } else {
+        const textContent = typeof msg.content === "string" ? msg.content : getTextContent(msg.content);
+        out.push({ role: "user", content: `[Tool result]: ${textContent}` });
+      }
+      continue;
+    }
+  }
+  return out;
+}
+
+// src/arc/utils.ts
+function truncate(value, max) {
+  if (value.length <= max) return value;
+  return `${value.slice(0, max)}
+...[truncated ${value.length - max} chars]`;
+}
+function truncateInline(value, max) {
+  return truncate(value.replace(/\s+/g, " ").trim(), max);
+}
+function looksLikePath(value) {
+  if (!value || /\s/.test(value)) return false;
+  return value.startsWith("/") || value.startsWith("./") || value.startsWith("../") || value.includes("/") || /\.[A-Za-z0-9]+$/.test(value);
+}
+
+// src/arc/trace-utils.ts
+function cloneForTrace(value) {
+  try {
+    return structuredClone(value);
+  } catch {
+    return JSON.parse(JSON.stringify(value, traceJsonReplacer));
+  }
+}
+function traceJsonReplacer(_key, value) {
+  if (typeof value === "bigint") return value.toString();
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+  }
+  if (value instanceof Uint8Array) {
+    return {
+      type: value.constructor.name,
+      byteLength: value.byteLength
+    };
+  }
+  return value;
+}
+function normalizeReadEpisodeArgs(args) {
+  const rawDetail = args.detail;
+  const detail = rawDetail === "summary" || rawDetail === "trace" || rawDetail === "artifacts" ? rawDetail : void 0;
+  return {
+    id: String(args.id ?? ""),
+    ...detail ? { detail } : {},
+    ...typeof args.artifactKey === "string" ? { artifactKey: args.artifactKey } : {},
+    ...typeof args.maxTokens === "number" ? { maxTokens: args.maxTokens } : {}
+  };
+}
+
+// src/arc/episode-projection.ts
+var DEFAULT_TRACE_MAX_CHARS = 8e4;
+var TRACE_TOOL_RESULT_LIMIT = 8e3;
+function formatDispatchForPrompt(record, options = {}) {
+  const maxChars = options.maxChars ?? 4e3;
+  const a = record.artifact;
+  const t = record.tuple;
+  const lines = [
+    `Dispatch ${t.id} [${a.status}]`,
+    `steps: ${a.stepsUsed}/${t.steps}`,
+    `summary: ${a.summary}`,
+    `instruction: ${truncateInline(t.instruction, options.compact ? 220 : 800)}`
+  ];
+  if (options.compact) return truncate(lines.join("\n"), maxChars);
+  if (a.output) {
+    lines.push(`output: ${a.output}`);
+  }
+  const workerArtifacts = record.workerResult?.artifacts ?? [];
+  const produced = workerArtifacts.filter((x) => x.action === "produced" || x.action === "modified");
+  if (produced.length > 0) {
+    lines.push(
+      "files_touched:",
+      ...produced.slice(0, 10).map((x) => `  - ${x.action} ${x.kind} ${truncateInline(x.uri, 180)}`)
+    );
+  }
+  const actions = a.actions ?? record.workerResult?.actions ?? [];
+  if (actions.length > 0) {
+    lines.push(
+      "actions:",
+      ...actions.slice(-10).map((action) => `  - ${truncateInline(action, 200)}`)
+    );
+  }
+  const textOutput = a.textOutput ?? record.workerResult?.lastMessage;
+  if (textOutput) {
+    const budget = Math.max(500, maxChars - lines.join("\n").length - 100);
+    lines.push(`worker_output:
+${truncate(textOutput, budget)}`);
+  }
+  return truncate(lines.join("\n"), maxChars);
+}
+function buildOodaSnapshot(input) {
+  const recent = input.dispatches.slice(-5);
+  const observations = recent.map(
+    (r) => [
+      `${r.tuple.id}: ${r.artifact.status}`,
+      r.artifact.summary
+    ].filter(Boolean).join("; ")
+  );
+  const disprovenApproaches = [];
+  for (const r of recent) {
+    if (r.artifact.status === "failed" || r.artifact.status === "incomplete") {
+      disprovenApproaches.push(
+        `${r.tuple.id}: ${truncateInline(r.tuple.instruction, 180)} -> ${r.artifact.status}`
+      );
+    }
+  }
+  const beliefs = [];
+  if (input.allIncomplete) {
+    beliefs.push("No dispatch has produced a complete artifact yet.");
+  }
+  if (beliefs.length === 0) {
+    beliefs.push("No unresolved issue detected.");
+  }
+  return {
+    observations: observations.length > 0 ? observations : ["No completed dispatches yet."],
+    beliefs,
+    disprovenApproaches,
+    blockers: [],
+    decisionPressure: {
+      turn: input.turn,
+      maxTurns: input.maxTurns,
+      turnsRemaining: input.turnsRemaining,
+      dispatchCount: input.dispatchCount,
+      allIncomplete: input.allIncomplete
+    }
+  };
+}
+function formatOodaSnapshotForPrompt(snapshot) {
+  return [
+    "## OODA State",
+    "decision_pressure:",
+    `  turn: ${snapshot.decisionPressure.turn}`,
+    `  max_turns: ${snapshot.decisionPressure.maxTurns}`,
+    `  turns_remaining: ${snapshot.decisionPressure.turnsRemaining}`,
+    `  dispatches_so_far: ${snapshot.decisionPressure.dispatchCount}`,
+    `  all_incomplete: ${snapshot.decisionPressure.allIncomplete}`,
+    "observations:",
+    formatList(snapshot.observations),
+    "beliefs:",
+    formatList(snapshot.beliefs),
+    "disproven_approaches:",
+    formatList(snapshot.disprovenApproaches),
+    "blockers:",
+    formatList(snapshot.blockers)
+  ].join("\n");
+}
+async function formatReadEpisodeResult(record, transcriptStore) {
+  const transcript = await transcriptStore.get(record.transcriptId);
+  const traceSection = transcript ? formatTranscriptTrace(transcript.messages, TRACE_TOOL_RESULT_LIMIT) : "(transcript not found)";
+  const base = [
+    `Dispatch ${record.tuple.id}`,
+    "",
+    formatDispatchForPrompt(record, { maxChars: 12e3 }),
+    "",
+    "--- Trace ---",
+    traceSection
+  ];
+  return truncate(base.join("\n"), DEFAULT_TRACE_MAX_CHARS);
+}
+function formatTranscriptTrace(messages, toolResultLimit) {
+  return messages.map((message, index) => {
+    const lines = [`message ${index + 1}: ${message.role}`];
+    const content = getTextContent(message.content);
+    if (content) lines.push(content);
+    if (message.toolCalls?.length) {
+      lines.push("tool_calls:");
+      for (const call of message.toolCalls) {
+        lines.push(`- ${call.toolName} ${JSON.stringify(call.args)}`);
+      }
+    }
+    if (message.toolResults?.length) {
+      lines.push("tool_results:");
+      for (const result of message.toolResults) {
+        const status = result.isError ? "error" : "ok";
+        lines.push(
+          `- ${result.toolName} ${status} ${truncate(result.result, toolResultLimit)}`
+        );
+      }
+    }
+    return lines.join("\n");
+  }).join("\n\n");
+}
+function formatList(items) {
+  if (items.length === 0) return "- none";
+  return items.map((item) => `- ${item}`).join("\n");
+}
+
+// src/arc/lcm/tools.ts
+async function expandSummary(deps, summaryId, maxTokens) {
+  const node = deps.summaryDAG.getNode(summaryId);
+  if (!node) return `Summary node not found: ${summaryId}`;
+  if (node.depth === 0) {
+    const conversationId = node.sourceConversationIds[0];
+    if (!conversationId) return node.summary;
+    const messages = deps.messageStore.getConversation(conversationId);
+    if (messages.length === 0) {
+      const record = deps.findDispatchRecord(summaryId);
+      if (record) {
+        const transcript = await deps.transcriptStore.get(record.transcriptId);
+        if (transcript) {
+          return formatTranscriptTrace(transcript.messages, 8e3);
+        }
+      }
+      return node.summary;
+    }
+    const trace = messages.map(
+      (m) => `[${m.role}:${m.index}] ${m.content.slice(0, Math.floor(maxTokens * 4 / messages.length))}`
+    ).join("\n");
+    return truncate(trace, maxTokens * 4);
+  }
+  const children = node.sourceIds.map((id) => deps.summaryDAG.getNode(id)).filter((n) => !!n);
+  return children.map((child) => `### ${child.id} (d${child.depth})
+${child.summary}`).join("\n\n");
+}
+function describeSummary(deps, summaryId) {
+  if (summaryId) {
+    const node = deps.summaryDAG.getNode(summaryId);
+    if (!node) return `Summary node not found: ${summaryId}`;
+    return [
+      `ID: ${node.id}`,
+      `Depth: ${node.depth}`,
+      `Sources: ${node.sourceIds.join(", ")}`,
+      `Conversations: ${node.sourceConversationIds.join(", ")}`,
+      `Artifacts: ${node.artifacts.join(", ") || "none"}`,
+      `Operations: ${node.operations.join(", ") || "none"}`,
+      `Outcome: ${node.outcome}`,
+      `Tokens: ${node.tokenCount}`,
+      `Summary:
+${node.summary}`
+    ].join("\n");
+  }
+  const allNodes = deps.summaryDAG.getAllNodes();
+  if (allNodes.length === 0) return "DAG is empty \u2014 no dispatches completed yet.";
+  const byDepth = /* @__PURE__ */ new Map();
+  for (const node of allNodes) {
+    byDepth.set(node.depth, (byDepth.get(node.depth) ?? 0) + 1);
+  }
+  const totalTokens = allNodes.reduce((sum, n) => sum + n.tokenCount, 0);
+  const lines = [
+    `DAG Overview: ${allNodes.length} total nodes, ~${totalTokens} tokens`,
+    "Nodes by depth:",
+    ...Array.from(byDepth.entries()).sort(([a], [b]) => a - b).map(([depth, count]) => `  d${depth}: ${count} nodes`),
+    "",
+    "All nodes:",
+    ...allNodes.map(
+      (n) => `  ${n.id}: d${n.depth}, ${n.outcome}, ${n.tokenCount} tokens`
+    )
+  ];
+  return lines.join("\n");
+}
+async function recallDirect(deps, query) {
+  const transcriptIds = await deps.vectorIndex.search(query, 5);
+  if (transcriptIds.length === 0) {
+    return "No relevant history found.";
+  }
+  const transcripts = await Promise.all(
+    transcriptIds.map((id) => deps.transcriptStore.get(id).then((t) => ({ id, t })))
+  );
+  const excerpts = [];
+  for (const { id, t: transcript } of transcripts) {
+    if (!transcript) continue;
+    const lastEntry = transcript.messages[transcript.messages.length - 1];
+    const lastMsg = lastEntry ? getTextContent(lastEntry.content).slice(0, 300) : "(no messages)";
+    excerpts.push(`**${id}**: ${transcript.instruction}
+  Last result: ${lastMsg}`);
+  }
+  if (excerpts.length === 0) {
+    return "No history available yet.";
+  }
+  return excerpts.join("\n\n");
+}
+function historyRead(deps, conversationId, messageIndex) {
+  const msg = deps.messageStore.getMessage(conversationId, messageIndex);
+  if (!msg) return null;
+  const parts = [msg.content];
+  if (msg.toolCalls) {
+    for (const tc of msg.toolCalls) {
+      parts.push(`[tool_call] ${tc.toolName} ${JSON.stringify(tc.args)}`);
+    }
+  }
+  if (msg.toolResults) {
+    for (const tr of msg.toolResults) {
+      parts.push(`[tool_result] ${tr.toolName}: ${tr.result}`);
+    }
+  }
+  return parts.join("\n");
+}
+var history_search = tool({
+  description: "Search across all stored messages from all conversations (orchestrator + workers). Returns matching excerpts with context. Use to find prior commands, errors, thread IDs, file paths, or any text across the full run history.",
+  inputSchema: z.object({
+    pattern: z.string().max(500).describe("Search pattern (literal text match) to search for across all messages"),
+    conversationId: z.string().max(200).optional().describe(
+      'Optional: limit search to a specific conversation (e.g., "orchestrator" or "worker_<tupleId>")'
+    ),
+    maxResults: z.number().min(1).max(100).optional().describe("Maximum number of results to return (default: 20)")
+  })
+});
+var history_expand = tool({
+  description: "Expand a compacted summary back to source messages or child summaries. For leaf nodes: returns the original worker transcript. For rollup nodes: returns the child summaries. Use when a ghost cue or summary reference needs full detail.",
+  inputSchema: z.object({
+    summaryId: z.string().max(200).describe("The summary node ID to expand (e.g., 'summary_d0_tuple_abc')"),
+    maxTokens: z.number().min(100).max(32e3).optional().describe("Approximate maximum tokens to return (default: 8000)")
+  })
+});
+var history_overview = tool({
+  description: "Show summary node metadata (sources, depth, artifacts, operations) or history overview. With summaryId: shows that node's details. Without: shows how many nodes at each depth, what's in context vs compacted.",
+  inputSchema: z.object({
+    summaryId: z.string().max(200).optional().describe(
+      "Optional summary node ID. Omit to get full history overview."
+    )
+  })
+});
+var history_read = tool({
+  description: "Read a specific message from run history at full fidelity. Use after history_search returns a [conversationId:messageIndex] reference and you need the complete, untruncated content.",
+  inputSchema: z.object({
+    conversationId: z.string().max(200).describe('Conversation ID (e.g., "orchestrator" or "worker_tuple_abc")'),
+    messageIndex: z.number().min(0).describe("Message index within the conversation")
+  })
+});
+
+// src/arc/tools.ts
+var expectedArtifactSchema = z.object({
+  type: z.enum(["file", "directory", "value", "unknown"]).describe("What kind of artifact or result is expected"),
+  path: z.string().optional().describe("Concrete path when type is file or directory"),
+  description: z.string().optional().describe("Short natural-language description of the artifact")
+});
+var expectedOutputSchema = z.union([
+  z.string().describe(
+    'Legacy format: file path, "file:path", "value:description", or natural-language description'
+  ),
+  z.object({
+    artifacts: z.array(expectedArtifactSchema).optional().describe("Concrete artifacts or values the worker should produce"),
+    successCriteria: z.array(z.string()).optional().describe("Observable conditions that mean the dispatch succeeded"),
+    verification: z.string().optional().describe("How the worker should verify the result"),
+    description: z.string().optional().describe(
+      "Short summary of the expected result when artifacts are not known upfront"
+    ),
+    // Compatibility with an earlier structured shape.
+    kind: z.enum(["file", "files", "value", "unknown"]).optional(),
+    path: z.string().optional(),
+    paths: z.array(z.string()).optional()
+  }).describe("Structured expected-output contract")
+]);
+var dispatch = tool({
+  description: "Dispatch a worker to accomplish a task. Workers are stateless and see only the instruction, input files, and tools. Call multiple times in one response for parallel execution.",
+  inputSchema: z.object({
+    instruction: z.string().describe("What the worker should do"),
+    inputs: z.array(z.string()).optional().describe("Artifact IDs to provide as context"),
+    expectedOutput: expectedOutputSchema.describe(
+      "Expected artifacts, success criteria, and verification contract"
+    ),
+    tier: z.enum(["fast", "strong"]).optional().describe("Worker model tier. 'fast' for simple lookups, reads, searches, and summaries. 'strong' (default) for complex reasoning, coding, and multi-step tasks.")
+  })
+});
+var recall = tool({
+  description: "Query project history. Use to check past decisions, approaches, or errors.",
+  inputSchema: z.object({
+    query: z.string().describe("Natural language question about project history")
+  })
+});
+var readEpisodeInputSchema = z.object({
+  id: z.string().describe("Episode, tuple, or transcript ID to read"),
+  detail: z.enum(["summary", "trace", "artifacts"]).optional().describe(
+    "summary is compact; trace hydrates the worker transcript; artifacts returns produced/observed artifact state"
+  ),
+  artifactKey: z.string().optional().describe("Optional artifact handle to focus on when detail is artifacts"),
+  maxTokens: z.number().optional().describe("Approximate maximum tokens to return")
+});
+tool({
+  description: "Read a prior episode from this task run. Default summary returns the compact projection; trace hydrates the full worker transcript when exact evidence is needed.",
+  inputSchema: readEpisodeInputSchema
+});
+var ReadEpisode = tool({
+  description: "Read a prior episode from this task run. Use when the provided episode projection is insufficient and exact prior trace or artifacts are needed.",
+  inputSchema: readEpisodeInputSchema
+});
+var done = tool({
+  description: "Mark task complete and return final output.",
+  inputSchema: z.object({
+    output: z.string().describe("Artifact ID or summary to return")
+  })
+});
+var ScratchPad_Write = tool({
+  description: "Write a note to the shared scratch pad. Future workers will see it listed and can read it.",
+  inputSchema: z.object({
+    key: z.string().describe("Note name (e.g., 'network-findings', 'port-scan-results')"),
+    content: z.string().max(1e5).describe("Note content (max 100KB)")
+  })
+});
+var ScratchPad_Read = tool({
+  description: "Read a note from the shared scratch pad.",
+  inputSchema: z.object({
+    key: z.string().describe("Note name to read")
+  })
+});
+var ScratchPad_List = tool({
+  description: "List all notes in the shared scratch pad.",
+  inputSchema: z.object({})
+});
+var Show = tool({
+  description: "Show content directly to the user's terminal. Use when the user asked to see a file, output, or result. The content is displayed immediately without waiting for your full response.",
+  inputSchema: z.object({
+    content: z.string().describe("The content to display (file contents, command output, etc.)"),
+    language: z.string().optional().describe("Language hint for syntax highlighting (e.g. 'python', 'typescript')")
+  })
+});
+function ok(output) {
+  return { success: true, output };
+}
+function err(error) {
+  return { success: false, output: "", error };
+}
+var s = (t) => t;
+function buildHistoryToolEntries(deps) {
+  const tools = /* @__PURE__ */ new Map();
+  tools.set("history_search", {
+    name: "history_search",
+    schema: s(history_search),
+    execute: async (_p, args) => {
+      if (!deps.historySearch) return err("history_search unavailable");
+      const pattern = String(args.pattern ?? "");
+      const conversationId = args.conversationId;
+      const maxResults = args.maxResults ?? 20;
+      const results = deps.historySearch(pattern, { ...conversationId ? { conversationId } : {}, maxResults });
+      return results.length === 0 ? ok(`No matches for "${pattern}"`) : ok(results.map((r) => `[${r.conversationId}:${r.messageIndex}] ${r.matchContext}`).join("\n"));
+    }
+  });
+  tools.set("history_expand", {
+    name: "history_expand",
+    schema: s(history_expand),
+    execute: async (_p, args) => {
+      if (!deps.historyExpand) return err("history_expand unavailable");
+      return ok(await deps.historyExpand(String(args.summaryId ?? ""), args.maxTokens ?? 8e3));
+    }
+  });
+  tools.set("history_overview", {
+    name: "history_overview",
+    schema: s(history_overview),
+    execute: async (_p, args) => {
+      if (!deps.historyOverview) return err("history_overview unavailable");
+      return ok(deps.historyOverview(args.summaryId));
+    }
+  });
+  tools.set("history_read", {
+    name: "history_read",
+    schema: s(history_read),
+    execute: async (_p, args) => {
+      if (!deps.historyRead) return err("history_read unavailable");
+      const conversationId = String(args.conversationId ?? "");
+      const messageIndex = Number(args.messageIndex ?? 0);
+      const content = deps.historyRead(conversationId, messageIndex);
+      return content === null ? ok(`No message found: ${conversationId}:${messageIndex}`) : ok(content);
+    }
+  });
+  return tools;
+}
+function buildWorkerToolEntries(deps) {
+  const tools = /* @__PURE__ */ new Map();
+  tools.set("ReadEpisode", {
+    name: "ReadEpisode",
+    schema: s(ReadEpisode),
+    execute: async (_p, args) => deps.readEpisode ? ok(await deps.readEpisode(normalizeReadEpisodeArgs(args))) : err("ReadEpisode unavailable")
+  });
+  tools.set("Show", {
+    name: "Show",
+    schema: s(Show),
+    execute: async () => ok("")
+  });
+  tools.set("ScratchPad_Write", {
+    name: "ScratchPad_Write",
+    schema: s(ScratchPad_Write),
+    execute: async (_p, args) => {
+      if (!deps.scratchPad) return err("ScratchPad unavailable");
+      await deps.scratchPad.write(String(args.key ?? ""), String(args.content ?? ""));
+      return ok(`Written to scratch pad: ${args.key}`);
+    }
+  });
+  tools.set("ScratchPad_Read", {
+    name: "ScratchPad_Read",
+    schema: s(ScratchPad_Read),
+    execute: async (_p, args) => {
+      if (!deps.scratchPad) return err("ScratchPad unavailable");
+      const content = await deps.scratchPad.read(String(args.key ?? ""));
+      return content === null ? ok(`No note found with key: ${args.key}`) : ok(content);
+    }
+  });
+  tools.set("ScratchPad_List", {
+    name: "ScratchPad_List",
+    schema: s(ScratchPad_List),
+    execute: async () => {
+      if (!deps.scratchPad) return err("ScratchPad unavailable");
+      const keys = await deps.scratchPad.list();
+      return keys.length === 0 ? ok("Scratch pad is empty.") : ok(keys.join("\n"));
+    }
+  });
+  for (const [name, entry] of buildHistoryToolEntries(deps)) {
+    tools.set(name, entry);
+  }
+  return tools;
+}
+function buildOrchestratorToolEntries(deps) {
+  const tools = /* @__PURE__ */ new Map();
+  if (deps.recall) {
+    const recallFn = deps.recall;
+    tools.set("recall", {
+      name: "recall",
+      schema: s(recall),
+      execute: async (_p, args) => ok(await recallFn(String(args.query ?? "")))
+    });
+  }
+  if (deps.askUser) {
+    const askUserFn = deps.askUser;
+    tools.set("AskUser", {
+      name: "AskUser",
+      schema: s(tool({
+        description: "Ask the user a clarifying question and wait for their response.",
+        inputSchema: z.object({
+          question: z.string().describe("The question to ask the user"),
+          options: z.array(z.string()).optional().describe("Optional choices to present")
+        })
+      })),
+      execute: async (_p, args) => {
+        const question = String(args.question ?? "");
+        const options = Array.isArray(args.options) ? args.options.map(String) : void 0;
+        return ok(await askUserFn(question, options));
+      }
+    });
+  }
+  for (const [name, entry] of buildHistoryToolEntries(deps)) {
+    tools.set(name, entry);
+  }
+  return tools;
+}
+function normalizeExpectedOutput(input) {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    const record = input;
+    const artifacts = normalizeExpectedArtifacts(record);
+    const successCriteria = Array.isArray(record.successCriteria) ? record.successCriteria.filter(
+      (item) => typeof item === "string"
+    ) : void 0;
+    const verification = typeof record.verification === "string" ? record.verification : void 0;
+    const description = typeof record.description === "string" ? record.description : void 0;
+    return {
+      artifacts: artifacts.length > 0 ? artifacts : [{ type: "unknown", ...description ? { description } : {} }],
+      ...successCriteria && successCriteria.length > 0 ? { successCriteria } : {},
+      ...verification ? { verification } : {},
+      ...description ? { description } : {}
+    };
+  }
+  const raw = typeof input === "string" ? input.trim() : "";
+  if (!raw) {
+    return {
+      artifacts: [{ type: "unknown", description: "unspecified output" }]
+    };
+  }
+  if (raw.startsWith("value:")) {
+    return {
+      artifacts: [
+        {
+          type: "value",
+          description: raw.slice("value:".length).trim() || "value output"
+        }
+      ],
+      description: raw
+    };
+  }
+  if (raw.startsWith("file:")) {
+    return {
+      artifacts: [{ type: "file", path: raw.slice("file:".length).trim() }],
+      description: raw
+    };
+  }
+  if (looksLikePath(raw)) {
+    return {
+      artifacts: [{ type: "file", path: raw }],
+      description: raw
+    };
+  }
+  return {
+    artifacts: [{ type: "unknown", description: raw }],
+    description: raw
+  };
+}
+function normalizeExpectedArtifacts(record) {
+  const direct = Array.isArray(record.artifacts) ? record.artifacts.flatMap((item) => normalizeExpectedArtifact(item)) : [];
+  if (direct.length > 0) return direct;
+  const kind = typeof record.kind === "string" ? record.kind : void 0;
+  if (kind === "file" && typeof record.path === "string") {
+    return [{ type: "file", path: record.path }];
+  }
+  if (kind === "files" && Array.isArray(record.paths)) {
+    return record.paths.filter((path2) => typeof path2 === "string").map((path2) => ({ type: "file", path: path2 }));
+  }
+  if (kind === "value") {
+    return [
+      {
+        type: "value",
+        ...typeof record.description === "string" ? { description: record.description } : {}
+      }
+    ];
+  }
+  if (kind === "unknown") {
+    return [
+      {
+        type: "unknown",
+        ...typeof record.description === "string" ? { description: record.description } : {}
+      }
+    ];
+  }
+  return [];
+}
+function normalizeExpectedArtifact(item) {
+  if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+  const record = item;
+  const type = record.type;
+  if (type !== "file" && type !== "directory" && type !== "value" && type !== "unknown")
+    return [];
+  return [
+    {
+      type,
+      ...typeof record.path === "string" ? { path: record.path } : {},
+      ...typeof record.description === "string" ? { description: record.description } : {}
+    }
+  ];
+}
+
+// src/arc/tool-registry.ts
+function toolSchemasFromRegistry(registry) {
+  const schemas = {};
+  for (const [name, meta] of registry) {
+    if (meta.schema) schemas[name] = meta.schema;
+  }
+  return schemas;
+}
+
+// src/arc/stores/memory-stores.ts
+var MemoryTranscriptStore = class {
+  transcripts = [];
+  byId = /* @__PURE__ */ new Map();
+  async append(transcript) {
+    this.transcripts.push(transcript);
+    this.byId.set(transcript.id, transcript);
+  }
+  async getAll() {
+    return [...this.transcripts];
+  }
+  async get(id) {
+    return this.byId.get(id) ?? null;
+  }
+};
+var MemoryVectorIndex = class {
+  entries = [];
+  async add(id, text) {
+    this.entries.push({ id, text });
+  }
+  async search(query, k) {
+    const lowerQuery = query.toLowerCase();
+    const scored = this.entries.map((e) => ({
+      id: e.id,
+      score: e.text.toLowerCase().includes(lowerQuery) ? 1 : 0
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, k).map((s2) => s2.id);
+  }
+  async load() {
+  }
+  async save() {
+  }
+};
+var MemoryScratchPad = class {
+  entries = /* @__PURE__ */ new Map();
+  async write(key, content) {
+    this.entries.set(key, content);
+  }
+  async read(key) {
+    return this.entries.get(key) ?? null;
+  }
+  async list() {
+    return [...this.entries.keys()];
+  }
+  async clear() {
+    this.entries.clear();
+  }
+};
+var MemoryArtifactStore = class {
+  artifacts = /* @__PURE__ */ new Map();
+  async set(id, artifact) {
+    this.artifacts.set(id, artifact);
+  }
+  async get(id) {
+    return this.artifacts.get(id) ?? null;
+  }
+  async getAll() {
+    const result = {};
+    for (const [id, artifact] of this.artifacts) {
+      result[id] = artifact;
+    }
+    return result;
+  }
+};
+var MemorySessionStore = class {
+  snapshots = /* @__PURE__ */ new Map();
+  metas = /* @__PURE__ */ new Map();
+  async load(id) {
+    return this.snapshots.get(id) ?? null;
+  }
+  async save(id, snapshot) {
+    this.snapshots.set(id, snapshot);
+  }
+  async getMeta(id) {
+    return this.metas.get(id) ?? null;
+  }
+  async saveMeta(id, meta) {
+    this.metas.set(id, meta);
+  }
+  async list() {
+    return [...this.metas.values()].sort((a, b) => b.lastActiveAt - a.lastActiveAt);
+  }
+};
+
+// src/arc/lcm/message-store.ts
+var MemoryMessageStore = class _MemoryMessageStore {
+  messages = [];
+  byConversation = /* @__PURE__ */ new Map();
+  append(message) {
+    this.messages.push(message);
+    let conv = this.byConversation.get(message.conversationId);
+    if (!conv) {
+      conv = [];
+      this.byConversation.set(message.conversationId, conv);
+    }
+    conv.push(message);
+  }
+  getConversation(conversationId) {
+    return this.byConversation.get(conversationId) ?? [];
+  }
+  getMessage(conversationId, index) {
+    const conv = this.byConversation.get(conversationId);
+    return conv?.find((m) => m.index === index) ?? null;
+  }
+  serialize() {
+    return [...this.messages];
+  }
+  loadFrom(messages) {
+    this.messages.length = 0;
+    this.byConversation.clear();
+    for (const msg of messages) this.append(msg);
+  }
+  static hydrate(messages) {
+    const store = new _MemoryMessageStore();
+    store.loadFrom(messages);
+    return store;
+  }
+  grep(pattern, opts) {
+    const maxResults = opts?.maxResults ?? 50;
+    const re = new RegExp(escapeRegex(pattern), "gi");
+    const source = opts?.conversationId ? this.byConversation.get(opts.conversationId) ?? [] : this.messages;
+    const results = [];
+    for (const msg of source) {
+      if (results.length >= maxResults) break;
+      const searchText = buildSearchText(msg);
+      re.lastIndex = 0;
+      const match = re.exec(searchText);
+      if (!match) continue;
+      const start = Math.max(0, match.index - 80);
+      const end = Math.min(searchText.length, match.index + match[0].length + 80);
+      results.push({
+        messageId: msg.id,
+        conversationId: msg.conversationId,
+        messageIndex: msg.index,
+        excerpt: match[0],
+        matchContext: searchText.slice(start, end)
+      });
+    }
+    return results;
+  }
+};
+function buildSearchText(msg) {
+  const parts = [msg.content];
+  if (msg.toolCalls) {
+    for (const tc of msg.toolCalls) {
+      parts.push(`${tc.toolName} ${JSON.stringify(tc.args)}`);
+    }
+  }
+  if (msg.toolResults) {
+    for (const tr of msg.toolResults) {
+      parts.push(`${tr.toolName}: ${tr.result}`);
+    }
+  }
+  return parts.join("\n");
+}
+function escapeRegex(s2) {
+  return s2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/arc/lcm/summary-dag.ts
+var MemorySummaryDAG = class _MemorySummaryDAG {
+  nodes = /* @__PURE__ */ new Map();
+  /** Tracks which source IDs have been covered by a parent node */
+  coveredBy = /* @__PURE__ */ new Map();
+  serialize() {
+    return {
+      nodes: [...this.nodes.values()],
+      coveredBy: [...this.coveredBy.entries()]
+    };
+  }
+  loadFrom(data) {
+    this.nodes.clear();
+    this.coveredBy.clear();
+    for (const node of data.nodes) this.nodes.set(node.id, node);
+    for (const [id, parent] of data.coveredBy) this.coveredBy.set(id, parent);
+  }
+  static hydrate(data) {
+    const dag = new _MemorySummaryDAG();
+    dag.loadFrom(data);
+    return dag;
+  }
+  addLeaf(node) {
+    this.nodes.set(node.id, node);
+  }
+  compact(opts) {
+    const minChildren = opts?.minChildren ?? 4;
+    const softTokenBudget = opts?.softTokenBudget ?? 8e3;
+    const created = [];
+    const maxDepth = Math.max(0, ...Array.from(this.nodes.values()).map((n) => n.depth));
+    for (let depth = 0; depth <= maxDepth; depth++) {
+      const nodesAtDepth = Array.from(this.nodes.values()).filter((n) => n.depth === depth).sort((a, b) => a.createdAt - b.createdAt);
+      const uncovered = nodesAtDepth.filter((n) => !this.coveredBy.has(n.id));
+      const totalTokens = uncovered.reduce((sum, n) => sum + n.tokenCount, 0);
+      if (uncovered.length >= minChildren && totalTokens > softTokenBudget) {
+        for (let i = 0; i + minChildren <= uncovered.length; i += minChildren) {
+          const batch = uncovered.slice(i, i + minChildren);
+          const rollup = buildRollupNode(batch, depth + 1);
+          this.nodes.set(rollup.id, rollup);
+          for (const child of batch) {
+            this.coveredBy.set(child.id, rollup.id);
+          }
+          created.push(rollup);
+        }
+      }
+    }
+    return created;
+  }
+  getNode(id) {
+    return this.nodes.get(id) ?? null;
+  }
+  getLineage(id, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(id)) return [];
+    visited.add(id);
+    const node = this.nodes.get(id);
+    if (!node) return [];
+    const result = [...node.sourceIds];
+    for (const sourceId of node.sourceIds) {
+      const child = this.nodes.get(sourceId);
+      if (child && child.depth >= 0) {
+        result.push(...this.getLineage(sourceId, visited));
+      }
+    }
+    return [...new Set(result)];
+  }
+  getFrontier(budget) {
+    const allNodes = Array.from(this.nodes.values());
+    if (allNodes.length === 0) return { frontier: [], coveredIds: /* @__PURE__ */ new Set() };
+    const maxDepth = Math.max(...allNodes.map((n) => n.depth));
+    const frontier = [];
+    const coveredIds = /* @__PURE__ */ new Set();
+    let tokensUsed = 0;
+    const lineageCache = /* @__PURE__ */ new Map();
+    const cachedLineage = (id) => {
+      let result = lineageCache.get(id);
+      if (!result) {
+        result = this.getLineage(id);
+        lineageCache.set(id, result);
+      }
+      return result;
+    };
+    for (let depth = maxDepth; depth >= 0; depth--) {
+      const nodesAtDepth = allNodes.filter((n) => n.depth === depth).sort((a, b) => a.createdAt - b.createdAt);
+      for (const node of nodesAtDepth) {
+        if (coveredIds.has(node.id)) continue;
+        if (tokensUsed + node.tokenCount <= budget) {
+          frontier.push(node);
+          tokensUsed += node.tokenCount;
+          for (const sourceId of cachedLineage(node.id)) {
+            coveredIds.add(sourceId);
+          }
+        }
+      }
+    }
+    frontier.sort((a, b) => a.createdAt - b.createdAt);
+    return { frontier, coveredIds };
+  }
+  getAllNodes() {
+    return Array.from(this.nodes.values());
+  }
+};
+function buildRollupNode(children, depth) {
+  const allArtifacts = [...new Set(children.flatMap((c) => c.artifacts))];
+  const allOperations = [...new Set(children.flatMap((c) => c.operations))];
+  const allConversationIds = [
+    ...new Set(children.flatMap((c) => c.sourceConversationIds))
+  ];
+  const outcomes = children.map((c) => c.outcome);
+  const complete = outcomes.filter((o) => o === "complete").length;
+  const incomplete = outcomes.filter((o) => o === "incomplete").length;
+  const failed = outcomes.filter((o) => o === "failed").length;
+  const parts = [];
+  if (complete) parts.push(`${complete} complete`);
+  if (incomplete) parts.push(`${incomplete} incomplete`);
+  if (failed) parts.push(`${failed} failed`);
+  const aggregateOutcome = parts.join(", ") || "unknown";
+  const firstId = children[0]?.id.replace(/^summary_d\d+_/, "") ?? "0";
+  const lastId = children[children.length - 1]?.id.replace(/^summary_d\d+_/, "") ?? "0";
+  const id = `summary_d${depth}_${firstId}_${lastId}`;
+  const summaryLines = [
+    `Rollup [${children.length} episodes]: ${aggregateOutcome}.`
+  ];
+  if (allArtifacts.length > 0) {
+    summaryLines.push(`Produced: ${allArtifacts.join(", ")}`);
+  }
+  if (allOperations.length > 0) {
+    summaryLines.push(`Active threads: ${allOperations.join(", ")}`);
+  }
+  const summary = summaryLines.join("\n");
+  return {
+    id,
+    depth,
+    sourceIds: children.map((c) => c.id),
+    sourceConversationIds: allConversationIds,
+    summary,
+    artifacts: allArtifacts,
+    operations: allOperations,
+    outcome: aggregateOutcome,
+    tokenCount: Math.ceil(summary.length / 4),
+    createdAt: Date.now()
+  };
+}
+
+// src/arc/lcm/context-assembler.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function assembleContext(opts) {
+  const {
+    conversationId,
+    store,
+    dag,
+    budget,
+    freshTailSize,
+    taskContext,
+    ooda
+  } = opts;
+  const messages = [];
+  let tokensUsed = 0;
+  const taskTokens = estimateTokens(taskContext);
+  messages.push({ role: "user", content: taskContext });
+  tokensUsed += taskTokens;
+  if (ooda) {
+    const oodaText = formatOodaSnapshotForPrompt(ooda);
+    const oodaTokens = estimateTokens(oodaText);
+    messages.push({ role: "user", content: oodaText });
+    tokensUsed += oodaTokens;
+  }
+  const remainingBudget = budget - tokensUsed;
+  const tailBudget = Math.floor(remainingBudget * 0.4);
+  const frontierBudget = remainingBudget - tailBudget;
+  const { ghostCues, frontierText, ghostCueText } = buildFrontierAndGhostCues(
+    dag,
+    frontierBudget
+  );
+  if (frontierText) {
+    messages.push({ role: "user", content: frontierText });
+    tokensUsed += estimateTokens(frontierText);
+  }
+  if (ghostCueText) {
+    messages.push({ role: "user", content: ghostCueText });
+    tokensUsed += estimateTokens(ghostCueText);
+  }
+  const conversation = store.getConversation(conversationId);
+  if (conversation.length > 0) {
+    const tail = conversation.slice(-freshTailSize);
+    for (const msg of tail) {
+      const msgTokens = estimateTokens(msg.content);
+      if (tokensUsed + msgTokens > budget) break;
+      messages.push(storedToAgentMessage(msg));
+      tokensUsed += msgTokens;
+    }
+  }
+  return {
+    messages,
+    ghostCues,
+    tokenEstimate: tokensUsed,
+    ...frontierText != null ? { frontierText } : {},
+    ...ghostCueText != null ? { ghostCueText } : {}
+  };
+}
+async function assembleWorkerContext(opts) {
+  const { vectorIndex, transcriptStore, scratchPad, instruction, budget } = opts;
+  const retrievalBudget = Math.floor(budget * 0.15);
+  const dagBudget = budget - retrievalBudget;
+  const base = assembleContext({
+    conversationId: "__worker__",
+    store: opts.store,
+    dag: opts.dag,
+    budget: dagBudget,
+    freshTailSize: 0,
+    taskContext: opts.taskContext
+  });
+  let retrievalTokensUsed = 0;
+  const retrievalSections = [];
+  if (vectorIndex && transcriptStore) {
+    const transcriptIds = await vectorIndex.search(instruction, 3);
+    if (transcriptIds.length > 0) {
+      const transcripts = await Promise.all(
+        transcriptIds.map((id) => transcriptStore.get(id).then((t) => ({ id, t })))
+      );
+      const summaries = [];
+      for (const { id, t: transcript } of transcripts) {
+        if (!transcript) continue;
+        const lastEntry = transcript.messages[transcript.messages.length - 1];
+        const lastMsg = lastEntry ? getTextContent(lastEntry.content) : "";
+        const summary = `- **${id}**: ${transcript.instruction}
+  Result: ${lastMsg.slice(0, 200)}`;
+        const tokens = estimateTokens(summary);
+        if (retrievalTokensUsed + tokens > retrievalBudget) break;
+        summaries.push(summary);
+        retrievalTokensUsed += tokens;
+      }
+      if (summaries.length > 0) {
+        retrievalSections.push(`## Relevant Prior Work
+${summaries.join("\n")}`);
+      }
+    }
+  }
+  if (scratchPad) {
+    const keys = await scratchPad.list();
+    if (keys.length > 0) {
+      const section = `## Scratch Notes
+Available notes (use ScratchPad_Read to view): ${keys.join(", ")}`;
+      const tokens = estimateTokens(section);
+      if (retrievalTokensUsed + tokens <= retrievalBudget) {
+        retrievalSections.push(section);
+        retrievalTokensUsed += tokens;
+      }
+    }
+  }
+  if (retrievalSections.length > 0) {
+    const retrievalText = retrievalSections.join("\n\n");
+    const frontierText = base.frontierText ? `${base.frontierText}
+
+${retrievalText}` : retrievalText;
+    return {
+      ...base,
+      frontierText,
+      tokenEstimate: base.tokenEstimate + retrievalTokensUsed
+    };
+  }
+  return base;
+}
+function buildFrontierAndGhostCues(dag, frontierBudget) {
+  const ghostCues = [];
+  const allNodes = dag.getAllNodes();
+  if (allNodes.length === 0) {
+    return { ghostCues, frontierText: null, ghostCueText: null };
+  }
+  const { frontier, coveredIds } = dag.getFrontier(frontierBudget);
+  const frontierIds = new Set(frontier.map((n) => n.id));
+  let frontierText = null;
+  if (frontier.length > 0) {
+    const text = frontier.map((node) => formatSummaryForContext(node)).join("\n\n");
+    frontierText = `## Prior Work (${frontier.length} episodes)
+${text}`;
+  }
+  const expandTool = "history_expand";
+  const grepTool = "history_search";
+  for (const node of allNodes) {
+    if (frontierIds.has(node.id)) continue;
+    if (coveredIds.has(node.id)) continue;
+    if (node.depth === 0) {
+      ghostCues.push({
+        summaryId: node.id,
+        conversationIds: node.sourceConversationIds,
+        depth: node.depth,
+        label: `[compacted \u2014 use ${expandTool}('${node.id}') for detail]`
+      });
+    }
+  }
+  let ghostCueText = null;
+  if (ghostCues.length > 0) {
+    const maxCues = 10;
+    const cueText = ghostCues.slice(0, maxCues).map((cue) => `- ${cue.summaryId}: ${cue.label}`).join("\n");
+    const remaining = ghostCues.length > maxCues ? `
+... and ${ghostCues.length - maxCues} more` : "";
+    ghostCueText = `## Compacted History
+${cueText}${remaining}
+
+Use ${grepTool} to search across all stored messages, or ${expandTool} to hydrate a specific summary.`;
+  }
+  return { ghostCues, frontierText, ghostCueText };
+}
+function formatSummaryForContext(node) {
+  const depthLabel = node.depth === 0 ? "episode" : node.depth === 1 ? "rollup" : `rollup-d${node.depth}`;
+  return `### ${node.id} (${depthLabel})
+${node.summary}`;
+}
+function storedToAgentMessage(msg) {
+  return {
+    role: msg.role,
+    content: msg.content,
+    ...msg.toolCalls ? { toolCalls: msg.toolCalls } : {},
+    ...msg.toolResults ? { toolResults: msg.toolResults } : {}
+  };
+}
+
+// src/arc/prompts.ts
+var ORCHESTRATOR_SYSTEM_PROMPT = `You accomplish tasks by dispatching workers and synthesizing results.
+
+Dispatch workers for anything requiring tool use. Answer directly with done for questions you can answer from knowledge or prior results.
+
+You can dispatch multiple workers in a single turn \u2014 they run in parallel. Two strategies:
+- Decompose: different subtasks in parallel, collate results.
+- Explore: same problem, different approaches, take the best.
+
+Each dispatch accepts an optional tier parameter:
+- tier: "fast" \u2014 cheap, fast model for simple lookups, file reads, searches, and summarization.
+- tier: "strong" (default) \u2014 full-capability model for coding, debugging, complex reasoning, and multi-step tasks.
+Use fast when the task is straightforward and doesn't require deep reasoning.
+
+Workers are stateless \u2014 they see only their instruction, input artifacts, and tools. They also have access to history and scratch pad tools, so you don't need to repeat everything.
+
+Older context gets compacted into summaries. Use history_search to find specific prior results, history_read for full content, and history_expand to restore compacted summaries.
+
+Before dispatching, check what prior workers attempted. Do not repeat failed approaches \u2014 change strategy or decompose differently.
+
+Explain your reasoning before each tool call.
+
+Before calling done, use readEpisode to verify the actual worker output \u2014 summaries may be truncated or stale. Call done only after confirming the result matches the task requirements. Re-dispatching costs turns \u2014 only follow up if the result is incomplete, failed, or clearly wrong.`;
+var WORKER_SYSTEM_PROMPT = `Complete the instruction using the available tools. Workers are stateless and cannot interact with the user \u2014 assume reasonable defaults and proceed.
+
+Before starting, check ScratchPad_List for notes from prior workers and use history_search to find relevant prior attempts.
+
+If you are running low on steps, stop and write your progress to ScratchPad_Write \u2014 this is more valuable than one more attempt.
+
+Before finishing, verify your work against the expected output contract. If verification fails, fix it.
+
+Explain your reasoning before each tool call.`;
+
+// src/arc/shared-types.ts
+function resolveToolChoice(config, turn) {
+  if (!config) return "auto";
+  return typeof config === "function" ? config(turn) : config;
+}
+
+// src/vercel-agent-loop.ts
+function toModelMessages2(messages) {
+  const out = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      out.push({
+        role: "system",
+        content: typeof msg.content === "string" ? msg.content : getTextContent(msg.content)
+      });
+      continue;
+    }
+    if (msg.role === "user") {
+      out.push({ role: "user", content: msg.content });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const textContent = typeof msg.content === "string" ? msg.content : getTextContent(msg.content);
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        const parts = [];
+        if (textContent) {
+          parts.push({ type: "text", text: textContent });
+        }
+        for (const tc of msg.toolCalls) {
+          parts.push({
+            type: "tool-call",
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            input: tc.args,
+            ...tc.providerMetadata ? { providerOptions: tc.providerMetadata } : {}
+          });
+        }
+        out.push({ role: "assistant", content: parts });
+      } else {
+        out.push({ role: "assistant", content: textContent });
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      if (msg.toolResults && msg.toolResults.length > 0) {
+        const parts = msg.toolResults.map((tr) => ({
+          type: "tool-result",
+          toolCallId: tr.toolCallId,
+          toolName: tr.toolName,
+          output: tr.isError ? { type: "error-text", value: tr.result } : { type: "text", value: tr.result }
+        }));
+        out.push({ role: "tool", content: parts });
+      } else {
+        const textContent = typeof msg.content === "string" ? msg.content : getTextContent(msg.content);
+        out.push({ role: "user", content: `[Tool result]: ${textContent}` });
+      }
+      continue;
+    }
+  }
+  return out;
+}
+var VercelAgentLoop = class _VercelAgentLoop {
+  model;
+  createModel;
+  systemPrompt;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  tools;
+  validToolNames;
+  toolChoiceConfig;
+  providerOptions;
+  prepareStep;
+  /** Track tool names called across steps for prepareStep context. */
+  toolCallHistory = [];
+  step = 0;
+  /** Last step's token usage — read after nextAction/streamAction completes. */
+  lastUsage;
+  constructor(config = {}) {
+    this.toolChoiceConfig = config.toolChoice;
+    this.model = config.model ?? process.env.HARNESS_MODEL ?? "claude-sonnet-4-5";
+    this.createModel = config.createModel ?? anthropic;
+    this.tools = config.tools ?? {};
+    this.validToolNames = new Set(Object.keys(this.tools));
+    this.providerOptions = config.providerOptions;
+    this.prepareStep = config.prepareStep;
+    this.systemPrompt = config.systemPrompt ?? [
+      "You are an agent that accomplishes tasks using tools.",
+      "You may call multiple independent tools in a single turn.",
+      "Use tools when shell or filesystem access is required.",
+      "Use TextEditor for file changes. Use ReadOnlyBash only for read-only inspection or verification commands.",
+      "Avoid rewriting the same file multiple times unless a previous run returned an error that requires a fix.",
+      "When the task is fully complete, respond with a brief text summary (no tool call)."
+    ].join(" ");
+    if (config.apiKey) {
+      process.env.ANTHROPIC_API_KEY = config.apiKey;
+    }
+  }
+  /** Build the `system` parameter for generateText/streamText. */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  buildSystemParam() {
+    if (typeof this.systemPrompt === "string") return this.systemPrompt;
+    return this.systemPrompt.map((block) => ({
+      role: "system",
+      content: block.text,
+      ...block.cacheControl ? {
+        providerOptions: {
+          anthropic: { cacheControl: block.cacheControl },
+          openrouter: { cacheControl: block.cacheControl }
+        }
+      } : {}
+    }));
+  }
+  /** Resolve model + tools for this step via prepareStep callback. */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolveStep(stepNumber) {
+    if (!this.prepareStep) {
+      return {
+        model: this.model,
+        tools: this.tools,
+        validNames: this.validToolNames
+      };
+    }
+    const overrides = this.prepareStep({
+      stepNumber,
+      toolCallHistory: this.toolCallHistory
+    });
+    if (!overrides) {
+      return {
+        model: this.model,
+        tools: this.tools,
+        validNames: this.validToolNames
+      };
+    }
+    const model = overrides.model ?? this.model;
+    let tools = this.tools;
+    let validNames = this.validToolNames;
+    if (overrides.activeTools) {
+      const allowed = new Set(overrides.activeTools);
+      tools = Object.fromEntries(
+        Object.entries(this.tools).filter(([k]) => allowed.has(k))
+      );
+      validNames = new Set(Object.keys(tools));
+    }
+    return { model, tools, validNames };
+  }
+  /** Extract StepUsage from AI SDK usage object. */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static extractUsage(usage) {
+    if (!usage) return void 0;
+    const u = {};
+    if (usage.inputTokens != null) u.inputTokens = usage.inputTokens;
+    if (usage.outputTokens != null) u.outputTokens = usage.outputTokens;
+    const inputDetails = usage.inputTokenDetails ?? usage;
+    const outputDetails = usage.outputTokenDetails ?? usage;
+    if (inputDetails.cacheReadTokens != null)
+      u.cacheReadTokens = inputDetails.cacheReadTokens;
+    if (inputDetails.cacheWriteTokens != null)
+      u.cacheWriteTokens = inputDetails.cacheWriteTokens;
+    if (outputDetails.reasoningTokens != null)
+      u.reasoningTokens = outputDetails.reasoningTokens;
+    return Object.keys(u).length > 0 ? u : void 0;
+  }
+  async nextAction(messages, signal) {
+    const currentStep = this.step++;
+    const { model, tools, validNames } = this.resolveStep(currentStep + 1);
+    const result = await generateText({
+      model: this.createModel(model),
+      tools,
+      toolChoice: resolveToolChoice(this.toolChoiceConfig, currentStep),
+      system: this.buildSystemParam(),
+      messages: toModelMessages2(messages),
+      stopWhen: stepCountIs(1),
+      ...signal ? { abortSignal: signal } : {},
+      ...this.providerOptions ? { providerOptions: this.providerOptions } : {}
+    });
+    this.lastUsage = _VercelAgentLoop.extractUsage(result.usage);
+    if (result.toolCalls && result.toolCalls.length > 0) {
+      const publicRationale = result.text?.trim() || void 0;
+      const validCalls = [];
+      for (const call of result.toolCalls) {
+        const name = call.toolName;
+        if (validNames.has(name)) {
+          const toolCallId = call.toolCallId;
+          const providerMetadata = call.providerMetadata ?? call.experimental_providerMetadata;
+          validCalls.push({
+            type: "tool",
+            name,
+            args: call.input,
+            ...toolCallId != null ? { toolCallId } : {},
+            ...providerMetadata != null ? { providerMetadata } : {}
+          });
+          this.toolCallHistory.push(name);
+        }
+      }
+      if (validCalls.length === 0) {
+        return {
+          type: "final",
+          content: `Unknown tool: ${result.toolCalls[0].toolName}`
+        };
+      }
+      if (validCalls.length === 1) {
+        const [call] = validCalls;
+        return publicRationale ? { ...call, publicRationale } : call;
+      }
+      return {
+        type: "tool_batch",
+        calls: validCalls,
+        ...publicRationale ? { publicRationale } : {}
+      };
+    }
+    const text = result.text?.trim();
+    return { type: "final", content: text || "Done." };
+  }
+  async *streamAction(messages) {
+    const currentStep = this.step++;
+    const { model, tools, validNames } = this.resolveStep(currentStep + 1);
+    const result = streamText({
+      model: this.createModel(model),
+      tools,
+      toolChoice: resolveToolChoice(this.toolChoiceConfig, currentStep),
+      system: this.buildSystemParam(),
+      messages: toModelMessages2(messages),
+      stopWhen: stepCountIs(1),
+      ...this.providerOptions ? { providerOptions: this.providerOptions } : {}
+    });
+    const toolArgs = /* @__PURE__ */ new Map();
+    for await (const part of result.fullStream) {
+      if (part.type === "text-delta") {
+        yield { type: "text_delta", text: part.text };
+      }
+      if (part.type === "tool-input-start") {
+        toolArgs.set(part.id, "");
+      }
+      if (part.type === "tool-input-delta") {
+        toolArgs.set(part.id, (toolArgs.get(part.id) ?? "") + part.delta);
+      }
+      if (part.type === "tool-call") {
+        const name = part.toolName;
+        if (validNames.has(name)) {
+          const p = part;
+          const args = p.args ?? p.input ?? {};
+          const toolCallId = p.toolCallId;
+          yield {
+            type: "tool_start",
+            name,
+            args,
+            ...toolCallId != null ? { toolCallId } : {}
+          };
+          this.toolCallHistory.push(name);
+        }
+      }
+    }
+    try {
+      const usage = await result.usage;
+      this.lastUsage = _VercelAgentLoop.extractUsage(usage);
+    } catch {
+      this.lastUsage = void 0;
+    }
+  }
+};
+
+// src/arc/worker.ts
+function summarizeArgs(args) {
+  return Object.values(args).map((v) => String(v).slice(0, 200)).join(", ");
+}
+async function runWorker(config) {
+  const {
+    task,
+    instruction,
+    expectedOutput,
+    lcmContext,
+    inputArtifacts,
+    tools,
+    toolRegistry,
+    maxSteps,
+    toolProvider,
+    createModel,
+    model,
+    workDir,
+    signal,
+    systemPromptPrefix,
+    systemPromptSuffix,
+    providerOptions,
+    orchestratorContext,
+    tupleId,
+    onProgress,
+    onTrace,
+    hookRunner
+  } = config;
+  const traceTupleId = tupleId ?? "worker";
+  const systemPrompt = [];
+  if (systemPromptPrefix) {
+    systemPrompt.push({
+      text: systemPromptPrefix,
+      cacheControl: { type: "ephemeral" }
+    });
+  }
+  systemPrompt.push({
+    text: WORKER_SYSTEM_PROMPT,
+    cacheControl: { type: "ephemeral" }
+  });
+  if (systemPromptSuffix) {
+    systemPrompt.push({
+      text: systemPromptSuffix,
+      cacheControl: { type: "ephemeral" }
+    });
+  }
+  let userContent = "";
+  if (orchestratorContext) {
+    userContent += `## Orchestrator Context
+${orchestratorContext}
+
+`;
+  }
+  if (task) {
+    userContent += `## Original Task
+${task}
+
+`;
+  }
+  userContent += [
+    `## Workspace`,
+    `Current workspace root: ${workDir}`,
+    `## Worker Budget`,
+    `max_steps: ${maxSteps}`,
+    ""
+  ].join("\n");
+  if (expectedOutput) {
+    userContent += `## Expected Output Contract
+${formatExpectedOutput(expectedOutput)}
+
+`;
+  }
+  if (lcmContext) {
+    if (lcmContext.frontierText) {
+      userContent += `${lcmContext.frontierText}
+
+`;
+    }
+    if (lcmContext.ghostCueText) {
+      userContent += `${lcmContext.ghostCueText}
+
+`;
+    }
+  }
+  userContent += `## Instruction
+${instruction}`;
+  if (inputArtifacts.size > 0) {
+    userContent += "\n\n## Input Files\n";
+    for (const [id, content] of inputArtifacts) {
+      userContent += `
+### ${id}
+\`\`\`
+${content}
+\`\`\`
+`;
+    }
+  }
+  const allTools = tools;
+  const loop = new VercelAgentLoop({
+    model,
+    createModel,
+    systemPrompt,
+    tools: allTools,
+    ...providerOptions ? { providerOptions } : {}
+  });
+  const messages = [{ role: "user", content: userContent }];
+  let stepsUsed = 0;
+  let lastMessage = "";
+  let output = null;
+  let status = "incomplete";
+  const actions = [];
+  const artifacts = [];
+  while (stepsUsed < maxSteps) {
+    if (signal?.aborted) {
+      status = "failed";
+      lastMessage = "Worker aborted";
+      break;
+    }
+    if (toolProvider.activeThreads) {
+      const updates = toolProvider.activeThreads();
+      if (updates.length > 0) {
+        const lines = updates.map((u) => {
+          const threadStatus = u.error ? `Error: ${u.error}` : u.isComplete ? `Completed (exit code: ${u.exitCode})` : "Running";
+          const parts = [`[auto] Thread ${u.threadId}: ${threadStatus}`];
+          if (u.output) parts.push(u.output);
+          return parts.join("\n");
+        });
+        messages.push({
+          role: "user",
+          content: `[System: background thread updates]
+${lines.join("\n\n")}`
+        });
+      }
+    }
+    const step = stepsUsed + 1;
+    const modelStartedAt = Date.now();
+    onProgress?.({ kind: "model_start", step, maxSteps });
+    onTrace?.({
+      scope: "worker",
+      phase: "model_input",
+      tupleId: traceTupleId,
+      step,
+      model,
+      system: systemPrompt.map((b) => b.text).join("\n\n"),
+      messages: cloneForTrace(messages),
+      toolNames: Object.keys(allTools)
+    });
+    let action;
+    try {
+      action = await loop.nextAction(messages, signal);
+    } catch (error) {
+      if (signal?.aborted) {
+        status = "interrupted";
+        lastMessage = "Worker interrupted by user";
+        break;
+      }
+      onProgress?.({
+        kind: "model_error",
+        step,
+        durationMs: Date.now() - modelStartedAt,
+        error: summarizeError(error)
+      });
+      throw error;
+    }
+    stepsUsed++;
+    onTrace?.({
+      scope: "worker",
+      phase: "model_output",
+      tupleId: traceTupleId,
+      step,
+      action: cloneForTrace(action)
+    });
+    const actionToolNames = toolNamesForAction(action);
+    const publicRationale = publicRationaleForAction(action);
+    const missingPublicRationale = actionToolNames.length > 0 && !publicRationale;
+    if (missingPublicRationale) {
+      onTrace?.({
+        scope: "worker",
+        phase: "public_rationale_missing",
+        tupleId: traceTupleId,
+        step,
+        toolNames: actionToolNames
+      });
+    }
+    onProgress?.({
+      kind: "model_complete",
+      step,
+      actionType: action.type,
+      durationMs: Date.now() - modelStartedAt,
+      ...actionToolNames.length > 0 ? { toolNames: actionToolNames } : {},
+      ...publicRationale ? { publicRationale } : {},
+      ...missingPublicRationale ? { missingPublicRationale } : {},
+      ...action.type === "final" ? { outputSummary: summarizeText(action.content, 240) } : {},
+      ...loop.lastUsage?.inputTokens != null ? { inputTokens: loop.lastUsage.inputTokens } : {},
+      ...loop.lastUsage?.outputTokens != null ? { outputTokens: loop.lastUsage.outputTokens } : {}
+    });
+    if (action.type === "final") {
+      messages.push({ role: "assistant", content: action.content });
+      lastMessage = action.content;
+      status = "complete";
+      output ??= action.content;
+      break;
+    }
+    if (action.type === "tool" || action.type === "tool_batch") {
+      const calls = action.type === "tool" ? [action] : action.calls;
+      const callsWithIds = calls.map((call) => ({
+        ...call,
+        toolCallId: call.toolCallId ?? `call_${Math.random().toString(36).slice(2)}`
+      }));
+      messages.push({
+        role: "assistant",
+        content: publicRationale ?? "",
+        toolCalls: callsWithIds.map((c) => ({
+          toolCallId: c.toolCallId,
+          toolName: c.name,
+          args: c.args,
+          ...c.providerMetadata ? { providerMetadata: c.providerMetadata } : {}
+        }))
+      });
+      const results = [];
+      for (const call of callsWithIds) {
+        const toolCallId = call.toolCallId;
+        const argSummary = summarizeArgs(call.args);
+        const toolStartedAt = Date.now();
+        onTrace?.({
+          scope: "worker",
+          phase: "tool_call",
+          tupleId: traceTupleId,
+          step: stepsUsed,
+          toolCallId,
+          toolName: call.name,
+          args: cloneForTrace(call.args)
+        });
+        onProgress?.({
+          kind: "tool_start",
+          step: stepsUsed,
+          toolCallId,
+          toolName: call.name,
+          ...argSummary ? { argsSummary: argSummary } : {}
+        });
+        if (hookRunner) {
+          const pre = await hookRunner.run({ event: "PreToolUse", toolName: call.name, input: call.args });
+          if (!pre.allow) {
+            const blockedResult = { success: false, output: "", error: pre.reason ?? "blocked by pre-hook" };
+            results.push({ toolCallId, toolName: call.name, result: toolResultText(blockedResult), isError: true, durationMs: Date.now() - toolStartedAt });
+            actions.push(`${call.name}${argSummary ? `: ${argSummary}` : ""} \u2192 ERROR: ${pre.reason ?? "blocked by pre-hook"}`);
+            continue;
+          }
+        }
+        let result2;
+        try {
+          const meta = toolRegistry.get(call.name);
+          if (meta?.execute) {
+            result2 = await meta.execute(toolProvider, call.args, workDir);
+          } else {
+            result2 = { success: false, output: "", error: `Unknown tool: ${call.name}` };
+          }
+        } catch (error) {
+          onProgress?.({
+            kind: "tool_error",
+            step: stepsUsed,
+            toolCallId,
+            toolName: call.name,
+            durationMs: Date.now() - toolStartedAt,
+            error: summarizeError(error)
+          });
+          throw error;
+        }
+        if (hookRunner) {
+          await hookRunner.run({ event: "PostToolUse", toolName: call.name, input: call.args, output: result2 });
+        }
+        const resultText = toolResultText(result2);
+        const exitCode = result2.metadata?.exitCode;
+        onTrace?.({
+          scope: "worker",
+          phase: "tool_result",
+          tupleId: traceTupleId,
+          step: stepsUsed,
+          toolCallId,
+          toolName: call.name,
+          result: cloneForTrace(result2),
+          resultText
+        });
+        onProgress?.({
+          kind: "tool_complete",
+          step: stepsUsed,
+          toolCallId,
+          toolName: call.name,
+          success: result2.success,
+          durationMs: Date.now() - toolStartedAt,
+          outputSummary: summarizeText(resultText, 300),
+          output: resultText,
+          ...exitCode !== void 0 ? { exitCode } : {}
+        });
+        results.push({
+          toolCallId,
+          toolName: call.name,
+          result: resultText,
+          isError: !result2.success,
+          durationMs: Date.now() - toolStartedAt
+        });
+        if (result2.success && result2.artifact) {
+          artifacts.push(result2.artifact);
+          if (result2.artifact.action !== "observed" && result2.artifact.kind === "file") {
+            output = result2.artifact.uri;
+          }
+        }
+        const resultSummary = summarizeText(resultText, 150);
+        actions.push(
+          `${call.name}${argSummary ? `: ${argSummary}` : ""} \u2192 ${result2.success ? resultSummary : `ERROR: ${resultSummary}`}`
+        );
+      }
+      messages.push({
+        role: "tool",
+        content: results.map((r) => `[${r.toolName}]: ${r.result}`).join("\n"),
+        toolResults: results
+      });
+    }
+  }
+  if (status === "incomplete" && stepsUsed >= maxSteps) {
+    lastMessage = lastMessage || "Worker ran out of steps";
+  }
+  onProgress?.({
+    kind: "worker_result",
+    status,
+    stepsUsed,
+    summary: summarizeText(lastMessage, 300)
+  });
+  const result = {
+    transcript: messages,
+    output,
+    status,
+    stepsUsed,
+    lastMessage,
+    actions,
+    artifacts
+  };
+  onTrace?.({
+    scope: "worker",
+    phase: "worker_result",
+    tupleId: traceTupleId,
+    result: cloneForTrace(result)
+  });
+  return result;
+}
+function toolResultText(result) {
+  if (result.modelOutput) return result.modelOutput;
+  if (result.success) return result.output;
+  return [result.error, result.output].filter(Boolean).join("\n") || "Unknown error";
+}
+function toolNamesForAction(action) {
+  if (action.type === "tool") return [action.name];
+  if (action.type === "tool_batch")
+    return action.calls.map((call) => call.name);
+  return [];
+}
+function publicRationaleForAction(action) {
+  if (action.type === "tool") return action.publicRationale;
+  if (action.type === "tool_batch") return action.publicRationale;
+  return void 0;
+}
+function formatExpectedOutput(expectedOutput) {
+  return JSON.stringify(expectedOutput, null, 2);
+}
+function summarizeText(value, max) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length <= max ? normalized : `${normalized.slice(0, max)}...`;
+}
+function summarizeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/arc/lcm/compactor.ts
+function buildLeafSummary(record) {
+  const conversationId = `worker_${record.tuple.id}`;
+  const a = record.artifact;
+  const wr = record.workerResult;
+  const artifactUris = (wr?.artifacts ?? []).filter((x) => x.action === "produced" || x.action === "modified").map((x) => x.uri);
+  const summaryParts = [
+    `[${a.status}] ${record.tuple.instruction}`,
+    `steps: ${a.stepsUsed}/${record.tuple.steps}`,
+    a.summary
+  ];
+  if (artifactUris.length > 0) {
+    summaryParts.push(`produced: ${artifactUris.join(", ")}`);
+  }
+  const actions = a.actions ?? wr?.actions ?? [];
+  if (actions.length > 0) {
+    summaryParts.push(`actions: ${actions.slice(-5).join("; ")}`);
+  }
+  const summary = summaryParts.join("\n");
+  return {
+    id: `summary_d0_${record.tuple.id}`,
+    depth: 0,
+    sourceIds: [record.transcriptId],
+    sourceConversationIds: [conversationId],
+    summary,
+    artifacts: artifactUris,
+    operations: [],
+    outcome: a.status,
+    tokenCount: Math.ceil(summary.length / 4),
+    createdAt: record.completedAt
+  };
+}
+
+// src/arc/dispatcher.ts
+function buildTuple(deps, args, orchestratorContext) {
+  const tier = args.tier === "fast" || args.tier === "strong" ? args.tier : void 0;
+  return {
+    id: `tuple_${randomUUID().slice(0, 8)}`,
+    instruction: String(args.instruction ?? ""),
+    inputs: Array.isArray(args.inputs) ? args.inputs.map(String) : [],
+    expectedOutput: normalizeExpectedOutput(args.expectedOutput),
+    tools: deps.allWorkerToolNames,
+    steps: deps.maxStepsPerWorker,
+    ...tier ? { tier } : {},
+    orchestratorContext
+  };
+}
+function resolveWorkerModel(deps, tuple) {
+  const tier = tuple.tier ?? "strong";
+  return deps.workerModelMap?.[tier] ?? deps.workerModel;
+}
+async function getInputArtifacts(artifactStore, toolProvider, inputs) {
+  const result = /* @__PURE__ */ new Map();
+  for (const id of inputs) {
+    const artifact = await artifactStore.get(id);
+    if (artifact?.output) {
+      try {
+        const fileResult = await toolProvider.readFile(artifact.output);
+        if (fileResult.success) {
+          result.set(id, fileResult.output);
+          continue;
+        }
+      } catch {
+      }
+    }
+    if (artifact?.textOutput) {
+      result.set(id, artifact.textOutput);
+      continue;
+    }
+    if (artifact?.summary) {
+      result.set(id, artifact.summary);
+    }
+  }
+  return result;
+}
+async function* runParallelDispatches(deps, state, calls, publicRationale, signal) {
+  const tuples = [];
+  for (const { args } of calls) {
+    state.dispatchCount++;
+    const tuple = buildTuple(deps, args, publicRationale);
+    tuples.push(tuple);
+    yield { type: "dispatch_full", tuple };
+    yield {
+      type: "dispatch",
+      tupleId: tuple.id,
+      instruction: tuple.instruction
+    };
+    yield {
+      type: "trace",
+      trace: {
+        scope: "orchestrator",
+        phase: "tool_call",
+        turn: state.turn,
+        toolName: "dispatch",
+        args: cloneForTrace(args)
+      }
+    };
+  }
+  const queuedEvents = [];
+  const workerPromises = [];
+  for (const tuple of tuples) {
+    const sections = [
+      `## Original Task
+${deps.task}`,
+      `## Workspace
+Current workspace root: ${deps.workDir}`,
+      `## Worker Budget
+max_steps: ${tuple.steps}`,
+      tuple.expectedOutput ? `## Expected Output Contract
+${JSON.stringify(tuple.expectedOutput, null, 2)}` : ""
+    ];
+    const priorWork = await buildPriorWorkContext(
+      state.dispatchRecords,
+      deps.transcriptStore,
+      4e3
+    );
+    if (priorWork) sections.push(priorWork);
+    const workerTaskContext = sections.filter(Boolean).join("\n\n");
+    const workerContext = await assembleWorkerContext({
+      store: deps.messageStore,
+      dag: deps.summaryDAG,
+      budget: 12e3,
+      taskContext: workerTaskContext,
+      instruction: tuple.instruction,
+      vectorIndex: deps.vectorIndex,
+      transcriptStore: deps.transcriptStore,
+      scratchPad: deps.scratchPad
+    });
+    const progressEvents = [];
+    const { hookRunner } = deps;
+    const promise = (async () => {
+      if (hookRunner) {
+        const pre = await hookRunner.run({ event: "BeforeWorker", metadata: { tupleId: tuple.id, instruction: tuple.instruction } });
+        if (!pre.allow) {
+          const failResult = {
+            transcript: [],
+            output: null,
+            status: "failed",
+            stepsUsed: 0,
+            lastMessage: pre.reason ?? "blocked by BeforeWorker hook",
+            actions: [],
+            artifacts: []
+          };
+          return { tuple, run: { result: failResult, progress: progressEvents } };
+        }
+      }
+      const result = await runWorker({
+        task: deps.task,
+        instruction: tuple.instruction,
+        expectedOutput: tuple.expectedOutput,
+        lcmContext: workerContext,
+        inputArtifacts: await getInputArtifacts(deps.artifactStore, deps.toolProvider, tuple.inputs),
+        tools: deps.workerTools,
+        toolRegistry: deps.workerToolRegistry,
+        maxSteps: tuple.steps,
+        toolProvider: deps.toolProvider,
+        createModel: deps.createModel,
+        model: resolveWorkerModel(deps, tuple),
+        workDir: deps.workDir,
+        signal,
+        systemPromptSuffix: deps.workerSystemPromptSuffix,
+        providerOptions: deps.providerOptions,
+        orchestratorContext: tuple.orchestratorContext,
+        tupleId: tuple.id,
+        hookRunner,
+        onProgress: (progress) => {
+          progressEvents.push(progress);
+          queuedEvents.push({
+            type: "worker_progress",
+            tupleId: tuple.id,
+            progress
+          });
+        },
+        onTrace: (trace) => {
+          queuedEvents.push({ type: "trace", trace });
+        }
+      });
+      if (hookRunner) {
+        await hookRunner.run({ event: "AfterWorker", metadata: { tupleId: tuple.id, status: result.status } });
+      }
+      return { tuple, run: { result, progress: progressEvents } };
+    })();
+    workerPromises.push(promise);
+  }
+  const allSettled = Promise.allSettled(workerPromises);
+  let settled = false;
+  allSettled.then(() => {
+    settled = true;
+  });
+  while (!settled || queuedEvents.length > 0) {
+    while (queuedEvents.length > 0) {
+      const event = queuedEvents.shift();
+      if (event) yield event;
+    }
+    if (!settled) {
+      await sleep(100);
+    }
+  }
+  const results = await allSettled;
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === "rejected") {
+      const tuple2 = tuples[i];
+      const error = result.reason instanceof Error ? result.reason.message : String(result.reason);
+      yield {
+        type: "worker_complete",
+        tupleId: tuple2.id,
+        status: "failed",
+        summary: `Worker error: ${error}`,
+        stepsUsed: 0
+      };
+      deps.appendOrchestratorMessage("user", `[result] Status: failed
+Summary: Worker error: ${error}`);
+      continue;
+    }
+    const { tuple, run } = result.value;
+    yield* recordDispatchResult(deps, state, tuple, run);
+  }
+}
+async function* recordDispatchResult(deps, state, tuple, workerRun) {
+  const workerResult = workerRun.result;
+  const artifact = {
+    id: tuple.id,
+    tupleId: tuple.id,
+    output: workerResult.output,
+    textOutput: workerResult.lastMessage,
+    status: workerResult.status,
+    summary: workerResult.lastMessage.slice(0, 200),
+    stepsUsed: workerResult.stepsUsed,
+    actions: workerResult.actions,
+    instruction: tuple.instruction
+  };
+  await deps.artifactStore.set(tuple.id, artifact);
+  state.lastArtifact = artifact;
+  yield {
+    type: "worker_complete",
+    tupleId: tuple.id,
+    status: artifact.status,
+    summary: artifact.summary,
+    stepsUsed: artifact.stepsUsed,
+    actions: artifact.actions
+  };
+  const transcript = {
+    id: `transcript_${tuple.id}`,
+    tupleId: tuple.id,
+    instruction: tuple.instruction,
+    messages: workerResult.transcript,
+    timestamp: Date.now()
+  };
+  await deps.transcriptStore.append(transcript);
+  const workerConversationId = `worker_${tuple.id}`;
+  for (const [idx, msg] of workerResult.transcript.entries()) {
+    deps.messageStore.append({
+      id: `${workerConversationId}_msg_${idx}`,
+      conversationId: workerConversationId,
+      index: idx,
+      role: msg.role === "tool" ? "tool" : msg.role === "assistant" ? "assistant" : "user",
+      content: getTextContent(msg.content),
+      ...msg.toolCalls ? { toolCalls: msg.toolCalls } : {},
+      ...msg.toolResults ? { toolResults: msg.toolResults } : {},
+      timestamp: transcript.timestamp
+    });
+  }
+  const dispatchRecord = {
+    tuple,
+    artifact,
+    transcriptId: transcript.id,
+    progress: workerRun.progress,
+    completedAt: transcript.timestamp
+  };
+  dispatchRecord.workerResult = workerResult;
+  state.dispatchRecords.push(dispatchRecord);
+  const leafSummary = buildLeafSummary(dispatchRecord);
+  deps.summaryDAG.addLeaf(leafSummary);
+  deps.summaryDAG.compact();
+  yield {
+    type: "trace",
+    trace: {
+      scope: "orchestrator",
+      phase: "tool_result",
+      turn: state.turn,
+      toolName: "dispatch",
+      args: cloneForTrace({ instruction: tuple.instruction }),
+      result: {
+        tuple: cloneForTrace(tuple),
+        artifact: cloneForTrace(artifact),
+        transcript: cloneForTrace(transcript),
+        progress: cloneForTrace(workerRun.progress),
+        workerResult: cloneForTrace(workerResult)
+      }
+    }
+  };
+  const textToEmbed = `${tuple.instruction}
+${workerResult.lastMessage}`;
+  deps.vectorIndex.add(transcript.id, textToEmbed).catch(() => {
+  });
+  const actionsText = artifact.actions?.length ? `
+Actions:
+${artifact.actions.map((a) => `- ${a}`).join("\n")}` : "";
+  const textOutput = artifact.textOutput && artifact.textOutput !== artifact.summary ? `
+Text output:
+${artifact.textOutput}` : "";
+  deps.appendOrchestratorMessage("assistant", `[dispatch] ${tuple.instruction}`);
+  deps.appendOrchestratorMessage("user", `[result] Status: ${artifact.status}
+Summary: ${artifact.summary}${textOutput}${actionsText}`);
+  if (artifact.status === "failed") {
+    deps.appendOrchestratorMessage(
+      "user",
+      `\u26A0 Worker failed. Review the output and dispatch a corrective worker.`
+    );
+  } else if (artifact.status === "incomplete") {
+    const actionsSummary = (artifact.actions ?? []).slice(-5).join("\n  ");
+    deps.appendOrchestratorMessage(
+      "user",
+      `Worker ran out of steps but made progress. Actions:
+  ${actionsSummary}
+Check if the result is already sufficient. Redispatch to finish \u2014 the new worker will automatically see prior attempt history.`
+    );
+  }
+}
+async function buildPriorWorkContext(dispatchRecords, transcriptStore, budgetChars) {
+  const relevant = dispatchRecords.filter(
+    (r) => r.artifact.status === "incomplete" || r.artifact.status === "failed"
+  );
+  if (relevant.length === 0) return null;
+  const sections = [];
+  let charsUsed = 0;
+  for (const record of relevant.slice().reverse()) {
+    const transcript = await transcriptStore.get(record.transcriptId);
+    if (!transcript || transcript.messages.length === 0) continue;
+    const header = `### Prior Attempt: ${record.tuple.id} [${record.artifact.status}]
+Instruction: ${record.tuple.instruction}`;
+    charsUsed += header.length;
+    if (charsUsed > budgetChars) break;
+    const lines = [header];
+    const msgs = transcript.messages;
+    for (let i = msgs.length - 1; i >= 0 && charsUsed < budgetChars; i--) {
+      const msg = msgs[i];
+      const text = getTextContent(msg.content);
+      const toolCalls = msg.toolCalls?.map(
+        (tc) => `${tc.toolName}(${Object.values(tc.args).map((v) => String(v).slice(0, 100)).join(", ").slice(0, 200)})`
+      );
+      const toolResults = msg.toolResults?.map(
+        (tr) => `${tr.toolName}: ${tr.isError ? "ERROR " : ""}${tr.result.slice(0, 300)}`
+      );
+      const parts = [];
+      if (text) parts.push(text.slice(0, 500));
+      if (toolCalls?.length) parts.push(`Tools: ${toolCalls.join("; ")}`);
+      if (toolResults?.length) parts.push(toolResults.join("\n"));
+      if (parts.length === 0) continue;
+      const entry = `[${msg.role}] ${parts.join("\n")}`;
+      charsUsed += entry.length;
+      lines.splice(1, 0, entry);
+    }
+    sections.push(lines.join("\n"));
+  }
+  if (sections.length === 0) return null;
+  return `## Prior Worker History
+${sections.join("\n\n")}`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/arc/loop.ts
+var ORCHESTRATOR_SYSTEM_CACHED = [
+  {
+    role: "system",
+    content: ORCHESTRATOR_SYSTEM_PROMPT,
+    providerOptions: {
+      anthropic: { cacheControl: { type: "ephemeral" } },
+      openrouter: { cacheControl: { type: "ephemeral" } }
+    }
+  }
+];
+var DEFAULT_WINDOW_SIZE = 10;
+var DEFAULT_MAX_TURNS = 12;
+var DEFAULT_MAX_STEPS_PER_WORKER = 15;
+var DEFAULT_CONTEXT_BUDGET = 24e3;
+var DEFAULT_FRESH_TAIL_SIZE = 6;
+var controlFlowTools = { dispatch, done };
+var ArcLoop = class {
+  config;
+  transcriptStore;
+  vectorIndex;
+  scratchPad;
+  artifactStore;
+  // LCM stores — mutable for session hydration
+  messageStore = new MemoryMessageStore();
+  summaryDAG = new MemorySummaryDAG();
+  createModel;
+  windowSize;
+  model;
+  /** Orchestrator tool schemas (for the model) */
+  orchestratorToolSchemas;
+  /** Orchestrator tool registry (for execute) — excludes dispatch/done (control flow) */
+  orchestratorToolRegistry;
+  /** Dispatcher deps + mutable state — shared with dispatcher.ts functions */
+  dispatchDeps;
+  dispatchState;
+  orchestratorMessageIndex = 0;
+  turn = 0;
+  maxTurns;
+  /** Per-turn abort controller — cancelled by interrupt(), refreshed each turn. */
+  turnController = new AbortController();
+  /** Resolver for the next task — set when the loop is waiting between tasks. */
+  taskResolve = null;
+  constructor(config) {
+    this.config = config;
+    this.maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
+    this.createModel = config.createModel ?? anthropic;
+    this.transcriptStore = config.transcriptStore ?? new MemoryTranscriptStore();
+    this.artifactStore = config.artifactStore ?? new MemoryArtifactStore();
+    this.vectorIndex = config.vectorIndex ?? new MemoryVectorIndex();
+    this.scratchPad = config.scratchPad ?? new MemoryScratchPad();
+    this.windowSize = config.orchestratorWindowSize ?? DEFAULT_WINDOW_SIZE;
+    this.model = config.model;
+    const lcmDeps = {
+      messageStore: this.messageStore,
+      summaryDAG: this.summaryDAG,
+      vectorIndex: this.vectorIndex,
+      transcriptStore: this.transcriptStore,
+      findDispatchRecord: (summaryId) => this.findEpisodeRecordBySummaryId(summaryId)
+    };
+    const toolDeps = {
+      readEpisode: (args) => this.readEpisode(args),
+      historySearch: (pattern, opts) => this.messageStore.grep(pattern, opts),
+      historyExpand: (summaryId, maxTokens) => expandSummary(lcmDeps, summaryId, maxTokens ?? 8e3),
+      historyOverview: (summaryId) => describeSummary(lcmDeps, summaryId),
+      historyRead: (conversationId, messageIndex) => historyRead(lcmDeps, conversationId, messageIndex),
+      scratchPad: this.scratchPad,
+      recall: (query) => recallDirect(lcmDeps, query),
+      ...config.askUser ? { askUser: config.askUser } : {}
+    };
+    this.orchestratorToolRegistry = buildOrchestratorToolEntries(toolDeps);
+    const workerArcTools = buildWorkerToolEntries(toolDeps);
+    this.orchestratorToolSchemas = {
+      ...controlFlowTools,
+      ...toolSchemasFromRegistry(this.orchestratorToolRegistry)
+    };
+    const agentToolRegistry = config.tools ?? /* @__PURE__ */ new Map();
+    const workerToolRegistry = new Map(agentToolRegistry);
+    for (const [name, tool3] of workerArcTools) {
+      workerToolRegistry.set(name, tool3);
+    }
+    const workerTools = {
+      ...toolSchemasFromRegistry(agentToolRegistry),
+      ...toolSchemasFromRegistry(workerArcTools)
+    };
+    this.dispatchState = {
+      turn: 0,
+      dispatchCount: 0,
+      dispatchRecords: [],
+      lastArtifact: null
+    };
+    this.dispatchDeps = {
+      task: config.task,
+      workDir: config.workDir,
+      maxStepsPerWorker: config.maxStepsPerWorker ?? DEFAULT_MAX_STEPS_PER_WORKER,
+      createModel: this.createModel,
+      workerModel: config.workerModel,
+      workerModelMap: config.workerModelMap,
+      toolProvider: config.toolProvider,
+      workerSystemPromptSuffix: config.workerSystemPromptSuffix,
+      providerOptions: config.providerOptions,
+      hookRunner: config.hookRunner,
+      messageStore: this.messageStore,
+      summaryDAG: this.summaryDAG,
+      vectorIndex: this.vectorIndex,
+      transcriptStore: this.transcriptStore,
+      artifactStore: this.artifactStore,
+      scratchPad: this.scratchPad,
+      workerTools,
+      workerToolRegistry,
+      allWorkerToolNames: Object.keys(workerTools),
+      appendOrchestratorMessage: (role, content) => this.appendOrchestratorMessage(role, content)
+    };
+  }
+  /**
+   * Interrupt the current turn — cancels in-flight model calls and workers.
+   * The orchestrator loop stays alive and will prompt for user steering.
+   */
+  interrupt() {
+    this.turnController.abort();
+  }
+  /** True when the loop is waiting for the next task (between done boundaries). */
+  get idle() {
+    return this.taskResolve !== null;
+  }
+  /**
+   * Push a follow-up task into the loop. The orchestrator sees it as
+   * a new user message with full conversational context from prior tasks.
+   */
+  pushTask(task) {
+    if (!this.taskResolve) return false;
+    const resolve = this.taskResolve;
+    this.taskResolve = null;
+    resolve(task);
+    return true;
+  }
+  waitForNextTask(signal) {
+    if (signal?.aborted) return Promise.resolve(null);
+    return new Promise((resolve) => {
+      const onAbort = () => {
+        this.taskResolve = null;
+        resolve(null);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      this.taskResolve = (task) => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve(task);
+      };
+    });
+  }
+  /** Save session snapshot + update meta if a session store is configured. */
+  async saveSession() {
+    const { sessionStore, sessionId } = this.config;
+    if (!sessionStore || !sessionId) return null;
+    try {
+      const dagSnapshot = this.summaryDAG.serialize();
+      await sessionStore.save(sessionId, {
+        messages: this.messageStore.serialize(),
+        dispatches: this.dispatchState.dispatchRecords.map(stripDispatchForSnapshot),
+        dagNodes: dagSnapshot.nodes,
+        dagCoveredBy: dagSnapshot.coveredBy,
+        turn: this.turn,
+        dispatchCount: this.dispatchState.dispatchCount,
+        orchestratorMessageIndex: this.orchestratorMessageIndex
+      });
+      const existing = await sessionStore.getMeta(sessionId);
+      await sessionStore.saveMeta(sessionId, {
+        id: sessionId,
+        slug: existing?.slug ?? sessionId.slice(0, 8),
+        createdAt: existing?.createdAt ?? Date.now(),
+        lastActiveAt: Date.now(),
+        taskCount: (existing?.taskCount ?? 0) + 1,
+        summary: truncate(this.config.task, 120)
+      });
+      return { type: "session_saved", sessionId };
+    } catch (err2) {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
+      return { type: "trace", trace: { scope: "orchestrator", phase: "tool_result", turn: this.turn, toolName: "session_save", args: {}, result: { error: msg } } };
+    }
+  }
+  /** Reset per-task state while keeping full conversation history. */
+  async resetForNewTask(task) {
+    this.config = { ...this.config, task };
+    this.dispatchDeps.task = task;
+    this.turn = 0;
+    this.dispatchState.turn = 0;
+    this.dispatchState.dispatchCount = 0;
+    this.dispatchState.lastArtifact = null;
+    await this.scratchPad.clear();
+  }
+  /**
+   * Stream events from the orchestration loop.
+   */
+  async *stream(signal) {
+    await this.vectorIndex.load();
+    if (this.config.sessionStore && this.config.sessionId) {
+      const snapshot = await this.config.sessionStore.load(this.config.sessionId);
+      if (snapshot) {
+        this.messageStore.loadFrom(snapshot.messages);
+        this.summaryDAG.loadFrom({ nodes: snapshot.dagNodes, coveredBy: snapshot.dagCoveredBy });
+        this.dispatchState.dispatchRecords.length = 0;
+        this.dispatchState.dispatchRecords.push(...snapshot.dispatches);
+        this.turn = Math.max(0, Math.min(snapshot.turn, this.maxTurns));
+        this.dispatchState.dispatchCount = Math.max(0, snapshot.dispatchCount);
+        const orchMsgs = this.messageStore.getConversation("orchestrator");
+        this.orchestratorMessageIndex = orchMsgs.length;
+      }
+    }
+    taskLoop: while (true) {
+      if (signal?.aborted) break;
+      while (this.turn < this.maxTurns) {
+        if (signal?.aborted) break;
+        this.turn++;
+        this.dispatchState.turn = this.turn;
+        this.turnController = new AbortController();
+        if (signal) {
+          if (signal.aborted) {
+            this.turnController.abort();
+            break;
+          }
+          signal.addEventListener("abort", () => this.turnController.abort(), { once: true });
+        }
+        const turnSignal = this.turnController.signal;
+        const context = await this.buildContext();
+        const { messages: orchestratorMessages, contextTokens } = this.buildOrchestratorMessages(context);
+        const modelMessages = toModelMessages(orchestratorMessages);
+        yield { type: "orchestrator_turn", turn: this.turn, contextTokens };
+        yield {
+          type: "trace",
+          trace: {
+            scope: "orchestrator",
+            phase: "model_input",
+            turn: this.turn,
+            model: this.model,
+            system: ORCHESTRATOR_SYSTEM_PROMPT,
+            messages: cloneForTrace(orchestratorMessages),
+            modelMessages: cloneForTrace(modelMessages),
+            toolNames: Object.keys(this.orchestratorToolSchemas)
+          }
+        };
+        let result;
+        try {
+          result = await generateText({
+            model: this.createModel(this.model),
+            system: ORCHESTRATOR_SYSTEM_CACHED,
+            tools: this.orchestratorToolSchemas,
+            messages: modelMessages,
+            toolChoice: "auto",
+            abortSignal: turnSignal,
+            ...this.config.providerOptions ? { providerOptions: this.config.providerOptions } : {}
+          });
+        } catch (err2) {
+          if (turnSignal.aborted && !signal?.aborted) {
+            yield* this.handleInterrupt();
+            continue;
+          }
+          throw err2;
+        }
+        yield {
+          type: "orchestrator_usage",
+          turn: this.turn,
+          ...result.usage?.inputTokens != null ? { inputTokens: result.usage.inputTokens } : {},
+          ...result.usage?.outputTokens != null ? { outputTokens: result.usage.outputTokens } : {}
+        };
+        yield {
+          type: "trace",
+          trace: {
+            scope: "orchestrator",
+            phase: "model_output",
+            turn: this.turn,
+            text: String(result.text ?? ""),
+            toolCalls: traceToolCalls(result.toolCalls ?? [])
+          }
+        };
+        if (result.toolCalls && result.toolCalls.length > 0) {
+          const publicRationale = result.text?.trim() || "";
+          if (publicRationale) {
+            yield { type: "text_delta", text: publicRationale + "\n" };
+            this.appendOrchestratorMessage("assistant", publicRationale);
+          } else {
+            yield {
+              type: "trace",
+              trace: {
+                scope: "orchestrator",
+                phase: "public_rationale_missing",
+                turn: this.turn,
+                toolCalls: traceToolCalls(result.toolCalls ?? [])
+              }
+            };
+          }
+          const dispatchCalls = [];
+          const nonDispatchCalls = [];
+          for (const toolCall of result.toolCalls) {
+            const args = toolCall.args ?? toolCall.input ?? {};
+            if (toolCall.toolName === "dispatch") {
+              dispatchCalls.push({ toolCall, args });
+            } else {
+              nonDispatchCalls.push({ toolCall, args });
+            }
+          }
+          for (const { toolCall, args } of nonDispatchCalls) {
+            yield {
+              type: "trace",
+              trace: {
+                scope: "orchestrator",
+                phase: "tool_call",
+                turn: this.turn,
+                toolName: toolCall.toolName,
+                args: cloneForTrace(args)
+              }
+            };
+            if (toolCall.toolName === "done") {
+              const output = String(args.output ?? "");
+              yield {
+                type: "trace",
+                trace: {
+                  scope: "orchestrator",
+                  phase: "tool_result",
+                  turn: this.turn,
+                  toolName: toolCall.toolName,
+                  args: cloneForTrace(args),
+                  result: { output, accepted: true }
+                }
+              };
+              this.appendOrchestratorMessage("assistant", `[done] ${output}`);
+              yield { type: "done", output };
+              const savedEvent2 = await this.saveSession();
+              if (savedEvent2) yield savedEvent2;
+              const nextTask2 = await this.waitForNextTask(signal);
+              if (nextTask2 == null) return;
+              this.appendOrchestratorMessage("user", nextTask2);
+              await this.resetForNewTask(nextTask2);
+              continue taskLoop;
+            }
+            const registryTool = this.orchestratorToolRegistry.get(toolCall.toolName);
+            if (registryTool?.execute) {
+              if (toolCall.toolName === "AskUser") {
+                yield { type: "ask_user", question: String(args.question ?? ""), options: Array.isArray(args.options) ? args.options.map(String) : void 0 };
+              }
+              const toolResult = await registryTool.execute(this.config.toolProvider, args, this.config.workDir);
+              const resultText = toolResult.success ? toolResult.output : toolResult.error ?? toolResult.output;
+              yield {
+                type: "trace",
+                trace: {
+                  scope: "orchestrator",
+                  phase: "tool_result",
+                  turn: this.turn,
+                  toolName: toolCall.toolName,
+                  args: cloneForTrace(args),
+                  result: cloneForTrace(toolResult)
+                }
+              };
+              if (toolCall.toolName === "recall") {
+                yield { type: "recall", query: String(args.query ?? ""), answer: resultText };
+              }
+              this.appendOrchestratorMessage("assistant", `[${toolCall.toolName}] ${truncate(JSON.stringify(args), 200)}`);
+              this.appendOrchestratorMessage("user", `[${toolCall.toolName} result]
+${resultText}`);
+            }
+          }
+          if (dispatchCalls.length > 0) {
+            yield* runParallelDispatches(this.dispatchDeps, this.dispatchState, dispatchCalls, publicRationale, turnSignal);
+            if (turnSignal.aborted && !signal?.aborted) {
+              yield* this.handleInterrupt();
+            }
+          }
+        } else {
+          const text = result.text?.trim() ?? "";
+          if (text) {
+            yield { type: "text_delta", text };
+            this.appendOrchestratorMessage("assistant", text);
+          }
+        }
+      }
+      await this.vectorIndex.save();
+      if (signal?.aborted) {
+        yield { type: "done", output: "[aborted]" };
+        break;
+      }
+      this.appendOrchestratorMessage("assistant", "[done] max turns reached");
+      yield { type: "done", output: "[max turns reached]" };
+      const savedEvent = await this.saveSession();
+      if (savedEvent) yield savedEvent;
+      const nextTask = await this.waitForNextTask(signal);
+      if (nextTask == null) break;
+      this.appendOrchestratorMessage("user", nextTask);
+      await this.resetForNewTask(nextTask);
+    }
+    await this.vectorIndex.save();
+  }
+  /**
+   * Run a single task to completion (for headless/test use).
+   * Breaks after the first `done` event — does not wait for follow-up tasks.
+   */
+  async run(signal) {
+    const events = [];
+    let output = "";
+    for await (const event of this.stream(signal)) {
+      events.push(event);
+      if (event.type === "done") {
+        output = event.output;
+        break;
+      }
+    }
+    return { output, events };
+  }
+  /** Append a message to the LCM message store (single source of truth) */
+  appendOrchestratorMessage(role, content) {
+    this.messageStore.append({
+      id: `orchestrator_msg_${this.orchestratorMessageIndex}`,
+      conversationId: "orchestrator",
+      index: this.orchestratorMessageIndex++,
+      role,
+      content,
+      timestamp: Date.now()
+    });
+  }
+  findEpisodeRecordBySummaryId(summaryId) {
+    const tupleId = summaryId.replace(/^summary_d0_/, "");
+    return this.dispatchState.dispatchRecords.find((r) => r.tuple.id === tupleId);
+  }
+  async buildContext() {
+    const artifacts = await this.artifactStore.getAll();
+    const artifactStatusCounts = { complete: 0, incomplete: 0, failed: 0, interrupted: 0 };
+    for (const a of Object.values(artifacts)) artifactStatusCounts[a.status]++;
+    const artifactCount = Object.keys(artifacts).length;
+    const allIncomplete = artifactCount > 0 && artifactStatusCounts.complete === 0;
+    return {
+      task: this.config.task,
+      artifacts,
+      lastResult: this.dispatchState.lastArtifact,
+      recentTurns: this.messageStore.getConversation("orchestrator").slice(-this.windowSize).map((msg) => ({ role: msg.role, content: msg.content })),
+      turn: this.turn,
+      maxTurns: this.maxTurns,
+      turnsRemaining: Math.max(0, this.maxTurns - this.turn),
+      dispatchCount: this.dispatchState.dispatchCount,
+      artifactStatusCounts,
+      allIncomplete,
+      dispatches: [...this.dispatchState.dispatchRecords],
+      ooda: buildOodaSnapshot({
+        turn: this.turn,
+        maxTurns: this.maxTurns,
+        turnsRemaining: Math.max(0, this.maxTurns - this.turn),
+        dispatchCount: this.dispatchState.dispatchCount,
+        allIncomplete,
+        dispatches: this.dispatchState.dispatchRecords
+      }),
+      // LCM additions
+      messageStore: this.messageStore,
+      summaryDAG: this.summaryDAG
+    };
+  }
+  buildOrchestratorMessages(context) {
+    const customContextMessages = this.config.formatOrchestratorContext?.(context);
+    if (customContextMessages) {
+      const taskContextMsg = {
+        role: "user",
+        content: this.buildTaskContextText(context)
+      };
+      const oodaMsg = {
+        role: "user",
+        content: formatOodaSnapshotForPrompt(context.ooda)
+      };
+      const messages = [taskContextMsg, oodaMsg, ...customContextMessages];
+      const contextTokens = messages.reduce(
+        (sum, m) => sum + Math.ceil((typeof m.content === "string" ? m.content : "").length / 4),
+        0
+      );
+      return { messages, contextTokens };
+    }
+    const taskContext = this.buildTaskContextText(context);
+    const assembled = assembleContext({
+      conversationId: "orchestrator",
+      store: this.messageStore,
+      dag: this.summaryDAG,
+      budget: DEFAULT_CONTEXT_BUDGET,
+      freshTailSize: DEFAULT_FRESH_TAIL_SIZE,
+      taskContext,
+      ooda: context.ooda
+    });
+    if (context.lastResult) {
+      let content = `## Last Result
+Artifact ${context.lastResult.id}: [${context.lastResult.status}]
+${context.lastResult.summary}`;
+      if (context.lastResult.instruction) {
+        content += `
+Your dispatch instruction was: "${context.lastResult.instruction}"`;
+      }
+      assembled.messages.push({ role: "user", content });
+    }
+    return { messages: assembled.messages, contextTokens: assembled.tokenEstimate };
+  }
+  buildTaskContextText(context) {
+    return `## Task
+${context.task}
+
+## Workspace
+root: ${this.config.workDir}
+
+## Budget
+turn: ${context.turn}
+max_turns: ${context.maxTurns}
+turns_remaining: ${context.turnsRemaining}
+dispatches_so_far: ${context.dispatchCount}
+
+## Progress
+artifact_status_counts: complete=${context.artifactStatusCounts.complete}, incomplete=${context.artifactStatusCounts.incomplete}, failed=${context.artifactStatusCounts.failed}
+all_incomplete: ${context.allIncomplete}`;
+  }
+  async readEpisode(args) {
+    const record = this.dispatchState.dispatchRecords.find(
+      (r) => r.tuple.id === args.id || r.transcriptId === args.id || r.artifact.id === args.id
+    );
+    if (!record) {
+      return `Episode not found: ${args.id}`;
+    }
+    return formatReadEpisodeResult(record, this.transcriptStore);
+  }
+  /**
+   * Handle a turn interrupt: prompt user for steering, inject into context.
+   */
+  async *handleInterrupt() {
+    this.appendOrchestratorMessage("user", "[system] Turn interrupted by user.");
+    if (this.config.askUser) {
+      const question = "Turn interrupted. How would you like to proceed?";
+      yield { type: "ask_user", question };
+      const answer = await this.config.askUser(question);
+      this.appendOrchestratorMessage("user", `[user steering] ${answer}`);
+    }
+  }
+};
+function stripDispatchForSnapshot(record) {
+  const { workerResult: _w, progress: _p, ...rest } = record;
+  return { ...rest, progress: [] };
+}
+function traceToolCalls(toolCalls) {
+  return toolCalls.map((toolCall) => {
+    const record = toolCall && typeof toolCall === "object" ? toolCall : {};
+    const rawArgs = record["args"] ?? record["input"] ?? {};
+    const args = rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs) ? rawArgs : {};
+    const toolCallId = typeof record["toolCallId"] === "string" ? record["toolCallId"] : void 0;
+    return {
+      toolName: String(record["toolName"] ?? ""),
+      ...toolCallId ? { toolCallId } : {},
+      args: cloneForTrace(args)
+    };
+  });
+}
+var FsTranscriptStore = class {
+  dir;
+  indexPath;
+  index = [];
+  loaded = false;
+  constructor(dir) {
+    this.dir = dir;
+    this.indexPath = path.join(dir, "index.json");
+  }
+  async append(transcript) {
+    await this.ensureLoaded();
+    await fs.mkdir(this.dir, { recursive: true });
+    const filePath = path.join(this.dir, `${transcript.id}.json`);
+    await fs.writeFile(filePath, JSON.stringify(transcript, null, 2));
+    this.index.push(transcript.id);
+    await fs.writeFile(this.indexPath, JSON.stringify(this.index, null, 2));
+  }
+  async getAll() {
+    await this.ensureLoaded();
+    const transcripts = [];
+    for (const id of this.index) {
+      const transcript = await this.get(id);
+      if (transcript) {
+        transcripts.push(transcript);
+      }
+    }
+    return transcripts;
+  }
+  async get(id) {
+    try {
+      const filePath = path.join(this.dir, `${id}.json`);
+      const data = await fs.readFile(filePath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async ensureLoaded() {
+    if (this.loaded) return;
+    try {
+      const data = await fs.readFile(this.indexPath, "utf-8");
+      this.index = JSON.parse(data);
+    } catch {
+      this.index = [];
+    }
+    this.loaded = true;
+  }
+};
+var FsArtifactStore = class {
+  filePath;
+  artifacts = {};
+  loaded = false;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async set(id, artifact) {
+    await this.ensureLoaded();
+    this.artifacts[id] = artifact;
+    await this.save();
+  }
+  async get(id) {
+    await this.ensureLoaded();
+    return this.artifacts[id] ?? null;
+  }
+  async getAll() {
+    await this.ensureLoaded();
+    return { ...this.artifacts };
+  }
+  async ensureLoaded() {
+    if (this.loaded) return;
+    try {
+      const data = await fs.readFile(this.filePath, "utf-8");
+      this.artifacts = JSON.parse(data);
+    } catch {
+      this.artifacts = {};
+    }
+    this.loaded = true;
+  }
+  async save() {
+    const dir = path.dirname(this.filePath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(this.filePath, JSON.stringify(this.artifacts, null, 2));
+  }
+};
+
+export { ArcLoop, FsArtifactStore, FsTranscriptStore, MemoryArtifactStore, MemoryMessageStore, MemoryScratchPad, MemorySessionStore, MemorySummaryDAG, MemoryTranscriptStore, MemoryVectorIndex, cloneForTrace, formatDispatchForPrompt };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map