@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/background/chain-append.js

@@ -3,7 +3,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { appendJsonl } from "../../shared/artifacts.js";
-import { readStatus } from "../../shared/utils.js";
+import { PROMPT_REDACTED, readStatus } from "../../shared/utils.js";
+import { deriveChildSessionName } from "../../shared/child-session-name.js";
 import { isDynamicRunnerGroup, isParallelGroup } from "../shared/parallel-utils.js";
 const APPEND_REQUESTS_DIR = "append-requests";
 function appendDir(asyncDir) {
@@ -60,30 +61,49 @@ export function enqueueChainAppendRequest(input) {
     steps: input.steps
   };
   fs.mkdirSync(appendDir(input.asyncDir), { recursive: true });
-  writeAtomicJson(appendRequestPath(input.asyncDir, request), request);
-  const pendingCount = countPendingChainAppendRequests(input.asyncDir);
+  const persist = () => writeAtomicJson(appendRequestPath(input.asyncDir, request), request);
+  if (input.admit)
+    input.admit(persist);
+  else
+    persist();
+  let pendingCount = 1;
+  const bookkeepingErrors = [];
+  try {
+    pendingCount = countPendingChainAppendRequests(input.asyncDir);
+  } catch (error) {
+    bookkeepingErrors.push(`pending append count failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
   const statusPath = path.join(input.asyncDir, "status.json");
   const updatedStatus = { ...status, pendingAppends: pendingCount, lastUpdate: request.createdAt };
-  writeAtomicJson(statusPath, updatedStatus);
-  appendJsonl(path.join(input.asyncDir, "events.jsonl"), JSON.stringify({
-    type: "subagent.chain.append.requested",
-    ts: request.createdAt,
-    runId: input.runId,
-    requestId: request.id,
-    stepCount: input.steps.length,
-    pendingAppends: pendingCount
-  }));
-  return { request, pendingCount };
+  try {
+    writeAtomicJson(statusPath, updatedStatus);
+  } catch (error) {
+    bookkeepingErrors.push(`status update failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  try {
+    appendJsonl(path.join(input.asyncDir, "events.jsonl"), JSON.stringify({
+      type: "subagent.chain.append.requested",
+      ts: request.createdAt,
+      runId: input.runId,
+      requestId: request.id,
+      stepCount: input.steps.length,
+      pendingAppends: pendingCount
+    }));
+  } catch (error) {
+    bookkeepingErrors.push(`event append failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return { request, pendingCount, ...bookkeepingErrors.length > 0 ? { bookkeepingError: bookkeepingErrors.join("; ") } : {} };
 }
 function readAppendRequest(filePath) {
   const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
   if (!raw.id || typeof raw.id !== "string")
     return;
-  if (!Number.isFinite(raw.createdAt))
+  const createdAt = raw.createdAt;
+  if (typeof createdAt !== "number" || !Number.isFinite(createdAt))
     return;
   if (!Array.isArray(raw.steps) || raw.steps.length === 0)
     return;
-  return { id: raw.id, createdAt: raw.createdAt, steps: raw.steps };
+  return { id: raw.id, createdAt, steps: raw.steps };
 }
 export function readPendingChainAppendRequests(asyncDir) {
   return listAppendRequestFiles(asyncDir).map((filePath) => readAppendRequest(filePath)).filter((request) => Boolean(request)).sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id));
@@ -100,9 +120,21 @@ export function consumeChainAppendRequests(asyncDir) {
   }
   return requests.sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id));
 }
+const MAX_STATUS_STEP_DESCRIPTION_CHARS = 160;
+export function statusStepDescription(task) {
+  if (!task?.trim())
+    return;
+  const description = PROMPT_REDACTED;
+  return description.length > MAX_STATUS_STEP_DESCRIPTION_CHARS ? `${description.slice(0, MAX_STATUS_STEP_DESCRIPTION_CHARS - 1)}…` : description;
+}
 function statusStepForTask(task) {
+  const description = statusStepDescription(task.task);
+  const sessionName = task.sessionName ?? deriveChildSessionName({ agent: task.agent, task: task.task, label: task.label });
   return {
     agent: task.agent,
+    ...sessionName ? { sessionName } : {},
+    ...description ? { description } : {},
+    ...task.context ? { context: task.context } : {},
     phase: task.phase,
     label: task.label,
     outputName: task.outputName,
@@ -111,6 +143,7 @@ function statusStepForTask(task) {
     ...task.sessionFile ? { sessionFile: task.sessionFile } : {},
     skills: task.skills,
     model: task.model,
+    ...task.contextLimit !== undefined ? { contextLimit: task.contextLimit } : {},
     thinking: task.thinking,
     attemptedModels: task.modelCandidates && task.modelCandidates.length > 0 ? task.modelCandidates : task.model ? [task.model] : undefined,
     recentTools: [],
@@ -123,10 +156,12 @@ function statusStepsForRunnerStep(step) {
   if (isDynamicRunnerGroup(step)) {
     return [{
       agent: `expand:${step.parallel.agent}`,
+      ...step.parallel.context ? { context: step.parallel.context } : {},
       phase: step.phase ?? step.parallel.phase,
       label: step.label ?? step.parallel.label ?? `Dynamic fanout (${step.collect.as})`,
       outputName: step.collect.as,
       structured: Boolean(step.collect.outputSchema),
+      ...step.parallel.contextLimit !== undefined ? { contextLimit: step.parallel.contextLimit } : {},
       status: "pending",
       recentTools: [],
       recentOutput: []

package/extensions/dm-subagents/src/runs/background/chain-root-attachment.js

@@ -1,8 +1,25 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { resultFilePath, resultPayloadPathForSessionRun } from "./result-files.js";
 import { readStatus } from "../../shared/utils.js";
-const TERMINAL_STATES = new Set(["complete", "failed", "paused"]);
-const TERMINAL_STEP_STATUSES = new Set(["complete", "completed", "failed", "paused"]);
+const TERMINAL_STATES = new Set(["complete", "failed", "partial", "paused", "stopped"]);
+const TERMINAL_STEP_STATUSES = new Set(["complete", "completed", "failed", "partial", "paused", "stopped"]);
+function usageFromAttempts(attempts) {
+  if (!attempts?.length)
+    return;
+  const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+  for (const attempt of attempts) {
+    if (!attempt.usage)
+      continue;
+    usage.input += attempt.usage.input;
+    usage.output += attempt.usage.output;
+    usage.cacheRead += attempt.usage.cacheRead;
+    usage.cacheWrite += attempt.usage.cacheWrite;
+    usage.cost += attempt.usage.cost;
+    usage.turns += attempt.usage.turns;
+  }
+  return usage.input !== 0 || usage.output !== 0 || usage.cacheRead !== 0 || usage.cacheWrite !== 0 || usage.cost !== 0 || usage.turns !== 0 ? usage : undefined;
+}
 function readResultFile(resultPath) {
   try {
     return JSON.parse(fs.readFileSync(resultPath, "utf-8"));
@@ -13,6 +30,13 @@ function readResultFile(resultPath) {
     throw error;
   }
 }
+function readImportedResultFile(root, status) {
+  const direct = readResultFile(root.resultPath);
+  if (direct || !status?.sessionId)
+    return direct;
+  const indexedPath = resultPayloadPathForSessionRun(path.dirname(root.resultPath), status.sessionId, root.runId);
+  return indexedPath ? readResultFile(indexedPath) : undefined;
+}
 function selectedStatusStep(status, index) {
   return status?.steps?.[index];
 }
@@ -27,11 +51,13 @@ function isTerminalStatus(status, index) {
 function resultState(result, child) {
   if (!result)
     return;
+  if (child?.stopped === true)
+    return "stopped";
   if (child?.success === true)
     return "complete";
   if (child?.success === false)
-    return result.state === "paused" ? "paused" : "failed";
-  if (result.state === "complete" || result.state === "failed" || result.state === "paused")
+    return result.state === "stopped" ? "stopped" : result.state === "paused" ? "paused" : result.state === "partial" ? "partial" : "failed";
+  if (result.state === "complete" || result.state === "failed" || result.state === "partial" || result.state === "paused" || result.state === "stopped")
     return result.state;
   if (result.success === true)
     return "complete";
@@ -42,7 +68,11 @@ function resultState(result, child) {
 function outputFromTerminalStatus(root, status, step) {
   const agent = step?.agent ?? status.steps?.[root.index]?.agent ?? "subagent";
   const timedOut = step?.timedOut === true || status.timedOut === true;
-  const message = step?.error ?? status.error ?? `Attached async root ${root.runId} ended without a result file at ${root.resultPath}.`;
+  const stopped = step?.stopped === true || status.stopped === true || status.state === "stopped";
+  const message = step?.error ?? status.error ?? (stopped ? "Subagent stopped by user." : `Attached async root ${root.runId} ended without a result file at ${root.resultPath}.`);
+  const partialStatus = status.state === "partial" || step?.status === "partial";
+  const execution = step?.execution ?? (partialStatus ? { status: "partial", success: false, exitCode: 1, error: message } : undefined);
+  const usage = usageFromAttempts(step?.modelAttempts);
   return {
     agent,
     output: message,
@@ -50,19 +80,27 @@ function outputFromTerminalStatus(root, status, step) {
     exitCode: 1,
     error: message,
     ...timedOut ? { timedOut: true } : {},
+    ...stopped ? { stopped: true } : {},
+    ...step?.sessionName ? { sessionName: step.sessionName } : {},
     ...step?.sessionFile ?? status.sessionFile ? { sessionFile: step?.sessionFile ?? status.sessionFile } : {},
     ...step?.model ? { model: step.model } : {},
     ...step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {},
     ...step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {},
+    ...step?.contextOverflow ? { contextOverflow: true } : {},
     ...step?.totalCost ? { totalCost: step.totalCost } : {},
+    ...usage ? { usage } : {},
     ...step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {},
     ...step?.structuredOutputPath ? { structuredOutputPath: step.structuredOutputPath } : {},
     ...step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: step.structuredOutputSchemaPath } : {},
-    ...step?.acceptance ? { acceptance: step.acceptance } : {}
+    ...step?.acceptance ? { acceptance: step.acceptance } : {},
+    ...execution ? { execution } : {},
+    ...step?.effects ? { effects: step.effects } : {},
+    ...step?.transcriptPath ? { transcriptPath: step.transcriptPath } : {}
   };
 }
 function outputFromTimeout(root, status, message) {
   const step = selectedStatusStep(status, root.index);
+  const usage = usageFromAttempts(step?.modelAttempts);
   return {
     agent: step?.agent ?? status?.steps?.[root.index]?.agent ?? "subagent",
     output: message,
@@ -70,11 +108,15 @@ function outputFromTimeout(root, status, message) {
     exitCode: 1,
     error: message,
     timedOut: true,
+    ...step?.sessionName ? { sessionName: step.sessionName } : {},
     ...step?.sessionFile ?? status?.sessionFile ? { sessionFile: step?.sessionFile ?? status?.sessionFile } : {},
     ...step?.model ? { model: step.model } : {},
     ...step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {},
     ...step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {},
-    ...step?.totalCost ? { totalCost: step.totalCost } : {}
+    ...step?.contextOverflow ? { contextOverflow: true } : {},
+    ...step?.totalCost ? { totalCost: step.totalCost } : {},
+    ...usage ? { usage } : {},
+    ...step?.transcriptPath ? { transcriptPath: step.transcriptPath } : {}
   };
 }
 function buildImportedResult(root, status, result) {
@@ -84,8 +126,11 @@ function buildImportedResult(root, status, result) {
   const agent = child?.agent ?? step?.agent ?? status?.steps?.[root.index]?.agent ?? "subagent";
   const output = child?.output ?? result.summary ?? "";
   const timedOut = child?.timedOut === true || step?.timedOut === true || result.timedOut === true || status?.timedOut === true;
-  const success = state === "complete" && !timedOut;
-  const error = child?.error ?? (success ? undefined : result.error ?? result.summary ?? status?.error ?? `Attached async root ${root.runId} did not complete successfully.`);
+  const stopped = child?.stopped === true || step?.stopped === true || result.stopped === true || status?.stopped === true || state === "stopped";
+  const success = state === "complete" && !timedOut && !stopped;
+  const error = child?.error ?? (success ? undefined : stopped ? "Subagent stopped by user." : result.error ?? result.summary ?? status?.error ?? `Attached async root ${root.runId} did not complete successfully.`);
+  const execution = state ? { status: state === "complete" ? "completed" : state, success, exitCode: success ? 0 : 1, ...error ? { error } : {} } : undefined;
+  const usage = child?.usage ?? usageFromAttempts(step?.modelAttempts);
   return {
     agent,
     output: success ? output : output || error || "",
@@ -93,16 +138,26 @@ function buildImportedResult(root, status, result) {
     exitCode: success ? 0 : 1,
     ...error ? { error } : {},
     ...timedOut ? { timedOut: true } : {},
+    ...stopped ? { stopped: true } : {},
+    ...child?.sessionName ?? step?.sessionName ? { sessionName: child?.sessionName ?? step?.sessionName } : {},
     ...child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile ? { sessionFile: child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile } : {},
     ...child?.intercomTarget ? { intercomTarget: child.intercomTarget } : {},
     ...child?.model ?? step?.model ? { model: child?.model ?? step?.model } : {},
     ...child?.attemptedModels ?? step?.attemptedModels ? { attemptedModels: child?.attemptedModels ?? step?.attemptedModels } : {},
     ...child?.modelAttempts ?? step?.modelAttempts ? { modelAttempts: child?.modelAttempts ?? step?.modelAttempts } : {},
+    ...child?.contextOverflow || step?.contextOverflow ? { contextOverflow: true } : {},
     ...child?.totalCost ?? step?.totalCost ? { totalCost: child?.totalCost ?? step?.totalCost } : {},
+    ...usage ? { usage } : {},
     ...child?.structuredOutput !== undefined ? { structuredOutput: child.structuredOutput } : step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {},
     ...child?.structuredOutputPath ?? step?.structuredOutputPath ? { structuredOutputPath: child?.structuredOutputPath ?? step?.structuredOutputPath } : {},
     ...child?.structuredOutputSchemaPath ?? step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: child?.structuredOutputSchemaPath ?? step?.structuredOutputSchemaPath } : {},
-    ...child?.acceptance ?? step?.acceptance ? { acceptance: child?.acceptance ?? step?.acceptance } : {}
+    ...child?.acceptance ?? step?.acceptance ? { acceptance: child?.acceptance ?? step?.acceptance } : {},
+    ...child?.artifactPaths ? { artifactPaths: child.artifactPaths } : {},
+    ...child?.outputSaveError ? { outputSaveError: child.outputSaveError } : {},
+    ...child?.transcriptPath ?? step?.transcriptPath ? { transcriptPath: child?.transcriptPath ?? step?.transcriptPath } : {},
+    ...child?.transcriptError ? { transcriptError: child.transcriptError } : {},
+    ...execution ? { execution } : {},
+    ...child?.effects ?? step?.effects ? { effects: child?.effects ?? step?.effects } : {}
   };
 }
 export async function waitForImportedAsyncRoot(root, options = {}) {
@@ -114,7 +169,7 @@ export async function waitForImportedAsyncRoot(root, options = {}) {
     const status = readStatus(root.asyncDir);
     if (options.shouldAbort?.())
       return outputFromTimeout(root, status, options.timeoutMessage ?? "Subagent timed out.");
-    const result = readResultFile(root.resultPath);
+    const result = readImportedResultFile(root, status);
     if (result)
       return buildImportedResult(root, status, result);
     if (isTerminalStatus(status, root.index)) {
@@ -132,5 +187,5 @@ export async function waitForImportedAsyncRoot(root, options = {}) {
   }
 }
 export function resolveAsyncRootResultPath(resultsDir, runId) {
-  return path.join(resultsDir, `${runId}.json`);
+  return resultFilePath(resultsDir, runId);
 }

package/extensions/dm-subagents/src/runs/background/completion-batcher.js

@@ -41,7 +41,9 @@ export function createCompletionBatcher(options) {
         options.emit([item]);
       },
       flush() {},
-      dispose() {}
+      dispose() {
+        return [];
+      }
     };
   }
   let pending = [];
@@ -88,7 +90,9 @@ export function createCompletionBatcher(options) {
     flush: emitGroup,
     dispose() {
       clearTimers();
+      const abandoned = pending;
       pending = [];
+      return abandoned;
     }
   };
 }

package/extensions/dm-subagents/src/runs/background/completion-dedupe.js

@@ -10,10 +10,11 @@ function asFiniteNumber(value) {
   return Number.isFinite(value) ? value : undefined;
 }
 export function buildCompletionKey(data, fallback) {
+  const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
   const id = asNonEmptyString(data.id);
+  const state = asNonEmptyString(data.state);
   if (id)
-    return `id:${id}`;
-  const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
+    return state ? `session:${sessionId}:id:${id}:state:${state}` : `session:${sessionId}:id:${id}`;
   const agent = asNonEmptyString(data.agent) ?? "unknown";
   const timestamp = asFiniteNumber(data.timestamp);
   const taskIndex = asFiniteNumber(data.taskIndex);
@@ -43,12 +44,3 @@ export function markSeenWithTtl(seen, key, now, ttlMs) {
   seen.set(key, now);
   return false;
 }
-export function getGlobalSeenMap(storeKey) {
-  const globalStore = globalThis;
-  const existing = globalStore[storeKey];
-  if (existing instanceof Map)
-    return existing;
-  const map = new Map;
-  globalStore[storeKey] = map;
-  return map;
-}

package/extensions/dm-subagents/src/runs/background/completion-replay.js

@@ -0,0 +1,245 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
+import { utf8Tail } from "../../shared/utf8.js";
+const REPLAY_VERSION = 1;
+const ARCHIVE_VERSION = 1;
+const ARCHIVE_TEXT_LIMIT_BYTES = 64 * 1024;
+const REPLAY_DIR_NAME = "completion-replay";
+const ARCHIVE_DIR_NAME = "output-archives";
+const CLEANUP_INTERVAL_MS = 60000;
+const lastCleanupByResultsDir = new Map;
+function safeRunFile(runId) {
+  return `${encodeURIComponent(runId)}.json`;
+}
+export function completionReplayPath(resultsDir, runId) {
+  return path.join(resultsDir, REPLAY_DIR_NAME, safeRunFile(runId));
+}
+export function completionArchivePath(resultsDir, runId) {
+  return path.join(resultsDir, ARCHIVE_DIR_NAME, safeRunFile(runId));
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function existingFile(value) {
+  const filePath = nonEmptyString(value);
+  if (!filePath)
+    return;
+  try {
+    return fs.statSync(filePath).isFile() ? filePath : undefined;
+  } catch {
+    return;
+  }
+}
+function outputArtifactPath(child) {
+  if (!child.artifactPaths || typeof child.artifactPaths !== "object" || Array.isArray(child.artifactPaths))
+    return;
+  return existingFile(child.artifactPaths.outputPath);
+}
+export function writeCompletionArchive(resultsDir, runId, data, createdAt) {
+  const entries = [];
+  const results = Array.isArray(data.results) ? data.results : [];
+  for (let resultIndex = 0;resultIndex < results.length; resultIndex++) {
+    const value = results[resultIndex];
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      continue;
+    const child = value;
+    const agent = nonEmptyString(child.agent);
+    const artifactPath = outputArtifactPath(child);
+    if (artifactPath) {
+      entries.push({ ...agent ? { agent } : {}, resultIndex, source: "output-artifact", path: artifactPath });
+      continue;
+    }
+    const sessionPath = existingFile(child.sessionFile);
+    if (sessionPath) {
+      entries.push({ ...agent ? { agent } : {}, resultIndex, source: "session", path: sessionPath });
+      continue;
+    }
+    const output = nonEmptyString(child.output);
+    const error = nonEmptyString(child.error);
+    if (output || error) {
+      const bounded = utf8Tail([error ? `Error: ${error}` : undefined, output].filter(Boolean).join(`
+`), ARCHIVE_TEXT_LIMIT_BYTES);
+      entries.push({
+        ...agent ? { agent } : {},
+        resultIndex,
+        source: "result-tail",
+        text: bounded.text,
+        ...bounded.truncated ? { truncated: true } : {}
+      });
+    }
+  }
+  if (results.length === 0) {
+    const sessionPath = existingFile(data.sessionFile);
+    if (sessionPath)
+      entries.push({ source: "session", path: sessionPath });
+  }
+  if (entries.length === 0) {
+    const summary = nonEmptyString(data.summary);
+    if (summary) {
+      const bounded = utf8Tail(summary, ARCHIVE_TEXT_LIMIT_BYTES);
+      entries.push({ source: "result-tail", text: bounded.text, ...bounded.truncated ? { truncated: true } : {} });
+    }
+  }
+  const archive = { version: ARCHIVE_VERSION, runId, createdAt, entries };
+  const archivePath = completionArchivePath(resultsDir, runId);
+  writePrivateAtomicJson(archivePath, archive);
+  return archivePath;
+}
+function parseCompletion(value, runId) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const completion = value;
+  if (completion.runId !== runId)
+    return;
+  return completion;
+}
+function parseReplay(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const record = value;
+  if (record.version !== REPLAY_VERSION || typeof record.runId !== "string" || typeof record.sessionId !== "string" || typeof record.completedAt !== "number" || typeof record.expiresAt !== "number" || typeof record.archivePath !== "string")
+    return;
+  const completion = parseCompletion(record.completion, record.runId);
+  return completion ? { ...record, completion } : undefined;
+}
+function validateReplayRecord(resultsDir, runId, record) {
+  if (record.runId !== runId)
+    return;
+  const archivePath = completionArchivePath(resultsDir, runId);
+  return path.resolve(record.archivePath) === path.resolve(archivePath) ? { ...record, archivePath, completion: { ...record.completion, archivePath } } : undefined;
+}
+function runIdFromReplayFile(file) {
+  if (!file.endsWith(".json"))
+    return;
+  try {
+    const runId = decodeURIComponent(file.slice(0, -".json".length));
+    return safeRunFile(runId) === file ? runId : undefined;
+  } catch {
+    return;
+  }
+}
+function removeBestEffort(filePath) {
+  try {
+    fs.rmSync(filePath, { force: true });
+  } catch {}
+}
+function parseArchive(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const archive = value;
+  if (archive.version !== ARCHIVE_VERSION || typeof archive.runId !== "string" || typeof archive.createdAt !== "number" || !Array.isArray(archive.entries))
+    return;
+  const entries = archive.entries.flatMap((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      return [];
+    const entry = value;
+    if (entry.source !== "output-artifact" && entry.source !== "session" && entry.source !== "result-tail")
+      return [];
+    return [{
+      ...typeof entry.agent === "string" ? { agent: entry.agent } : {},
+      ...typeof entry.resultIndex === "number" && Number.isSafeInteger(entry.resultIndex) && entry.resultIndex >= 0 ? { resultIndex: entry.resultIndex } : {},
+      source: entry.source,
+      ...typeof entry.path === "string" ? { path: entry.path } : {},
+      ...typeof entry.text === "string" ? { text: entry.text } : {},
+      ...entry.truncated === true ? { truncated: true } : {}
+    }];
+  });
+  return { version: ARCHIVE_VERSION, runId: archive.runId, createdAt: archive.createdAt, entries };
+}
+export function writeCompletionReplay(input) {
+  const archivePath = writeCompletionArchive(input.resultsDir, input.runId, input.data, input.now);
+  const completion = { ...input.completion, archivePath };
+  const record = {
+    version: REPLAY_VERSION,
+    runId: input.runId,
+    sessionId: input.sessionId,
+    completedAt: input.now,
+    expiresAt: input.now + input.ttlMs,
+    completion,
+    archivePath
+  };
+  writePrivateAtomicJson(completionReplayPath(input.resultsDir, input.runId), record);
+  cleanupCompletionReplayIfDue(input.resultsDir, input.now, input.ttlMs);
+  return record;
+}
+export function readCompletionReplay(resultsDir, runId, options = {}) {
+  const replayPath = completionReplayPath(resultsDir, runId);
+  let parsed;
+  try {
+    parsed = parseReplay(JSON.parse(fs.readFileSync(replayPath, "utf-8")));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  if (!parsed)
+    return;
+  const safeRecord = validateReplayRecord(resultsDir, runId, parsed);
+  if (!safeRecord) {
+    removeBestEffort(replayPath);
+    return;
+  }
+  parsed = safeRecord;
+  if (options.sessionId !== undefined && parsed.sessionId !== options.sessionId)
+    return;
+  if (parsed.expiresAt <= (options.now ?? Date.now())) {
+    removeBestEffort(replayPath);
+    removeBestEffort(parsed.archivePath);
+    return;
+  }
+  return parsed;
+}
+export function readCompletionArchive(archivePath) {
+  try {
+    const archive = parseArchive(JSON.parse(fs.readFileSync(archivePath, "utf-8")));
+    if (!archive)
+      throw new Error("Completion archive is malformed.");
+    return archive;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+export function cleanupCompletionReplayIfDue(resultsDir, now, maxAgeMs, intervalMs = CLEANUP_INTERVAL_MS) {
+  const last = lastCleanupByResultsDir.get(resultsDir);
+  if (last !== undefined && now - last < intervalMs)
+    return false;
+  lastCleanupByResultsDir.set(resultsDir, now);
+  cleanupCompletionReplay(resultsDir, now, maxAgeMs);
+  return true;
+}
+export function cleanupCompletionReplay(resultsDir, now, maxAgeMs) {
+  const replayDir = path.join(resultsDir, REPLAY_DIR_NAME);
+  try {
+    for (const file of fs.readdirSync(replayDir)) {
+      const runId = runIdFromReplayFile(file);
+      if (!runId)
+        continue;
+      const filePath = path.join(replayDir, file);
+      try {
+        const record = parseReplay(JSON.parse(fs.readFileSync(filePath, "utf-8")));
+        const safeRecord = record ? validateReplayRecord(resultsDir, runId, record) : undefined;
+        if (record && !safeRecord) {
+          fs.rmSync(filePath, { force: true });
+        } else if (safeRecord && safeRecord.expiresAt <= now) {
+          fs.rmSync(filePath, { force: true });
+          fs.rmSync(safeRecord.archivePath, { force: true });
+        } else if (!record && now - fs.statSync(filePath).mtimeMs > maxAgeMs) {
+          fs.rmSync(filePath, { force: true });
+        }
+      } catch {}
+    }
+  } catch {}
+  const archiveDir = path.join(resultsDir, ARCHIVE_DIR_NAME);
+  try {
+    for (const file of fs.readdirSync(archiveDir)) {
+      const filePath = path.join(archiveDir, file);
+      try {
+        if (now - fs.statSync(filePath).mtimeMs > maxAgeMs)
+          fs.rmSync(filePath, { force: true });
+      } catch {}
+    }
+  } catch {}
+}