@bluecopa/harness 0.1.0-snapshot.101 → 0.1.0-snapshot.103

package/dist/arc/app-adapter.d.ts

@@ -1,4 +1,4 @@
-import { A as ArcEvent, S as StepUsage } from '../types-g-3DvSSE.js';
+import { A as ArcEvent, S as StepUsage } from '../types-BV-E1pvS.js';
 import 'zod';
 import 'ai';
 

package/dist/arc/create-arc-agent.d.ts

@@ -1,4 +1,4 @@
-import { a as ArcLoopConfig, b as AgentMessage, A as ArcEvent, c as ArcRunResult, T as TraceEvent } from '../types-g-3DvSSE.js';
+import { a as ArcLoopConfig, b as AgentMessage, A as ArcEvent, c as ArcRunResult, T as TraceEvent } from '../types-BV-E1pvS.js';
 import 'zod';
 import 'ai';
 

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

@@ -231,13 +231,24 @@ var Remember = tool({
   })
 });
 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.",
+  description: 'Retrieve prior episode context by ID. Default output is summary-first and includes structured output plus artifact handles when available. Set detail to "trace" or "artifacts" for richer detail.',
   inputSchema: z.object({
     id: z.string().describe("Episode ID to read"),
+    detail: z.enum(["summary", "trace", "artifacts"]).optional().describe("Level of detail to retrieve. Default: summary."),
+    artifactKey: z.string().optional().describe('Optional artifact handle to focus on when detail is "artifacts".'),
     maxTokens: z.number().optional().describe("Max tokens to return (truncates from the end). Default: no limit.")
   })
 });
