@wrongstack/core 0.313.1 → 0.316.1

package/dist/{chunk-K3G6JBUC.js → chunk-WLYKU45P.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SWUFN7XM.js";
 import {
   normalizeInlineProviderModels
-} from "./chunk-IQ35HMQL.js";
+} from "./chunk-5YPSXQXM.js";
 import {
   decryptConfigSecrets
 } from "./chunk-YY6APYUM.js";
@@ -13,30 +13,28 @@ import {
   scrubPersistedSessionEvent,
   scrubPersistedSessionSummary,
   sessionContentPreview,
+  summarizeSessionFile,
   userInputTitle
-} from "./chunk-UIWONWVG.js";
-import {
-  SECRET_FILE_MODE
-} from "./chunk-H5E77KUJ.js";
-import {
-  DefaultSecretScrubber
-} from "./chunk-3E244UDA.js";
-import {
-  MEMORY_TYPE_LABELS
-} from "./chunk-57GEWK5X.js";
+} from "./chunk-NSOFPKGT.js";
 import {
   compileUserRegex
-} from "./chunk-TYW2GI5I.js";
+} from "./chunk-J2WRWR37.js";
 import {
   safeParse
-} from "./chunk-RPOA7IAE.js";
+} from "./chunk-W5VITDM2.js";
 import {
   sessionScopedPath
-} from "./chunk-AD7ZFZCS.js";
+} from "./chunk-5BMIE7QG.js";
 import {
   readBundledInstructionText,
   renderInstructionTemplate
 } from "./chunk-5S437PRC.js";
+import {
+  DefaultSecretScrubber
+} from "./chunk-QSTSJOCK.js";
+import {
+  SECRET_FILE_MODE
+} from "./chunk-6FHWXLPT.js";
 import {
   isPidAlive
 } from "./chunk-TRT2HRWZ.js";
@@ -44,19 +42,22 @@ import {
   atomicWrite,
   ensureDir,
   withFileLock
-} from "./chunk-7ZHZE5EO.js";
+} from "./chunk-OSGLYW5J.js";
+import {
+  MEMORY_TYPE_LABELS
+} from "./chunk-57GEWK5X.js";
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
 import {
   ConfigError,
   ERROR_CODES,
   SessionError,
   WrongStackError
-} from "./chunk-WOEZV3Q4.js";
+} from "./chunk-25LSLC3G.js";
 import {
   toErrorMessage
 } from "./chunk-TBRL2RCC.js";
-import {
-  expectDefined
-} from "./chunk-PFZO3C6H.js";
 
 // src/session-catalog/session-registry.ts
 import * as fs2 from "node:fs/promises";
