@bluecopa/harness 0.1.0-snapshot.99 → 2.0.0

package/dist/arc/create-arc-agent.js

@@ -1,2926 +0,0 @@
-import { anthropic, createAnthropic } from '@ai-sdk/anthropic';
-import { tool, generateText, generateObject, streamText, stepCountIs } from 'ai';
-import { z } from 'zod';
-import { randomUUID } from 'crypto';
-import { readFile } from 'fs/promises';
-import { dirname, resolve } from 'path';
-
-// src/arc/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/arc-types.ts
-var DEFAULT_MODEL_MAP = {
-  fast: "claude-haiku-4-5",
-  medium: "claude-sonnet-4-6",
-  strong: "claude-opus-4-6"
-};
-function resolveModel(modelOrTier, modelMap, fallback) {
-  if (!modelOrTier) return fallback;
-  if (modelOrTier in modelMap) return modelMap[modelOrTier];
-  return modelOrTier;
-}
-
-// 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;
-}
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function estimateMessagesTokens(messages) {
-  let total = 0;
-  for (const msg of messages) {
-    const text = typeof msg.content === "string" ? msg.content : getTextContent(msg.content);
-    total += estimateTokens(text);
-    if (msg.toolCalls) {
-      for (const tc of msg.toolCalls) {
-        total += estimateTokens(JSON.stringify(tc.args));
-      }
-    }
-    if (msg.toolResults) {
-      for (const tr of msg.toolResults) {
-        total += estimateTokens(tr.result);
-      }
-    }
-  }
-  return total;
-}
-
-// src/arc/types.ts
-function resolveToolChoice(config, turn) {
-  if (!config) return "auto";
-  return typeof config === "function" ? config(turn) : config;
-}
-function isProfileDeclaration(p) {
-  return "signature" in p && typeof p.signature === "string";
-}
-var builtinTools = {
-  Bash: tool({
-    description: "Run a shell command",
-    inputSchema: z.object({
-      command: z.string().describe("The shell command to run"),
-      cwd: z.string().optional().describe("Working directory"),
-      timeout: z.number().optional().describe("Timeout in milliseconds")
-    })
-  }),
-  Read: tool({
-    description: "Read a file from the filesystem",
-    inputSchema: z.object({
-      path: z.string().describe("Absolute path to the file")
-    })
-  }),
-  Write: tool({
-    description: "Write content to a file (creates or overwrites)",
-    inputSchema: z.object({
-      path: z.string().describe("Absolute path to the file"),
-      content: z.string().describe("Content to write")
-    })
-  }),
-  Edit: tool({
-    description: "Replace text in a file (exact match)",
-    inputSchema: z.object({
-      path: z.string().describe("Absolute path to the file"),
-      old_text: z.string().describe("Exact text to find"),
-      new_text: z.string().describe("Replacement text")
-    })
-  }),
-  Glob: tool({
-    description: "Find files matching a glob pattern",
-    inputSchema: z.object({
-      pattern: z.string().describe("Glob pattern (e.g. **/*.ts)")
-    })
-  }),
-  Grep: tool({
-    description: "Search file contents with a regex pattern",
-    inputSchema: z.object({
-      pattern: z.string().describe("Regex pattern to search for"),
-      path: z.string().optional().describe("Directory or file to search in")
-    })
-  }),
-  WebFetch: tool({
-    description: "Fetch content from a URL",
-    inputSchema: z.object({
-      url: z.string().describe("URL to fetch"),
-      selector: z.string().optional().describe("CSS selector to extract"),
-      maxContentLength: z.number().optional().describe("Max content length")
-    })
-  }),
-  WebSearch: tool({
-    description: "Search the web",
-    inputSchema: z.object({
-      query: z.string().describe("Search query")
-    })
-  }),
-  AskUser: tool({
-    description: "Ask the user a question and wait for their response",
-    inputSchema: z.object({
-      question: z.string().describe("The question to ask"),
-      options: z.array(z.string()).optional().describe("Optional choices")
-    })
-  }),
-  TellUser: tool({
-    description: "Display a message to the user (no response expected)",
-    inputSchema: z.object({
-      message: z.string().describe("The message to display")
-    })
-  }),
-  DownloadRawFile: tool({
-    description: "Download a file from the sandbox to the local machine",
-    inputSchema: z.object({
-      path: z.string().describe("Sandbox path to download")
-    })
-  })
-};
-
-// src/arc/tools.ts
-var Thread = tool({
-  description: "Dispatch a process. Returns immediately. Multiple per turn = parallel.",
-  inputSchema: z.object({
-    action: z.string().describe("What the process should accomplish"),
-    contextEpisodeIds: z.array(z.string()).optional().describe("Episode IDs to seed as context"),
-    model: z.enum(["fast", "medium", "strong"]).optional().describe("Model tier (default: medium)"),
-    maxSteps: z.number().optional().describe("Max tool-call steps"),
-    label: z.string().optional().describe("Human-readable label"),
-    profile: z.string().optional().describe('Named process profile (e.g. "readonly", "generalist")')
-  })
-});
-var Check = tool({
-  description: "Check status or retrieve results of a process by ID.",
-  inputSchema: z.object({
-    id: z.string().describe("Process ID to check")
-  })
-});
-var Cancel = tool({
-  description: "Cancel a running process.",
-  inputSchema: z.object({
-    id: z.string().describe("Process ID to cancel")
-  })
-});
-var Remember = tool({
-  description: "Save information to persistent memory.",
-  inputSchema: z.object({
-    content: z.string().describe("What to remember"),
-    category: z.enum(["instruction", "preference", "fact", "pattern"]).optional().describe("Memory category")
-  })
-});
-var ReadEpisode = tool({
-  description: "Retrieve the full trace of a completed episode by ID. Use to inspect detailed tool outputs, file contents, or error messages that the episode summary omits.",
-  inputSchema: z.object({
-    id: z.string().describe("Episode ID to read"),
-    maxTokens: z.number().optional().describe("Max tokens to return (truncates from the end). Default: no limit.")
-  })
-});
-var orchestratorTools = { Thread, Check, Cancel, Remember, ReadEpisode };
-tool({
-  description: "Ask the user a question and wait for their response.",
-  inputSchema: z.object({
-    question: z.string().describe("The question to ask"),
-    options: z.array(z.string()).optional().describe("Optional choices")
-  })
-});
-tool({
-  description: "Display a message to the user (no response expected).",
-  inputSchema: z.object({
-    message: z.string().describe("The message to display")
-  })
-});
-
-// src/arc/openrouter-models.ts
-var OPENROUTER_API_URL = "https://openrouter.ai/api/v1/models";
-var CACHE_TTL_MS = 5 * 60 * 1e3;
-var DEFAULT_CONTEXT_LIMIT = 128e3;
-var modelCache = null;
-var fetchPromise = null;
-async function fetchOpenRouterModels() {
-  if (modelCache && Date.now() - modelCache.fetchedAt < CACHE_TTL_MS) {
-    return modelCache.models;
-  }
-  if (fetchPromise) {
-    return fetchPromise;
-  }
-  fetchPromise = (async () => {
-    try {
-      const response = await fetch(OPENROUTER_API_URL, {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-      if (!response.ok) {
-        throw new Error(`OpenRouter API error: ${response.status} ${response.statusText}`);
-      }
-      const data = await response.json();
-      const models = /* @__PURE__ */ new Map();
-      for (const model of data.data) {
-        if (model.context_length) {
-          models.set(model.id, model.context_length);
-        }
-      }
-      modelCache = {
-        models,
-        fetchedAt: Date.now()
-      };
-      return models;
-    } catch (error) {
-      console.warn("[OpenRouter] Failed to fetch models, using fallback:", error);
-      const emptyCache = /* @__PURE__ */ new Map();
-      modelCache = {
-        models: emptyCache,
-        fetchedAt: Date.now()
-      };
-      return emptyCache;
-    } finally {
-      fetchPromise = null;
-    }
-  })();
-  return fetchPromise;
-}
-async function getModelContextLimit(modelId, fallback = DEFAULT_CONTEXT_LIMIT) {
-  const models = await fetchOpenRouterModels();
-  if (models.has(modelId)) {
-    return models.get(modelId);
-  }
-  for (const [id, limit] of models.entries()) {
-    if (id.endsWith(modelId) || modelId.endsWith(id)) {
-      return limit;
-    }
-  }
-  return fallback;
-}
-
-// src/arc/context-window.ts
-var ContextWindow = class {
-  config;
-  turns = [];
-  episodes = [];
-  cachedContextSize = null;
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Get the effective context window size.
-   * If dynamicContextWindow is enabled, fetches from OpenRouter API.
-   * Otherwise uses the configured contextWindowSize.
-   */
-  async getContextWindowSize() {
-    if (this.cachedContextSize !== null) {
-      return this.cachedContextSize;
-    }
-    if (this.config.dynamicContextWindow && this.config.modelId) {
-      try {
-        const dynamicSize = await getModelContextLimit(this.config.modelId, 128e3);
-        this.cachedContextSize = dynamicSize;
-        return dynamicSize;
-      } catch (error) {
-        console.warn("[ContextWindow] Failed to fetch dynamic context limit, using fallback:", error);
-        this.cachedContextSize = 128e3;
-        return 128e3;
-      }
-    }
-    this.cachedContextSize = this.config.contextWindowSize;
-    return this.config.contextWindowSize;
-  }
-  async prepare(signal) {
-    const contextWindowSize = await this.getContextWindowSize();
-    const totalBudget = contextWindowSize - this.config.outputReserve;
-    this.episodes = await this.config.episodeStore.getEpisodesByTask(this.config.taskId);
-    const filesBeingTouched = this.extractFilesBeingTouched();
-    const systemTokens = estimateTokens(this.config.systemPrompt);
-    const memoryBudget = Math.min(Math.floor(totalBudget * 0.15), 4e3);
-    const memoryMessages = await this.config.memory.retrieve(memoryBudget, { filesBeingTouched });
-    const memoryTokens = estimateMessagesTokens(memoryMessages);
-    const episodeMessages = this.buildEpisodeSummaries();
-    let episodeTokens = estimateMessagesTokens(episodeMessages);
-    let turnMessages = this.buildTurnMessages();
-    let conversationTokens = estimateMessagesTokens(turnMessages);
-    let totalUsed = systemTokens + memoryTokens + episodeTokens + conversationTokens;
-    if (totalUsed > totalBudget * 0.6) {
-      turnMessages = this.compressTemplate(turnMessages);
-      conversationTokens = estimateMessagesTokens(turnMessages);
-      totalUsed = systemTokens + memoryTokens + episodeTokens + conversationTokens;
-    }
-    const episodeBudget = Math.floor(totalBudget * 0.2);
-    if (episodeTokens > episodeBudget && this.episodes.length > 10) {
-      const grouped = this.groupEpisodeSummaries();
-      episodeTokens = estimateMessagesTokens(grouped);
-      episodeMessages.length = 0;
-      episodeMessages.push(...grouped);
-      totalUsed = systemTokens + memoryTokens + episodeTokens + conversationTokens;
-    }
-    if (totalUsed > totalBudget * 0.8 && signal) {
-      try {
-        turnMessages = await this.compressLLM(turnMessages, signal);
-        conversationTokens = estimateMessagesTokens(turnMessages);
-        totalUsed = systemTokens + memoryTokens + episodeTokens + conversationTokens;
-      } catch {
-      }
-    }
-    const finalMemoryMessages = await this.config.memory.retrieve(memoryBudget, { filesBeingTouched });
-    const finalMemoryTokens = estimateMessagesTokens(finalMemoryMessages);
-    const messages = [
-      ...finalMemoryMessages,
-      ...episodeMessages,
-      ...turnMessages
-    ];
-    const budget = {
-      limit: totalBudget,
-      used: systemTokens + finalMemoryTokens + episodeTokens + conversationTokens,
-      layers: {
-        system: systemTokens,
-        memories: finalMemoryTokens,
-        episodes: episodeTokens,
-        conversation: conversationTokens
-      }
-    };
-    const statusText = `[Context: ${Math.round(budget.used / 1e3)}K/${Math.round(budget.limit / 1e3)}K tokens | system: ${Math.round(budget.layers.system / 1e3)}K | memories: ${Math.round(budget.layers.memories / 1e3)}K | episodes: ${Math.round(budget.layers.episodes / 1e3)}K | conversation: ${Math.round(budget.layers.conversation / 1e3)}K]`;
-    messages.push({ role: "system", content: statusText });
-    return { messages, budget };
-  }
-  recordTurn(turn) {
-    this.turns.push(turn);
-  }
-  async budget() {
-    const contextWindowSize = await this.getContextWindowSize();
-    const totalBudget = contextWindowSize - this.config.outputReserve;
-    const systemTokens = estimateTokens(this.config.systemPrompt);
-    let conversationTokens = 0;
-    for (const turn of this.turns) {
-      conversationTokens += turn.tokenEstimate;
-    }
-    let episodeTokens = 0;
-    for (const ep of this.episodes) {
-      episodeTokens += estimateTokens(ep.summary);
-    }
-    return {
-      limit: totalBudget,
-      used: systemTokens + conversationTokens + episodeTokens,
-      layers: {
-        system: systemTokens,
-        memories: 0,
-        episodes: episodeTokens,
-        conversation: conversationTokens
-      }
-    };
-  }
-  addEpisode(episode) {
-    this.episodes.push(episode);
-  }
-  extractFilesBeingTouched() {
-    const files = /* @__PURE__ */ new Set();
-    for (const ep of this.episodes) {
-      for (const f of ep.filesModified) files.add(f);
-      for (const f of ep.filesRead) files.add(f);
-    }
-    for (const turn of this.turns.slice(-5)) {
-      for (const msg of turn.messages) {
-        const text = typeof msg.content === "string" ? msg.content : getTextContent(msg.content);
-        const pathMatches = text.match(/(?:\/[\w.-]+)+\.\w+/g);
-        if (pathMatches) {
-          for (const p of pathMatches) files.add(p);
-        }
-      }
-    }
-    return [...files];
-  }
-  buildEpisodeSummaries() {
-    if (this.episodes.length === 0) return [];
-    const episodeText = this.episodes.map((e) => `Episode ${e.index} [${e.id}] (${e.success ? "ok" : "failed"}):
-${e.summary}`).join("\n\n");
-    return [{
-      role: "system",
-      content: `Prior episodes for this task:
-${episodeText}`
-    }];
-  }
-  buildTurnMessages() {
-    const messages = [];
-    for (const turn of this.turns) {
-      messages.push(...turn.messages);
-    }
-    return messages;
-  }
-  compressTemplate(messages) {
-    if (messages.length <= 6) return messages;
-    const result = [];
-    const recentCount = Math.min(6, Math.ceil(messages.length * 0.3));
-    const oldMessages = messages.slice(0, -recentCount);
-    const recentMessages = messages.slice(-recentCount);
-    for (const msg of oldMessages) {
-      if (msg.role === "tool") {
-        const text = typeof msg.content === "string" ? msg.content : getTextContent(msg.content);
-        const truncated = text.length > 500 ? text.slice(0, 500) + "..." : text;
-        const compressed = { ...msg, content: truncated };
-        if (msg.toolResults) {
-          compressed.toolResults = msg.toolResults.map((tr) => ({
-            ...tr,
-            result: tr.result.length > 500 ? tr.result.slice(0, 500) + "..." : tr.result
-          }));
-        }
-        result.push(compressed);
-      } else if (msg.role === "assistant") {
-        const text = typeof msg.content === "string" ? msg.content : getTextContent(msg.content);
-        const oneLiner = text.length > 200 ? text.slice(0, 200) + "..." : text;
-        result.push({
-          ...msg,
-          content: oneLiner
-        });
-      } else {
-        result.push(msg);
-      }
-    }
-    result.push(...recentMessages);
-    return result;
-  }
-  groupEpisodeSummaries() {
-    if (this.episodes.length <= 10) return this.buildEpisodeSummaries();
-    const oldEpisodes = this.episodes.slice(0, -5);
-    const recentEpisodes = this.episodes.slice(-5);
-    const groupSummary = [
-      `Grouped summary of ${oldEpisodes.length} earlier episodes:`,
-      `  Successful: ${oldEpisodes.filter((e) => e.success).length}`,
-      `  Failed: ${oldEpisodes.filter((e) => !e.success).length}`,
-      `  Files modified: ${[...new Set(oldEpisodes.flatMap((e) => e.filesModified))].join(", ")}`,
-      `  Actions: ${oldEpisodes.map((e) => e.threadAction.slice(0, 60)).join("; ")}`
-    ].join("\n");
-    const recentText = recentEpisodes.map((e) => `Episode ${e.index} [${e.id}] (${e.success ? "ok" : "failed"}):
-${e.summary}`).join("\n\n");
-    return [{
-      role: "system",
-      content: `${groupSummary}
-
-Recent episodes:
-${recentText}`
-    }];
-  }
-  async compressLLM(messages, signal) {
-    if (messages.length <= 10) return messages;
-    const splitPoint = Math.floor(messages.length / 2);
-    const toSummarize = messages.slice(0, splitPoint);
-    const toKeep = messages.slice(splitPoint);
-    const textToSummarize = toSummarize.map((m) => {
-      const text = typeof m.content === "string" ? m.content : getTextContent(m.content);
-      return `[${m.role}] ${text.slice(0, 300)}`;
-    }).join("\n");
-    const fastModel = resolveModel("fast", DEFAULT_MODEL_MAP, DEFAULT_MODEL_MAP.fast);
-    const result = await generateText({
-      model: (this.config.createModel ?? anthropic)(fastModel),
-      system: "Summarize this conversation history into a concise context summary. Preserve key decisions, outcomes, and any information needed to continue the conversation. Keep under 500 words.",
-      messages: [{ role: "user", content: textToSummarize.slice(0, 8e3) }],
-      abortSignal: signal
-    });
-    const summaryMessage = {
-      role: "system",
-      content: `[Compressed conversation history]
-${result.text}`
-    };
-    return [summaryMessage, ...toKeep];
-  }
-};
-var TOPIC_MAP = [
-  [/\bapi\b/i, "api-rules"],
-  [/\bauth\b/i, "auth"],
-  [/\btest/i, "testing"],
-  [/\bbuild\b|\bci\b|\bpipeline\b/i, "build"],
-  [/\bdeploy/i, "deployment"],
-  [/\bdb\b|\bmigrat/i, "database"],
-  [/\bstyle|\.css|\.scss/i, "styling"],
-  [/\bconfig/i, "config"]
-];
-function matchTopics(filesBeingTouched) {
-  const topics = /* @__PURE__ */ new Set();
-  for (const file of filesBeingTouched) {
-    for (const [pattern, topic] of TOPIC_MAP) {
-      if (pattern.test(file)) {
-        topics.add(topic);
-      }
-    }
-  }
-  return topics;
-}
-var MemoryManager = class {
-  memoStore;
-  ltStore;
-  sessionId;
-  constructor(config) {
-    this.memoStore = config.sessionMemoStore;
-    this.ltStore = config.longTermStore;
-    this.sessionId = config.sessionId;
-  }
-  async store(content, opts) {
-    const scope = opts?.scope ?? "session";
-    if (scope === "persistent") {
-      const id2 = randomUUID();
-      const now = Date.now();
-      const memory = {
-        id: id2,
-        content,
-        category: opts?.category ?? "fact",
-        sourceSessionMemoIds: [],
-        createdAt: now,
-        updatedAt: now
-      };
-      await this.ltStore.addMemory(memory);
-      return id2;
-    }
-    const existing = this.memoStore.getMemoBySession ? await this.memoStore.getMemoBySession(this.sessionId) : (await this.memoStore.getMemosBySession(this.sessionId))[0] ?? null;
-    const createdAt = existing?.createdAt ?? Date.now();
-    const updatedAt = Date.now();
-    const combinedContent = existing?.content ? `${existing.content}
-${content}` : content;
-    const id = this.sessionId;
-    const memo = {
-      id,
-      sessionId: this.sessionId,
-      content: combinedContent,
-      sourceEpisodeIds: [],
-      createdAt,
-      updatedAt
-    };
-    await this.memoStore.addMemo(memo);
-    return id;
-  }
-  async retrieve(budget, context) {
-    const messages = [];
-    let used = 0;
-    const allMemories = await this.ltStore.getAllMemories();
-    const indexMemories = allMemories.filter((m) => m.category === "index");
-    const indexBudget = Math.min(budget * 0.15, 2e3);
-    if (indexMemories.length > 0) {
-      const indexText = indexMemories.map((m) => m.content).join("\n");
-      const tokens = estimateTokens(indexText);
-      if (tokens <= indexBudget) {
-        messages.push({ role: "system", content: `[Memory Index]
-${indexText}` });
-        used += tokens;
-      }
-    }
-    if (context.filesBeingTouched && context.filesBeingTouched.length > 0) {
-      const topics = matchTopics(context.filesBeingTouched);
-      const topicBudget = Math.min((budget - used) * 0.3, 4e3);
-      let topicUsed = 0;
-      for (const topic of topics) {
-        if (topicUsed >= topicBudget) break;
-        const topicMemories = allMemories.filter((m) => m.category === topic);
-        for (const mem of topicMemories) {
-          const tokens = estimateTokens(mem.content);
-          if (topicUsed + tokens > topicBudget) break;
-          messages.push({ role: "system", content: `[Memory: ${topic}]
-${mem.content}` });
-          topicUsed += tokens;
-          used += tokens;
-        }
-      }
-    }
-    const remaining = budget - used;
-    if (remaining > 0) {
-      const sid = context.sessionId ?? this.sessionId;
-      const memo = this.memoStore.getMemoBySession ? await this.memoStore.getMemoBySession(sid) : (await this.memoStore.getMemosBySession(sid))[0] ?? null;
-      if (memo) {
-        const memoBudget = remaining * 0.5;
-        const tokens = estimateTokens(memo.content);
-        if (tokens <= memoBudget) {
-          messages.push({ role: "system", content: `[Session Memo]
-${memo.content}` });
-          used += tokens;
-        }
-      }
-      const alreadyCategories = /* @__PURE__ */ new Set([
-        "index",
-        ...context.filesBeingTouched ? matchTopics(context.filesBeingTouched) : []
-      ]);
-      const ltByRecency = allMemories.filter((m) => !alreadyCategories.has(m.category)).sort((a, b) => b.updatedAt - a.updatedAt);
-      for (const mem of ltByRecency) {
-        const tokens = estimateTokens(mem.content);
-        if (used + tokens > budget) break;
-        messages.push({ role: "system", content: `[Memory: ${mem.category}]
-${mem.content}` });
-        used += tokens;
-      }
-    }
-    return messages;
-  }
-  async detectAndPromote(episodes) {
-    if (episodes.length < 2) return;
-    const fileFreq = /* @__PURE__ */ new Map();
-    const errorPatterns = /* @__PURE__ */ new Map();
-    for (const ep of episodes) {
-      for (const f of ep.filesModified) {
-        fileFreq.set(f, (fileFreq.get(f) ?? 0) + 1);
-      }
-      if (!ep.success) {
-        const normalized = ep.threadAction.toLowerCase().slice(0, 100);
-        errorPatterns.set(normalized, (errorPatterns.get(normalized) ?? 0) + 1);
-      }
-    }
-    const frequentFiles = [...fileFreq.entries()].filter(([, count]) => count >= 3);
-    if (frequentFiles.length > 0) {
-      const content = `Frequently modified files:
-${frequentFiles.map(([f, n]) => `  ${f} (${n}x)`).join("\n")}`;
-      await this.store(content, { category: "pattern", scope: "session" });
-    }
-    const repeatedErrors = [...errorPatterns.entries()].filter(([, count]) => count >= 2);
-    if (repeatedErrors.length > 0) {
-      const content = `Common failure patterns:
-${repeatedErrors.map(([action, n]) => `  "${action}" failed ${n}x`).join("\n")}`;
-      await this.store(content, { category: "pattern", scope: "session" });
-    }
-  }
-  async compact() {
-    const allMemories = await this.ltStore.getAllMemories();
-    if (allMemories.length < 2) return { removed: 0, merged: 0 };
-    let removed = 0;
-    let merged = 0;
-    const keywordSets = allMemories.map((m) => {
-      const words = m.content.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
-      return new Set(words);
-    });
-    const toRemove = /* @__PURE__ */ new Set();
-    for (let i = 0; i < allMemories.length; i++) {
-      if (toRemove.has(allMemories[i].id)) continue;
-      for (let j = i + 1; j < allMemories.length; j++) {
-        if (toRemove.has(allMemories[j].id)) continue;
-        const setA = keywordSets[i];
-        const setB = keywordSets[j];
-        const intersection = [...setA].filter((w) => setB.has(w)).length;
-        const union = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
-        const overlap = union > 0 ? intersection / union : 0;
-        if (overlap > 0.7) {
-          const keepIdx = allMemories[i].updatedAt >= allMemories[j].updatedAt ? i : j;
-          const removeIdx = keepIdx === i ? j : i;
-          toRemove.add(allMemories[removeIdx].id);
-          merged++;
-        }
-      }
-    }
-    const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1e3;
-    for (const mem of allMemories) {
-      if (mem.category === "session-summary" && mem.updatedAt < thirtyDaysAgo) {
-        toRemove.add(mem.id);
-      }
-    }
-    for (const id of toRemove) {
-      await this.ltStore.deleteMemory(id);
-      removed++;
-    }
-    return { removed, merged };
-  }
-};
-async function consolidateEpisodes(episodes, sessionId, sessionMemoStore) {
-  if (episodes.length === 0) {
-    throw new Error("Cannot consolidate zero episodes");
-  }
-  const filesModified = /* @__PURE__ */ new Set();
-  const toolsUsed = /* @__PURE__ */ new Set();
-  const actions = [];
-  let successCount = 0;
-  for (const ep of episodes) {
-    for (const f of ep.filesModified) filesModified.add(f);
-    for (const t of ep.toolCalls) toolsUsed.add(t);
-    actions.push(`${ep.index}. ${ep.threadAction} (${ep.success ? "ok" : "failed"})`);
-    if (ep.success) successCount++;
-  }
-  const parts = [
-    `Task summary (${episodes.length} threads, ${successCount} succeeded):`,
-    ...actions
-  ];
-  if (filesModified.size > 0) {
-    parts.push(`Files modified: ${[...filesModified].join(", ")}`);
-  }
-  if (toolsUsed.size > 0) {
-    parts.push(`Tools used: ${[...toolsUsed].join(", ")}`);
-  }
-  const existing = sessionMemoStore.getMemoBySession ? await sessionMemoStore.getMemoBySession(sessionId) : (await sessionMemoStore.getMemosBySession(sessionId))[0] ?? null;
-  const createdAt = existing?.createdAt ?? Date.now();
-  const updatedAt = Date.now();
-  const memo = {
-    id: sessionId,
-    sessionId,
-    content: parts.join("\n"),
-    sourceEpisodeIds: episodes.map((e) => e.id),
-    createdAt,
-    updatedAt
-  };
-  await sessionMemoStore.addMemo(memo);
-  return memo;
-}
-async function runConsolidation(_taskId, sessionId, episodeStore, sessionMemoStore, _longTermStore) {
-  const episodes = await episodeStore.getEpisodesBySession(sessionId);
-  if (episodes.length > 0) {
-    await consolidateEpisodes(episodes, sessionId, sessionMemoStore);
-  }
-}
-var routeSchema = z.object({
-  skillName: z.string().nullable(),
-  confidence: z.number().min(0).max(1),
-  rationale: z.string()
-});
-var DEFAULT_ALIASES = {
-  xlsx: ["excel", "spreadsheet", "workbook", "csv"],
-  docx: ["word", "document", "doc"],
-  pptx: ["powerpoint", "slides", "presentation"],
-  "visual-explainer": ["visual explainer", "visual explanation", "interactive visual", "visualize", "diagram d3", "data visualization", "d3"],
-  "excalidraw-diagram": ["excalidraw", "architecture diagram", "flowchart", "sequence diagram"],
-  "json-render": ["jsonrender", "interactive ui", "action buttons"]
-};
-var SkillRouter = class {
-  model;
-  createModel;
-  minConfidence;
-  aliases;
-  constructor(config = {}) {
-    this.model = config.model ?? process.env.HARNESS_SKILL_ROUTER_MODEL ?? "claude-3-5-haiku-latest";
-    this.createModel = config.createModel ?? anthropic;
-    this.minConfidence = config.minConfidence ?? Number(process.env.HARNESS_SKILL_ROUTER_THRESHOLD ?? "0.55");
-    this.aliases = {
-      ...DEFAULT_ALIASES,
-      ...config.aliases ?? {}
-    };
-  }
-  async selectSkill(prompt, summaries) {
-    if (summaries.length === 0) return null;
-    const lower = prompt.toLowerCase();
-    const direct = summaries.find((skill) => this.containsToken(lower, skill.name.toLowerCase()));
-    if (direct) return direct;
-    for (const summary of summaries) {
-      const aliasList = this.aliases[summary.name.toLowerCase()] ?? [];
-      if (aliasList.some((alias) => this.containsToken(lower, alias.toLowerCase()))) {
-        return summary;
-      }
-    }
-    try {
-      const skillList = summaries.map((s) => `- ${s.name}: ${s.description}`).join("\n");
-      const { object } = await generateObject({
-        model: this.createModel(this.model),
-        schema: routeSchema,
-        system: [
-          "You are a skill router.",
-          "Pick at most one skill name from the provided list.",
-          "Only choose a skill when it clearly helps with the user request.",
-          "If nothing clearly matches, return null skillName and low confidence."
-        ].join(" "),
-        prompt: [
-          "User request:",
-          prompt,
-          "",
-          "Available skills:",
-          skillList,
-          "",
-          "Return one object with skillName, confidence, rationale."
-        ].join("\n")
-      });
-      if (!object.skillName || object.confidence < this.minConfidence) {
-        return null;
-      }
-      return summaries.find((s) => s.name === object.skillName) ?? null;
-    } catch {
-      return null;
-    }
-  }
-  containsToken(haystack, needle) {
-    if (!needle) return false;
-    const escaped = needle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`\\b${escaped}\\b`, "i");
-    return regex.test(haystack);
-  }
-};
-function parseFrontmatter(raw) {
-  if (!raw.startsWith("---\n")) {
-    return { meta: {}, body: raw };
-  }
-  const end = raw.indexOf("\n---\n", 4);
-  if (end === -1) {
-    return { meta: {}, body: raw };
-  }
-  const header = raw.slice(4, end).split("\n");
-  const meta = {};
-  for (const line of header) {
-    const idx = line.indexOf(":");
-    if (idx <= 0) continue;
-    const key = line.slice(0, idx).trim();
-    const value = line.slice(idx + 1).trim().replace(/^"|"$/g, "");
-    meta[key] = value;
-  }
-  return {
-    meta,
-    body: raw.slice(end + 5).trim()
-  };
-}
-async function loadSkillFromFile(path) {
-  const raw = await readFile(path, "utf8");
-  const parsed = parseFrontmatter(raw);
-  const pythonDeps = parsed.meta.python_deps ? parsed.meta.python_deps.split(",").map((item) => item.trim()).filter(Boolean) : [];
-  const npmDeps = parsed.meta.npm_deps ? parsed.meta.npm_deps.split(",").map((item) => item.trim()).filter(Boolean) : [];
-  return {
-    name: parsed.meta.name ?? path.split("/").slice(-2, -1)[0] ?? "unknown-skill",
-    description: parsed.meta.description ?? "No description provided",
-    path,
-    contextMode: parsed.meta.context === "fork" ? "fork" : "inline",
-    dependencies: {
-      python: pythonDeps,
-      npm: npmDeps
-    },
-    instructions: parsed.body
-  };
-}
-
-// src/arc/skill-resolver.ts
-var DefaultSkillResolver = class {
-  router;
-  summariesPromise;
-  summaries = null;
-  constructor(config) {
-    this.router = new SkillRouter(config.routerConfig);
-    this.summariesPromise = import('fs/promises').then((fs) => fs.readFile(config.skillIndexPath, "utf-8")).then((raw) => JSON.parse(raw)).catch(() => []);
-  }
-  async resolve(action, profileSkills) {
-    if (!this.summaries) {
-      this.summaries = await this.summariesPromise;
-    }
-    if (this.summaries.length === 0) return null;
-    const candidates = profileSkills ? this.summaries.filter((s) => profileSkills.includes(s.name)) : this.summaries;
-    if (candidates.length === 0) return null;
-    const matched = await this.router.selectSkill(action, candidates);
-    if (matched) {
-      console.log(`[skill-resolver] Matched skill "${matched.name}" for action: "${action.slice(0, 80)}..."`);
-    } else {
-      console.log(`[skill-resolver] No match for action: "${action.slice(0, 80)}..."`);
-    }
-    if (!matched) return null;
-    try {
-      const skill = await loadSkillFromFile(matched.path);
-      console.log(`[skill-resolver] Loaded skill "${matched.name}" (${skill.instructions?.length ?? 0} chars) path: ${matched.path}`);
-      if (!skill.instructions) return null;
-      const subGuides = {};
-      const linkPattern = /\[([^\]]+)\]\(([^)]+\.md)\)/g;
-      let m;
-      const dir = dirname(resolve(matched.path));
-      while ((m = linkPattern.exec(skill.instructions)) !== null) {
-        const file = m[2];
-        if (subGuides[file]) continue;
-        try {
-          const content = await readFile(resolve(dir, file), "utf8");
-          subGuides[file] = content;
-          console.log(`[skill-resolver] Pre-read sub-guide "${file}" (${content.length} chars)`);
-        } catch {
-        }
-      }
-      return {
-        name: matched.name,
-        systemPrompt: skill.instructions,
-        path: matched.path,
-        ...Object.keys(subGuides).length > 0 ? { subGuides } : {}
-      };
-    } catch (err) {
-      console.error(`[skill-resolver] Failed to load skill "${matched.name}":`, err);
-      return null;
-    }
-  }
-};
-function extractToolNames(messages) {
-  const names = /* @__PURE__ */ new Set();
-  for (const msg of messages) {
-    if (msg.role === "assistant" && msg.toolCalls) {
-      for (const tc of msg.toolCalls) {
-        names.add(tc.toolName);
-      }
-    }
-  }
-  return [...names];
-}
-function extractFilesRead(messages) {
-  const paths = /* @__PURE__ */ new Set();
-  for (const msg of messages) {
-    if (msg.role === "assistant" && msg.toolCalls) {
-      for (const tc of msg.toolCalls) {
-        if (tc.toolName === "Read" && tc.args.path) {
-          paths.add(String(tc.args.path));
-        }
-      }
-    }
-  }
-  return [...paths];
-}
-function extractFilesModified(messages) {
-  const paths = /* @__PURE__ */ new Set();
-  for (const msg of messages) {
-    if (msg.role === "assistant" && msg.toolCalls) {
-      for (const tc of msg.toolCalls) {
-        if ((tc.toolName === "Write" || tc.toolName === "Edit") && tc.args.path) {
-          paths.add(String(tc.args.path));
-        }
-      }
-    }
-  }
-  return [...paths];
-}
-function countSteps(messages) {
-  return messages.filter((m) => m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0).length;
-}
-function extractFinalOutput(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role === "assistant" && (!msg.toolCalls || msg.toolCalls.length === 0)) {
-      return getTextContent(msg.content).slice(0, 200);
-    }
-  }
-  return "";
-}
-function templateSummary(threadAction, messages, success) {
-  const toolNames = extractToolNames(messages);
-  const filesRead = extractFilesRead(messages);
-  const filesModified = extractFilesModified(messages);
-  const finalOutput = extractFinalOutput(messages);
-  const steps = countSteps(messages);
-  const parts = [
-    `Action: ${threadAction}`,
-    `Status: ${success ? "success" : "failed"}`,
-    `Steps: ${steps}`
-  ];
-  if (toolNames.length > 0) {
-    parts.push(`Tools used: ${toolNames.join(", ")}`);
-  }
-  if (filesRead.length > 0) {
-    parts.push(`Files read: ${filesRead.slice(0, 10).join(", ")}${filesRead.length > 10 ? ` (+${filesRead.length - 10} more)` : ""}`);
-  }
-  if (filesModified.length > 0) {
-    parts.push(`Files modified: ${filesModified.join(", ")}`);
-  }
-  if (finalOutput) {
-    parts.push(`Result: ${finalOutput}`);
-  }
-  return parts.join("\n");
-}
-function extractArtifacts(messages) {
-  const artifacts = [];
-  for (const msg of messages) {
-    if (msg.role === "tool" && msg.toolResults) {
-      for (const tr of msg.toolResults) {
-        if (tr.isError) {
-          artifacts.push({
-            key: `error_${tr.toolName}`,
-            content: tr.result.slice(0, 2e3)
-          });
-        }
-      }
-    }
-  }
-  for (const msg of messages) {
-    if (msg.role === "assistant" && msg.toolCalls) {
-      for (const tc of msg.toolCalls) {
-        if ((tc.toolName === "Write" || tc.toolName === "Edit") && tc.args.path) {
-          const filename = String(tc.args.path).split("/").pop() ?? String(tc.args.path);
-          const preview = tc.toolName === "Edit" ? `old: ${String(tc.args.old_text ?? "").slice(0, 200)}
-new: ${String(tc.args.new_text ?? "").slice(0, 200)}` : String(tc.args.content ?? "").slice(0, 400);
-          artifacts.push({
-            key: `edit_${filename}`,
-            content: `${tc.args.path}
-${preview}`
-          });
-        }
-      }
-    }
-  }
-  const finalOutput = extractFinalOutput(messages);
-  if (finalOutput) {
-    artifacts.push({
-      key: "final_output",
-      content: finalOutput
-    });
-  }
-  return artifacts;
-}
-var EpisodeCompressor = class {
-  createModel;
-  constructor(createModel) {
-    this.createModel = createModel ?? anthropic;
-  }
-  compress(input) {
-    const now = Date.now();
-    const id = randomUUID();
-    const episode = {
-      id,
-      taskId: input.taskId,
-      sessionId: input.sessionId,
-      index: input.index,
-      threadAction: input.threadAction,
-      summary: templateSummary(input.threadAction, input.messages, input.success),
-      toolCalls: extractToolNames(input.messages),
-      filesRead: extractFilesRead(input.messages),
-      filesModified: extractFilesModified(input.messages),
-      model: input.model,
-      steps: countSteps(input.messages),
-      success: input.success,
-      createdAt: now,
-      parentEpisodeIds: input.parentEpisodeIds
-    };
-    const trace = {
-      episodeId: id,
-      messages: input.messages,
-      createdAt: now
-    };
-    const artifacts = extractArtifacts(input.messages);
-    return { episode, trace, artifacts };
-  }
-  async compressLLM(input, signal) {
-    const result = this.compress(input);
-    if (countSteps(input.messages) <= 10) {
-      return result;
-    }
-    try {
-      const conversationText = input.messages.map((m) => {
-        const text = typeof m.content === "string" ? m.content : getTextContent(m.content);
-        if (m.role === "assistant" && m.toolCalls?.length) {
-          const calls = m.toolCalls.map((tc) => `${tc.toolName}(${JSON.stringify(tc.args).slice(0, 100)})`).join(", ");
-          return `[assistant] ${text}
-  tools: ${calls}`;
-        }
-        if (m.role === "tool" && m.toolResults?.length) {
-          const results = m.toolResults.map((tr) => `${tr.toolName}: ${tr.result.slice(0, 200)}`).join("; ");
-          return `[tool] ${results}`;
-        }
-        return `[${m.role}] ${text.slice(0, 300)}`;
-      }).join("\n");
-      const fastModel = resolveModel("fast", DEFAULT_MODEL_MAP, DEFAULT_MODEL_MAP.fast);
-      const llmResult = await generateText({
-        model: this.createModel(fastModel),
-        system: "Summarize this agent conversation into a concise episode summary. Focus on: what was attempted, what tools were used, what files were changed, and the outcome. Keep it under 300 words.",
-        messages: [{ role: "user", content: conversationText.slice(0, 8e3) }],
-        abortSignal: signal
-      });
-      if (llmResult.text) {
-        result.episode.summary = llmResult.text;
-      }
-    } catch {
-    }
-    return result;
-  }
-};
-
-// src/arc/utils.ts
-function normalizeTools(tools) {
-  const out = {};
-  for (const [name, t] of Object.entries(tools)) {
-    if (t.parameters && !t.inputSchema) {
-      out[name] = { ...t, inputSchema: t.parameters };
-    } else {
-      out[name] = t;
-    }
-  }
-  return out;
-}
-function pickDefined(obj, keys) {
-  const result = {};
-  for (const key of keys) {
-    if (obj[key] != null) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}
-
-// src/arc/agent-runner.ts
-function createChannel() {
-  const buffer = [];
-  let closed = false;
-  let resolve = null;
-  return {
-    push(value) {
-      if (closed) return;
-      buffer.push(value);
-      if (resolve) {
-        const r = resolve;
-        resolve = null;
-        r();
-      }
-    },
-    close() {
-      closed = true;
-      if (resolve) {
-        const r = resolve;
-        resolve = null;
-        r();
-      }
-    },
-    async *[Symbol.asyncIterator]() {
-      let index = 0;
-      while (true) {
-        while (index < buffer.length) {
-          yield buffer[index];
-          index++;
-        }
-        if (closed) return;
-        await new Promise((r) => {
-          resolve = r;
-        });
-      }
-    }
-  };
-}
-var DEFAULT_PAGE_THRESHOLD = 4e3;
-var READ_FULL_RESULT_HARD_CAP = 32e3;
-function extractStepUsage(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;
-}
-var PROCESS_SYSTEM_PROMPT = [
-  "You are a focused execution thread within a larger agent system.",
-  "Complete the assigned task using the available tools.",
-  "Be efficient \u2014 accomplish the objective with minimal steps.",
-  "If your context includes the user's original message or attachment metadata, use that information directly.",
-  "When done, provide a brief summary of what you accomplished."
-].join(" ");
-async function executeBuiltinTool(provider, action, runtime) {
-  switch (action.name) {
-    case "Bash":
-      return provider.bash(String(action.args.command ?? ""), {
-        cwd: action.args.cwd,
-        timeout: action.args.timeout
-      });
-    case "Read":
-      return provider.readFile(String(action.args.path ?? ""));
-    case "Write":
-      return provider.writeFile(String(action.args.path ?? ""), String(action.args.content ?? ""));
-    case "Edit":
-      return provider.editFile(
-        String(action.args.path ?? ""),
-        String(action.args.old_text ?? ""),
-        String(action.args.new_text ?? "")
-      );
-    case "Glob":
-      return provider.glob(String(action.args.pattern ?? ""));
-    case "Grep":
-      return provider.grep(String(action.args.pattern ?? ""), action.args.path);
-    case "WebFetch":
-      if (!provider.webFetch) return { success: false, output: "", error: "WebFetch unavailable" };
-      return provider.webFetch({
-        url: String(action.args.url ?? ""),
-        selector: action.args.selector,
-        maxContentLength: action.args.maxContentLength
-      });
-    case "WebSearch":
-      if (!provider.webSearch) return { success: false, output: "", error: "WebSearch unavailable" };
-      return provider.webSearch(String(action.args.query ?? ""));
-    case "AskUser":
-      if (!runtime.askUser) return { success: false, output: "", error: "AskUser unavailable" };
-      return { success: true, output: await runtime.askUser(String(action.args.question ?? ""), Array.isArray(action.args.options) ? action.args.options.map(String) : void 0) };
-    case "TellUser":
-      if (!runtime.tellUser) return { success: false, output: "", error: "TellUser unavailable" };
-      await runtime.tellUser(String(action.args.message ?? ""));
-      return { success: true, output: "ok" };
-    case "DownloadRawFile":
-      if (!runtime.downloadRawFile) return { success: false, output: "", error: "DownloadRawFile unavailable" };
-      return { success: true, output: await runtime.downloadRawFile(String(action.args.path ?? "")) };
-    default:
-      return { success: false, output: "", error: `Unknown tool: ${action.name}` };
-  }
-}
-async function executeTool(action, provider, runtime) {
-  if (runtime.hookRunner) {
-    const pre = await runtime.hookRunner.run({ event: "PreToolUse", toolName: action.name, input: action.args });
-    if (!pre.allow) {
-      return { success: false, output: "", error: pre.reason ?? "blocked by pre-hook" };
-    }
-  }
-  if (runtime.permissionManager) {
-    const permission = await runtime.permissionManager.check({ toolName: action.name, input: action.args });
-    if (!permission.allow) {
-      return { success: false, output: "", error: permission.reason ?? "blocked by permission manager" };
-    }
-  }
-  if (runtime.executeToolAction) {
-    const result2 = await runtime.executeToolAction(action);
-    if (result2) {
-      if (runtime.hookRunner) {
-        await runtime.hookRunner.run({ event: "PostToolUse", toolName: action.name, input: action.args, output: result2 });
-      }
-      return result2;
-    }
-  }
-  const result = await executeBuiltinTool(provider, action, runtime);
-  if (runtime.hookRunner) {
-    await runtime.hookRunner.run({ event: "PostToolUse", toolName: action.name, input: action.args, output: result });
-  }
-  return result;
-}
-var AgentRunner = class {
-  async run(config) {
-    const stream = this.stream(config);
-    while (true) {
-      const next = await stream.next();
-      if (next.done) return next.value;
-    }
-  }
-  async *stream(config) {
-    const messages = [
-      ...config.seed ?? [],
-      { role: "user", content: config.prompt }
-    ];
-    const systemContent = config.contextFacts?.length ? config.systemPrompt + "\n\n## Known Facts\n" + config.contextFacts.map((f) => `- ${f}`).join("\n") : config.systemPrompt;
-    const cachedSystem = [{
-      role: "system",
-      content: systemContent
-    }];
-    const pageThreshold = config.resultPageThreshold ?? DEFAULT_PAGE_THRESHOLD;
-    const pagingExcludeSet = new Set(config.pagingExclude ?? []);
-    const effectiveTools = config.resultPager ? {
-      ...config.tools,
-      ReadFullResult: tool({
-        description: "Retrieve the full content of a paged tool result. Use when the summary is insufficient and you need the complete data.",
-        inputSchema: z.object({
-          ref: z.string().describe("The paged result reference from a previous tool output"),
-          lineRange: z.object({
-            start: z.number().int().min(1).describe("Start line (1-indexed, inclusive)"),
-            end: z.number().int().min(1).describe("End line (1-indexed, inclusive)")
-          }).optional().describe("Optional line range to retrieve. Omit for full content.")
-        })
-      })
-    } : config.tools;
-    for (let step = 0; step < config.maxSteps; step++) {
-      config.signal.throwIfAborted();
-      yield { type: "step_start", step: step + 1 };
-      if (config.inbox) {
-        for await (const msg of drainNonBlocking(config.inbox)) {
-          messages.push(msg);
-        }
-      }
-      if (config.maxContextTokens && step > 0) {
-        trimContext(messages, config.maxContextTokens);
-      }
-      const result = streamText({
-        model: (config.createModel ?? anthropic)(config.model),
-        tools: normalizeTools(effectiveTools),
-        toolChoice: resolveToolChoice(config.toolChoice, step),
-        messages: toModelMessages(messages),
-        system: cachedSystem,
-        abortSignal: config.signal,
-        stopWhen: stepCountIs(1)
-      });
-      const toolCalls = [];
-      let finalText = "";
-      for await (const part of result.fullStream) {
-        if (part.type === "text-delta") {
-          finalText += part.text;
-          yield { type: "text_delta", text: part.text };
-        }
-        if (part.type === "tool-call") {
-          const raw = part;
-          toolCalls.push({
-            toolName: raw.toolName,
-            input: raw.args ?? raw.input ?? {},
-            ...raw.toolCallId != null ? { toolCallId: raw.toolCallId } : {},
-            ...raw.providerMetadata || raw.experimental_providerMetadata ? { providerMetadata: raw.providerMetadata ?? raw.experimental_providerMetadata } : {}
-          });
-        }
-      }
-      let usage;
-      try {
-        usage = extractStepUsage(await result.usage);
-      } catch {
-        usage = void 0;
-      }
-      if (toolCalls.length === 0) {
-        const rawText = finalText.trim();
-        if (!rawText && step === 0) {
-          const text2 = "ERROR: LLM returned empty response with no tool calls on first step. This may indicate an API billing issue, authentication error, or rate limit.";
-          messages.push({ role: "assistant", content: text2 });
-          yield usage ? { type: "step_end", step: step + 1, usage } : { type: "step_end", step: step + 1 };
-          return { messages, output: text2, steps: step + 1 };
-        }
-        const text = rawText || "Done.";
-        messages.push({ role: "assistant", content: text });
-        if (config.hookRunner) {
-          const decision = await config.hookRunner.run({
-            event: "RunComplete",
-            metadata: {
-              messages,
-              steps: step + 1,
-              output: text
-            }
-          });
-          if (!decision.allow) {
-            messages.push({
-              role: "user",
-              content: decision.reason ?? "Continue \u2014 a required post-completion step was not performed."
-            });
-            yield usage ? { type: "step_end", step: step + 1, usage } : { type: "step_end", step: step + 1 };
-            continue;
-          }
-        }
-        if (config.outputSchema) {
-          try {
-            const extractionMessages = [
-              ...messages,
-              { role: "user", content: "Extract the structured output from your response above." }
-            ];
-            const structured = await generateObject({
-              model: (config.createModel ?? anthropic)(config.model),
-              schema: config.outputSchema,
-              messages: toModelMessages(extractionMessages),
-              system: config.systemPrompt,
-              abortSignal: config.signal
-            });
-            yield usage ? { type: "step_end", step: step + 1, usage } : { type: "step_end", step: step + 1 };
-            return { messages, output: text, steps: step + 1, structuredOutput: structured.object };
-          } catch {
-          }
-        }
-        yield usage ? { type: "step_end", step: step + 1, usage } : { type: "step_end", step: step + 1 };
-        return { messages, output: text, steps: step + 1 };
-      }
-      const toolCallInfos = toolCalls.map((tc) => {
-        const info = {
-          toolCallId: tc.toolCallId ?? randomUUID(),
-          toolName: tc.toolName,
-          args: tc.input ?? {}
-        };
-        if (tc.providerMetadata) {
-          info.providerMetadata = tc.providerMetadata;
-        }
-        return info;
-      });
-      messages.push({
-        role: "assistant",
-        content: finalText || toolCalls.map((tc) => `${tc.toolName}(${JSON.stringify(tc.input ?? {}).slice(0, 100)})`).join(", "),
-        toolCalls: toolCallInfos
-      });
-      for (let index = 0; index < toolCallInfos.length; index += 1) {
-        const tc = toolCallInfos[index];
-        const action = {
-          type: "tool",
-          name: tc.toolName,
-          args: tc.args,
-          toolCallId: tc.toolCallId
-        };
-        config.onActivity?.({
-          type: "tool_start",
-          name: tc.toolName,
-          args: tc.args,
-          ts: Date.now()
-        });
-        yield { type: "tool_start", name: tc.toolName, args: tc.args, ...tc.toolCallId ? { toolCallId: tc.toolCallId } : {} };
-        if (tc.toolName === "ReadFullResult" && config.resultPager) {
-          const ref = String(tc.args.ref ?? "");
-          const content = await config.resultPager.retrieve(ref);
-          if (!content) {
-            const errorText = "ERROR: Content expired or not found. Use the summary above.";
-            messages.push({
-              role: "tool",
-              content: errorText,
-              toolResults: [{ toolCallId: tc.toolCallId, toolName: tc.toolName, result: errorText, isError: true }]
-            });
-            config.onActivity?.({
-              type: "tool_end",
-              name: tc.toolName,
-              ok: false,
-              ms: 0,
-              preview: "",
-              ts: Date.now()
-            });
-            yield { type: "tool_end", name: tc.toolName, result: { success: false, output: "", error: errorText } };
-            continue;
-          }
-          let output = content;
-          const lr = tc.args.lineRange;
-          if (lr && typeof lr === "object" && "start" in lr && "end" in lr) {
-            const start2 = Number(lr.start);
-            const end = Number(lr.end);
-            if (Number.isFinite(start2) && Number.isFinite(end) && start2 >= 1 && end >= start2) {
-              const lines = content.split("\n");
-              output = lines.slice(start2 - 1, end).join("\n");
-            }
-          }
-          if (output.length > READ_FULL_RESULT_HARD_CAP) {
-            output = output.slice(0, READ_FULL_RESULT_HARD_CAP) + `
-
-[Showing first ${READ_FULL_RESULT_HARD_CAP} of ${output.length} chars. Use lineRange for specific sections.]`;
-          }
-          messages.push({
-            role: "tool",
-            content: output,
-            toolResults: [{ toolCallId: tc.toolCallId, toolName: tc.toolName, result: output, isError: false }]
-          });
-          config.onActivity?.({
-            type: "tool_end",
-            name: tc.toolName,
-            ok: true,
-            ms: 0,
-            preview: output.slice(0, 200),
-            ts: Date.now()
-          });
-          yield { type: "tool_end", name: tc.toolName, result: { success: true, output } };
-          continue;
-        }
-        if (config.allowedToolNames && !config.allowedToolNames.includes(tc.toolName)) {
-          const resultText2 = `ERROR: Tool "${tc.toolName}" is not available in this profile.`;
-          messages.push({
-            role: "tool",
-            content: resultText2,
-            toolResults: [{
-              toolCallId: tc.toolCallId,
-              toolName: tc.toolName,
-              result: resultText2,
-              isError: true
-            }]
-          });
-          config.onActivity?.({
-            type: "tool_end",
-            name: tc.toolName,
-            ok: false,
-            ms: 0,
-            preview: "",
-            ts: Date.now()
-          });
-          yield { type: "tool_end", name: tc.toolName, result: { success: false, output: "", error: resultText2 } };
-          continue;
-        }
-        const start = Date.now();
-        let toolResult;
-        try {
-          toolResult = await executeTool(action, config.toolProvider, {
-            ...config.executeToolAction != null ? { executeToolAction: config.executeToolAction } : {},
-            ...config.hookRunner != null ? { hookRunner: config.hookRunner } : {},
-            ...config.permissionManager != null ? { permissionManager: config.permissionManager } : {},
-            ...config.askUser != null ? { askUser: config.askUser } : {},
-            ...config.tellUser != null ? { tellUser: config.tellUser } : {},
-            ...config.downloadRawFile != null ? { downloadRawFile: config.downloadRawFile } : {}
-          });
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          toolResult = {
-            success: false,
-            output: "",
-            error: errorMsg.length > 500 ? errorMsg.slice(0, 500) + "..." : errorMsg
-          };
-        }
-        const durationMs = Date.now() - start;
-        let resultText = toolResult.success ? toolResult.output : `ERROR: ${toolResult.error ?? "unknown failure"}`;
-        if (config.resultPager && toolResult.success && resultText.length > pageThreshold && !pagingExcludeSet.has(tc.toolName) && tc.toolName !== "ReadFullResult") {
-          try {
-            const paged = await config.resultPager.page(resultText, {
-              toolName: tc.toolName,
-              toolCallId: tc.toolCallId
-            });
-            resultText = [
-              paged.summary,
-              "",
-              `[Full result: ${paged.originalLength} chars \u2014 call ReadFullResult("${paged.ref}") to retrieve]`
-            ].join("\n");
-          } catch {
-            resultText = resultText.slice(0, pageThreshold) + `
-
-[Truncated \u2014 ${resultText.length} chars total. Storage unavailable.]`;
-          }
-        }
-        if (config.maxToolResultLength && resultText.length > config.maxToolResultLength) {
-          const originalLength = resultText.length;
-          resultText = resultText.slice(0, config.maxToolResultLength) + `
-
-[Truncated \u2014 ${originalLength} chars total, showing first ${config.maxToolResultLength}.]`;
-        }
-        messages.push({
-          role: "tool",
-          content: resultText,
-          toolResults: [{
-            toolCallId: tc.toolCallId,
-            toolName: tc.toolName,
-            result: resultText,
-            isError: !toolResult.success
-          }]
-        });
-        config.onActivity?.({
-          type: "tool_end",
-          name: tc.toolName,
-          ok: toolResult.success,
-          ms: durationMs,
-          preview: toolResult.output.slice(0, 200),
-          ts: Date.now()
-        });
-        yield {
-          type: "tool_end",
-          name: tc.toolName,
-          result: {
-            success: toolResult.success,
-            output: toolResult.output,
-            ...toolResult.error != null ? { error: toolResult.error } : {}
-          }
-        };
-      }
-      yield usage ? { type: "step_end", step: step + 1, usage } : { type: "step_end", step: step + 1 };
-    }
-    return { messages, output: "max steps reached", steps: config.maxSteps };
-  }
-};
-function createProcess(request, config) {
-  const id = randomUUID();
-  const model = resolveModel(request.model, config.modelMap, config.defaultModel);
-  const maxSteps = request.model === "fast" ? 1 : request.maxSteps ?? config.processMaxSteps;
-  const inboxChannel = createChannel();
-  const ac = new AbortController();
-  const onParentAbort = () => ac.abort();
-  config.parentSignal.addEventListener("abort", onParentAbort, { once: true });
-  const outbox = createChannel();
-  const compressor = new EpisodeCompressor(config.createModel);
-  const runner = new AgentRunner();
-  const process2 = {
-    id,
-    action: request.action,
-    model,
-    status: "pending",
-    outbox,
-    inbox: {
-      send(message) {
-        inboxChannel.push(message);
-      },
-      cancel() {
-        ac.abort();
-        inboxChannel.close();
-      }
-    }
-  };
-  const seedPromise = buildSeedMessages(request.contextEpisodeIds ?? [], config.episodeStore);
-  const startTime = Date.now();
-  void (async () => {
-    try {
-      process2.status = "running";
-      const seed = [
-        ...config.demoMessages ?? [],
-        ...await seedPromise,
-        ...normalizeSeedContext(config.processSeedContext)
-      ];
-      let systemPrompt = config.processSystemPrompt ?? PROCESS_SYSTEM_PROMPT;
-      const skillRef = config.skillRefPromise ? await config.skillRefPromise : null;
-      if (skillRef) {
-        const subGuideBlocks = skillRef.subGuides ? Object.entries(skillRef.subGuides).map(([file, content]) => `
-### Sub-guide: ${file}
-
-${content}`).join("\n") : "";
-        systemPrompt += `
-
-<skill_system>
-**Skill: ${skillRef.name}**
-
-Follow these skill instructions precisely. Do NOT use alternative tools or libraries.
-
-${skillRef.content ?? ""}
-${subGuideBlocks}
-</skill_system>`;
-      } else if (config.skillPromptPromise) {
-        const skillInstructions = await config.skillPromptPromise;
-        if (skillInstructions) {
-          systemPrompt += "\n\n<skill_instructions>\nIMPORTANT: Follow the skill instructions below precisely. They contain tested, working patterns.\n\n" + skillInstructions + "\n</skill_instructions>";
-        }
-      }
-      const result = await Promise.race([
-        (async () => {
-          const stream = runner.stream({
-            model,
-            prompt: request.action,
-            tools: config.processTools,
-            systemPrompt,
-            toolProvider: config.toolProvider,
-            maxSteps,
-            signal: ac.signal,
-            seed,
-            inbox: inboxChannel,
-            ...pickDefined(config, [
-              "createModel",
-              "hookRunner",
-              "permissionManager",
-              "telemetry",
-              "executeToolAction",
-              "askUser",
-              "tellUser",
-              "downloadRawFile",
-              "allowedToolNames",
-              "outputSchema",
-              "toolChoice",
-              "resultPager",
-              "resultPageThreshold",
-              "pagingExclude",
-              "maxToolResultLength",
-              "contextFacts",
-              "maxContextTokens"
-            ])
-          });
-          while (true) {
-            const next = await stream.next();
-            if (next.done) {
-              return next.value;
-            }
-            const event = next.value;
-            if (event.type === "text_delta") {
-              outbox.push({ type: "text_delta", text: event.text });
-              continue;
-            }
-            if (event.type === "step_start") {
-              outbox.push({ type: "step_start", step: event.step });
-              continue;
-            }
-            if (event.type === "step_end") {
-              outbox.push({
-                type: "step_end",
-                step: event.step,
-                ...event.usage ? { usage: event.usage } : {}
-              });
-              continue;
-            }
-            if (event.type === "tool_start") {
-              outbox.push({
-                type: "activity",
-                activity: {
-                  type: "tool_start",
-                  name: event.name,
-                  args: event.args,
-                  ts: Date.now()
-                }
-              });
-              continue;
-            }
-            if (event.type === "tool_end") {
-              outbox.push({
-                type: "activity",
-                activity: {
-                  type: "tool_end",
-                  name: event.name,
-                  ok: event.result.success,
-                  ms: 0,
-                  preview: String(event.result.output ?? "").slice(0, 200),
-                  ts: Date.now()
-                }
-              });
-            }
-          }
-        })(),
-        timeoutPromise(config.processTimeout)
-      ]);
-      const durationMs = Date.now() - startTime;
-      const nextIndex = await getNextEpisodeIndex(config.episodeStore, config.taskId);
-      const compressInput = {
-        taskId: config.taskId,
-        sessionId: config.sessionId,
-        index: nextIndex,
-        threadAction: request.action,
-        messages: result.messages,
-        model,
-        parentEpisodeIds: request.contextEpisodeIds ?? [],
-        success: true
-      };
-      const { episode, trace, artifacts } = compressor.compress(compressInput);
-      if (result.structuredOutput) {
-        episode.structuredOutput = result.structuredOutput;
-      }
-      await config.episodeStore.addEpisode(episode);
-      await config.episodeStore.addTrace(trace);
-      const processResult = {
-        episode,
-        trace,
-        artifacts,
-        success: true,
-        durationMs,
-        resolvedModel: model
-      };
-      process2.result = processResult;
-      process2.status = "completed";
-      outbox.push({ type: "episode", episode });
-      outbox.push({ type: "done", result: processResult });
-      if (episode.steps > 10) {
-        const upgradeAc = new AbortController();
-        void compressor.compressLLM(compressInput, upgradeAc.signal).then(async (upgraded) => {
-          episode.summary = upgraded.episode.summary;
-          await config.episodeStore.addEpisode(episode);
-        }).catch(() => {
-        });
-      }
-    } catch (error) {
-      const durationMs = Date.now() - startTime;
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (ac.signal.aborted) {
-        process2.status = "cancelled";
-        outbox.push({ type: "failed", error: "cancelled" });
-        outbox.close();
-        return;
-      }
-      const nextIndex = await getNextEpisodeIndex(config.episodeStore, config.taskId).catch(() => 0);
-      const { episode, trace, artifacts } = compressor.compress({
-        taskId: config.taskId,
-        sessionId: config.sessionId,
-        index: nextIndex,
-        threadAction: request.action,
-        messages: [
-          { role: "user", content: request.action },
-          { role: "assistant", content: `Failed: ${errorMessage}` }
-        ],
-        model,
-        parentEpisodeIds: request.contextEpisodeIds ?? [],
-        success: false
-      });
-      await config.episodeStore.addEpisode(episode).catch(() => {
-      });
-      await config.episodeStore.addTrace(trace).catch(() => {
-      });
-      const processResult = {
-        episode,
-        trace,
-        artifacts,
-        success: false,
-        durationMs,
-        resolvedModel: model,
-        error: errorMessage
-      };
-      process2.result = processResult;
-      process2.status = "failed";
-      outbox.push({ type: "failed", error: errorMessage });
-    } finally {
-      config.parentSignal.removeEventListener("abort", onParentAbort);
-      outbox.close();
-      inboxChannel.close();
-    }
-  })();
-  return process2;
-}
-var STUB_THRESHOLD = 500;
-function trimContext(messages, maxTokens) {
-  let totalTokens = 0;
-  for (const m of messages) {
-    const text = typeof m.content === "string" ? m.content : "";
-    totalTokens += estimateTokens(text);
-  }
-  if (totalTokens <= maxTokens) return;
-  const hotBoundary = Math.floor(messages.length * 0.6);
-  for (let i = 0; i < hotBoundary; i++) {
-    const m = messages[i];
-    if (m.role === "tool" && typeof m.content === "string" && m.content.length > STUB_THRESHOLD) {
-      const toolName = m.toolResults?.[0]?.toolName ?? "tool";
-      const stubbed = `[${toolName}: output stubbed, ${m.content.length} chars]`;
-      m.content = stubbed;
-      if (m.toolResults) {
-        for (const tr of m.toolResults) {
-          tr.result = stubbed;
-        }
-      }
-    }
-  }
-}
-async function getNextEpisodeIndex(store, taskId) {
-  const episodes = await store.getEpisodesByTask(taskId);
-  return episodes.length;
-}
-async function buildSeedMessages(episodeIds, episodeStore) {
-  if (episodeIds.length === 0) return [];
-  const messages = [];
-  for (const id of episodeIds) {
-    const trace = await episodeStore.getTrace(id);
-    if (!trace) continue;
-    const traceText = trace.messages.map((m) => {
-      const text = getTextContent(m.content);
-      if (m.role === "assistant" && m.toolCalls?.length) {
-        const calls = m.toolCalls.map((tc) => `  ${tc.toolName}(${JSON.stringify(tc.args)})`).join("\n");
-        return `[assistant]
-${text}
-[tool calls]
-${calls}`;
-      }
-      if (m.role === "tool" && m.toolResults?.length) {
-        const results = m.toolResults.map((tr) => {
-          const output = tr.result.length > 500 ? tr.result.slice(0, 500) + "..." : tr.result;
-          return `  ${tr.toolName}: ${tr.isError ? "ERROR: " : ""}${output}`;
-        }).join("\n");
-        return `[tool results]
-${results}`;
-      }
-      return `[${m.role}]
-${text}`;
-    }).join("\n\n");
-    messages.push({
-      role: "system",
-      content: `Context from prior episode (${id}):
-${traceText}`
-    });
-  }
-  return messages;
-}
-function normalizeSeedContext(ctx) {
-  if (!ctx) return [];
-  if (typeof ctx === "string") {
-    return [{ role: "system", content: ctx }];
-  }
-  return ctx;
-}
-function timeoutPromise(ms) {
-  return new Promise(
-    (_, reject) => setTimeout(() => reject(new Error(`Process timed out after ${ms}ms`)), ms)
-  );
-}
-async function* drainNonBlocking(iterable) {
-  const iterator = iterable[Symbol.asyncIterator]();
-  while (true) {
-    const next = await Promise.race([
-      iterator.next(),
-      Promise.resolve({ done: true, value: void 0 })
-    ]);
-    if (next.done) return;
-    yield next.value;
-  }
-}
-var FIELD_RE = /^(\w+)(?::(\w+)(\[\])?)(\?)?(?:\s*\(([^)]+)\))?$/;
-function parseField(raw) {
-  const trimmed = raw.trim();
-  const match = trimmed.match(FIELD_RE);
-  if (!match) {
-    const name2 = trimmed.replace(/\?$/, "");
-    return {
-      name: name2,
-      type: "string",
-      isArray: false,
-      isOptional: trimmed.endsWith("?")
-    };
-  }
-  const [, name, typeStr, arrayMark, optionalMark, desc] = match;
-  const type = ["string", "number", "boolean"].includes(typeStr) ? typeStr : "string";
-  const field = {
-    name,
-    type,
-    isArray: arrayMark === "[]",
-    isOptional: optionalMark === "?"
-  };
-  if (desc) field.description = desc.trim();
-  return field;
-}
-function parseSignature(sig) {
-  const arrowIdx = sig.indexOf("->");
-  if (arrowIdx < 0) {
-    throw new Error(`Invalid signature: missing "->". Got: "${sig}"`);
-  }
-  const inputStr = sig.slice(0, arrowIdx).trim();
-  const outputStr = sig.slice(arrowIdx + 2).trim();
-  const inputs = inputStr.split(",").map((s) => s.trim()).filter(Boolean).map(parseField);
-  const outputs = outputStr.split(",").map((s) => s.trim()).filter(Boolean).map(parseField);
-  return { inputs, outputs };
-}
-function signatureToSchema(sig) {
-  const shape = {};
-  for (const field of sig.outputs) {
-    let base;
-    switch (field.type) {
-      case "number":
-        base = z.number();
-        break;
-      case "boolean":
-        base = z.boolean();
-        break;
-      default:
-        base = z.string();
-        break;
-    }
-    if (field.isArray) base = z.array(base);
-    if (field.description) base = base.describe(field.description);
-    if (field.isOptional) base = base.optional();
-    shape[field.name] = base;
-  }
-  return z.object(shape);
-}
-function isTypedSignature(sig) {
-  return /\b\w+:\w+/.test(sig);
-}
-
-// src/arc/profile-builder.ts
-function buildProfilePrompt(decl) {
-  const [input, output] = decl.signature.split("->").map((s) => s.trim());
-  const lines = [
-    `You are a ${decl.name} thread.`,
-    `Your task: take ${input} and produce ${output}.`,
-    "",
-    `## Available tools`,
-    `You have access to: ${decl.tools.join(", ")}`,
-    "Use ONLY these tools. You cannot use any other tools.",
-    "If you have Skill Instructions below, follow them for delivery method and style."
-  ];
-  if (decl.background) {
-    lines.push("", "## Background", decl.background);
-  }
-  return lines.join("\n");
-}
-function resolveProfileTools(toolNames, globalTools) {
-  const resolved = {};
-  for (const name of toolNames) {
-    if (globalTools[name]) {
-      resolved[name] = globalTools[name];
-    }
-  }
-  return resolved;
-}
-function buildProcessProfile(decl, globalTools) {
-  const profile = {
-    systemPrompt: buildProfilePrompt(decl),
-    tools: resolveProfileTools(decl.tools, globalTools),
-    allowedToolNames: decl.tools
-  };
-  if (decl.model) profile.model = decl.model;
-  if (decl.maxSteps) profile.maxSteps = decl.maxSteps;
-  if (isTypedSignature(decl.signature)) {
-    const parsed = parseSignature(decl.signature);
-    if (parsed.outputs.length > 0) {
-      profile.outputSchema = signatureToSchema(parsed);
-    }
-  }
-  if (decl.demos && decl.demos.length > 0) {
-    profile.demoMessages = decl.demos.flatMap((demo) => [
-      { role: "user", content: Object.entries(demo.input).map(([k, v]) => `${k}: ${v}`).join("\n") },
-      { role: "assistant", content: JSON.stringify(demo.output, null, 2) }
-    ]);
-  }
-  return profile;
-}
-function resolveProfile(config, globalTools) {
-  if (isProfileDeclaration(config)) {
-    return buildProcessProfile(config, globalTools);
-  }
-  if (config.tools && !config.allowedToolNames) {
-    return { ...config, allowedToolNames: Object.keys(config.tools) };
-  }
-  return config;
-}
-
-// src/arc/process-manager.ts
-function normalizeAction(action) {
-  return action.trim().replace(/\s+/g, " ");
-}
-var ProcessManager = class {
-  config;
-  processes = /* @__PURE__ */ new Map();
-  actionIndex = /* @__PURE__ */ new Map();
-  processListeners = [];
-  pendingEventResolvers = /* @__PURE__ */ new Set();
-  tracedRunning = /* @__PURE__ */ new Set();
-  pendingEvents = [];
-  cachedSessionMemoFacts = [];
-  constructor(config) {
-    this.config = config;
-  }
-  setSessionMemoFacts(facts) {
-    this.cachedSessionMemoFacts = facts ?? [];
-  }
-  get size() {
-    return this.processes.size;
-  }
-  get(id) {
-    return this.processes.get(id);
-  }
-  values() {
-    return this.processes.values();
-  }
-  entries() {
-    return this.processes.entries();
-  }
-  findByAction(action) {
-    const existingId = this.actionIndex.get(normalizeAction(action));
-    return existingId ? this.processes.get(existingId) : void 0;
-  }
-  dispatch(request, parentSignal) {
-    const { loopConfig } = this.config;
-    const profileConfig = request.profile ? loopConfig.processProfiles?.[request.profile] : void 0;
-    const globalTools = loopConfig.processTools ?? builtinTools;
-    const profile = profileConfig ? resolveProfile(profileConfig, globalTools) : void 0;
-    const defaultModel = this.config.modelMap[profile?.model ?? "medium"] ?? this.config.modelMap.medium;
-    const profileSkills = profileConfig && isProfileDeclaration(profileConfig) ? profileConfig.skills : void 0;
-    const skillRefPromise = this.config.skillResolver ? this.config.skillResolver.resolve(request.action, profileSkills).then((result) => {
-      if (!result) return null;
-      result.name;
-      result.path;
-      return {
-        name: result.name,
-        path: result.path,
-        ...result.systemPrompt ? { content: result.systemPrompt } : {},
-        ...result.subGuides ? { subGuides: result.subGuides } : {}
-      };
-    }) : void 0;
-    const skillPromptPromise = skillRefPromise?.then(() => null);
-    const threadContextFacts = [
-      ...loopConfig.contextFacts ?? [],
-      ...this.cachedSessionMemoFacts
-    ];
-    const proc = createProcess(request, {
-      toolProvider: loopConfig.toolProvider,
-      episodeStore: loopConfig.episodeStore,
-      taskId: loopConfig.taskId,
-      sessionId: loopConfig.sessionId,
-      createModel: this.config.createModel,
-      modelMap: this.config.modelMap,
-      defaultModel,
-      processMaxSteps: profile?.maxSteps ?? loopConfig.processMaxSteps ?? 20,
-      processTimeout: loopConfig.processTimeout ?? 12e4,
-      processTools: profile?.tools ?? globalTools,
-      ...profile?.systemPrompt ?? loopConfig.processSystemPrompt ? { processSystemPrompt: profile?.systemPrompt ?? loopConfig.processSystemPrompt } : {},
-      ...profile?.allowedToolNames ? { allowedToolNames: profile.allowedToolNames } : {},
-      ...profile?.outputSchema ? { outputSchema: profile.outputSchema } : {},
-      ...profile?.demoMessages ? { demoMessages: profile.demoMessages } : {},
-      ...loopConfig.processToolChoice ? { toolChoice: loopConfig.processToolChoice } : {},
-      ...loopConfig.resultPager ? { resultPager: loopConfig.resultPager } : {},
-      ...loopConfig.resultPageThreshold != null ? { resultPageThreshold: loopConfig.resultPageThreshold } : {},
-      ...loopConfig.pagingExclude ? { pagingExclude: loopConfig.pagingExclude } : {},
-      ...loopConfig.maxToolResultLength != null ? { maxToolResultLength: loopConfig.maxToolResultLength } : {},
-      contextFacts: threadContextFacts,
-      ...loopConfig.maxContextTokens != null ? { maxContextTokens: loopConfig.maxContextTokens } : {},
-      ...loopConfig.processSeedContext ? { processSeedContext: loopConfig.processSeedContext } : {},
-      ...skillPromptPromise ? { skillPromptPromise } : {},
-      ...skillRefPromise ? { skillRefPromise } : {},
-      parentSignal,
-      ...pickDefined(loopConfig, [
-        "hookRunner",
-        "permissionManager",
-        "telemetry",
-        "executeToolAction"
-      ])
-    });
-    this.processes.set(proc.id, proc);
-    this.actionIndex.set(normalizeAction(request.action), proc.id);
-    this.processListeners.push(this.listenToProcess(proc));
-    this.trace({ type: "process_created", id: proc.id, status: "pending" });
-    if (skillRefPromise) {
-      skillRefPromise.then((ref) => {
-        if (ref) {
-          this.enqueuePendingEvent({
-            type: "skill_resolved",
-            processId: proc.id,
-            skillName: ref.name,
-            skillPath: ref.path
-          });
-        }
-      }).catch(() => {
-      });
-    }
-    return proc;
-  }
-  cancel(id) {
-    const proc = this.processes.get(id);
-    if (!proc) return void 0;
-    proc.inbox.cancel();
-    this.trace({ type: "process_transition", id, from: proc.status, to: "cancelled" });
-    this.enqueuePendingEvent({ type: "process_cancelled", id });
-    return proc;
-  }
-  hasRunningProcesses() {
-    for (const proc of this.processes.values()) {
-      if (proc.status === "running" || proc.status === "pending") {
-        return true;
-      }
-    }
-    return false;
-  }
-  *drainPendingEvents() {
-    while (this.pendingEvents.length > 0) {
-      yield this.pendingEvents.shift();
-    }
-  }
-  async waitForPendingEvent(signal, timeoutMs) {
-    if (this.pendingEvents.length > 0) {
-      return;
-    }
-    await new Promise((resolve) => {
-      const onAbort = () => {
-        cleanup();
-        resolve();
-      };
-      const onEvent = () => {
-        cleanup();
-        resolve();
-      };
-      const timer = setTimeout(() => {
-        cleanup();
-        resolve();
-      }, timeoutMs);
-      const cleanup = () => {
-        clearTimeout(timer);
-        signal.removeEventListener("abort", onAbort);
-        this.pendingEventResolvers.delete(onEvent);
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
-      this.pendingEventResolvers.add(onEvent);
-    });
-  }
-  async waitForProcessListeners() {
-    await Promise.allSettled(this.processListeners);
-  }
-  trace(kind) {
-    this.config.trace?.(kind);
-  }
-  traceProcessRunning(procId) {
-    if (!this.tracedRunning.has(procId)) {
-      this.tracedRunning.add(procId);
-      this.trace({ type: "process_transition", id: procId, from: "pending", to: "running" });
-    }
-  }
-  enqueuePendingEvent(event) {
-    this.pendingEvents.push(event);
-    for (const resolve of this.pendingEventResolvers) {
-      resolve();
-    }
-    this.pendingEventResolvers.clear();
-  }
-  async listenToProcess(proc) {
-    try {
-      for await (const event of proc.outbox) {
-        if (event.type === "activity") {
-          this.traceProcessRunning(proc.id);
-          this.enqueuePendingEvent({
-            type: "process_activity",
-            id: proc.id,
-            activity: event.activity
-          });
-        } else if (event.type === "text_delta") {
-          this.traceProcessRunning(proc.id);
-          this.enqueuePendingEvent({
-            type: "process_text_delta",
-            id: proc.id,
-            text: event.text
-          });
-        } else if (event.type === "step_start") {
-          this.traceProcessRunning(proc.id);
-          this.enqueuePendingEvent({
-            type: "process_step_start",
-            id: proc.id,
-            step: event.step
-          });
-        } else if (event.type === "step_end") {
-          this.traceProcessRunning(proc.id);
-          this.enqueuePendingEvent({
-            type: "process_step_end",
-            id: proc.id,
-            step: event.step,
-            ...event.usage ? { usage: event.usage } : {}
-          });
-        } else if (event.type === "done") {
-          this.traceProcessRunning(proc.id);
-          this.trace({ type: "process_transition", id: proc.id, from: "running", to: "completed" });
-          this.config.onEpisodeCompleted?.(event.result.episode);
-          this.enqueuePendingEvent({
-            type: "process_completed",
-            id: proc.id,
-            episodeId: event.result.episode.id,
-            summary: event.result.episode.summary,
-            durationMs: event.result.durationMs
-          });
-        } else if (event.type === "failed") {
-          this.traceProcessRunning(proc.id);
-          const toStatus = event.error === "cancelled" ? "cancelled" : "failed";
-          this.trace({ type: "process_transition", id: proc.id, from: "running", to: toStatus });
-          this.enqueuePendingEvent({
-            type: "process_failed",
-            id: proc.id,
-            error: event.error
-          });
-        }
-      }
-    } catch {
-    }
-  }
-};
-var OrchestratorTurnRunner = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  async *runTurn(params) {
-    const { turn, maxTurns, prepared, signal, forcedFinalResponseRetry } = params;
-    this.config.trace({ type: "llm_call_start" });
-    const callLLM = async (effectiveSignal) => (
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      streamText({
-        model: this.config.createModel(this.config.orchestratorModel),
-        tools: normalizeTools(this.config.tools),
-        toolChoice: resolveToolChoice(this.config.orchestratorToolChoice, turn),
-        messages: toModelMessages(prepared.messages),
-        system: this.config.cachedSystem,
-        abortSignal: effectiveSignal
-      })
-    );
-    let stream;
-    if (this.config.resilience) {
-      const resilienceCtx = {
-        attempt: 0,
-        totalAttempts: 1,
-        startTime: Date.now(),
-        signal
-      };
-      stream = await this.config.resilience.execute(
-        (ctx) => callLLM(ctx.signal),
-        resilienceCtx
-      );
-    } else {
-      stream = await callLLM(signal);
-    }
-    const toolCalls = [];
-    let text = "";
-    for await (const part of stream.fullStream) {
-      if (part.type === "text-delta") {
-        text += part.text;
-        yield { type: "text_delta", text: part.text };
-      }
-      if (part.type === "tool-call") {
-        const p = part;
-        toolCalls.push({
-          toolName: p.toolName,
-          args: p.args ?? p.input ?? {},
-          toolCallId: p.toolCallId
-        });
-      }
-    }
-    const responseType = toolCalls.length === 0 ? "text_only" : toolCalls.length === 1 ? "single_tool" : "multiple_tools";
-    this.config.trace({ type: "llm_call_end", response_type: responseType });
-    if (toolCalls.length === 0) {
-      if (!text.trim()) {
-        if (!forcedFinalResponseRetry && turn < maxTurns - 1) {
-          const retryInstruction = "Respond to the user now using the completed thread results. Do not call tools or dispatch threads unless absolutely necessary. Give a direct final answer.";
-          this.config.ctx.recordTurn({
-            role: "user",
-            messages: [{ role: "user", content: retryInstruction }],
-            tokenEstimate: estimateTokens(retryInstruction),
-            timestamp: Date.now()
-          });
-          return { type: "retry_empty" };
-        }
-        text = "No final synthesis was produced.";
-      }
-      this.config.ctx.recordTurn({
-        role: "orchestrator",
-        messages: [{ role: "assistant", content: text }],
-        tokenEstimate: estimateTokens(text),
-        timestamp: Date.now()
-      });
-      return { type: "done", output: text };
-    }
-    const assistantMessages = this.buildAssistantMessages(text, toolCalls);
-    this.config.ctx.recordTurn({
-      role: "orchestrator",
-      messages: assistantMessages,
-      tokenEstimate: estimateTokens(text) + toolCalls.reduce((sum, call) => sum + estimateTokens(JSON.stringify(call.args)), 0),
-      timestamp: Date.now()
-    });
-    const toolResultMessages = [];
-    for (const call of toolCalls) {
-      const toolCallId = call.toolCallId ?? randomUUID();
-      this.config.trace({ type: "tool_call", tool: call.toolName });
-      if (call.toolName === "Thread") {
-        const request = this.toProcessRequest(call.args);
-        const hasProfiles = this.config.config.processProfiles && Object.keys(this.config.config.processProfiles).length > 0;
-        if (hasProfiles && !request.profile) {
-          const names = Object.keys(this.config.config.processProfiles).map((name) => `"${name}"`).join(", ");
-          const resultText2 = `ERROR: profile parameter is required. Available profiles: ${names}. Re-call Thread with a profile.`;
-          toolResultMessages.push({
-            role: "tool",
-            content: resultText2,
-            toolResults: [{ toolCallId, toolName: "Thread", result: resultText2 }]
-          });
-          yield { type: "thread_rejected", action: request.action, reason: "missing profile" };
-          continue;
-        }
-        if (hasProfiles && request.profile && !this.config.config.processProfiles[request.profile]) {
-          const names = Object.keys(this.config.config.processProfiles).map((name) => `"${name}"`).join(", ");
-          const resultText2 = `ERROR: unknown profile "${request.profile}". Available profiles: ${names}. Re-call Thread with a valid profile.`;
-          toolResultMessages.push({
-            role: "tool",
-            content: resultText2,
-            toolResults: [{ toolCallId, toolName: "Thread", result: resultText2 }]
-          });
-          yield { type: "thread_rejected", action: request.action, reason: `unknown profile "${request.profile}"` };
-          continue;
-        }
-        const existing = this.config.processManager.findByAction(request.action);
-        if (existing && (existing.status === "running" || existing.status === "pending")) {
-          const resultText2 = `DUPLICATE \u2014 thread already running for this action (process ${existing.id}). Wait for it to complete.`;
-          toolResultMessages.push({
-            role: "tool",
-            content: resultText2,
-            toolResults: [{ toolCallId, toolName: "Thread", result: resultText2 }]
-          });
-          yield { type: "thread_rejected", action: request.action, reason: "duplicate (running)" };
-          continue;
-        }
-        if (existing && existing.status === "completed" && existing.result) {
-          const ep = existing.result.episode;
-          const resultText2 = `DUPLICATE \u2014 this action already completed (process ${existing.id}, episodeId: ${ep.id}). Use contextEpisodeIds: ["${ep.id}"] to reference it.`;
-          toolResultMessages.push({
-            role: "tool",
-            content: resultText2,
-            toolResults: [{ toolCallId, toolName: "Thread", result: resultText2 }]
-          });
-          yield { type: "thread_rejected", action: request.action, reason: "duplicate (completed)" };
-          continue;
-        }
-        const completedEpisodeIds = [...this.config.processManager.values()].filter((proc2) => proc2.status === "completed" && proc2.result?.episode).map((proc2) => proc2.result.episode.id);
-        if (completedEpisodeIds.length > 0) {
-          request.contextEpisodeIds = [
-            ...request.contextEpisodeIds ?? [],
-            ...completedEpisodeIds.filter((id) => !request.contextEpisodeIds?.includes(id))
-          ];
-        }
-        const proc = this.config.processManager.dispatch(request, signal);
-        const resultText = `Process ${proc.id} dispatched: "${request.action}" (model: ${request.model ?? "medium"})`;
-        toolResultMessages.push({
-          role: "tool",
-          content: resultText,
-          toolResults: [{ toolCallId, toolName: "Thread", result: resultText }]
-        });
-        yield {
-          type: "process_dispatched",
-          id: proc.id,
-          action: request.action,
-          model: proc.model,
-          ...request.label ? { label: request.label } : {},
-          ...request.profile ? { profile: request.profile } : {}
-        };
-        continue;
-      }
-      if (call.toolName === "Check") {
-        const proc = this.config.processManager.get(String(call.args.id));
-        let resultText;
-        if (!proc) {
-          resultText = `Process not found: ${call.args.id}`;
-        } else if (proc.result) {
-          resultText = `Process ${proc.id} [${proc.status}] (episodeId: ${proc.result.episode.id}):
-${proc.result.episode.summary}`;
-        } else {
-          resultText = `Process ${proc.id}: status=${proc.status}`;
-        }
-        toolResultMessages.push({
-          role: "tool",
-          content: resultText,
-          toolResults: [{ toolCallId, toolName: "Check", result: resultText }]
-        });
-        continue;
-      }
-      if (call.toolName === "Cancel") {
-        const proc = this.config.processManager.cancel(String(call.args.id));
-        const resultText = proc ? `Process ${call.args.id} cancelled` : `Process not found: ${call.args.id}`;
-        toolResultMessages.push({
-          role: "tool",
-          content: resultText,
-          toolResults: [{ toolCallId, toolName: "Cancel", result: resultText }]
-        });
-        continue;
-      }
-      if (call.toolName === "ReadEpisode") {
-        const episodeId = String(call.args.id);
-        const trace = await this.config.config.episodeStore.getTrace(episodeId);
-        let resultText;
-        if (!trace) {
-          resultText = `Trace not found for episode: ${episodeId}`;
-        } else {
-          resultText = trace.messages.map((message) => {
-            const textContent = getTextContent(message.content);
-            if (message.role === "assistant" && message.toolCalls?.length) {
-              const calls = message.toolCalls.map((toolCall) => `  ${toolCall.toolName}(${JSON.stringify(toolCall.args)})`).join("\n");
-              return `[assistant]
-${textContent}
-[tool calls]
-${calls}`;
-            }
-            if (message.role === "tool" && message.toolResults?.length) {
-              const results = message.toolResults.map((toolResult) => {
-                const output = toolResult.result.length > 500 ? toolResult.result.slice(0, 500) + "..." : toolResult.result;
-                return `  ${toolResult.toolName}: ${toolResult.isError ? "ERROR: " : ""}${output}`;
-              }).join("\n");
-              return `[tool results]
-${results}`;
-            }
-            return `[${message.role}]
-${textContent}`;
-          }).join("\n\n");
-          const proc = [...this.config.processManager.values()].find((process2) => process2.result?.episode.id === episodeId);
-          if (proc?.result && proc.result.artifacts.length > 0) {
-            resultText += "\n\n--- Artifacts ---\n";
-            resultText += proc.result.artifacts.map((artifact) => `[${artifact.key}]
-${artifact.content}`).join("\n\n");
-          }
-          if (typeof call.args.maxTokens === "number" && call.args.maxTokens > 0) {
-            const maxChars = call.args.maxTokens * 4;
-            if (resultText.length > maxChars) {
-              resultText = resultText.slice(0, maxChars) + "\n... [truncated]";
-            }
-          }
-        }
-        toolResultMessages.push({
-          role: "tool",
-          content: resultText,
-          toolResults: [{ toolCallId, toolName: "ReadEpisode", result: resultText }]
-        });
-        continue;
-      }
-      if (call.toolName === "Remember") {
-        const memOpts = {};
-        if (call.args.category != null) memOpts.category = String(call.args.category);
-        const memId = await this.config.memory.store(String(call.args.content), memOpts);
-        yield { type: "memory_stored", id: memId, content: String(call.args.content) };
-        const resultText = `Stored to memory (id: ${memId})`;
-        toolResultMessages.push({
-          role: "tool",
-          content: resultText,
-          toolResults: [{ toolCallId, toolName: "Remember", result: resultText }]
-        });
-        continue;
-      }
-      if (this.config.config.onOrchestratorTool) {
-        const action = await this.config.config.onOrchestratorTool(call.toolName, call.args);
-        const resultText = this.toToolContent(action, call.toolName);
-        toolResultMessages.push({
-          role: "tool",
-          content: resultText,
-          toolResults: [{ toolCallId, toolName: call.toolName, result: resultText }]
-        });
-      }
-    }
-    if (toolResultMessages.length > 0) {
-      this.config.ctx.recordTurn({
-        role: "process_result",
-        messages: toolResultMessages,
-        tokenEstimate: toolResultMessages.reduce((sum, message) => {
-          const textContent = typeof message.content === "string" ? message.content : getTextContent(message.content);
-          return sum + estimateTokens(textContent);
-        }, 0),
-        timestamp: Date.now()
-      });
-    }
-    return { type: "continue" };
-  }
-  toProcessRequest(args) {
-    const req = { action: String(args.action ?? "") };
-    if (Array.isArray(args.contextEpisodeIds)) {
-      req.contextEpisodeIds = args.contextEpisodeIds.map(String);
-    }
-    if (args.model != null) {
-      req.model = String(args.model);
-    }
-    if (typeof args.maxSteps === "number") {
-      req.maxSteps = args.maxSteps;
-    }
-    if (typeof args.label === "string") {
-      req.label = args.label;
-    }
-    if (typeof args.profile === "string") {
-      req.profile = args.profile;
-    }
-    return req;
-  }
-  buildAssistantMessages(text, toolCalls) {
-    const content = text || toolCalls.map((call) => `${call.toolName}: ${JSON.stringify(call.args).slice(0, 100)}`).join("\n");
-    return [{
-      role: "assistant",
-      content,
-      toolCalls: toolCalls.map((call) => ({
-        toolCallId: call.toolCallId ?? randomUUID(),
-        toolName: call.toolName,
-        args: call.args
-      }))
-    }];
-  }
-  toToolContent(action, toolName) {
-    return action && "content" in action && typeof action.content === "string" ? action.content : `${toolName}: handled`;
-  }
-};
-
-// src/arc/completion-policy.ts
-var CompletionPolicy = class {
-  config;
-  reportedCompletions = /* @__PURE__ */ new Set();
-  constructor(config) {
-    this.config = config;
-  }
-  async *settleTurn(signal) {
-    yield* this.waitForRunningProcesses(signal);
-    this.recordCompletionMessages();
-  }
-  async *waitForRunningProcesses(signal) {
-    const active = [...this.config.processManager.values()].filter(
-      (process2) => process2.status === "running" || process2.status === "pending"
-    );
-    if (active.length === 0) return;
-    const deadline = Date.now() + (this.config.processTimeout ?? 12e4);
-    while (active.some((process2) => process2.status === "running" || process2.status === "pending") && Date.now() <= deadline) {
-      await this.config.processManager.waitForPendingEvent(signal, 400);
-      yield* this.config.processManager.drainPendingEvents();
-    }
-  }
-  recordCompletionMessages() {
-    const completionMessages = [];
-    for (const [id, process2] of this.config.processManager.entries()) {
-      if (!process2.result || this.reportedCompletions.has(id)) continue;
-      this.reportedCompletions.add(id);
-      const episode = process2.result.episode;
-      const status = process2.result.success ? "success" : `failed: ${process2.result.error ?? "unknown"}`;
-      const deliveredFile = process2.result.trace?.messages?.some(
-        (message) => message.role === "tool" && message.toolResults?.some(
-          (toolResult) => toolResult.toolName === "DownloadRawFile" && !toolResult.isError
-        )
-      );
-      const hints = [
-        `To give a dependent thread the full data from this thread, pass contextEpisodeIds: ["${episode.id}"]`
-      ];
-      if (deliveredFile) {
-        hints.push("File was delivered to the user. Do NOT recreate or redo this work \u2014 synthesize the result and respond.");
-      }
-      completionMessages.push({
-        role: "user",
-        content: `[Thread ${id} completed] (episodeId: ${episode.id}) \u2014 ${status}
-${episode.summary}
-
-${hints.join("\n")}`
-      });
-    }
-    if (completionMessages.length === 0) return;
-    this.config.ctx.recordTurn({
-      role: "process_result",
-      messages: completionMessages,
-      tokenEstimate: completionMessages.reduce((sum, message) => {
-        const text = typeof message.content === "string" ? message.content : getTextContent(message.content);
-        return sum + estimateTokens(text);
-      }, 0),
-      timestamp: Date.now()
-    });
-  }
-};
-
-// src/arc/arc-loop.ts
-var DEFAULT_ORCHESTRATOR_PROMPT = `You are an orchestrator agent. You accomplish tasks by decomposing them into focused processes, delegating each to a Thread, and synthesizing the results.
-
-## Workflow: Decompose \u2192 Delegate \u2192 Synthesize
-
-1. **Decompose**: Break the user's request into independent, focused sub-tasks.
-2. **Delegate**: Dispatch each sub-task as a Thread call. Independent sub-tasks go in the SAME turn (parallel).
-3. **Synthesize**: Once threads complete, combine their results into a coherent response.
-
-## Tools
-
-- **Thread**: Dispatch a background process. Returns immediately. Multiple per turn = parallel.
-- **Check**: Check status or results of a process by ID.
-- **Cancel**: Cancel a running process.
-- **Remember**: Save information to persistent memory.
-- **ReadEpisode**: Retrieve the full trace of a completed episode (detailed tool outputs, file contents, errors).
-
-## When to dispatch threads
-
-Dispatch when the task requires tool use (search, code, file I/O, web access). Examples:
-- "Research X and Y" \u2192 2 parallel research threads
-- "Read file A, then modify it" \u2192 1 read thread, then 1 write thread with contextEpisodeIds
-- "Create a report with data from 3 sources" \u2192 3 parallel data threads, then 1 synthesis thread
-
-## When NOT to dispatch
-
-Do NOT dispatch threads for tasks you can answer directly:
-- Simple factual questions from your knowledge
-- Clarifying the user's request (ask directly instead)
-- Summarizing results already in your context
-
-## Clarification
-
-If the request is ambiguous, ask the user before dispatching. It is better to ask one clarifying question than to dispatch threads that do the wrong thing.
-
-## Model selection
-
-- **"fast"** \u2014 1 step only: a single search, read, or check. Use parallel fast threads for multiple lookups.
-- **"medium"** (default) \u2014 implementation, writing code, running tests, standard tasks.
-- **"strong"** \u2014 complex refactoring, debugging subtle issues, architectural decisions, multi-file changes.
-
-## Concurrency
-
-Dispatch at most 3 threads per turn. If more are needed, dispatch the first batch and wait for results before the next.
-
-## Context passing
-
-Threads automatically receive the user's current message and any attachment metadata as seed context. You do NOT need to copy-paste URLs, file contents, or pasted data into the action text \u2014 threads can read this directly from their context.
-
-Use contextEpisodeIds to chain dependent threads: research threads first (parallel), then implementation threads with their episodeIds.
-
-## Completion
-
-When the task is fully complete, respond with a text summary (no Thread call). Include key findings, actions taken, and any follow-up recommendations.`;
-var ArcLoop = class {
-  config;
-  ctx;
-  memory;
-  modelMap;
-  orchestratorModel;
-  systemPrompt;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  cachedSystem;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  tools;
-  resilience;
-  traceWriter;
-  skillResolver;
-  createModel;
-  processManager;
-  turnRunner;
-  completionPolicy;
-  /** Cached session memo facts — loaded once at stream start, injected into all threads. */
-  cachedSessionMemoFacts;
-  constructor(config) {
-    this.config = config;
-    this.createModel = config.createModel ?? (config.apiKey ? createAnthropic({ apiKey: config.apiKey }) : anthropic);
-    this.modelMap = { ...DEFAULT_MODEL_MAP, ...config.modelMap };
-    this.orchestratorModel = resolveModel(config.model, this.modelMap, this.modelMap.strong);
-    this.systemPrompt = config.systemPrompt ?? DEFAULT_ORCHESTRATOR_PROMPT;
-    this.cachedSystem = [{
-      role: "system",
-      content: this.systemPrompt
-    }];
-    this.tools = {
-      ...orchestratorTools,
-      ...config.extraOrchestratorTools
-    };
-    this.memory = new MemoryManager({
-      sessionMemoStore: config.sessionMemoStore,
-      longTermStore: config.longTermStore,
-      sessionId: config.sessionId
-    });
-    this.ctx = new ContextWindow({
-      contextWindowSize: config.contextWindowSize ?? 2e5,
-      outputReserve: config.outputReserve ?? 2e4,
-      systemPrompt: this.systemPrompt,
-      episodeStore: config.episodeStore,
-      memory: this.memory,
-      taskId: config.taskId,
-      createModel: this.createModel,
-      modelId: this.orchestratorModel,
-      dynamicContextWindow: config.dynamicContextWindow ?? false
-    });
-    this.resilience = config.resilience;
-    this.traceWriter = config.traceWriter;
-    this.skillResolver = config.skillResolver ?? (config.skillIndexPath ? new DefaultSkillResolver({
-      skillIndexPath: config.skillIndexPath,
-      routerConfig: {
-        createModel: this.createModel,
-        model: this.modelMap.fast
-      }
-    }) : void 0);
-    this.processManager = new ProcessManager({
-      loopConfig: config,
-      createModel: this.createModel,
-      modelMap: this.modelMap,
-      ...this.skillResolver ? { skillResolver: this.skillResolver } : {},
-      onEpisodeCompleted: (episode) => {
-        this.ctx.addEpisode(episode);
-      },
-      trace: (kind) => {
-        this.trace(kind);
-      }
-    });
-    this.turnRunner = new OrchestratorTurnRunner({
-      createModel: this.createModel,
-      orchestratorModel: this.orchestratorModel,
-      tools: this.tools,
-      cachedSystem: this.cachedSystem,
-      ...this.config.orchestratorToolChoice ? { orchestratorToolChoice: this.config.orchestratorToolChoice } : {},
-      ...this.resilience ? { resilience: this.resilience } : {},
-      config: this.config,
-      ctx: this.ctx,
-      memory: this.memory,
-      processManager: this.processManager,
-      trace: (kind) => {
-        this.trace(kind);
-      }
-    });
-    this.completionPolicy = new CompletionPolicy({
-      ctx: this.ctx,
-      processManager: this.processManager,
-      ...this.config.processTimeout != null ? { processTimeout: this.config.processTimeout } : {}
-    });
-  }
-  trace(kind) {
-    this.traceWriter?.({ ts: Date.now(), kind });
-  }
-  async *stream(userMessages, signal) {
-    try {
-      const memo = this.config.sessionMemoStore.getMemoBySession ? await this.config.sessionMemoStore.getMemoBySession(this.config.sessionId) : (await this.config.sessionMemoStore.getMemosBySession(this.config.sessionId))[0] ?? null;
-      this.cachedSessionMemoFacts = memo ? [memo.content] : [];
-    } catch {
-      this.cachedSessionMemoFacts = [];
-    }
-    this.processManager.setSessionMemoFacts(this.cachedSessionMemoFacts);
-    const startTime = Date.now();
-    const maxTurns = this.config.maxTurns ?? 30;
-    let forcedFinalResponseRetry = false;
-    this.ctx.recordTurn({
-      role: "user",
-      messages: userMessages,
-      tokenEstimate: userMessages.reduce((sum, m) => {
-        const text = typeof m.content === "string" ? m.content : getTextContent(m.content);
-        return sum + estimateTokens(text);
-      }, 0),
-      timestamp: Date.now()
-    });
-    for (let turn = 0; turn < maxTurns; turn++) {
-      signal.throwIfAborted();
-      this.trace({ type: "turn_start", turn });
-      yield { type: "turn_start", turn };
-      yield* this.processManager.drainPendingEvents();
-      if (this.processManager.hasRunningProcesses()) {
-        await this.processManager.waitForPendingEvent(signal, 400);
-        const pending = [...this.processManager.drainPendingEvents()];
-        if (pending.length > 0) {
-          yield* pending;
-          continue;
-        }
-      }
-      const prepared = await this.ctx.prepare(signal);
-      this.trace({
-        type: "context_prepare",
-        used: prepared.budget.used,
-        limit: prepared.budget.limit,
-        compression_tier: "none"
-        // TODO: propagate actual tier from ContextWindow
-      });
-      const turnResult = yield* this.turnRunner.runTurn({
-        turn,
-        maxTurns,
-        prepared,
-        signal,
-        forcedFinalResponseRetry
-      });
-      if (turnResult.type === "retry_empty") {
-        forcedFinalResponseRetry = true;
-        continue;
-      }
-      if (turnResult.type === "done") {
-        this.trace({ type: "turn_end", turn });
-        yield { type: "turn_end", turn };
-        await this.processManager.waitForProcessListeners();
-        yield* this.processManager.drainPendingEvents();
-        this.trace({ type: "done" });
-        yield {
-          type: "done",
-          output: turnResult.output,
-          stats: { turns: turn + 1, processes: this.processManager.size, durationMs: Date.now() - startTime }
-        };
-        return;
-      }
-      this.trace({ type: "turn_end", turn });
-      yield { type: "turn_end", turn };
-      yield* this.completionPolicy.settleTurn(signal);
-    }
-    await this.processManager.waitForProcessListeners();
-    yield* this.processManager.drainPendingEvents();
-    this.trace({ type: "done" });
-    yield {
-      type: "done",
-      output: "Orchestrator reached maximum turns.",
-      stats: { turns: maxTurns, processes: this.processManager.size, durationMs: Date.now() - startTime }
-    };
-  }
-  async run(messages, signal) {
-    let output = "";
-    const events = [];
-    for await (const e of this.stream(messages, signal)) {
-      events.push(e);
-      if (e.type === "done") output = e.output;
-    }
-    return { output, events };
-  }
-};
-
-// src/arc/create-arc-agent.ts
-function createArcAgent(config) {
-  const loop = new ArcLoop(config);
-  return {
-    loop,
-    async run(messages, signal) {
-      const ac = new AbortController();
-      const effectiveSignal = signal ?? ac.signal;
-      const result = await loop.run(messages, effectiveSignal);
-      if (config.consolidate !== false) {
-        try {
-          await runConsolidation(
-            config.taskId,
-            config.sessionId,
-            config.episodeStore,
-            config.sessionMemoStore,
-            config.longTermStore
-          );
-        } catch {
-        }
-        if (config.autoMemory !== false) {
-          const memory = new MemoryManager({
-            sessionMemoStore: config.sessionMemoStore,
-            longTermStore: config.longTermStore,
-            sessionId: config.sessionId
-          });
-          try {
-            const episodes = await config.episodeStore.getEpisodesByTask(config.taskId);
-            await memory.detectAndPromote(episodes);
-          } catch {
-          }
-        }
-      }
-      return result;
-    },
-    async *stream(messages, signal) {
-      const ac = new AbortController();
-      const effectiveSignal = signal ?? ac.signal;
-      yield* loop.stream(messages, effectiveSignal);
-      if (config.consolidate !== false) {
-        void (async () => {
-          try {
-            await runConsolidation(
-              config.taskId,
-              config.sessionId,
-              config.episodeStore,
-              config.sessionMemoStore,
-              config.longTermStore
-            );
-          } catch {
-          }
-          if (config.autoMemory !== false) {
-            const memory = new MemoryManager({
-              sessionMemoStore: config.sessionMemoStore,
-              longTermStore: config.longTermStore,
-              sessionId: config.sessionId
-            });
-            try {
-              const episodes = await config.episodeStore.getEpisodesByTask(config.taskId);
-              await memory.detectAndPromote(episodes);
-            } catch {
-            }
-          }
-        })();
-      }
-    }
-  };
-}
-
-export { createArcAgent };
-//# sourceMappingURL=create-arc-agent.js.map
-//# sourceMappingURL=create-arc-agent.js.map