-var orchestratorTools = { Thread, Check, Cancel, Remember, ReadEpisode };
+var ReadRollup = tool({
+  description: "Retrieve a rollup summary by ref or ID. Use to inspect compressed older history and discover which episode refs to hydrate next.",
+  inputSchema: z.object({
+    id: z.string().describe("Rollup ref or ID to read (for example: EE1)"),
+    detail: z.enum(["summary", "children"]).optional().describe("Whether to return just the rollup summary or include child refs/summaries. Default: summary."),
+    maxTokens: z.number().optional().describe("Max tokens to return (truncates from the end). Default: no limit.")
+  })
+});
+var orchestratorTools = { Thread, Check, Cancel, Remember, ReadEpisode, ReadRollup };
+var processTools = { ...builtinTools, ReadEpisode };
 tool({
   description: "Ask the user a question and wait for their response.",
   inputSchema: z.object({
@@ -320,6 +331,7 @@ var ContextWindow = class {
   config;
   turns = [];
   episodes = [];
+  rollups = [];
   cachedContextSize = null;
   constructor(config) {
     this.config = config;
@@ -351,6 +363,7 @@ var ContextWindow = class {
     const contextWindowSize = await this.getContextWindowSize();
     const totalBudget = contextWindowSize - this.config.outputReserve;
     this.episodes = await this.config.episodeStore.getEpisodesByTask(this.config.taskId);
+    this.rollups = this.config.rollupStore ? await this.config.rollupStore.getRollupsByTask(this.config.taskId) : [];
     const filesBeingTouched = this.extractFilesBeingTouched();
     const systemTokens = estimateTokens(this.config.systemPrompt);
     const memoryBudget = Math.min(Math.floor(totalBudget * 0.15), 4e3);
@@ -367,7 +380,7 @@ var ContextWindow = class {
       totalUsed = systemTokens + memoryTokens + episodeTokens + conversationTokens;
     }
     const episodeBudget = Math.floor(totalBudget * 0.2);
-    if (episodeTokens > episodeBudget && this.episodes.length > 10) {
+    if (episodeTokens > episodeBudget && this.episodes.length > 10 && this.rollups.length === 0) {
       const grouped = this.groupEpisodeSummaries();
       episodeTokens = estimateMessagesTokens(grouped);
       episodeMessages.length = 0;
@@ -410,14 +423,13 @@ var ContextWindow = class {
     const contextWindowSize = await this.getContextWindowSize();
     const totalBudget = contextWindowSize - this.config.outputReserve;
     const systemTokens = estimateTokens(this.config.systemPrompt);
+    this.episodes = await this.config.episodeStore.getEpisodesByTask(this.config.taskId);
+    this.rollups = this.config.rollupStore ? await this.config.rollupStore.getRollupsByTask(this.config.taskId) : [];
     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);
-    }
+    const episodeTokens = estimateMessagesTokens(this.buildEpisodeSummaries());
     return {
       limit: totalBudget,
       used: systemTokens + conversationTokens + episodeTokens,
@@ -451,14 +463,40 @@ var ContextWindow = class {
   }
   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");
+    const recentEpisodes = this.episodes.slice(-5);
+    const recentStartIndex = recentEpisodes[0]?.index ?? Number.MAX_SAFE_INTEGER;
+    const rollupLines = this.buildRollupFrontier(recentStartIndex).map((rollup) => `${rollup.ref} [E${rollup.rangeStartIndex}-E${rollup.rangeEndIndex}]:
+${rollup.summary}`);
+    const coveredEpisodeIds = new Set(
+      this.buildRollupFrontier(recentStartIndex).flatMap((rollup) => rollup.childEpisodeIds)
+    );
+    const olderLeafLines = this.episodes.filter((episode) => episode.index < recentStartIndex && !coveredEpisodeIds.has(episode.id)).map((episode) => `Episode E${episode.index} [${episode.id}] (${episode.success ? "ok" : "failed"}):
+${episode.summary}`);
+    const recentLines = recentEpisodes.map((episode) => `Episode E${episode.index} [${episode.id}] (${episode.success ? "ok" : "failed"}):
+${episode.summary}`);
+    const episodeText = [...rollupLines, ...olderLeafLines, ...recentLines].join("\n\n");
     return [{
       role: "system",
       content: `Prior episodes for this task:
 ${episodeText}`
     }];
   }
+  buildRollupFrontier(beforeEpisodeIndex) {
+    if (this.rollups.length === 0) {
+      return [];
+    }
+    const eligible = this.rollups.filter((rollup) => rollup.rangeEndIndex < beforeEpisodeIndex).sort((a, b) => b.level - a.level || a.rangeStartIndex - b.rangeStartIndex);
+    const selected = [];
+    for (const rollup of eligible) {
+      const overlaps = selected.some(
+        (existing) => !(rollup.rangeEndIndex < existing.rangeStartIndex || rollup.rangeStartIndex > existing.rangeEndIndex)
+      );
+      if (!overlaps) {
+        selected.push(rollup);
+      }
+    }
+    return selected.sort((a, b) => a.rangeStartIndex - b.rangeStartIndex);
+  }
   buildTurnMessages() {
     const messages = [];
     for (const turn of this.turns) {
@@ -732,6 +770,96 @@ ${repeatedErrors.map(([action, n]) => `  "${action}" failed ${n}x`).join("\n")}`
     return { removed, merged };
   }
 };
+var ROLLUP_GROUP_SIZE = 6;
+function nextRollupRef(level, existing) {
+  const prefix = "E".repeat(level + 1);
+  const maxIndex = existing.filter((rollup) => rollup.level === level).map((rollup) => Number(rollup.ref.slice(prefix.length))).filter((value) => Number.isFinite(value)).reduce((max, value) => Math.max(max, value), 0);
+  return `${prefix}${maxIndex + 1}`;
+}
+function summarizeEpisodeBatch(episodes) {
+  const files = [...new Set(episodes.flatMap((episode) => [...episode.filesRead, ...episode.filesModified]))];
+  const childRefs = episodes.map((episode) => `E${episode.index}`);
+  const actions = episodes.map((episode) => `- E${episode.index}: ${episode.threadAction} (${episode.success ? "ok" : "failed"})`);
+  return [
+    `Summary of [${childRefs[0]}-${childRefs[childRefs.length - 1]}]`,
+    ...actions,
+    ...files.length > 0 ? [`Key files: ${files.join(", ")}`] : []
+  ].join("\n");
+}
+function summarizeRollupBatch(rollups) {
+  const childRefs = rollups.map((rollup) => rollup.ref);
+  const files = [...new Set(rollups.flatMap((rollup) => rollup.keyFiles))];
+  const summaries = rollups.map((rollup) => `- ${rollup.ref}: ${rollup.summary.split("\n")[0] ?? rollup.summary}`);
+  return [
+    `Summary of [${childRefs[0]}-${childRefs[childRefs.length - 1]}]`,
+    ...summaries,
+    ...files.length > 0 ? [`Key files: ${files.join(", ")}`] : []
+  ].join("\n");
+}
+async function buildEpisodeRollups(episodes, sessionId, rollupStore) {
+  const sortedEpisodes = [...episodes].sort((a, b) => a.index - b.index);
+  let rollups = await rollupStore.getRollupsBySession(sessionId);
+  const coveredEpisodeIds = new Set(rollups.flatMap((rollup) => rollup.childEpisodeIds));
+  const uncoveredEpisodes = sortedEpisodes.filter((episode) => !coveredEpisodeIds.has(episode.id));
+  const level1Chunks = [];
+  for (let index = 0; index + ROLLUP_GROUP_SIZE <= uncoveredEpisodes.length; index += ROLLUP_GROUP_SIZE) {
+    level1Chunks.push(uncoveredEpisodes.slice(index, index + ROLLUP_GROUP_SIZE));
+  }
+  for (const chunk of level1Chunks) {
+    const rollup = {
+      id: randomUUID(),
+      ref: nextRollupRef(1, rollups),
+      taskId: chunk[0].taskId,
+      sessionId,
+      level: 1,
+      summary: summarizeEpisodeBatch(chunk),
+      childEpisodeIds: chunk.map((episode) => episode.id),
+      childRollupIds: [],
+      rangeStartIndex: chunk[0].index,
+      rangeEndIndex: chunk[chunk.length - 1].index,
+      keyFiles: [...new Set(chunk.flatMap((episode) => [...episode.filesRead, ...episode.filesModified]))],
+      createdAt: Date.now()
+    };
+    await rollupStore.addRollup(rollup);
+    rollups = [...rollups, rollup];
+  }
+  let level = 1;
+  while (true) {
+    const allRollups = await rollupStore.getRollupsBySession(sessionId);
+    const parentedChildIds = new Set(
+      allRollups.flatMap((rollup) => rollup.childRollupIds)
+    );
+    const levelCandidates = allRollups.filter((rollup) => rollup.level === level && !parentedChildIds.has(rollup.id)).sort((a, b) => a.rangeStartIndex - b.rangeStartIndex);
+    if (levelCandidates.length < ROLLUP_GROUP_SIZE) {
+      break;
+    }
+    const batches = [];
+    for (let index = 0; index + ROLLUP_GROUP_SIZE <= levelCandidates.length; index += ROLLUP_GROUP_SIZE) {
+      batches.push(levelCandidates.slice(index, index + ROLLUP_GROUP_SIZE));
+    }
+    if (batches.length === 0) {
+      break;
+    }
+    for (const batch of batches) {
+      const rollup = {
+        id: randomUUID(),
+        ref: nextRollupRef(level + 1, allRollups),
+        taskId: batch[0].taskId,
+        sessionId,
+        level: level + 1,
+        summary: summarizeRollupBatch(batch),
+        childEpisodeIds: [],
+        childRollupIds: batch.map((child) => child.id),
+        rangeStartIndex: batch[0].rangeStartIndex,
+        rangeEndIndex: batch[batch.length - 1].rangeEndIndex,
+        keyFiles: [...new Set(batch.flatMap((rollupChild) => rollupChild.keyFiles))],
+        createdAt: Date.now()
+      };
+      await rollupStore.addRollup(rollup);
+    }
+    level += 1;
+  }
+}
 async function consolidateEpisodes(episodes, sessionId, sessionMemoStore) {
   if (episodes.length === 0) {
     throw new Error("Cannot consolidate zero episodes");
@@ -770,9 +898,12 @@ async function consolidateEpisodes(episodes, sessionId, sessionMemoStore) {
   await sessionMemoStore.addMemo(memo);
   return memo;
 }
-async function runConsolidation(_taskId, sessionId, episodeStore, sessionMemoStore, _longTermStore) {
+async function runConsolidation(_taskId, sessionId, episodeStore, sessionMemoStore, _longTermStore, rollupStore) {
   const episodes = await episodeStore.getEpisodesBySession(sessionId);
   if (episodes.length > 0) {
+    if (rollupStore) {
+      await buildEpisodeRollups(episodes, sessionId, rollupStore);
+    }
     await consolidateEpisodes(episodes, sessionId, sessionMemoStore);
   }
 }
@@ -1064,6 +1195,7 @@ var EpisodeCompressor = class {
   compress(input) {
     const now = Date.now();
     const id = randomUUID();
+    const artifacts = extractArtifacts(input.messages);
     const episode = {
       id,
       taskId: input.taskId,
@@ -1078,14 +1210,14 @@ var EpisodeCompressor = class {
       steps: countSteps(input.messages),
       success: input.success,
       createdAt: now,
-      parentEpisodeIds: input.parentEpisodeIds
+      parentEpisodeIds: input.parentEpisodeIds,
+      artifactKeys: artifacts.map((artifact) => artifact.key)
     };
     const trace = {
       episodeId: id,
       messages: input.messages,
       createdAt: now
     };
-    const artifacts = extractArtifacts(input.messages);
     return { episode, trace, artifacts };
   }
   async compressLLM(input, signal) {
@@ -1844,32 +1976,29 @@ 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");
+    const episode = await episodeStore.getEpisode(id);
+    if (!episode) continue;
+    const blocks = [
+      `Action: ${episode.threadAction}`,
+      `Status: ${episode.success ? "success" : "failed"}`,
+      `Summary:
+${episode.summary}`
+    ];
+    if (episode.structuredOutput && Object.keys(episode.structuredOutput).length > 0) {
+      const structuredOutput = JSON.stringify(episode.structuredOutput, null, 2);
+      const truncated = structuredOutput.length > 2e3 ? structuredOutput.slice(0, 2e3) + "\n... [truncated]" : structuredOutput;
+      blocks.push(`Structured output:
+${truncated}`);
+    }
+    if (episode.artifactKeys && episode.artifactKeys.length > 0) {
+      blocks.push(`Artifact handles:
+${episode.artifactKeys.join(", ")}`);
+    }
+    blocks.push('Use ReadEpisode with detail: "trace" or "artifacts" only if you need more than this summary.');
     messages.push({
       role: "system",
       content: `Context from prior episode (${id}):
-${traceText}`
+${blocks.join("\n\n")}`
     });
   }
   return messages;
@@ -1897,6 +2026,114 @@ async function* drainNonBlocking(iterable) {
     yield next.value;
   }
 }
+
+// src/arc/episode-reader.ts
+function coerceDetail(value, fallback) {
+  if (value === "summary" || value === "trace" || value === "artifacts") {
+    return value;
+  }
+  return fallback;
+}
+function renderTraceText(messages) {
+  return 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");
+}
+function formatSummaryBlock(episode) {
+  const lines = [
+    `Action: ${episode.threadAction}`,
+    `Status: ${episode.success ? "success" : "failed"}`,
+    `Summary:
+${episode.summary}`
+  ];
+  if (episode.structuredOutput && Object.keys(episode.structuredOutput).length > 0) {
+    const structuredOutput = JSON.stringify(episode.structuredOutput, null, 2);
+    const truncated = structuredOutput.length > 2e3 ? structuredOutput.slice(0, 2e3) + "\n... [truncated]" : structuredOutput;
+    lines.push(`Structured output:
+${truncated}`);
+  }
+  if (episode.artifactKeys && episode.artifactKeys.length > 0) {
+    lines.push(`Artifact handles:
+${episode.artifactKeys.join(", ")}`);
+  }
+  lines.push(`Use ReadEpisode with detail: "trace" or "artifacts" for more detail from this episode.`);
+  return lines.join("\n\n");
+}
+function formatArtifactsBlock(artifacts, artifactKey) {
+  const filtered = artifactKey ? artifacts.filter((artifact) => artifact.key === artifactKey) : artifacts;
+  if (filtered.length === 0) {
+    return artifactKey ? `Artifact not found: ${artifactKey}` : "No artifact content is currently available for this episode.";
+  }
+  return filtered.map((artifact) => `[${artifact.key}]
+${artifact.content}`).join("\n\n");
+}
+function applyMaxTokens(text, maxTokens) {
+  if (typeof maxTokens !== "number" || maxTokens <= 0) {
+    return text;
+  }
+  const maxChars = maxTokens * 4;
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return text.slice(0, maxChars) + "\n... [truncated]";
+}
+async function renderEpisodeReadResult(options) {
+  const episodeId = String(options.args.id ?? "");
+  const detail = coerceDetail(options.args.detail, options.defaultDetail ?? "summary");
+  const artifactKey = options.args.artifactKey != null ? String(options.args.artifactKey) : void 0;
+  const episode = await options.episodeStore.getEpisode(episodeId);
+  if (!episode) {
+    return `Episode not found: ${episodeId}`;
+  }
+  const proc = options.processes ? [...options.processes].find((process2) => process2.result?.episode.id === episodeId) : void 0;
+  const liveArtifacts = proc?.result?.artifacts ?? [];
+  let resultText = `Episode ${episodeId}
+
+${formatSummaryBlock(episode)}`;
+  if (detail === "artifacts") {
+    resultText = `Episode ${episodeId}
+
+${formatArtifactsBlock(liveArtifacts, artifactKey)}`;
+  } else if (detail === "trace") {
+    const trace = await options.episodeStore.getTrace(episodeId);
+    if (!trace) {
+      resultText += "\n\nTrace not found.";
+    } else {
+      resultText += `
+
+--- Trace ---
+${renderTraceText(trace.messages)}`;
+    }
+    if (liveArtifacts.length > 0) {
+      resultText += `
+
+--- Artifacts ---
+${formatArtifactsBlock(liveArtifacts, artifactKey)}`;
+    }
+  } else if (artifactKey) {
+    resultText += `
+
+Requested artifact handle: ${artifactKey}`;
+  }
+  return applyMaxTokens(resultText, options.args.maxTokens);
+}
 var FIELD_RE = /^(\w+)(?::(\w+)(\[\])?)(\?)?(?:\s*\(([^)]+)\))?$/;
 function parseField(raw) {
   const trimmed = raw.trim();
@@ -2054,7 +2291,7 @@ var ProcessManager = class {
   dispatch(request, parentSignal) {
     const { loopConfig } = this.config;
     const profileConfig = request.profile ? loopConfig.processProfiles?.[request.profile] : void 0;
-    const globalTools = loopConfig.processTools ?? builtinTools;
+    const globalTools = loopConfig.processTools ?? processTools;
     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;
@@ -2103,9 +2340,32 @@ var ProcessManager = class {
       ...pickDefined(loopConfig, [
         "hookRunner",
         "permissionManager",
-        "telemetry",
-        "executeToolAction"
-      ])
+        "telemetry"
+      ]),
+      executeToolAction: async (action) => {
+        if (action.name === "ReadEpisode") {
+          const allowedEpisodeIds = new Set(request.contextEpisodeIds ?? []);
+          const requestedEpisodeId = String(action.args.id ?? "");
+          if (!allowedEpisodeIds.has(requestedEpisodeId)) {
+            return {
+              success: false,
+              output: "",
+              error: `ReadEpisode is limited to contextEpisodeIds for this thread. Allowed episode IDs: ${[...allowedEpisodeIds].join(", ") || "(none)"}`
+            };
+          }
+          const output = await renderEpisodeReadResult({
+            episodeStore: loopConfig.episodeStore,
+            args: action.args,
+            defaultDetail: "summary",
+            processes: this.processes.values()
+          });
+          return { success: true, output };
+        }
+        if (loopConfig.executeToolAction) {
+          return loopConfig.executeToolAction(action);
+        }
+        return null;
+      }
     });
     this.processes.set(proc.id, proc);
     this.actionIndex.set(normalizeAction(request.action), proc.id);
@@ -2250,6 +2510,64 @@ var ProcessManager = class {
     }
   }
 };
+
+// src/arc/rollup-reader.ts
+function applyMaxTokens2(text, maxTokens) {
+  if (typeof maxTokens !== "number" || maxTokens <= 0) {
+    return text;
+  }
+  const maxChars = maxTokens * 4;
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return text.slice(0, maxChars) + "\n... [truncated]";
+}
+function formatRollupSummary(rollup) {
+  return [
+    `Rollup ${rollup.ref}`,
+    `Level: ${rollup.level}`,
+    `Covers: E${rollup.rangeStartIndex}-E${rollup.rangeEndIndex}`,
+    `Child episodes: ${rollup.childEpisodeIds.length}`,
+    `Child rollups: ${rollup.childRollupIds.length}`,
+    ...rollup.keyFiles.length > 0 ? [`Key files: ${rollup.keyFiles.join(", ")}`] : [],
+    "",
+    rollup.summary
+  ].join("\n");
+}
+async function renderRollupReadResult(options) {
+  const rollupId = String(options.args.id ?? "");
+  const rollup = await options.rollupStore.getRollup(rollupId);
+  if (!rollup) {
+    return `Rollup not found: ${rollupId}`;
+  }
+  const detail = options.args.detail === "children" ? "children" : "summary";
+  let resultText = formatRollupSummary(rollup);
+  if (detail === "children") {
+    const childSections = [];
+    for (const childRollupId of rollup.childRollupIds) {
+      const childRollup = await options.rollupStore.getRollup(childRollupId);
+      if (childRollup) {
+        childSections.push(`--- Child rollup ${childRollup.ref} ---
+${childRollup.summary}`);
+      }
+    }
+    for (const childEpisodeId of rollup.childEpisodeIds) {
+      const episode = await options.episodeStore.getEpisode(childEpisodeId);
+      if (episode) {
+        childSections.push(`--- Episode E${episode.index} [${episode.id}] ---
+${episode.summary}`);
+      }
+    }
+    if (childSections.length > 0) {
+      resultText += `
+
+${childSections.join("\n\n")}`;
+    }
+  }
+  return applyMaxTokens2(resultText, options.args.maxTokens);
+}
+
+// src/arc/orchestrator-turn-runner.ts
 var OrchestratorTurnRunner = class {
   config;
   constructor(config) {
@@ -2382,13 +2700,6 @@ var OrchestratorTurnRunner = class {
           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({
@@ -2435,45 +2746,12 @@ ${proc.result.episode.summary}`;
         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]";
-            }
-          }
-        }
+        const resultText = await renderEpisodeReadResult({
+          episodeStore: this.config.config.episodeStore,
+          args: call.args,
+          defaultDetail: "summary",
+          processes: this.config.processManager.values()
+        });
         toolResultMessages.push({
           role: "tool",
           content: resultText,
@@ -2481,6 +2759,20 @@ ${artifact.content}`).join("\n\n");
         });
         continue;
       }
+      if (call.toolName === "ReadRollup") {
+        const rollupStore = this.config.config.rollupStore;
+        const resultText = rollupStore ? await renderRollupReadResult({
+          rollupStore,
+          episodeStore: this.config.config.episodeStore,
+          args: call.args
+        }) : "Rollup store is not configured.";
+        toolResultMessages.push({
+          role: "tool",
+          content: resultText,
+          toolResults: [{ toolCallId, toolName: "ReadRollup", result: resultText }]
+        });
+        continue;
+      }
       if (call.toolName === "Remember") {
         const memOpts = {};
         if (call.args.category != null) memOpts.category = String(call.args.category);
@@ -2630,6 +2922,7 @@ var DEFAULT_ORCHESTRATOR_PROMPT = `You are an orchestrator agent. You accomplish
 - **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).
+- **ReadRollup**: Retrieve an indexed rollup of older episode history and discover which episode refs to hydrate next.
 
 ## When to dispatch threads
 
@@ -2712,6 +3005,7 @@ var ArcLoop = class {
       outputReserve: config.outputReserve ?? 2e4,
       systemPrompt: this.systemPrompt,
       episodeStore: config.episodeStore,
+      ...config.rollupStore ? { rollupStore: config.rollupStore } : {},
       memory: this.memory,
       taskId: config.taskId,
       createModel: this.createModel,
@@ -2868,7 +3162,8 @@ function createArcAgent(config) {
             config.sessionId,
             config.episodeStore,
             config.sessionMemoStore,
-            config.longTermStore
+            config.longTermStore,
+            config.rollupStore
           );
         } catch {
         }
@@ -2899,7 +3194,8 @@ function createArcAgent(config) {
               config.sessionId,
               config.episodeStore,
               config.sessionMemoStore,
-              config.longTermStore
+              config.longTermStore,
+              config.rollupStore
             );
           } catch {
           }