@@ -109,8 +110,8 @@ async function breakStaleLock(lockPath) {
     const ownerPid = Number.parseInt(trimmed.slice(colonIdx + 1), 10);
     if (ownerHost === HOST_NAME && Number.isInteger(ownerPid) && ownerPid > 0) {
       if (isPidAlive(ownerPid)) {
-        const stat7 = await fs.stat(lockPath);
-        if (Date.now() - stat7.mtimeMs > SAME_HOST_STALE_MS) {
+        const stat8 = await fs.stat(lockPath);
+        if (Date.now() - stat8.mtimeMs > SAME_HOST_STALE_MS) {
           return await breakStaleLockVerified(lockPath, async () => {
             const st = await fs.stat(lockPath);
             return Date.now() - st.mtimeMs > SAME_HOST_STALE_MS;
@@ -196,9 +197,9 @@ async function pruneStaleTempFiles(filePath) {
     for (const name of await fs.readdir(dir)) {
       const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
       if (!isTemp) continue;
-      const stat7 = await fs.stat(path.join(dir, name)).catch(() => null);
-      if (!stat7) continue;
-      if (now - stat7.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat7.mtimeMs });
+      const stat8 = await fs.stat(path.join(dir, name)).catch(() => null);
+      if (!stat8) continue;
+      if (now - stat8.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat8.mtimeMs });
     }
     stale.sort((a, b) => a.mtimeMs - b.mtimeMs);
     await Promise.all(
@@ -293,10 +294,6 @@ var SessionRegistry = class {
     await this.atomicUpdate((registry) => {
       const now = Date.now();
       for (const [id, existing] of Object.entries(registry)) {
-        if (existing.pid === entry.pid) {
-          if (id !== entry.sessionId) delete registry[id];
-          continue;
-        }
         const heartbeatAt = Date.parse(existing.lastHeartbeatAt);
         if (!Number.isFinite(heartbeatAt) || now - heartbeatAt > PID_CHECK_AFTER_MS && !pidAlive(existing.pid)) {
           delete registry[id];
@@ -1035,7 +1032,8 @@ var DefaultAttachmentStore = class {
       let ref;
       if (m[3] !== void 0) {
         const wantPath = m[3];
-        ref = findLast(this.refs, (r) => r.kind === "file" && refPath(r) === wantPath);
+        const norm = (s) => s?.replace(/\\/g, "/");
+        ref = findLast(this.refs, (r) => r.kind === "file" && norm(refPath(r)) === norm(wantPath));
       } else {
         const kind = prefixToKind(m[1]);
         const seq = Number(m[2]);
@@ -1123,6 +1121,19 @@ async function loadCompletedWorkCheckpoint(filePath, events, traceId) {
   try {
     raw = await fsp2.readFile(filePath, "utf8");
   } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      events?.emit("storage.read", {
+        sessionId: traceId ?? "~boot~",
+        store: "completed-work",
+        filePath,
+        operation: "load",
+        outcome: "success",
+        durationMs: Date.now() - t0,
+        ...traceId !== void 0 && { traceId }
+      });
+      return null;
+    }
     events?.emit("storage.error", {
       sessionId: traceId ?? "~boot~",
       store: "completed-work",
@@ -1307,7 +1318,7 @@ var DefaultConfigStore = class {
     }
     const prev = this.current;
     this.current = next;
-    for (const w of this.watchers) {
+    for (const w of [...this.watchers]) {
       try {
         w(next, prev);
       } catch (err) {
@@ -1409,13 +1420,11 @@ var InputHistoryStore = class {
   }
   /**
    * Heuristic: did the scrubber actually redact anything? DefaultSecretScrubber
-   * replaces matches with "***REDACTED***", so a residual marker means a secret
-   * was detected. Subclasses of SecretScrubber that use a different sentinel
-   * can be accommodated by widening this check in the future; for now the
-   * marker check covers the shipped scrubber.
+   * replaces matches with "[REDACTED:<type>]" (and legacy mocks with
+   * "***REDACTED***"), so a residual marker means a secret was detected.
    */
   looksRedacted(text) {
-    return text.includes("***REDACTED***");
+    return text.includes("***REDACTED***") || /\[REDACTED:[a-zA-Z0-9_-]+\]/.test(text);
   }
 };
 
@@ -1577,8 +1586,8 @@ var FileMemoryBackend = class {
   }
   async getMtime(file) {
     try {
-      const stat7 = await fs5.stat(file);
-      return stat7.mtimeMs;
+      const stat8 = await fs5.stat(file);
+      return stat8.mtimeMs;
     } catch {
       return 0;
     }
@@ -1631,13 +1640,13 @@ var FileMemoryBackend = class {
     await withFileLock(file, async () => {
       const handle = await fs5.open(file, "a+", SECRET_FILE_MODE);
       try {
-        const stat7 = await handle.stat();
+        const stat8 = await handle.stat();
         let prefix = "";
-        if (stat7.size === 0) {
+        if (stat8.size === 0) {
           prefix = "# Agent Memory\n\n";
         } else {
           const tail = Buffer.allocUnsafe(1);
-          const { bytesRead } = await handle.read(tail, 0, 1, stat7.size - 1);
+          const { bytesRead } = await handle.read(tail, 0, 1, stat8.size - 1);
           if (bytesRead === 1 && tail[0] !== 10) prefix = "\n";
         }
         await handle.appendFile(`${prefix}${line}`, "utf8");
@@ -1828,8 +1837,8 @@ ${existingEntries.map((e) => `- [${e.ts.slice(0, 10)}] ${e.text}`).join("\n")}`
   });
 }
 function relativeEvidencePath(projectRoot, filePath) {
-  const relative3 = path6.relative(projectRoot, filePath);
-  return relative3 && !relative3.startsWith("..") && !path6.isAbsolute(relative3) ? relative3.replaceAll("\\", "/") : filePath.replaceAll("\\", "/");
+  const relative4 = path6.relative(projectRoot, filePath);
+  return relative4 && !relative4.startsWith("..") && !path6.isAbsolute(relative4) ? relative4.replaceAll("\\", "/") : filePath.replaceAll("\\", "/");
 }
 function safeCommandEvidence(value) {
   if (typeof value !== "string") return void 0;
@@ -2038,6 +2047,252 @@ function buildSessionDigestText(finalText, iterations, factsAdded) {
   return `Session digest (${iterations} iter${factsAdded > 0 ? `, ${factsAdded} facts added` : ""}): ` + summary + (cleaned.length > 400 ? "\u2026" : "");
 }
 
+// src/storage/memory-curator.ts
+import * as path7 from "node:path";
+function toSageKind2(type) {
+  switch (type) {
+    case "decision":
+    case "convention":
+    case "preference":
+    case "anti_pattern":
+    case "warning":
+    case "workflow":
+    case "bug_root_cause":
+    case "file_note":
+    case "symbol_note":
+    case "command_note":
+      return type;
+    default:
+      return "fact";
+  }
+}
+function importanceFromPriority2(priority) {
+  switch (priority) {
+    case "critical":
+      return 0.95;
+    case "high":
+      return 0.8;
+    case "medium":
+      return 0.55;
+    case "low":
+      return 0.25;
+    default:
+      return 0.6;
+  }
+}
+function relativePath(projectRoot, filePath) {
+  const rel = path7.relative(projectRoot, filePath);
+  return rel && !rel.startsWith("..") && !path7.isAbsolute(rel) ? rel.replaceAll("\\", "/") : filePath.replaceAll("\\", "/");
+}
+function formatCandidateRecord(record) {
+  const anchors = record.anchors && record.anchors.length > 0 ? ` [anchors: ${record.anchors.map((a) => a.path ? `${a.type}:${a.path}` : a.type).join(", ")}]` : "";
+  const tags = record.tags && record.tags.length > 0 ? ` [tags: ${record.tags.join(", ")}]` : "";
+  const status = record.status ? ` (status: ${record.status})` : "";
+  const kind = record.kind ? ` [${record.kind}]` : "";
+  return `- ID: ${record.id}${status}${kind}: "${record.text}"${tags}${anchors} (importance: ${record.importance ?? 0.6}, confidence: ${record.confidence ?? 0.8})`;
+}
+var SessionMemoryCurator = class {
+  name = "session-memory-curator";
+  owner = "core";
+  Sage;
+  provider;
+  model;
+  maxTargetMemories;
+  oneShotOrchestrator;
+  constructor(opts) {
+    this.Sage = opts.Sage;
+    this.provider = opts.provider;
+    this.model = opts.model;
+    this.maxTargetMemories = opts.maxTargetMemories ?? 10;
+    this.oneShotOrchestrator = opts.oneShotOrchestrator;
+  }
+  afterRun = async (ctx, result) => {
+    if (result.status !== "done") return;
+    if (!this.Sage?.updateSage) return;
+    const provider = this.provider ?? ctx.provider;
+    if (!provider?.complete && !this.oneShotOrchestrator) return;
+    const projectRoot = ctx.projectRoot ?? ctx.cwd ?? "";
+    const writtenFiles = [...ctx.writtenFiles ?? []].slice(0, 6).map((f) => relativePath(projectRoot, f));
+    const targetMap = /* @__PURE__ */ new Map();
+    try {
+      for (const file of writtenFiles) {
+        if (targetMap.size >= this.maxTargetMemories) break;
+        if (this.Sage.retrieveForPath) {
+          const matched = await this.Sage.retrieveForPath({
+            path: file,
+            limit: 4,
+            includeStatuses: ["active", "stale"]
+          });
+          for (const m of matched) {
+            if (m.id && !targetMap.has(m.id)) {
+              targetMap.set(m.id, m);
+            }
+          }
+        } else if (this.Sage.searchSage) {
+          const searchHits = await this.Sage.searchSage(file, {
+            limit: 4,
+            scope: "project",
+            includeStatuses: ["active", "stale"]
+          });
+          for (const m of searchHits) {
+            if (m.id && !targetMap.has(m.id)) {
+              targetMap.set(m.id, m);
+            }
+          }
+        }
+      }
+      if (this.Sage.listCandidates && targetMap.size < this.maxTargetMemories) {
+        const candidates = await this.Sage.listCandidates(false);
+        for (const c of candidates) {
+          if (targetMap.size >= this.maxTargetMemories) break;
+          if (c.memoryId && !targetMap.has(c.memoryId) && this.Sage.getSage) {
+            const mem = await this.Sage.getSage(c.memoryId);
+            if (mem?.id) {
+              targetMap.set(mem.id, mem);
+            }
+          }
+        }
+      }
+      if (targetMap.size === 0) return;
+      const candidatesBlock = [...targetMap.values()].slice(0, this.maxTargetMemories).map(formatCandidateRecord).join("\n");
+      const prompt = renderInstructionTemplate(
+        readBundledInstructionText("llm/memory-curator.md"),
+        {
+          writtenFiles: writtenFiles.length > 0 ? writtenFiles.join(", ") : "(none)",
+          summary: (result.finalText ?? "").slice(0, 800),
+          candidates: candidatesBlock
+        }
+      );
+      const _model = this.model ?? ctx.model;
+      let text = "";
+      if (this.oneShotOrchestrator) {
+        const oneShotResult = await this.oneShotOrchestrator.call({
+          system: prompt,
+          userPrompt: "Review candidate memories against session changes and return JSON operations.",
+          model: _model ?? "deepseek-chat",
+          maxTokens: 400,
+          timeoutMs: 1e4
+        });
+        text = oneShotResult.text;
+      } else if (provider?.complete) {
+        const signal = AbortSignal.timeout(1e4);
+        const response = await provider.complete(
+          {
+            model: _model,
+            system: [{ type: "text", text: prompt }],
+            messages: [
+              {
+                role: "user",
+                content: "Review candidate memories against session changes and return JSON operations."
+              }
+            ],
+            maxTokens: 400
+          },
+          { signal }
+        );
+        text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+      }
+      if (!text) return;
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return;
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed.operations) || parsed.operations.length === 0) return;
+      let supersededCount = 0;
+      let mergedCount = 0;
+      let splitCount = 0;
+      let recalibratedCount = 0;
+      for (const op of parsed.operations.slice(0, 15)) {
+        try {
+          if (!op || typeof op !== "object") continue;
+          if (op.action === "supersede" && typeof op.targetId === "string") {
+            const target = targetMap.get(op.targetId);
+            if (target?.persistence === "permanent") continue;
+            await this.Sage.updateSage(op.targetId, {
+              status: "superseded",
+              ...op.supersededBy ? { supersedes: [op.supersededBy] } : {}
+            });
+            supersededCount++;
+          } else if (op.action === "contradict" && typeof op.targetId === "string") {
+            const target = targetMap.get(op.targetId);
+            if (target?.persistence === "permanent") continue;
+            await this.Sage.updateSage(op.targetId, {
+              status: "contradicted",
+              ...op.contradictsWith ? { contradicts: [op.contradictsWith] } : {}
+            });
+            supersededCount++;
+          } else if (op.action === "merge" && Array.isArray(op.targetIds) && op.text?.trim()) {
+            const remembered = await this.Sage.rememberSage({
+              text: op.text.trim(),
+              kind: toSageKind2(op.type),
+              importance: importanceFromPriority2(op.priority),
+              confidence: typeof op.confidence === "number" ? op.confidence : 0.85,
+              tags: op.tags,
+              anchors: op.anchors,
+              persistence: "long_lived",
+              supersedes: op.targetIds,
+              sources: [{ type: "session", sessionId: ctx.session.id }]
+            });
+            const newId = remembered?.id;
+            for (const oldId of op.targetIds) {
+              const old = targetMap.get(oldId);
+              if (old?.persistence !== "permanent") {
+                await this.Sage.updateSage(oldId, {
+                  status: "superseded",
+                  ...newId ? { supersedes: [newId] } : {}
+                });
+              }
+            }
+            mergedCount++;
+          } else if (op.action === "split" && typeof op.targetId === "string" && Array.isArray(op.items)) {
+            for (const item of op.items.slice(0, 4)) {
+              if (!item.text?.trim()) continue;
+              await this.Sage.rememberSage({
+                text: item.text.trim(),
+                kind: toSageKind2(item.type),
+                importance: importanceFromPriority2(item.priority),
+                confidence: typeof item.confidence === "number" ? item.confidence : 0.85,
+                tags: item.tags,
+                anchors: item.anchors,
+                persistence: "long_lived",
+                supersedes: [op.targetId],
+                sources: [{ type: "session", sessionId: ctx.session.id }]
+              });
+            }
+            const target = targetMap.get(op.targetId);
+            if (target?.persistence !== "permanent") {
+              await this.Sage.updateSage(op.targetId, { status: "superseded" });
+            }
+            splitCount++;
+          } else if (op.action === "recalibrate" && typeof op.targetId === "string") {
+            const patch = {};
+            if (typeof op.importance === "number") patch.importance = Math.max(0, Math.min(1, op.importance));
+            if (typeof op.confidence === "number") patch.confidence = Math.max(0, Math.min(1, op.confidence));
+            if (typeof op.freshness === "number") patch.freshness = Math.max(0, Math.min(1, op.freshness));
+            if (typeof op.status === "string" && ["active", "stale", "archived"].includes(op.status)) {
+              const target = targetMap.get(op.targetId);
+              if (target?.persistence !== "permanent" || op.status === "active") {
+                patch.status = op.status;
+              }
+            }
+            if (Object.keys(patch).length > 0) {
+              await this.Sage.updateSage(op.targetId, patch);
+              recalibratedCount++;
+            }
+          }
+        } catch {
+        }
+      }
+      if (supersededCount > 0 || mergedCount > 0 || splitCount > 0 || recalibratedCount > 0) {
+        process.stderr.write(
+          `[memory] Session curation: ${supersededCount} superseded, ${mergedCount} merged, ${splitCount} split, ${recalibratedCount} recalibrated
+`
+        );
+      }
+    } catch {
+    }
+  };
+};
+
 // src/storage/memory-graph-backend.ts
 import * as fs6 from "node:fs/promises";
 var GraphMemoryBackend = class _GraphMemoryBackend {
@@ -2389,9 +2644,63 @@ function simpleHash(s) {
   return Math.abs(h).toString(36);
 }
 
+// src/storage/orphan-lock-cleaner.ts
+import * as fsp3 from "node:fs/promises";
+import * as path8 from "node:path";
+async function cleanOrphanLocks(projectRoot, options) {
+  const result = {
+    cleanedGitLocks: [],
+    cleanedWorktrees: [],
+    errors: []
+  };
+  const pidAlive2 = options?.isPidAlive ?? isPidAlive;
+  const maxAgeMs = options?.maxLockAgeMs ?? 10 * 60 * 1e3;
+  const now = Date.now();
+  const worktreesDir = path8.join(projectRoot, ".wrongstack", "worktrees");
+  try {
+    const entries = await fsp3.readdir(worktreesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const wtPath = path8.join(worktreesDir, entry.name);
+      const lockPath = path8.join(wtPath, ".lock");
+      try {
+        const lockStat = await fsp3.stat(lockPath).catch(() => null);
+        if (lockStat) {
+          const raw = await fsp3.readFile(lockPath, "utf8").catch(() => "");
+          const pid = parseInt(raw.trim(), 10);
+          if (Number.isInteger(pid) && pid > 0) {
+            if (!pidAlive2(pid)) {
+              try {
+                await fsp3.unlink(lockPath);
+                result.cleanedWorktrees.push(wtPath);
+              } catch (unlinkErr) {
+                result.errors.push(`Failed removing stale lock ${lockPath}: ${toErrorMessage(unlinkErr)}`);
+              }
+            }
+          } else if (now - lockStat.mtimeMs > maxAgeMs) {
+            try {
+              await fsp3.unlink(lockPath);
+              result.cleanedWorktrees.push(wtPath);
+            } catch (unlinkErr) {
+              result.errors.push(`Failed removing expired lock ${lockPath}: ${toErrorMessage(unlinkErr)}`);
+            }
+          }
+        }
+      } catch (err) {
+        result.errors.push(`Failed inspecting worktree ${entry.name}: ${toErrorMessage(err)}`);
+      }
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      result.errors.push(`Failed reading worktrees dir: ${toErrorMessage(err)}`);
+    }
+  }
+  return result;
+}
+
 // src/storage/plan-store.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import * as fsp3 from "node:fs/promises";
+import * as fsp4 from "node:fs/promises";
 function assertPlanMutationInvariants(previous, updated) {
   const ids = updated.items.map((item) => item.id);
   const uniqueIds = new Set(ids);
@@ -2419,7 +2728,7 @@ async function loadPlan(filePath, events) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp3.readFile(filePath, "utf8");
+    raw = await fsp4.readFile(filePath, "utf8");
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: "~boot~",
@@ -2731,7 +3040,7 @@ ${cat}:`);
 // src/storage/provider-config-watcher.ts
 import * as syncFs from "node:fs";
 import * as fs7 from "node:fs/promises";
-import * as path7 from "node:path";
+import * as path9 from "node:path";
 async function readProviderSnapshot(configPath, vault, warn) {
   let raw;
   try {
@@ -2807,7 +3116,7 @@ function serializeSnapshot(s) {
 function watchProviderConfig(configPath, vault, onChange, opts = {}) {
   const debounceMs = opts.debounceMs ?? 200;
   const warn = opts.warn;
-  const base = path7.basename(configPath);
+  const base = path9.basename(configPath);
   let timer;
   let closed = false;
   let lastSerialized;
@@ -2818,7 +3127,7 @@ function watchProviderConfig(configPath, vault, onChange, opts = {}) {
   });
   let watcher;
   try {
-    watcher = syncFs.watch(path7.dirname(configPath), { recursive: false });
+    watcher = syncFs.watch(path9.dirname(configPath), { recursive: false });
   } catch (err) {
     warn?.(`Provider config watcher could not start: ${err.message}`);
     return { close: () => {
@@ -2861,8 +3170,8 @@ function watchProviderConfig(configPath, vault, onChange, opts = {}) {
 }
 
 // src/storage/queue-store.ts
-import * as fsp4 from "node:fs/promises";
-import * as path8 from "node:path";
+import * as fsp5 from "node:fs/promises";
+import * as path10 from "node:path";
 var QUEUE_MAX_ITEMS = 100;
 var QUEUE_MAX_BYTES = 16 * 1024 * 1024;
 var QUEUE_MAX_ITEM_BYTES = 8 * 1024 * 1024;
@@ -2895,7 +3204,7 @@ var QueueStore = class {
   traceId;
   logger;
   constructor(opts) {
-    this.file = path8.join(opts.dir, "queue.json");
+    this.file = path10.join(opts.dir, "queue.json");
     this.events = opts.events;
     this.traceId = opts.traceId;
     this.logger = opts.logger;
@@ -2964,12 +3273,12 @@ var QueueStore = class {
     const t0 = Date.now();
     let raw;
     try {
-      const stat7 = await fsp4.stat(this.file);
-      if (stat7.size > QUEUE_MAX_BYTES) {
+      const stat8 = await fsp5.stat(this.file);
+      if (stat8.size > QUEUE_MAX_BYTES) {
         this.logWarn("Queue file exceeds the safe read budget; ignoring it", {
           event: "queue_store.read_budget_exceeded",
           path: this.file,
-          bytes: stat7.size,
+          bytes: stat8.size,
           maxBytes: QUEUE_MAX_BYTES
         });
         this.events?.emit("storage.read", {
@@ -2984,7 +3293,7 @@ var QueueStore = class {
         });
         return [];
       }
-      raw = await fsp4.readFile(this.file, "utf8");
+      raw = await fsp5.readFile(this.file, "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
@@ -3071,7 +3380,7 @@ var QueueStore = class {
   async clear() {
     const t0 = Date.now();
     try {
-      await fsp4.unlink(this.file);
+      await fsp5.unlink(this.file);
       this.events?.emit("storage.write", {
         sessionId: this.traceId ?? "~boot~",
         store: "queue",
@@ -3109,9 +3418,9 @@ function isPersistedQueueItem(v) {
 }
 
 // src/storage/recovery-lock.ts
-import * as fsp5 from "node:fs/promises";
+import * as fsp6 from "node:fs/promises";
 import * as os from "node:os";
-import * as path9 from "node:path";
+import * as path11 from "node:path";
 var LOCK_FILE = "active.json";
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var RecoveryLock = class {
@@ -3122,7 +3431,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path9.join(opts.dir, LOCK_FILE);
+    this.file = path11.join(opts.dir, LOCK_FILE);
     this.pid = opts.pid ?? process.pid;
     this.hostname = opts.hostname ?? os.hostname();
     this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
@@ -3160,13 +3469,14 @@ var RecoveryLock = class {
     if (this.sessionStore) {
       try {
         const data = await this.sessionStore.load(lock.sessionId);
-        const lastEnd = data.events.findLastIndex((e) => e.type === "session_end");
-        const closed = lastEnd >= 0 && !data.events.slice(lastEnd + 1).some(
+        const events = Array.isArray(data?.events) ? data.events : [];
+        const lastEnd = events.findLastIndex ? events.findLastIndex((e) => e.type === "session_end") : -1;
+        const closed = lastEnd >= 0 && !events.slice(lastEnd + 1).some(
           (e) => e.type === "user_input" || e.type === "llm_response" || e.type === "in_flight_start"
         );
         if (closed) return null;
-        messageCount = data.messages.length;
-        for (const event of data.events) {
+        messageCount = Array.isArray(data?.messages) ? data.messages.length : 0;
+        for (const event of events) {
           if (event.type !== "user_input") continue;
           if (title === void 0) title = userInputTitle(event.content);
           lastUserMessage = sessionContentPreview(event.content);
@@ -3196,7 +3506,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path9.dirname(this.file));
+    await ensureDir(path11.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -3205,7 +3515,7 @@ var RecoveryLock = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     try {
-      await fsp5.writeFile(this.file, JSON.stringify(lock), { flag: "wx", mode: 384 });
+      await fsp6.writeFile(this.file, JSON.stringify(lock), { flag: "wx", mode: 384 });
     } catch (err) {
       const code = err.code;
       if (code === "EEXIST") {
@@ -3221,7 +3531,7 @@ var RecoveryLock = class {
    */
   async clear() {
     try {
-      await fsp5.unlink(this.file);
+      await fsp6.unlink(this.file);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") return;
@@ -3231,7 +3541,7 @@ var RecoveryLock = class {
   async readLock() {
     let raw;
     try {
-      raw = await fsp5.readFile(this.file, "utf8");
+      raw = await fsp6.readFile(this.file, "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") return null;
@@ -3253,55 +3563,9 @@ function isLockFile(v) {
 }
 var defaultIsPidAlive = isPidAlive;
 
-// src/storage/orphan-lock-cleaner.ts
-import * as fsp6 from "node:fs/promises";
-import * as path10 from "node:path";
-async function cleanOrphanLocks(projectRoot, options) {
-  const result = {
-    cleanedGitLocks: [],
-    cleanedWorktrees: [],
-    errors: []
-  };
-  const pidAlive2 = options?.isPidAlive ?? isPidAlive;
-  const maxAgeMs = options?.maxLockAgeMs ?? 10 * 60 * 1e3;
-  const now = Date.now();
-  const worktreesDir = path10.join(projectRoot, ".wrongstack", "worktrees");
-  try {
-    const entries = await fsp6.readdir(worktreesDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const wtPath = path10.join(worktreesDir, entry.name);
-      const lockPath = path10.join(wtPath, ".lock");
-      try {
-        const lockStat = await fsp6.stat(lockPath).catch(() => null);
-        if (lockStat) {
-          const raw = await fsp6.readFile(lockPath, "utf8").catch(() => "");
-          const pid = parseInt(raw.trim(), 10);
-          if (Number.isInteger(pid) && pid > 0) {
-            if (!pidAlive2(pid)) {
-              await fsp6.unlink(lockPath).catch(() => void 0);
-              result.cleanedWorktrees.push(wtPath);
-            }
-          } else if (now - lockStat.mtimeMs > maxAgeMs) {
-            await fsp6.unlink(lockPath).catch(() => void 0);
-            result.cleanedWorktrees.push(wtPath);
-          }
-        }
-      } catch (err) {
-        result.errors.push(`Failed inspecting worktree ${entry.name}: ${toErrorMessage(err)}`);
-      }
-    }
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      result.errors.push(`Failed reading worktrees dir: ${toErrorMessage(err)}`);
-    }
-  }
-  return result;
-}
-
 // src/storage/replay-log-store.ts
 import * as fs8 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 function storageErrorString(err) {
   if (err instanceof Error) {
     const code = err.code;
@@ -3355,11 +3619,12 @@ var ReplayLogStore = class _ReplayLogStore {
             const line = JSON.stringify(entry) + "\n";
             let offset2 = 0;
             try {
-              const stat7 = await fs8.stat(fp);
-              offset2 = stat7.size;
+              const stat8 = await fs8.stat(fp);
+              offset2 = stat8.size;
             } catch (err) {
               if (err.code !== "ENOENT") throw err;
             }
+            await fs8.mkdir(path12.dirname(fp), { recursive: true });
             await fs8.appendFile(fp, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
             cache.set(hash, { entry, offset: offset2, length: Buffer.byteLength(line, "utf8") });
             this.diskCount.set(input.sessionId, currentCount + 1);
@@ -3506,13 +3771,13 @@ var ReplayLogStore = class _ReplayLogStore {
       for (const entry of entries) {
         if (entry.name.startsWith(".")) continue;
         if (entry.isDirectory()) {
-          if (depth === 0) await scan(path11.join(dir, entry.name), entry.name, depth + 1);
+          if (depth === 0) await scan(path12.join(dir, entry.name), entry.name, depth + 1);
           continue;
         }
         if (!entry.isFile() || !entry.name.endsWith(".replay.jsonl")) continue;
         const base = entry.name.slice(0, -".replay.jsonl".length);
         const sessionId = prefix ? `${prefix}/${base}` : base;
-        const fp = path11.join(dir, entry.name);
+        const fp = path12.join(dir, entry.name);
         out.push({
           sessionId,
           entryCount: await this.countEntries(fp),
@@ -3721,6 +3986,28 @@ var ReplayLogStore = class _ReplayLogStore {
   }
 };
 
+// src/storage/session-agent-attribution.ts
+function stampAgentId(event, agentId) {
+  if (event.agentId !== void 0) return event;
+  return { ...event, agentId };
+}
+function withAgentAttribution(writer, agentId) {
+  const cleanId = agentId?.trim();
+  if (!cleanId) return writer;
+  return new Proxy(writer, {
+    get(target, property, receiver) {
+      if (property === "append") {
+        return (event) => target.append(stampAgentId(event, cleanId));
+      }
+      if (property === "appendBatch") {
+        return (events) => target.appendBatch(events.map((event) => stampAgentId(event, cleanId)));
+      }
+      const value = Reflect.get(target, property, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
 // src/storage/session-analyzer.ts
 var SessionAnalyzer = class {
   analyze(events) {
@@ -3802,9 +4089,9 @@ var SessionAnalyzer = class {
         if (!filter.toolNames.includes(toolEvent.name)) return false;
       }
       if (filter.timeRange) {
-        const ts = new Date(e.ts).getTime();
-        const start = new Date(filter.timeRange.start).getTime();
-        const end = new Date(filter.timeRange.end).getTime();
+        const ts = Date.parse(e.ts) || 0;
+        const start = Date.parse(filter.timeRange.start) || 0;
+        const end = Date.parse(filter.timeRange.end) || Number.POSITIVE_INFINITY;
         if (ts < start || ts > end) return false;
       }
       return true;
@@ -3815,12 +4102,253 @@ var SessionAnalyzer = class {
     const firstEvent = events[0];
     const lastEvent = events[events.length - 1];
     if (!firstEvent || !lastEvent) return 0;
-    const first = new Date(firstEvent.ts).getTime();
-    const last = new Date(lastEvent.ts).getTime();
-    return last - first;
+    const first = Date.parse(firstEvent.ts) || 0;
+    const last = Date.parse(lastEvent.ts) || 0;
+    return Math.max(0, last - first);
   }
 };
 
+// src/storage/session-doctor.ts
+import { createReadStream } from "node:fs";
+import * as fsp7 from "node:fs/promises";
+import * as path13 from "node:path";
+import { createInterface } from "node:readline";
+var BOUNDARY_TYPES = /* @__PURE__ */ new Set([
+  "session_start",
+  "in_flight_start",
+  "in_flight_end",
+  "session_end"
+]);
+var TYPE_RE = /"type"\s*:\s*"([A-Za-z0-9_:.-]+)"/;
+var TYPE_PROBE_CHARS = 200;
+function readEventType(line) {
+  if (line.length === 0 || line[0] !== "{") return null;
+  const fast = TYPE_RE.exec(line.slice(0, TYPE_PROBE_CHARS));
+  if (fast?.[1]) return fast[1];
+  return line.length > TYPE_PROBE_CHARS ? TYPE_RE.exec(line)?.[1] ?? null : null;
+}
+function severityRank(diagnosis) {
+  if (diagnosis.findings.some((f) => f.severity === "error")) return 0;
+  if (diagnosis.findings.some((f) => f.severity === "warn")) return 1;
+  return 2;
+}
+async function collectJournals(sessionsDir) {
+  const out = [];
+  let days;
+  try {
+    const entries = await fsp7.readdir(sessionsDir, { withFileTypes: true });
+    days = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return out;
+  }
+  for (const day of days) {
+    if (day.startsWith("_")) continue;
+    let names;
+    try {
+      names = await fsp7.readdir(path13.join(sessionsDir, day));
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      if (!name.endsWith(".jsonl")) continue;
+      out.push({
+        id: `${day}/${name.slice(0, -".jsonl".length)}`,
+        file: path13.join(sessionsDir, day, name)
+      });
+    }
+  }
+  return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+async function endsWithNewline(file, bytes) {
+  if (bytes === 0) return true;
+  const handle = await fsp7.open(file, "r");
+  try {
+    const buffer = Buffer.alloc(1);
+    await handle.read(buffer, 0, 1, bytes - 1);
+    return buffer.toString("utf8") === "\n";
+  } finally {
+    await handle.close();
+  }
+}
+async function scanJournal(id, file, oversizedBytes, signal) {
+  const stat8 = await fsp7.stat(file);
+  const diagnosis = {
+    id,
+    file,
+    bytes: stat8.size,
+    lines: 0,
+    unparsableLines: 0,
+    snapshotBytes: 0,
+    lastBoundary: null,
+    hasSessionStart: false,
+    hasSummarySidecar: false,
+    summaryStale: false,
+    findings: []
+  };
+  const stream = createReadStream(file, { encoding: "utf8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      signal?.throwIfAborted();
+      diagnosis.lines++;
+      if (line.length === 0) continue;
+      const type = readEventType(line);
+      if (type === null) {
+        diagnosis.unparsableLines++;
+        continue;
+      }
+      if (type === "session_start") diagnosis.hasSessionStart = true;
+      if (BOUNDARY_TYPES.has(type)) {
+        diagnosis.lastBoundary = type;
+      }
+      if (type === "messages_replaced" || type === "context_snapshot") {
+        diagnosis.snapshotBytes += line.length;
+      }
+    }
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+  const sidecar = `${file.slice(0, -".jsonl".length)}.summary.json`;
+  const sidecarStat = await fsp7.stat(sidecar).catch(() => null);
+  diagnosis.hasSummarySidecar = sidecarStat !== null;
+  diagnosis.summaryStale = sidecarStat !== null && sidecarStat.mtimeMs + 1 < stat8.mtimeMs;
+  const add = (finding) => {
+    diagnosis.findings.push(finding);
+  };
+  if (diagnosis.lines === 0) {
+    add({ code: "empty", severity: "info", detail: "no events recorded" });
+  }
+  if (diagnosis.unparsableLines > 0) {
+    add({
+      code: "unparsable_lines",
+      severity: "error",
+      // The loader skips these without a word, so the only symptom is a
+      // transcript that is quietly missing turns.
+      detail: `${diagnosis.unparsableLines} of ${diagnosis.lines} lines cannot be parsed \u2014 the loader skips them silently`
+    });
+  }
+  if (!await endsWithNewline(file, stat8.size)) {
+    add({
+      code: "truncated_tail",
+      severity: "warn",
+      detail: "last line is incomplete \u2014 the process died mid-write"
+    });
+  }
+  if (diagnosis.lines > 0 && !diagnosis.hasSessionStart) {
+    add({
+      code: "missing_session_start",
+      severity: "warn",
+      detail: "no session_start \u2014 model/provider metadata is unknown"
+    });
+  }
+  if (diagnosis.lastBoundary === "in_flight_start") {
+    add({
+      code: "died_mid_turn",
+      severity: "warn",
+      // Not a defect to fix here: `store.resume()` heals it on open, pairing
+      // the dangling tool_uses with synthesized results.
+      detail: "died mid-turn \u2014 resume repairs this on open"
+    });
+  } else if (diagnosis.lines > 0 && diagnosis.lastBoundary !== "session_end") {
+    add({
+      code: "never_closed",
+      severity: "info",
+      detail: "no session_end \u2014 killed rather than closed"
+    });
+  }
+  if (!diagnosis.hasSummarySidecar && diagnosis.lines > 0) {
+    add({
+      code: "missing_summary",
+      severity: "warn",
+      detail: "no .summary.json \u2014 the picker has no title or counts for it",
+      fix: "rebuild the summary from the journal"
+    });
+  } else if (diagnosis.summaryStale) {
+    add({
+      code: "stale_summary",
+      severity: "info",
+      detail: ".summary.json is older than the transcript",
+      fix: "rebuild the summary from the journal"
+    });
+  }
+  if (stat8.size >= oversizedBytes) {
+    const share = stat8.size > 0 ? Math.round(diagnosis.snapshotBytes / stat8.size * 100) : 0;
+    add({
+      code: "oversized",
+      severity: "info",
+      detail: `${(stat8.size / 1e6).toFixed(0)} MB \u2014 slow to open` + (share >= 50 ? `; ${share}% is superseded conversation snapshots` : "")
+    });
+  }
+  return diagnosis;
+}
+async function diagnoseSessions(options) {
+  const { sessionsDir, onProgress, signal } = options;
+  const oversizedBytes = options.oversizedBytes ?? 64 * 1024 * 1024;
+  const journals = await collectJournals(sessionsDir);
+  const sessions = [];
+  const unreadable = [];
+  let scanned = 0;
+  for (const { id, file } of journals) {
+    signal?.throwIfAborted();
+    onProgress?.({ scanned, total: journals.length, id });
+    try {
+      sessions.push(await scanJournal(id, file, oversizedBytes, signal));
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      unreadable.push({ id, reason: error instanceof Error ? error.message : String(error) });
+    }
+    scanned++;
+  }
+  onProgress?.({ scanned, total: journals.length, id: "" });
+  const totals = {
+    sessions: sessions.length,
+    bytes: sessions.reduce((sum, s) => sum + s.bytes, 0),
+    snapshotBytes: sessions.reduce((sum, s) => sum + s.snapshotBytes, 0),
+    unparsableLines: sessions.reduce((sum, s) => sum + s.unparsableLines, 0)
+  };
+  const byCode = {};
+  for (const session of sessions) {
+    for (const finding of session.findings) {
+      byCode[finding.code] = (byCode[finding.code] ?? 0) + 1;
+    }
+  }
+  sessions.sort((a, b) => severityRank(a) - severityRank(b) || b.bytes - a.bytes);
+  return { sessionsDir, totals, byCode, sessions, unreadable };
+}
+async function repairSessionSummaries(options) {
+  const { report, onProgress, signal } = options;
+  const scrubber = options.secretScrubber ?? new DefaultSecretScrubber();
+  const targets = report.sessions.filter(
+    (session) => session.findings.some((f) => f.code === "missing_summary" || f.code === "stale_summary")
+  );
+  const result = { repaired: [], failed: [] };
+  for (const session of targets) {
+    signal?.throwIfAborted();
+    onProgress?.({ repaired: result.repaired.length, total: targets.length, id: session.id });
+    try {
+      const stat8 = await fsp7.stat(session.file);
+      const summary = await summarizeSessionFile({
+        id: session.id,
+        file: session.file,
+        mtime: stat8.mtime.toISOString(),
+        secretScrubber: scrubber
+      });
+      const sidecar = `${session.file.slice(0, -".jsonl".length)}.summary.json`;
+      await atomicWrite(sidecar, `${JSON.stringify(summary, null, 2)}
+`, { mode: 384 });
+      result.repaired.push(session.id);
+    } catch (error) {
+      result.failed.push({
+        id: session.id,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  onProgress?.({ repaired: result.repaired.length, total: targets.length, id: "" });
+  return result;
+}
+
 // src/storage/session-event-bridge.ts
 var CORE_RECONSTRUCT_EVENTS = /* @__PURE__ */ new Set([
   "session_start",
@@ -3828,6 +4356,7 @@ var CORE_RECONSTRUCT_EVENTS = /* @__PURE__ */ new Set([
   "session_forked",
   "user_input",
   "llm_response",
+  "tool_use",
   "tool_result",
   "message_appended",
   "message_updated",
@@ -3844,7 +4373,6 @@ var CORE_RECONSTRUCT_EVENTS = /* @__PURE__ */ new Set([
 ]);
 var STANDARD_AUDIT_EVENTS = /* @__PURE__ */ new Set([
   "llm_request",
-  "tool_use",
   "tool_call_start",
   "tool_call_end",
   "compaction",
@@ -3860,8 +4388,13 @@ var STANDARD_AUDIT_EVENTS = /* @__PURE__ */ new Set([
   // at the DEFAULT level and the resume timeline would lose them silently.
   "mode_changed",
   "agent_spawned",
+  "agent_session_linked",
   "agent_stopped",
   "agent_error",
+  "delegate_started",
+  "delegate_completed",
+  "loop_detected",
+  "model_switched",
   "task_created",
   "task_updated",
   "task_completed",
@@ -4322,10 +4855,10 @@ async function applyRewindToConversation(opts) {
 }
 
 // src/storage/session-rewinder.ts
-import { createReadStream } from "node:fs";
-import * as fsp7 from "node:fs/promises";
-import * as path12 from "node:path";
-import { createInterface } from "node:readline";
+import { createReadStream as createReadStream2 } from "node:fs";
+import * as fsp8 from "node:fs/promises";
+import * as path14 from "node:path";
+import { createInterface as createInterface2 } from "node:readline";
 var DefaultSessionRewinder = class {
   constructor(sessionsDir, projectRoot) {
     this.sessionsDir = sessionsDir;
@@ -4337,8 +4870,8 @@ var DefaultSessionRewinder = class {
     return sessionScopedPath(this.sessionsDir, sessionId, ".jsonl");
   }
   async *readEvents(file) {
-    const stream = createReadStream(file, { encoding: "utf8" });
-    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    const stream = createReadStream2(file, { encoding: "utf8" });
+    const lines = createInterface2({ input: stream, crlfDelay: Infinity });
     try {
       for await (const line of lines) {
         if (!line.trim()) continue;
@@ -4458,10 +4991,10 @@ async function revertSnapshots(snapshots, projectRoot) {
   for (const snapshot of [...snapshots].reverse()) {
     for (const file of [...snapshot.files].reverse()) {
       try {
-        const absPath = path12.resolve(file.path);
-        const root = path12.resolve(projectRoot);
-        const rel = path12.relative(root, absPath);
-        if (rel.startsWith("..") || path12.isAbsolute(rel)) {
+        const absPath = path14.resolve(file.path);
+        const root = path14.resolve(projectRoot);
+        const rel = path14.relative(root, absPath);
+        if (rel.startsWith("..") || path14.isAbsolute(rel)) {
           errors.push(`${file.path}: path resolves outside project root \u2014 skipping`);
           continue;
         }
@@ -4471,7 +5004,7 @@ async function revertSnapshots(snapshots, projectRoot) {
             revertedFiles.push(file.path);
           }
         } else if (file.action === "created") {
-          await fsp7.unlink(file.path);
+          await fsp8.unlink(file.path);
           revertedFiles.push(file.path);
         } else if (file.action === "modified") {
           if (file.before !== null) {
@@ -4488,7 +5021,7 @@ async function revertSnapshots(snapshots, projectRoot) {
 }
 
 // src/storage/task-store.ts
-import * as fsp8 from "node:fs/promises";
+import * as fsp9 from "node:fs/promises";
 function assertTaskMutationInvariants(previous, updated) {
   const ids = updated.tasks.map((task) => task.id);
   const uniqueIds = new Set(ids);
@@ -4549,7 +5082,7 @@ async function loadTasks(filePath, events, traceId) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp8.readFile(filePath, "utf8");
+    raw = await fsp9.readFile(filePath, "utf8");
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: traceId ?? "~boot~",
@@ -4658,12 +5191,12 @@ async function mutateTasks(filePath, sessionId, fn, events, traceId) {
 }
 
 // src/storage/todos-checkpoint.ts
-import * as fsp9 from "node:fs/promises";
+import * as fsp10 from "node:fs/promises";
 async function loadTodosCheckpoint(filePath, events, traceId, sessionId) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp9.readFile(filePath, "utf8");
+    raw = await fsp10.readFile(filePath, "utf8");
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: sessionId ?? "~boot~",
@@ -5186,7 +5719,9 @@ export {
   FileMemoryBackend,
   parseEntries,
   SessionMemoryConsolidator,
+  SessionMemoryCurator,
   GraphMemoryBackend,
+  cleanOrphanLocks,
   loadPlan,
   savePlan,
   emptyPlan,
@@ -5209,9 +5744,12 @@ export {
   retainPersistedQueueItems,
   QueueStore,
   RecoveryLock,
-  cleanOrphanLocks,
   ReplayLogStore,
+  stampAgentId,
+  withAgentAttribution,
   SessionAnalyzer,
+  diagnoseSessions,
+  repairSessionSummaries,
   CORE_RECONSTRUCT_EVENTS,
   STANDARD_AUDIT_EVENTS,
   createSessionEventBridge,
@@ -5229,4 +5767,4 @@ export {
   attachTodosCheckpoint,
   ToolAuditLog
 };
-//# sourceMappingURL=chunk-K3G6JBUC.js.map
+//# sourceMappingURL=chunk-WLYKU45P.js.map