@wrongstack/core 0.3.1 → 0.3.2

package/dist/{compactor-BUU6Zm_3.d.ts → compactor-DpJBI1YH.d.ts}

@@ -1,5 +1,10 @@
 import { a0 as Context } from './context-IovtuTf8.js';
 
+interface CompactRepairReport {
+    removedToolUses: string[];
+    removedToolResults: string[];
+    removedMessages: number;
+}
 interface CompactReport {
     before: number;
     after: number;
@@ -7,6 +12,7 @@ interface CompactReport {
         phase: 'elision' | 'summary' | 'selective';
         saved: number;
     }[];
+    repaired?: CompactRepairReport;
 }
 interface Compactor {
     compact(ctx: Context, opts?: {
@@ -14,4 +20,4 @@ interface Compactor {
     }): Promise<CompactReport>;
 }
 
-export type { Compactor as C, CompactReport as a };
+export type { CompactReport as C, Compactor as a };

package/dist/{config-CKLYPkCi.d.ts → config-D2qvAxVd.d.ts}

@@ -1,7 +1,44 @@
 import { W as WireFamily } from './models-registry-Y2xbog0E.js';
 import { P as Permission } from './context-IovtuTf8.js';
 
+type ContextWindowModeId = 'balanced' | 'frugal' | 'deep' | 'archival';
+type ContextWindowAggressiveOn = 'hard' | 'soft' | 'warn';
+interface ContextWindowThresholds {
+    warn: number;
+    soft: number;
+    hard: number;
+}
+interface ContextWindowMode {
+    id: ContextWindowModeId;
+    name: string;
+    description: string;
+    thresholds: ContextWindowThresholds;
+    aggressiveOn: ContextWindowAggressiveOn;
+    preserveK: number;
+    eliseThreshold: number;
+    targetLoad: number;
+}
+interface ContextWindowPolicy extends ContextWindowMode {
+}
+interface ContextWindowConfigLike {
+    mode?: ContextWindowModeId | string;
+    warnThreshold?: number;
+    softThreshold?: number;
+    hardThreshold?: number;
+    preserveK?: number;
+    eliseThreshold?: number;
+}
+declare const DEFAULT_CONTEXT_WINDOW_MODE_ID: ContextWindowModeId;
+declare const CONTEXT_WINDOW_MODES: readonly ContextWindowMode[];
+declare function listContextWindowModes(): ContextWindowMode[];
+declare function getContextWindowMode(id: string | null | undefined): ContextWindowMode | null;
+declare function isContextWindowModeId(id: string): id is ContextWindowModeId;
+declare function resolveContextWindowPolicy(config?: ContextWindowConfigLike, overrideMode?: string | null): ContextWindowPolicy;
+declare function formatContextWindowModeList(activeId?: string | null): string;
+
 interface ContextConfig {
+    /** Context-window policy mode. Controls compaction thresholds and preservation depth. */
+    mode?: ContextWindowModeId;
     warnThreshold: number;
     softThreshold: number;
     hardThreshold: number;
@@ -190,4 +227,4 @@ interface ConfigStore {
     watch(cb: (next: Readonly<Config>, prev: Readonly<Config>) => void): () => void;
 }
 
-export type { Config as C, FeaturesConfig as F, LogConfig as L, MCPServerConfig as M, PluginConfig as P, ToolsConfig as T, ConfigLoader as a, ConfigStore as b, ContextConfig as c, ProviderApiKey as d, ProviderConfig as e };
+export { CONTEXT_WINDOW_MODES as C, DEFAULT_CONTEXT_WINDOW_MODE_ID as D, type FeaturesConfig as F, type LogConfig as L, type MCPServerConfig as M, type PluginConfig as P, type ToolsConfig as T, type Config as a, type ConfigLoader as b, type ConfigStore as c, type ContextConfig as d, type ContextWindowAggressiveOn as e, type ContextWindowConfigLike as f, type ContextWindowMode as g, type ContextWindowModeId as h, type ContextWindowPolicy as i, type ContextWindowThresholds as j, type ProviderApiKey as k, type ProviderConfig as l, formatContextWindowModeList as m, getContextWindowMode as n, isContextWindowModeId as o, listContextWindowModes as p, resolveContextWindowPolicy as r };

package/dist/coordination/index.d.ts

@@ -3,14 +3,14 @@ export { n as BudgetExceededError, o as BudgetKind, p as BudgetLimits, q as Budg
 import { q as SessionWriter, u as Tool, o as SessionStore } from '../context-IovtuTf8.js';
 import { I as InMemoryAgentBridge } from '../agent-bridge-C3DUGjSb.js';
 export { a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-C3DUGjSb.js';
-import { E as EventBus } from '../events-CNB9PALO.js';
+import { E as EventBus } from '../events-BHIQs4o1.js';
 import { EventEmitter } from 'node:events';
-import { r as Agent, u as AgentInput } from '../index-BDb0cAMP.js';
+import { r as Agent, u as AgentInput } from '../index-hWNybrNZ.js';
 import '../logger-BMQgxvdy.js';
 import '../system-prompt-Dk1qm8ey.js';
 import '../observability-BhnVLBLS.js';
 import '../secret-scrubber-CgG2tV2B.js';
-import '../config-CKLYPkCi.js';
+import '../config-D2qvAxVd.js';
 import '../models-registry-Y2xbog0E.js';
 
 /**

package/dist/coordination/index.js

@@ -290,6 +290,7 @@ var InMemoryAgentBridge = class {
     this.stopped = true;
     for (const [, p] of this.pendingRequests) {
       clearTimeout(p.timer);
+      p.reject(new Error("Bridge stopped"));
     }
     this.pendingRequests.clear();
     this.inflightGuards.clear();
@@ -1201,6 +1202,179 @@ function providerErrorToSubagentError(err, message, cause) {
   }
   return { kind: "unknown", message, retryable: err.retryable, cause };
 }
+function makeSpawnTool(director, roster) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      role: { type: "string", description: "Roster role id (preferred). When set, the spawn uses the matching config from the roster and ignores other fields." },
+      name: { type: "string", description: "Display name for the subagent. Required when not using roster." },
+      provider: { type: "string", description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the leader provider when omitted.' },
+      model: { type: "string", description: "Model id within the provider. Defaults to the leader model when omitted." },
+      systemPromptOverride: { type: "string", description: "Extra prompt text appended after the role-base prompt." },
+      maxIterations: { type: "number" },
+      maxToolCalls: { type: "number" },
+      maxCostUsd: { type: "number" }
+    },
+    required: []
+  };
+  return {
+    name: "spawn_subagent",
+    description: "Create a new subagent under this director. Returns the subagent id.",
+    usageHint: "Either pass `role` (matches the roster) OR pass `name` + optional `provider`/`model`. Returns `{ subagentId }`.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input ?? {};
+      const role = typeof i.role === "string" ? i.role : void 0;
+      const base = role && roster ? roster[role] : void 0;
+      if (role && !base) {
+        return { error: `unknown role "${role}". roster has: ${roster ? Object.keys(roster).join(", ") : "(empty)"}` };
+      }
+      const cfg = { ...base ?? { name: i.name ?? "subagent" } };
+      if (typeof i.name === "string") cfg.name = i.name;
+      if (typeof i.provider === "string") cfg.provider = i.provider;
+      if (typeof i.model === "string") cfg.model = i.model;
+      if (typeof i.systemPromptOverride === "string") cfg.systemPromptOverride = i.systemPromptOverride;
+      if (typeof i.maxIterations === "number") cfg.maxIterations = i.maxIterations;
+      if (typeof i.maxToolCalls === "number") cfg.maxToolCalls = i.maxToolCalls;
+      if (typeof i.maxCostUsd === "number") cfg.maxCostUsd = i.maxCostUsd;
+      try {
+        const subagentId = await director.spawn(cfg);
+        return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name };
+      } catch (err) {
+        if (err instanceof DirectorBudgetError) {
+          return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
+        }
+        return { error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+  };
+}
+function makeAssignTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      subagentId: { type: "string", description: "Target subagent id. Required." },
+      description: { type: "string", description: "The task in natural language \u2014 what you want this subagent to do." },
+      maxToolCalls: { type: "number", description: "Optional per-task tool-call budget override." },
+      timeoutMs: { type: "number", description: "Optional per-task timeout in ms." }
+    },
+    required: ["subagentId", "description"]
+  };
+  return {
+    name: "assign_task",
+    description: "Hand a task to a previously spawned subagent. Returns the task id.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      const task = { id: randomUUID(), description: i.description, subagentId: i.subagentId, maxToolCalls: i.maxToolCalls, timeoutMs: i.timeoutMs };
+      const taskId = await director.assign(task);
+      return { taskId, subagentId: i.subagentId };
+    }
+  };
+}
+function makeAwaitTasksTool(director) {
+  return {
+    name: "await_tasks",
+    description: "Block until every named task completes. Returns the array of TaskResult.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: { taskIds: { type: "array", items: { type: "string" }, description: "One or more task ids returned by `assign_task`." } }, required: ["taskIds"] },
+    async execute(input) {
+      const i = input;
+      const results = await director.awaitTasks(i.taskIds);
+      return { results };
+    }
+  };
+}
+function makeAskTool(director) {
+  return {
+    name: "ask_subagent",
+    description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        subagentId: { type: "string", description: "Subagent to ask. Must be a previously spawned id." },
+        question: { type: "string", description: "The question or instruction." },
+        timeoutMs: { type: "number", description: "Optional timeout in ms (default 30s)." }
+      },
+      required: ["subagentId", "question"]
+    },
+    async execute(input) {
+      const i = input;
+      try {
+        const answer = await director.ask(i.subagentId, { question: i.question }, i.timeoutMs);
+        return { ok: true, answer };
+      } catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+  };
+}
+function makeRollUpTool(director) {
+  return {
+    name: "roll_up",
+    description: "Aggregate completed task results into a single formatted summary.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskIds: { type: "array", items: { type: "string" }, description: "Completed task ids to aggregate." },
+        style: { type: "string", enum: ["markdown", "json"], description: "Output flavor \u2014 markdown (default) or json." }
+      },
+      required: ["taskIds"]
+    },
+    async execute(input) {
+      const i = input;
+      const summary = director.rollUp(i.taskIds, i.style ?? "markdown");
+      return { summary, count: i.taskIds.length };
+    }
+  };
+}
+function makeTerminateTool(director) {
+  return {
+    name: "terminate_subagent",
+    description: "Forcibly abort a subagent.",
+    permission: "auto",
+    mutating: true,
+    inputSchema: { type: "object", properties: { subagentId: { type: "string", description: "Subagent to abort." } }, required: ["subagentId"] },
+    async execute(input) {
+      const i = input;
+      await director.terminate(i.subagentId);
+      return { ok: true };
+    }
+  };
+}
+function makeFleetStatusTool(director) {
+  return {
+    name: "fleet_status",
+    description: "Snapshot of the fleet \u2014 every subagent's current status, pending vs. completed task counts.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      return director.status();
+    }
+  };
+}
+function makeFleetUsageTool(director) {
+  return {
+    name: "fleet_usage",
+    description: "Token + cost breakdown across the fleet, per-subagent and totals.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      return director.snapshot();
+    }
+  };
+}
 
 // src/coordination/director.ts
 var DirectorBudgetError = class extends Error {
@@ -1759,242 +1933,6 @@ var Director = class {
     return t;
   }
 };
-function makeSpawnTool(director, roster) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      role: {
-        type: "string",
-        description: "Roster role id (preferred). When set, the spawn uses the matching config from the roster and ignores other fields."
-      },
-      name: {
-        type: "string",
-        description: "Display name for the subagent. Required when not using roster."
-      },
-      provider: {
-        type: "string",
-        description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the leader provider when omitted.'
-      },
-      model: {
-        type: "string",
-        description: "Model id within the provider. Defaults to the leader model when omitted."
-      },
-      systemPromptOverride: {
-        type: "string",
-        description: "Extra prompt text appended after the role-base prompt."
-      },
-      maxIterations: { type: "number" },
-      maxToolCalls: { type: "number" },
-      maxCostUsd: { type: "number" }
-    },
-    required: []
-  };
-  return {
-    name: "spawn_subagent",
-    description: "Create a new subagent under this director. Returns the subagent id. Use this when you need a worker with a specific provider, model, or role to handle a piece of the plan.",
-    usageHint: "Either pass `role` (matches the roster) OR pass `name` + optional `provider`/`model`. Returns `{ subagentId }`.",
-    permission: "auto",
-    mutating: false,
-    inputSchema,
-    async execute(input) {
-      const i = input ?? {};
-      const role = typeof i.role === "string" ? i.role : void 0;
-      const base = role && roster ? roster[role] : void 0;
-      if (role && !base) {
-        return {
-          error: `unknown role "${role}". roster has: ${roster ? Object.keys(roster).join(", ") : "(empty)"}`
-        };
-      }
-      const cfg = {
-        ...base ?? { name: i.name ?? "subagent" }
-      };
-      if (typeof i.name === "string") cfg.name = i.name;
-      if (typeof i.provider === "string") cfg.provider = i.provider;
-      if (typeof i.model === "string") cfg.model = i.model;
-      if (typeof i.systemPromptOverride === "string")
-        cfg.systemPromptOverride = i.systemPromptOverride;
-      if (typeof i.maxIterations === "number") cfg.maxIterations = i.maxIterations;
-      if (typeof i.maxToolCalls === "number") cfg.maxToolCalls = i.maxToolCalls;
-      if (typeof i.maxCostUsd === "number") cfg.maxCostUsd = i.maxCostUsd;
-      try {
-        const subagentId = await director.spawn(cfg);
-        return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name };
-      } catch (err) {
-        if (err instanceof DirectorBudgetError) {
-          return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
-        }
-        return { error: err instanceof Error ? err.message : String(err) };
-      }
-    }
-  };
-}
-function makeAssignTool(director) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      subagentId: { type: "string", description: "Target subagent id. Required." },
-      description: {
-        type: "string",
-        description: "The task in natural language \u2014 what you want this subagent to do."
-      },
-      maxToolCalls: { type: "number", description: "Optional per-task tool-call budget override." },
-      timeoutMs: { type: "number", description: "Optional per-task timeout in ms." }
-    },
-    required: ["subagentId", "description"]
-  };
-  return {
-    name: "assign_task",
-    description: "Hand a task to a previously spawned subagent. Returns the task id \u2014 pass it to `await_tasks` to block on completion.",
-    permission: "auto",
-    mutating: false,
-    inputSchema,
-    async execute(input) {
-      const i = input;
-      const task = {
-        id: randomUUID(),
-        description: i.description,
-        subagentId: i.subagentId,
-        maxToolCalls: i.maxToolCalls,
-        timeoutMs: i.timeoutMs
-      };
-      const taskId = await director.assign(task);
-      return { taskId, subagentId: i.subagentId };
-    }
-  };
-}
-function makeAwaitTasksTool(director) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      taskIds: {
-        type: "array",
-        items: { type: "string" },
-        description: "One or more task ids returned by `assign_task`. The call blocks until every id resolves."
-      }
-    },
-    required: ["taskIds"]
-  };
-  return {
-    name: "await_tasks",
-    description: "Block until every named task completes. Returns the array of TaskResult \u2014 use this to gather subagent output before deciding the next step.",
-    permission: "auto",
-    mutating: false,
-    inputSchema,
-    async execute(input) {
-      const i = input;
-      const results = await director.awaitTasks(i.taskIds);
-      return { results };
-    }
-  };
-}
-function makeAskTool(director) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      subagentId: {
-        type: "string",
-        description: "Subagent to ask. Must be a previously spawned id."
-      },
-      question: {
-        type: "string",
-        description: "The question or instruction. Sent as the bridge message payload."
-      },
-      timeoutMs: { type: "number", description: "Optional timeout in ms (default 30s)." }
-    },
-    required: ["subagentId", "question"]
-  };
-  return {
-    name: "ask_subagent",
-    description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge (or the timeout fires). Use this when you need a one-shot answer without spawning a fresh task.",
-    permission: "auto",
-    mutating: false,
-    inputSchema,
-    async execute(input) {
-      const i = input;
-      try {
-        const answer = await director.ask(i.subagentId, { question: i.question }, i.timeoutMs);
-        return { ok: true, answer };
-      } catch (err) {
-        return { ok: false, error: err instanceof Error ? err.message : String(err) };
-      }
-    }
-  };
-}
-function makeRollUpTool(director) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      taskIds: {
-        type: "array",
-        items: { type: "string" },
-        description: "Completed task ids to aggregate. Pass the ids returned by previous `assign_task` calls."
-      },
-      style: {
-        type: "string",
-        enum: ["markdown", "json"],
-        description: "Output flavor \u2014 markdown (default) for in-prompt summarization, json for structured downstream processing."
-      }
-    },
-    required: ["taskIds"]
-  };
-  return {
-    name: "roll_up",
-    description: "Aggregate completed task results into a single formatted summary. Use this after `await_tasks` to fold subagent outputs back into the director's context before deciding the next step.",
-    permission: "auto",
-    mutating: false,
-    inputSchema,
-    async execute(input) {
-      const i = input;
-      const summary = director.rollUp(i.taskIds, i.style ?? "markdown");
-      return { summary, count: i.taskIds.length };
-    }
-  };
-}
-function makeTerminateTool(director) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      subagentId: { type: "string", description: "Subagent to abort." }
-    },
-    required: ["subagentId"]
-  };
-  return {
-    name: "terminate_subagent",
-    description: 'Forcibly abort a subagent. Use sparingly \u2014 prefer waiting on the natural budget to expire. The current task (if any) ends with status "stopped".',
-    permission: "auto",
-    mutating: true,
-    inputSchema,
-    async execute(input) {
-      const i = input;
-      await director.terminate(i.subagentId);
-      return { ok: true };
-    }
-  };
-}
-function makeFleetStatusTool(director) {
-  return {
-    name: "fleet_status",
-    description: "Snapshot of the fleet \u2014 every subagent's current status, pending vs. completed task counts, and the running total iteration count. Cheap; call freely.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: { type: "object", properties: {}, required: [] },
-    async execute() {
-      return director.status();
-    }
-  };
-}
-function makeFleetUsageTool(director) {
-  return {
-    name: "fleet_usage",
-    description: "Token + cost breakdown across the fleet, per-subagent and totals. Use this to reason about which workers to assign costly tasks to or when to wrap up to stay within budget.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: { type: "object", properties: {}, required: [] },
-    async execute() {
-      return director.snapshot();
-    }
-  };
-}
 function createDelegateTool(opts) {
   const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
   const rosterIds = opts.roster ? Object.keys(opts.roster) : [];
@@ -2357,6 +2295,100 @@ function makeAgentSubagentRunner(opts) {
 function defaultFormatTaskInput(task) {
   return task.description ?? "";
 }
+
+// src/utils/message-invariants.ts
+function repairToolUseAdjacency(messages) {
+  const removedToolUses = [];
+  const removedToolResults = [];
+  let removedMessages = 0;
+  let changed = false;
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const original = messages[i];
+    let msg = original;
+    if (hasToolUse(msg)) {
+      const nextIds = toolResultIds(messages[i + 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_use" && !nextIds.has(block.id)) {
+            removedToolUses.push(block.id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (hasToolResult(msg)) {
+      const allowed = toolUseIds(out[out.length - 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_result" && !allowed.has(block.tool_use_id)) {
+            removedToolResults.push(block.tool_use_id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (isEmptyMessage(msg)) {
+      removedMessages++;
+      changed = true;
+      continue;
+    }
+    out.push(msg);
+  }
+  return {
+    messages: changed ? out : messages,
+    report: { changed, removedToolUses, removedToolResults, removedMessages }
+  };
+}
+function hasToolUse(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_use");
+}
+function hasToolResult(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_result");
+}
+function toolUseIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!msg || msg.role !== "assistant") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_use") ids.add(block.id);
+  }
+  return ids;
+}
+function toolResultIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!msg || msg.role !== "user") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_result") ids.add(block.tool_use_id);
+  }
+  return ids;
+}
+function contentBlocks(msg) {
+  return msg && Array.isArray(msg.content) ? msg.content : [];
+}
+function mapContent(msg, fn) {
+  if (!Array.isArray(msg.content)) return msg;
+  const next = fn(msg.content);
+  if (next.length === msg.content.length && next.every((b, idx) => b === msg.content[idx])) {
+    return msg;
+  }
+  return { ...msg, content: next };
+}
+function isEmptyMessage(msg) {
+  if (typeof msg.content === "string") return msg.content.trim().length === 0;
+  return msg.content.length === 0;
+}
+
+// src/storage/session-store.ts
 var DefaultSessionStore = class {
   dir;
   events;
@@ -2558,11 +2590,17 @@ var DefaultSessionStore = class {
     if (openToolUses.size > 0) {
       this.events?.emit("session.damaged", {
         sessionId,
-        detail: `${openToolUses.size} tool_use blocks without matching results \u2014 replay truncated`
+        detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
       });
-      return { messages, usage };
     }
-    return { messages, usage };
+    const repaired = repairToolUseAdjacency(messages);
+    if (repaired.report.changed) {
+      this.events?.emit("session.damaged", {
+        sessionId,
+        detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
+      });
+    }
+    return { messages: repaired.messages, usage };
   }
 };
 var FileSessionWriter = class {
@@ -2588,6 +2626,7 @@ var FileSessionWriter = class {
   startedAt;
   meta;
   closed = false;
+  closing = false;
   manifestFile;
   summary;
   tokenIn = 0;
@@ -2603,9 +2642,7 @@ var FileSessionWriter = class {
   resumed;
   appendFailCount = 0;
   lastAppendWarnAt = 0;
-  async writeSessionStart() {
-    if (this.initDone || this.closed) return;
-    this.initDone = true;
+  async writeSessionStartLazy() {
     const record = `${JSON.stringify({
       type: this.resumed ? "session_resumed" : "session_start",
       ts: this.startedAt,
@@ -2624,7 +2661,8 @@ var FileSessionWriter = class {
   async append(event) {
     if (this.closed) return;
     if (!this.initDone) {
-      await this.writeSessionStart();
+      this.initDone = true;
+      await this.writeSessionStartLazy();
     }
     this.observeForSummary(event);
     try {
@@ -2665,7 +2703,8 @@ var FileSessionWriter = class {
     }
   }
   async close() {
-    if (this.closed) return;
+    if (this.closing) return;
+    this.closing = true;
     this.closed = true;
     if (this.manifestFile) {
       try {