@wrongstack/core 0.287.0 → 0.291.0

package/dist/storage/index.js

@@ -147,6 +147,12 @@ var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
 function isStdoutTTY() {
   return hasStdout() && Boolean(process.stdout.isTTY);
 }
+var ESCAPE_TERMINATOR = Object.freeze({
+  BEL: "\x07",
+  // OSC 0 / OSC 2 (title)
+  ST: "\x1B\\"
+  // DCS / strict OSC
+});
 
 // src/utils/color.ts
 var isColorTty = () => {
@@ -255,6 +261,16 @@ function expectDefined(value, label) {
 }
 
 // src/utils/message-invariants.ts
+function hasMeaningfulContent(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  return content.some((block) => {
+    if (block.type === "text") return block.text.trim().length > 0;
+    if (block.type === "thinking") {
+      return block.thinking.trim().length > 0 || Boolean(block.signature);
+    }
+    return true;
+  });
+}
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
   const removedToolResults = [];
@@ -342,8 +358,7 @@ function mapContent(msg, fn) {
   return { ...msg, content: next };
 }
 function isEmptyMessage(msg) {
-  if (typeof msg.content === "string") return msg.content.trim().length === 0;
-  return msg.content.length === 0;
+  return !hasMeaningfulContent(msg.content);
 }
 
 // src/utils/regex-guard.ts
@@ -384,7 +399,7 @@ function compileUserRegex(pattern, flags) {
 
 // src/utils/safe-json.ts
 function safeParse(input, maxBytes = 5e6) {
-  if (input.length > maxBytes) {
+  if (Buffer.byteLength(input, "utf8") > maxBytes) {
     return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
   }
   try {
@@ -504,6 +519,11 @@ function resolveWstackPaths(opts) {
     homeDir,
     configDir: globalRoot,
     globalConfig: path2.join(globalRoot, "config.json"),
+    profilesDir: path2.join(globalRoot, "profiles"),
+    profileConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path2.join(globalRoot, "profiles", safe || "default", "config.json");
+    },
     secretsKey: path2.join(globalRoot, ".key"),
     globalMemory: path2.join(globalRoot, "memory.md"),
     globalSkills: path2.join(globalRoot, "skills"),
@@ -731,7 +751,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
   const dir = path3.dirname(targetPath);
   await fs2.mkdir(dir, { recursive: true });
   const lockPath = path3.join(dir, `.${path3.basename(targetPath)}.lock`);
-  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const timeoutMs = opts.timeoutMs ?? 15e3;
   const staleMs = opts.staleMs ?? 3e4;
   const started = Date.now();
   let handle;
@@ -741,6 +761,13 @@ async function withFileLock(targetPath, fn, opts = {}) {
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
+      if (handle) {
+        await handle.close().catch(() => {
+        });
+        await fs2.unlink(lockPath).catch(() => {
+        });
+        handle = void 0;
+      }
       const code = err.code;
       if (code === "ENOENT") {
         await fs2.mkdir(dir, { recursive: true });
@@ -961,24 +988,24 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Scrub secrets out of conversation-turn events before they are observed
    * for the summary, written to the JSONL log, or surfaced on resume. Only
-   * `user_input`, `llm_response`, and `context_snapshot` carry free-form
-   * user/model text; other event types either have no secret-bearing content
-   * or are already scrubbed upstream (tool results). Snapshot normalization
-   * also strips transient token-cache fields even when no scrubber is set.
+   * Conversation events carry free-form user/model text. Snapshot and exact
+   * message-journal normalization also strips transient token-cache fields
+   * even when no scrubber is set.
    */
   scrubEvent(event) {
     const s = this.secretScrubber;
-    if (event.type === "context_snapshot") {
+    const persistMessage = (message) => {
+      const { _estTokens: _ignored, ...persisted } = message;
       return {
-        ...event,
-        messages: event.messages.map((message) => {
-          const { _estTokens: _ignored, ...persisted } = message;
-          return {
-            ...persisted,
-            content: typeof persisted.content === "string" ? s?.scrub(persisted.content) ?? persisted.content : s?.scrubObject(persisted.content) ?? persisted.content
-          };
-        })
+        ...persisted,
+        content: typeof persisted.content === "string" ? s?.scrub(persisted.content) ?? persisted.content : s?.scrubObject(persisted.content) ?? persisted.content
       };
+    };
+    if (event.type === "context_snapshot" || event.type === "messages_replaced") {
+      return { ...event, messages: event.messages.map(persistMessage) };
+    }
+    if (event.type === "message_appended" || event.type === "message_updated") {
+      return { ...event, message: persistMessage(event.message) };
     }
     if (!s) return event;
     if (event.type === "user_input") {
@@ -1033,7 +1060,8 @@ var FileSessionWriter = class _FileSessionWriter {
     this.bufferSynchronousEvent(event);
   }
   recordFileObservation(input) {
-    if (!input.path || !/^[a-f\d]{64}$/i.test(input.hash) || !Number.isFinite(input.mtimeMs)) return;
+    if (!input.path || !/^[a-f\d]{64}$/i.test(input.hash) || !Number.isFinite(input.mtimeMs))
+      return;
     this.bufferSynchronousEvent({
       type: "file_observation",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1195,12 +1223,7 @@ var FileSessionWriter = class _FileSessionWriter {
       const now = Date.now();
       if (now - this.lastAppendWarnAt > 5e3) {
         const suppressed = this.appendFailCount - 1;
-        const tail = suppressed > 0 ? ` (+${suppressed} suppressed)` : "";
-        console.warn(
-          "[session] flush failed:",
-          toErrorMessage(err),
-          tail
-        );
+        console.warn(JSON.stringify({ level: "warn", event: "session.flush_failed", sessionId: this.id, message: toErrorMessage(err), ...suppressed > 0 ? { suppressed } : {}, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
         this.lastAppendWarnAt = now;
         this.appendFailCount = 0;
       }
@@ -1220,6 +1243,43 @@ var FileSessionWriter = class _FileSessionWriter {
       });
     }
   }
+  /**
+   * Rebuild every accumulated summary counter by replaying the JSONL as it now
+   * stands on disk.
+   *
+   * Only truncation needs this: the counters are fed by `observeForSummary` as
+   * events go by and cannot un-count. Reading the whole file is fine here —
+   * rewind is a rare, explicitly user-driven operation, and the alternative
+   * (reversing each counter per discarded event) has to stay in lockstep with
+   * observeForSummary forever.
+   *
+   * `title` is deliberately re-derived too: the first surviving user_input may
+   * differ once earlier prompts are gone.
+   */
+  async recomputeSummaryFromDisk() {
+    if (!this.filePath) return;
+    const raw = await fsp.readFile(this.filePath, "utf8").catch(() => null);
+    if (raw === null) return;
+    this.iterationCount = 0;
+    this.toolCallCount = 0;
+    this.toolErrorCount = 0;
+    this.toolBreakdown = {};
+    this.fileChangeCount = 0;
+    this.compactionCount = 0;
+    this.outcome = void 0;
+    this.openToolUses = /* @__PURE__ */ new Set();
+    this.tokenIn = 0;
+    this.tokenOut = 0;
+    this.summary = { ...this.summary, title: "(empty session)", tokenTotal: 0 };
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      try {
+        this.observeForSummary(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+  }
   observeForSummary(event) {
     if (event.type === "llm_response") {
       for (const block of event.content) {
@@ -1270,10 +1330,7 @@ var FileSessionWriter = class _FileSessionWriter {
   }
   async doClose() {
     if (this.pendingFileSnapshots.length > 0) {
-      await this.writeFileSnapshot(
-        this.activePromptIndex ?? 0,
-        [...this.pendingFileSnapshots]
-      );
+      await this.writeFileSnapshot(this.activePromptIndex ?? 0, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
     this.closed = true;
@@ -1393,7 +1450,7 @@ var FileSessionWriter = class _FileSessionWriter {
    * so post-checkpoint content is never read or parsed — O(1) memory instead
    * of O(N) JSON.parse calls over the full file.
    */
-  async truncateToCheckpoint(targetPromptIndex) {
+  async truncateToCheckpoint(targetPromptIndex, revertedFiles = []) {
     if (!this.filePath) return 0;
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
@@ -1404,7 +1461,7 @@ var FileSessionWriter = class _FileSessionWriter {
     const CHUNK_SIZE = 65536;
     let fd;
     let fileOffset = 0;
-    let lineStartOffset = 0;
+    let pendingLine = Buffer.alloc(0);
     let checkpointByteOffset = -1;
     let removedCount = 0;
     let targetCheckpointSeen = false;
@@ -1414,17 +1471,18 @@ var FileSessionWriter = class _FileSessionWriter {
         const buf = Buffer.alloc(CHUNK_SIZE);
         const { bytesRead } = await fd.read(buf, 0, CHUNK_SIZE, fileOffset);
         if (bytesRead === 0) break;
+        const carriedBytes = pendingLine.length;
+        const chunk = carriedBytes === 0 ? buf.subarray(0, bytesRead) : Buffer.concat([pendingLine, buf.subarray(0, bytesRead)]);
+        const chunkFileOffset = fileOffset - carriedBytes;
         let chunkPos = 0;
-        while (chunkPos < bytesRead) {
-          const idx = buf.indexOf("\n", chunkPos);
-          if (idx === -1) {
-            lineStartOffset = fileOffset + chunkPos;
-            break;
-          }
+        while (chunkPos < chunk.length) {
+          const idx = chunk.indexOf("\n", chunkPos);
+          if (idx === -1) break;
+          const lineStartOffset = chunkFileOffset + chunkPos;
           if (checkpointByteOffset !== -1) {
             removedCount++;
           } else {
-            const lineBytes = buf.subarray(chunkPos, idx);
+            const lineBytes = chunk.subarray(chunkPos, idx);
             const line = new TextDecoder("utf-8", { fatal: false }).decode(lineBytes);
             if (line.trim()) {
               try {
@@ -1450,12 +1508,9 @@ var FileSessionWriter = class _FileSessionWriter {
             }
           }
           chunkPos = idx + 1;
-          lineStartOffset = fileOffset + chunkPos;
         }
+        pendingLine = chunk.subarray(chunkPos);
         fileOffset += bytesRead;
-        if (chunkPos >= bytesRead) {
-          lineStartOffset = fileOffset;
-        }
       }
     } finally {
       await fd?.close();
@@ -1535,17 +1590,19 @@ var FileSessionWriter = class _FileSessionWriter {
       this.handle = await fsp.open(this.filePath, "a", 384).catch(() => this.handle);
       throw err;
     }
+    await this.recomputeSummaryFromDisk();
+    const reverted = [...revertedFiles];
     await this.append({
       type: "rewound",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       toPromptIndex: targetPromptIndex,
-      revertedFiles: []
+      revertedFiles: reverted
     });
     this.activePromptIndex = targetPromptIndex;
     this.events?.emit("session.rewound", {
       sessionId: this.id,
       toPromptIndex: targetPromptIndex,
-      revertedFiles: [],
+      revertedFiles: reverted,
       removedEvents: removedCount
     });
     return removedCount;
@@ -1586,7 +1643,11 @@ var FileSessionWriter = class _FileSessionWriter {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       context
     });
-    this.events?.emit("in_flight.started", { sessionId: this.id, context, ts: (/* @__PURE__ */ new Date()).toISOString() });
+    this.events?.emit("in_flight.started", {
+      sessionId: this.id,
+      context,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
   /**
    * Close the in-flight marker. Idempotent in spirit
@@ -1597,10 +1658,7 @@ var FileSessionWriter = class _FileSessionWriter {
    */
   async clearInFlightMarker(reason) {
     if (this.pendingFileSnapshots.length > 0) {
-      await this.writeFileSnapshot(
-        this.activePromptIndex ?? 0,
-        [...this.pendingFileSnapshots]
-      );
+      await this.writeFileSnapshot(this.activePromptIndex ?? 0, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
     await this.append({
@@ -1608,7 +1666,11 @@ var FileSessionWriter = class _FileSessionWriter {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       reason
     });
-    this.events?.emit("in_flight.ended", { sessionId: this.id, reason, ts: (/* @__PURE__ */ new Date()).toISOString() });
+    this.events?.emit("in_flight.ended", {
+      sessionId: this.id,
+      reason,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
 };
 
@@ -1999,6 +2061,16 @@ function defaultRunGit(args, cwd) {
   });
 }
 
+// src/storage/session-id.ts
+function sanitizeModel(model) {
+  return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function generateSessionId(startedAt, _model) {
+  const date = startedAt.slice(0, 10);
+  const seedTime = Number.isNaN(Date.parse(startedAt)) ? Date.now() : Date.parse(startedAt);
+  return `${date}/sess_${ulid(seedTime)}`;
+}
+
 // src/storage/session-resume-validation.ts
 import { createHash as createHash3 } from "node:crypto";
 import * as fsp3 from "node:fs/promises";
@@ -2108,15 +2180,14 @@ function formatResumeValidationNotice(validation, projectRoot) {
     ...shown
   ].join("\n");
 }
-
-// src/storage/session-id.ts
-function sanitizeModel(model) {
-  return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
-}
-function generateSessionId(startedAt, _model) {
-  const date = startedAt.slice(0, 10);
-  const seedTime = Number.isNaN(Date.parse(startedAt)) ? Date.now() : Date.parse(startedAt);
-  return `${date}/sess_${ulid(seedTime)}`;
+function formatInterruptedToolNotice(pendingToolUseCount) {
+  if (!Number.isFinite(pendingToolUseCount) || pendingToolUseCount <= 0) return null;
+  const plural = pendingToolUseCount === 1 ? "tool call was" : "tool calls were";
+  return [
+    "[SESSION RESUME INTERRUPTED WORK]",
+    `The previous run left ${pendingToolUseCount} ${plural} in flight \u2014 no result was recorded before it stopped (crash or interrupt).`,
+    "Those interrupted tool calls were removed from the restored conversation and were NOT re-executed. Re-run the work if it still needs doing."
+  ].join("\n");
 }
 
 // src/storage/session-summary.ts
@@ -2162,18 +2233,27 @@ function isReplayableMessage(value) {
   const candidate = value;
   return (candidate.role === "user" || candidate.role === "assistant" || candidate.role === "system") && (typeof candidate.content === "string" || Array.isArray(candidate.content));
 }
+function trackMessageToolState(message, openToolUses) {
+  if (!Array.isArray(message.content)) return;
+  for (const block of message.content) {
+    if (block.type === "tool_use") openToolUses.add(block.id);
+    else if (block.type === "tool_result") openToolUses.delete(block.tool_use_id);
+  }
+}
+function replayableMessage(value, fallbackTs) {
+  if (!isReplayableMessage(value)) return null;
+  const { _estTokens: _ignored, ...message } = value;
+  return message.ts === void 0 && fallbackTs ? { ...message, ts: fallbackTs } : message;
+}
 function applyContextSnapshot(target, openToolUses, snapshot) {
   if (!Array.isArray(snapshot) || !snapshot.every(isReplayableMessage)) return false;
   target.length = 0;
   openToolUses.clear();
   for (const raw of snapshot) {
-    const { _estTokens: _ignored, ...message } = raw;
+    const message = replayableMessage(raw);
+    if (!message) return false;
     target.push(message);
-    if (!Array.isArray(message.content)) continue;
-    for (const block of message.content) {
-      if (block.type === "tool_use") openToolUses.add(block.id);
-      else if (block.type === "tool_result") openToolUses.delete(block.tool_use_id);
-    }
+    trackMessageToolState(message, openToolUses);
   }
   return true;
 }
@@ -2326,10 +2406,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       handle = await fsp4.open(file, "a", 384);
     } catch (err) {
       this.emitError(id, file, "create", toErrorMessage(err), false);
-      throw new Error(
-        `Failed to open session file: ${toErrorMessage(err)}`,
-        { cause: err }
-      );
+      throw new Error(`Failed to open session file: ${toErrorMessage(err)}`, { cause: err });
     }
     try {
       const writer = new FileSessionWriter(id, handle, startedAt, meta, this.events, {
@@ -2342,10 +2419,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite(id, file, "create", "success", Date.now() - t0);
       return writer;
     } catch (err) {
-      await handle.close().catch((e) => this.logWarn(
-        "Session handle close failed",
-        { event: "session_store.handle_close_failed", message: e instanceof Error ? e.message : String(e) }
-      ));
+      await handle.close().catch(
+        (e) => this.logWarn("Session handle close failed", {
+          event: "session_store.handle_close_failed",
+          message: e instanceof Error ? e.message : String(e)
+        })
+      );
       this.emitError(id, file, "create", toErrorMessage(err), true);
       throw err;
     }
@@ -2364,9 +2443,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         }
       }
       if (boundary === -1) {
-        throw new Error(
-          `Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`
-        );
+        throw new Error(`Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`);
       }
     }
     const parentPrefix = parent.events.slice(0, boundary + 1);
@@ -2413,7 +2490,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   async materializeWorkspaceCheckpoint(checkpoint, targetRoot) {
     if (!this.checkpointCas) {
-      throw new Error("Workspace checkpoint materialization requires a projectRoot-aware session store");
+      throw new Error(
+        "Workspace checkpoint materialization requires a projectRoot-aware session store"
+      );
     }
     return this.checkpointCas.materialize(checkpoint, targetRoot);
   }
@@ -2421,34 +2500,44 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const file = this.sessionPath(id, ".jsonl");
     const t0 = Date.now();
     const data = await this.load(id);
-    let resumedData = data;
+    const noticeMessages = [];
+    let resumeValidation;
     if (this.projectRoot) {
       try {
-        const resumeValidation = await validateResumeFileObservations(data.events, this.projectRoot);
+        resumeValidation = await validateResumeFileObservations(data.events, this.projectRoot);
         const notice = formatResumeValidationNotice(resumeValidation, this.projectRoot);
-        resumedData = {
-          ...data,
-          resumeValidation,
-          ...notice ? {
-            messages: [
-              ...data.messages,
-              { role: "system", content: notice, ts: resumeValidation.checkedAt }
-            ]
-          } : {}
-        };
+        if (notice) {
+          noticeMessages.push({
+            role: "system",
+            content: notice,
+            ts: resumeValidation.checkedAt
+          });
+        }
       } catch (err) {
         this.emitError(id, file, "resume_validation", toErrorMessage(err), true);
       }
     }
+    const interruptedNotice = formatInterruptedToolNotice(data.pendingToolUseCount ?? 0);
+    if (interruptedNotice) {
+      noticeMessages.push({
+        role: "system",
+        content: interruptedNotice,
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    const resumedData = {
+      ...data,
+      ...resumeValidation ? { resumeValidation } : {},
+      ...noticeMessages.length > 0 ? { messages: [...data.messages, ...noticeMessages] } : {}
+    };
     let handle;
     try {
       handle = await fsp4.open(file, "a", 384);
     } catch (err) {
       this.emitError(id, file, "resume", toErrorMessage(err), false);
-      throw new Error(
-        `Failed to open session "${id}" for append: ${toErrorMessage(err)}`,
-        { cause: err }
-      );
+      throw new Error(`Failed to open session "${id}" for append: ${toErrorMessage(err)}`, {
+        cause: err
+      });
     }
     try {
       const writer = new FileSessionWriter(
@@ -2476,10 +2565,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite(id, file, "resume", "success", Date.now() - t0);
       return { writer, data: resumedData };
     } catch (err) {
-      await handle.close().catch((e) => this.logWarn(
-        "Session handle close failed",
-        { event: "session_store.handle_close_failed", message: e instanceof Error ? e.message : String(e) }
-      ));
+      await handle.close().catch(
+        (e) => this.logWarn("Session handle close failed", {
+          event: "session_store.handle_close_failed",
+          message: e instanceof Error ? e.message : String(e)
+        })
+      );
       this.emitError(id, file, "resume", toErrorMessage(err), true);
       throw err;
     }
@@ -2530,6 +2621,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       let sessionForkedEvent;
       const messages = mode.full ? [] : void 0;
       const openToolUses = mode.full ? /* @__PURE__ */ new Set() : void 0;
+      let exactJournalActive = false;
       let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
       const stream = createReadStream(file, { encoding: "utf8" });
       const rl = createInterface({ input: stream, crlfDelay: Infinity });
@@ -2554,20 +2646,59 @@ var DefaultSessionStore = class _DefaultSessionStore {
                 sessionForkedEvent = ev;
               }
               if (mode.full && messages !== void 0 && openToolUses !== void 0) {
-                if (ev.type === "context_snapshot") {
+                if (ev.type === "message_appended" && ev.version === 1) {
+                  const message = replayableMessage(ev.message, ev.ts);
+                  if (message) {
+                    if (!exactJournalActive) {
+                      messages.length = 0;
+                      openToolUses.clear();
+                      exactJournalActive = true;
+                    }
+                    messages.push(message);
+                    trackMessageToolState(message, openToolUses);
+                  } else {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: "Ignored malformed message_appended event"
+                    });
+                  }
+                } else if (ev.type === "message_updated" && ev.version === 1) {
+                  const message = replayableMessage(ev.message, ev.ts);
+                  if (message && exactJournalActive && ev.index >= 0 && ev.index < messages.length) {
+                    messages[ev.index] = message;
+                    openToolUses.clear();
+                    for (const current of messages) trackMessageToolState(current, openToolUses);
+                  } else {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: `Ignored malformed message_updated event at index ${ev.index}`
+                    });
+                  }
+                } else if (ev.type === "messages_replaced" && ev.version === 1) {
+                  if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
+                    exactJournalActive = true;
+                  } else {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: "Ignored malformed messages_replaced event"
+                    });
+                  }
+                } else if (ev.type === "context_snapshot") {
                   if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
                     this.events?.emit("session.damaged", {
                       sessionId: id,
                       detail: "Ignored malformed context_snapshot event"
                     });
                   }
-                } else if (ev.type === "user_input") {
+                } else if (!exactJournalActive && ev.type === "user_input") {
                   openToolUses.clear();
                   messages.push({ role: "user", content: ev.content, ts: ev.ts });
                 } else if (ev.type === "llm_response") {
-                  messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
-                  for (const b of ev.content) {
-                    if (b.type === "tool_use") openToolUses.add(b.id);
+                  if (!exactJournalActive) {
+                    messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
+                    for (const b of ev.content) {
+                      if (b.type === "tool_use") openToolUses.add(b.id);
+                    }
                   }
                   usage = {
                     input: usage.input + (ev.usage.input ?? 0),
@@ -2575,7 +2706,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
                     cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
                     cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
                   };
-                } else if (ev.type === "tool_result") {
+                } else if (!exactJournalActive && ev.type === "tool_result") {
                   if (!openToolUses.has(ev.id)) {
                     this.events?.emit("session.damaged", {
                       sessionId: id,
@@ -2647,7 +2778,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
         } : void 0
       };
       const toolCallEnds = extractToolCallEnds(events);
-      const data = { metadata: meta, events, messages: finalMessages, usage, toolCallEnds };
+      const pendingToolUseCount = openToolUses && openToolUses.size > 0 ? openToolUses.size : void 0;
+      const data = {
+        metadata: meta,
+        events,
+        messages: finalMessages,
+        usage,
+        toolCallEnds,
+        ...pendingToolUseCount !== void 0 ? { pendingToolUseCount } : {}
+      };
       if (mode.full) {
         if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
           const oldest = this._loadCache.keys().next().value;
@@ -2663,7 +2802,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
       errorMsg = toErrorMessage(err);
       throw err;
     } finally {
-      this.emitRead(id, file, mode.full ? "load" : "load_events_only", outcome, Date.now() - t0, errorMsg);
+      this.emitRead(
+        id,
+        file,
+        mode.full ? "load" : "load_events_only",
+        outcome,
+        Date.now() - t0,
+        errorMsg
+      );
       if (cacheHit) {
         this.events?.emit("storage.cache_hit", {
           sessionId: id,
@@ -2865,7 +3011,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
     } finally {
-      this.emitWrite("~compact~", this.indexFile, "compact", outcome, Date.now() - t0, void 0, errorMsg);
+      this.emitWrite(
+        "~compact~",
+        this.indexFile,
+        "compact",
+        outcome,
+        Date.now() - t0,
+        void 0,
+        errorMsg
+      );
     }
   }
   /**
@@ -2937,7 +3091,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
    */
   async rebuildIndex() {
     const ids = await this.collectSessionIds(this.dir);
-    const summaries = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
+    const summaries = await Promise.all(
+      ids.map((id) => this.summaryFor(id).catch(() => null))
+    );
     const valid = summaries.filter((s) => s !== null);
     const lines = valid.map((s) => JSON.stringify(s)).join("\n") + "\n";
     await withFileLock(this.indexFile, async () => {
@@ -2978,7 +3134,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const shardKeys = [""];
     for (const entry of entries) {
       if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
-      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments") continue;
+      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+        continue;
       if (entry.isDirectory()) shardKeys.push(entry.name);
     }
     return shardKeys;
@@ -3100,10 +3257,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
-        this.logWarn(
-          "Session manifest write failed",
-          { event: "session_store.manifest_write_failed", sessionId: id, message: msg }
-        );
+        this.logWarn("Session manifest write failed", {
+          event: "session_store.manifest_write_failed",
+          sessionId: id,
+          message: msg
+        });
       });
       outcome = "failure";
       errorMsg = "summary fallback \xE2\u20AC\u201D manifest rebuilt";
@@ -3210,24 +3368,28 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (r.status === "rejected") {
         const msg = r.reason instanceof Error ? r.reason.message : String(r.reason);
         if (r.reason?.code !== "ENOENT") {
-          console.warn(JSON.stringify({
-            level: "warn",
-            event: "session_store.delete_failed",
-            sessionId: id,
-            message: msg,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }));
+          console.warn(
+            JSON.stringify({
+              level: "warn",
+              event: "session_store.delete_failed",
+              sessionId: id,
+              message: msg,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
         }
       }
     }
     await fsp4.rm(sessDir, { recursive: true, force: true }).catch((err) => {
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "session_store.rmdir_failed",
-        sessionId: id,
-        message: toErrorMessage(err),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "session_store.rmdir_failed",
+          sessionId: id,
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
     });
     await this.writeTombstone(id);
   }
@@ -4516,6 +4678,43 @@ function isDirectory(candidate) {
 }
 
 // src/storage/memory-consolidator.ts
+function isSuperMemoryRecord(value) {
+  return typeof value === "object" && value !== null && typeof value.text === "string";
+}
+function toPromptEntries(records, limit) {
+  return records.filter(isSuperMemoryRecord).filter((record) => record.scope === "project").slice(0, limit).map((record) => ({
+    scope: "project-memory",
+    text: record.text,
+    ts: record.updatedAt ?? record.createdAt ?? ""
+  }));
+}
+function toSuperMemoryKind(type) {
+  switch (type) {
+    case "decision":
+    case "convention":
+    case "preference":
+    case "anti_pattern":
+      return type;
+    case "reference":
+      return "file_note";
+    default:
+      return "fact";
+  }
+}
+function importanceFromPriority(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 buildConsolidationPrompt(finalText, iterations, existingEntries) {
   const existingBlock = existingEntries.length > 0 ? `
 
@@ -4531,6 +4730,7 @@ var SessionMemoryConsolidator = class {
   name = "session-memory-consolidator";
   owner = "core";
   memoryStore;
+  superMemory;
   provider;
   model;
   minIterations;
@@ -4538,6 +4738,7 @@ var SessionMemoryConsolidator = class {
   oneShotOrchestrator;
   constructor(opts) {
     this.memoryStore = opts.memoryStore;
+    this.superMemory = opts.superMemory;
     this.provider = opts.provider;
     this.model = opts.model;
     this.minIterations = opts.minIterations ?? 2;
@@ -4553,9 +4754,20 @@ var SessionMemoryConsolidator = class {
     const _finalText = result.finalText;
     const _iterations = result.iterations;
     const _model = this.model ?? ctx.model;
+    const _sessionId = ctx.session.id;
     void (async () => {
       try {
-        const existingEntries = await this.memoryStore.list("project-memory", this.maxExistingEntries);
+        let existingEntries;
+        if (this.superMemory) {
+          const records = this.superMemory.listSuper ? await this.superMemory.listSuper(["active"]) : await this.superMemory.searchSuper?.("", {
+            limit: this.maxExistingEntries,
+            scope: "project",
+            includeStatuses: ["active"]
+          }) ?? [];
+          existingEntries = toPromptEntries(records, this.maxExistingEntries);
+        } else {
+          existingEntries = await this.memoryStore.list("project-memory", this.maxExistingEntries);
+        }
         const prompt = buildConsolidationPrompt(
           _finalText,
           _iterations,
@@ -4568,8 +4780,7 @@ var SessionMemoryConsolidator = class {
             userPrompt: "Review the session and return memory operations as JSON.",
             model: _model ?? "deepseek-chat",
             maxTokens: 500,
-            timeoutMs: 15e3,
-            fallbackProfile: "memory"
+            timeoutMs: 15e3
           });
           text = oneShotResult.text;
         } else {
@@ -4593,48 +4804,33 @@ var SessionMemoryConsolidator = class {
         const parsed = JSON.parse(jsonMatch[0]);
         if (!Array.isArray(parsed.operations) || parsed.operations.length === 0) return;
         let added = 0;
-        let edited = 0;
-        let deleted = 0;
         for (const op of parsed.operations) {
-          switch (op.action) {
-            case "add": {
-              if (op.text?.trim()) {
-                await this.memoryStore.remember(op.text.trim(), void 0, {
-                  type: op.type,
-                  tags: op.tags,
-                  priority: op.priority
-                });
-                added++;
-              }
-              break;
-            }
-            case "edit": {
-              if (op.query && op.text?.trim()) {
-                await this.memoryStore.forget(op.query);
-                await this.memoryStore.remember(op.text.trim(), void 0, {
-                  type: op.type,
-                  tags: op.tags,
-                  priority: op.priority
-                });
-                edited++;
-              }
-              break;
-            }
-            case "delete": {
-              if (op.query) {
-                const n = await this.memoryStore.forget(op.query);
-                deleted += n;
-              }
-              break;
+          try {
+            if (!op || typeof op !== "object" || op.action !== "add") continue;
+            if (typeof op.text !== "string" || !op.text.trim()) continue;
+            const memoryText = op.text.trim();
+            if (this.superMemory) {
+              await this.superMemory.rememberSuper({
+                text: memoryText,
+                scope: "project",
+                kind: toSuperMemoryKind(op.type),
+                tags: op.tags,
+                importance: importanceFromPriority(op.priority),
+                sources: [{ type: "session", sessionId: _sessionId }]
+              });
+            } else {
+              await this.memoryStore.remember(memoryText, void 0, {
+                type: op.type,
+                tags: op.tags,
+                priority: op.priority
+              });
             }
+            added++;
+          } catch {
           }
         }
-        if (added > 0 || edited > 0 || deleted > 0) {
-          const parts = [];
-          if (added) parts.push(`${added} added`);
-          if (edited) parts.push(`${edited} edited`);
-          if (deleted) parts.push(`${deleted} deleted`);
-          process.stderr.write(`[memory] Session consolidation: ${parts.join(", ")}
+        if (added > 0) {
+          process.stderr.write(`[memory] Session consolidation: ${added} added
 `);
         }
       } catch {
@@ -4785,6 +4981,15 @@ async function readProviderSnapshot(configPath, vault, warn) {
   if (typeof decrypted.baseUrl === "string") snapshot.baseUrl = decrypted.baseUrl;
   if (typeof decrypted.uiLocale === "string" && decrypted.uiLocale)
     snapshot.uiLocale = decrypted.uiLocale;
+  if (Array.isArray(decrypted.fallbackModels)) snapshot.fallbackModels = decrypted.fallbackModels;
+  if (decrypted.fallbackProfiles) snapshot.fallbackProfiles = decrypted.fallbackProfiles;
+  if (Array.isArray(decrypted.favoriteModels)) snapshot.favoriteModels = decrypted.favoriteModels;
+  if (typeof decrypted.favoriteModelsOnly === "boolean")
+    snapshot.favoriteModelsOnly = decrypted.favoriteModelsOnly;
+  if (decrypted.modelMatrix) snapshot.modelMatrix = decrypted.modelMatrix;
+  if (typeof decrypted.fallbackAuto === "boolean") snapshot.fallbackAuto = decrypted.fallbackAuto;
+  if (Array.isArray(decrypted.modelAvailabilitySchedule))
+    snapshot.modelAvailabilitySchedule = decrypted.modelAvailabilitySchedule;
   return snapshot;
 }
 function serializeSnapshot(s) {
@@ -4792,7 +4997,14 @@ function serializeSnapshot(s) {
     providers: s.providers,
     apiKey: s.apiKey ?? null,
     baseUrl: s.baseUrl ?? null,
-    uiLocale: s.uiLocale ?? null
+    uiLocale: s.uiLocale ?? null,
+    fallbackModels: s.fallbackModels ?? null,
+    fallbackProfiles: s.fallbackProfiles ?? null,
+    favoriteModels: s.favoriteModels ?? null,
+    favoriteModelsOnly: s.favoriteModelsOnly ?? null,
+    modelMatrix: s.modelMatrix ?? null,
+    fallbackAuto: s.fallbackAuto ?? null,
+    modelAvailabilitySchedule: s.modelAvailabilitySchedule ?? null
   });
 }
 function watchProviderConfig(configPath, vault, onChange, opts = {}) {
@@ -5153,6 +5365,7 @@ var defaultIndexing = {
 };
 var IN_PROJECT_ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "version",
+  "activeProfile",
   "model",
   "cwd",
   "context",
@@ -5175,6 +5388,7 @@ var IN_PROJECT_ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "fallbackProfiles",
   "favoriteModels",
   "favoriteModelsOnly",
+  "modelAvailabilitySchedule",
   "fallbackAuto",
   "models",
   "modelMatrix",
@@ -5210,6 +5424,7 @@ var KNOWN_DENIED_IN_PROJECT = [
 ];
 var KNOWN_CONFIG_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "version",
+  "activeProfile",
   "provider",
   "model",
   "apiKey",
@@ -5226,6 +5441,7 @@ var KNOWN_CONFIG_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "fallbackProfiles",
   "favoriteModels",
   "favoriteModelsOnly",
+  "modelAvailabilitySchedule",
   "fallbackAuto",
   "hooks",
   "plugins",
@@ -5430,12 +5646,17 @@ var DefaultConfigLoader = class {
     let cfg = { ...BEHAVIOR_DEFAULTS };
     await this.ensureGlobalDefaults();
     const inProjectCollides = samePath(this.paths.inProjectConfig, this.paths.globalConfig) || samePath(this.paths.inProjectConfig, this.paths.projectLocalConfig);
-    const [global, local, inProject] = await Promise.all([
+    const [bootstrap, local, inProject] = await Promise.all([
       this.readJson(this.paths.globalConfig),
       this.readJson(this.paths.projectLocalConfig),
       inProjectCollides ? Promise.resolve({}) : this.readJson(this.paths.inProjectConfig)
     ]);
-    cfg = deepMerge2(cfg, global);
+    cfg = deepMerge2(cfg, bootstrap);
+    const profileName = bootstrap.activeProfile ?? "default";
+    const profileCfg = await this.readJson(this.paths.profileConfig(profileName));
+    if (Object.keys(profileCfg).length > 0) {
+      cfg = deepMerge2(cfg, profileCfg);
+    }
     cfg = deepMerge2(cfg, local);
     cfg = deepMerge2(
       cfg,
@@ -5461,10 +5682,11 @@ var DefaultConfigLoader = class {
           cfg = deepMerge2(cfg, patch);
         }
       } catch (err) {
-        this.logWarn(
-          "Config source load failed",
-          { event: "config.source_load_failed", source: src.name, message: toErrorMessage(err) }
-        );
+        this.logWarn("Config source load failed", {
+          event: "config.source_load_failed",
+          source: src.name,
+          message: toErrorMessage(err)
+        });
       }
     }
     if (opts.cliFlags) {
@@ -5503,6 +5725,7 @@ var DefaultConfigLoader = class {
     try {
       await withFileLock(fp, async () => {
         let parsed;
+        let fileExisted = true;
         try {
           const raw = await fs6.readFile(fp, "utf8");
           const result = safeParse(raw);
@@ -5523,25 +5746,115 @@ var DefaultConfigLoader = class {
               durationMs: Date.now() - t0,
               ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
             });
-            this.logWarn(
-              "Config defaults read failed",
-              { event: "config.defaults_read_failed", path: fp, message: toErrorMessage(err) }
-            );
+            this.logWarn("Config defaults read failed", {
+              event: "config.defaults_read_failed",
+              path: fp,
+              message: toErrorMessage(err)
+            });
             return;
           }
+          fileExisted = false;
           parsed = {};
         }
-        const { value, changed } = fillMissingDefaults(
-          parsed,
-          BEHAVIOR_DEFAULTS
-        );
-        if (!changed) return;
-        await atomicWrite(fp, JSON.stringify(value, null, 2), { mode: 384 });
+        const bootstrap = {
+          version: 1,
+          activeProfile: parsed.activeProfile ?? "default"
+        };
+        let needsBootstrapWrite = false;
+        if (parsed.version !== 1) {
+          needsBootstrapWrite = true;
+        }
+        if (parsed.activeProfile === void 0) {
+          needsBootstrapWrite = true;
+        }
+        if (needsBootstrapWrite) {
+          await atomicWrite(fp, JSON.stringify(bootstrap, null, 2), { mode: 384 });
+          this.events?.emit("storage.write", {
+            sessionId: "~config~",
+            store: "config",
+            filePath: fp,
+            operation: "ensure_defaults",
+            outcome: "success",
+            durationMs: Date.now() - t0,
+            ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+          });
+        }
+        const profileName = bootstrap.activeProfile ?? "default";
+        const profileFp = this.paths.profileConfig(profileName);
+        await this.ensureProfileConfig(profileFp, parsed, fileExisted);
+      });
+    } catch (err) {
+      this.events?.emit("storage.error", {
+        sessionId: "~config~",
+        store: "config",
+        filePath: fp,
+        operation: "ensure_defaults",
+        outcome: "failure",
+        error: storageErrorString(err),
+        recoverable: false,
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      this.logWarn("Config defaults write failed", {
+        event: "config.defaults_write_failed",
+        path: fp,
+        message: toErrorMessage(err)
+      });
+    }
+  }
+  /**
+   * Ensure a profile config file exists at the given path.
+   * On first boot: migrate content from the old flat global config, or seed
+   * with behavior defaults. Subsequent boots: fill any missing keys from
+   * BEHAVIOR_DEFAULTS (keeping user settings intact).
+   */
+  async ensureProfileConfig(profileFp, oldGlobalParsed, oldFileExisted) {
+    const t0 = Date.now();
+    try {
+      await withFileLock(profileFp, async () => {
+        let parsed;
+        let existed = true;
+        try {
+          const raw = await fs6.readFile(profileFp, "utf8");
+          const result = safeParse(raw);
+          if (!result.ok || !isPlainRecord(result.value)) {
+            this.logWarn("Profile config parse failed \u2014 falling back to defaults", {
+              event: "config.profile_parse_failed",
+              path: profileFp
+            });
+            parsed = {};
+          } else {
+            parsed = result.value;
+          }
+        } catch (err) {
+          if (err.code !== "ENOENT") {
+            this.logWarn("Profile config read failed", {
+              event: "config.profile_read_failed",
+              path: profileFp,
+              message: toErrorMessage(err)
+            });
+            return;
+          }
+          existed = false;
+          parsed = {};
+        }
+        let seed;
+        if (!existed && oldFileExisted && Object.keys(oldGlobalParsed).length >= 1) {
+          seed = { ...oldGlobalParsed };
+          delete seed["activeProfile"];
+          const filled = fillMissingDefaults(seed, BEHAVIOR_DEFAULTS);
+          seed = filled.value;
+        } else {
+          const filled = fillMissingDefaults(parsed, BEHAVIOR_DEFAULTS);
+          if (!filled.changed) return;
+          seed = filled.value;
+        }
+        await atomicWrite(profileFp, JSON.stringify(seed, null, 2), { mode: 384 });
         this.events?.emit("storage.write", {
           sessionId: "~config~",
           store: "config",
-          filePath: fp,
-          operation: "ensure_defaults",
+          filePath: profileFp,
+          operation: "ensure_profile_defaults",
           outcome: "success",
           durationMs: Date.now() - t0,
           ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
@@ -5551,18 +5864,19 @@ var DefaultConfigLoader = class {
       this.events?.emit("storage.error", {
         sessionId: "~config~",
         store: "config",
-        filePath: fp,
-        operation: "ensure_defaults",
+        filePath: profileFp,
+        operation: "ensure_profile_defaults",
         outcome: "failure",
         error: storageErrorString(err),
         recoverable: false,
         durationMs: Date.now() - t0,
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config defaults write failed",
-        { event: "config.defaults_write_failed", path: fp, message: toErrorMessage(err) }
-      );
+      this.logWarn("Profile config defaults write failed", {
+        event: "config.profile_write_failed",
+        path: profileFp,
+        message: toErrorMessage(err)
+      });
     }
   }
   /**
@@ -5664,10 +5978,10 @@ var DefaultConfigLoader = class {
         error: storageErrorString(err),
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config sync load failed",
-        { event: "config.sync_load_failed", message: toErrorMessage(err) }
-      );
+      this.logWarn("Config sync load failed", {
+        event: "config.sync_load_failed",
+        message: toErrorMessage(err)
+      });
       return null;
     }
   }
@@ -5696,10 +6010,11 @@ var DefaultConfigLoader = class {
         error: storageErrorString(err),
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config read failed (stat)",
-        { event: "config.read_failed", path: file, message: toErrorMessage(err) }
-      );
+      this.logWarn("Config read failed (stat)", {
+        event: "config.read_failed",
+        path: file,
+        message: toErrorMessage(err)
+      });
       return {};
     }
     let raw;
@@ -5717,10 +6032,11 @@ var DefaultConfigLoader = class {
           error: storageErrorString(err),
           ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
         });
-        this.logWarn(
-          "Config read failed (read)",
-          { event: "config.read_failed", path: file, message: toErrorMessage(err) }
-        );
+        this.logWarn("Config read failed (read)", {
+          event: "config.read_failed",
+          path: file,
+          message: toErrorMessage(err)
+        });
       }
       this.jsonCache.set(file, { mtimeMs: null, value: {} });
       return {};
@@ -5737,10 +6053,10 @@ var DefaultConfigLoader = class {
         error: "parse error or empty file",
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config parse failed \u2014 falling back to defaults",
-        { event: "config.parse_failed", path: file }
-      );
+      this.logWarn("Config parse failed \u2014 falling back to defaults", {
+        event: "config.parse_failed",
+        path: file
+      });
       return {};
     }
     this.jsonCache.set(file, { mtimeMs, value: structuredClone(parsed.value) });
@@ -7701,9 +8017,9 @@ var SessionAnalyzer = class {
 };
 
 // src/session-registry.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
 import * as fs12 from "node:fs/promises";
 import * as path17 from "node:path";
-import { randomUUID as randomUUID5 } from "node:crypto";
 var REGISTRY_FILE = "session-registry.json";
 var HEARTBEAT_INTERVAL_MS = 5e3;
 var STALE_TIMEOUT_MS = 3e4;
@@ -8075,6 +8391,201 @@ var AGENT_REAP_MS = 3e4;
 var AGENT_SWEEP_INTERVAL_MS = 1e4;
 var PARTIAL_TEXT_CAP = 1200;
 var PARTIAL_FLUSH_THROTTLE_MS = 300;
+var RECENT_TOOL_LIMIT = 12;
+var RECENT_MAIL_LIMIT = 12;
+var TOOL_TEXT_CAP = 360;
+var TOUCHED_FILE_LIMIT = 200;
+var TASK_TEXT_CAP = 1200;
+var PROMPT_TEXT_CAP = 6e3;
+var TODO_TEXT_CAP = 360;
+var TODO_LIMIT = 32;
+function lineCount(value) {
+  return value.length === 0 ? 0 : value.split(/\r?\n/).length;
+}
+function patchDelta(value) {
+  let addedLines = 0;
+  let removedLines = 0;
+  const hunkStart = value.indexOf("@@");
+  if (hunkStart === -1) return { addedLines, removedLines };
+  for (const line of value.slice(hunkStart).split(/\r?\n/)) {
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+")) addedLines += 1;
+    else if (line.startsWith("-")) removedLines += 1;
+  }
+  return { addedLines, removedLines };
+}
+function compactText(value) {
+  return value.length <= TOOL_TEXT_CAP ? value : `${value.slice(0, TOOL_TEXT_CAP - 1)}\u2026`;
+}
+function boundedText(value, cap) {
+  const trimmed = value.trim();
+  return trimmed.length <= cap ? trimmed : `${trimmed.slice(0, cap - 1)}\u2026`;
+}
+function compactTodos(value) {
+  if (!Array.isArray(value)) return void 0;
+  const todos = [];
+  for (const candidate of value) {
+    if (typeof candidate !== "object" || candidate === null) continue;
+    const todo = candidate;
+    const id = typeof todo["id"] === "string" ? todo["id"].trim() : "";
+    const content = typeof todo["content"] === "string" ? boundedText(todo["content"], TODO_TEXT_CAP) : "";
+    const status = todo["status"];
+    if (!id || !content || status !== "pending" && status !== "in_progress" && status !== "completed") {
+      continue;
+    }
+    const activeForm = typeof todo["activeForm"] === "string" ? boundedText(todo["activeForm"], TODO_TEXT_CAP) : void 0;
+    todos.push({ id, content, status, ...activeForm ? { activeForm } : {} });
+    if (todos.length >= TODO_LIMIT) break;
+  }
+  return todos;
+}
+function compactToolInput(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return typeof input === "string" ? { input: compactText(input) } : {};
+  }
+  const source = input;
+  const safe = {};
+  const safeKeys = [
+    "file_path",
+    "filePath",
+    "path",
+    "filename",
+    "target_file",
+    "targetFile",
+    "line",
+    "start_line",
+    "startLine",
+    "end_line",
+    "endLine",
+    "offset",
+    "limit",
+    "command",
+    "cmd",
+    "url",
+    "href",
+    "uri",
+    "query",
+    "pattern"
+  ];
+  for (const key of safeKeys) {
+    const value = source[key];
+    if (typeof value === "string") safe[key] = compactText(value);
+    else if (typeof value === "number" || typeof value === "boolean") safe[key] = value;
+  }
+  const content = [source["content"], source["text"], source["data"]].find(
+    (value) => typeof value === "string"
+  );
+  const oldText = [source["old_string"], source["oldString"], source["search"]].find(
+    (value) => typeof value === "string"
+  );
+  const newText = [source["new_string"], source["newString"], source["replacement"]].find(
+    (value) => typeof value === "string"
+  );
+  const patch = [source["patch"], source["diff"]].find(
+    (value) => typeof value === "string"
+  );
+  const delta = patch ? patchDelta(patch) : void 0;
+  return {
+    ...Object.keys(safe).length > 0 ? { input: safe } : {},
+    ...content !== void 0 ? { inputLines: lineCount(content) } : {},
+    ...oldText !== void 0 ? { oldLines: lineCount(oldText) } : {},
+    ...newText !== void 0 ? { newLines: lineCount(newText) } : {},
+    ...delta && delta.addedLines > 0 ? { addedLines: delta.addedLines } : {},
+    ...delta && delta.removedLines > 0 ? { removedLines: delta.removedLines } : {}
+  };
+}
+function completedToolReceipt(payload, pending) {
+  const completedAt = Date.now();
+  const durationMs = Math.max(
+    0,
+    payload.durationMs ?? completedAt - (pending?.startedAt ?? completedAt)
+  );
+  const compact = compactToolInput(payload.input ?? pending?.input);
+  return {
+    id: payload.id ?? `${payload.name}:${completedAt}`,
+    name: payload.name,
+    startedAt: pending?.startedAt ?? Math.max(0, completedAt - durationMs),
+    completedAt,
+    durationMs,
+    ok: payload.ok !== false,
+    ...compact,
+    ...payload.output !== void 0 ? { output: compactText(payload.output) } : {},
+    ...payload.outputLines !== void 0 ? { outputLines: payload.outputLines } : {},
+    ...payload.outputBytes !== void 0 ? { outputBytes: payload.outputBytes } : {},
+    ...payload.outputTokens !== void 0 ? { outputTokens: payload.outputTokens } : {}
+  };
+}
+function emptyActivityTotals() {
+  return {
+    filesTouched: [],
+    reads: 0,
+    writes: 0,
+    edits: 0,
+    terminalCalls: 0,
+    webCalls: 0,
+    searches: 0,
+    otherCalls: 0,
+    mailReceived: 0,
+    mailSent: 0,
+    linesRead: 0,
+    linesWritten: 0,
+    linesAdded: 0,
+    linesRemoved: 0
+  };
+}
+function addMailTotal(current, direction) {
+  const next = { ...current ?? emptyActivityTotals() };
+  if (direction === "incoming") next.mailReceived += 1;
+  else next.mailSent += 1;
+  return next;
+}
+function toolActivityKind(name) {
+  const normalized = name.toLowerCase().replace(/[.:/-]+/g, "_");
+  if (/^(read|view|open_file|read_file)|file_read/.test(normalized)) return "read";
+  if (/^(write|create|save)|file_write/.test(normalized)) return "write";
+  if (/edit|update|patch|replace|apply_patch/.test(normalized)) return "edit";
+  if (/bash|shell|terminal|exec|command|powershell|cmd/.test(normalized)) return "terminal";
+  if (/fetch|browser|browse|http|url|web/.test(normalized)) return "web";
+  if (/search|grep|find|glob|query/.test(normalized)) return "search";
+  return "other";
+}
+function receiptFilePath(receipt) {
+  if (!receipt.input || typeof receipt.input !== "object" || Array.isArray(receipt.input)) {
+    return void 0;
+  }
+  const input = receipt.input;
+  for (const key of ["file_path", "filePath", "path", "filename", "target_file", "targetFile"]) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function addToolActivity(current, receipt) {
+  const next = {
+    ...current ?? emptyActivityTotals(),
+    filesTouched: [...current?.filesTouched ?? []]
+  };
+  const kind = toolActivityKind(receipt.name);
+  if (kind === "read") {
+    next.reads += 1;
+    next.linesRead += receipt.outputLines ?? 0;
+  } else if (kind === "write") {
+    next.writes += 1;
+    next.linesWritten += receipt.inputLines ?? 0;
+  } else if (kind === "edit") {
+    next.edits += 1;
+    next.linesAdded += receipt.addedLines ?? receipt.newLines ?? 0;
+    next.linesRemoved += receipt.removedLines ?? receipt.oldLines ?? 0;
+  } else if (kind === "terminal") next.terminalCalls += 1;
+  else if (kind === "web") next.webCalls += 1;
+  else if (kind === "search") next.searches += 1;
+  else next.otherCalls += 1;
+  const filePath = receiptFilePath(receipt);
+  if (filePath && !next.filesTouched.includes(filePath) && next.filesTouched.length < TOUCHED_FILE_LIMIT) {
+    next.filesTouched.push(filePath);
+  }
+  return next;
+}
 function clampPct(pct) {
   if (!Number.isFinite(pct)) return 0;
   return Math.max(0, Math.min(100, pct));
@@ -8092,6 +8603,7 @@ var AgentStatusTracker = class {
   // Leader tracking
   leaderStatus = "idle";
   leaderCurrentTool;
+  leaderCurrentTask;
   leaderIterations = 0;
   leaderToolCalls = 0;
   leaderCostUsd = 0;
@@ -8101,10 +8613,22 @@ var AgentStatusTracker = class {
   leaderModel;
   leaderPartialText = "";
   leaderStartedAt;
+  leaderRecentTools = [];
+  leaderRecentMail = [];
+  leaderTodos = [];
+  leaderLatestPrompt;
+  leaderLatestPromptAt;
+  leaderActivity = emptyActivityTotals();
+  leaderPendingTools = /* @__PURE__ */ new Map();
+  subagentPendingTools = /* @__PURE__ */ new Map();
+  seenIncomingMail = /* @__PURE__ */ new Set();
+  seenOutgoingMail = /* @__PURE__ */ new Set();
   unsubscribers = [];
   onUpdate;
   sweepTimer = null;
   partialTimer = null;
+  /** Serialize registry writes so concurrent flush() calls don't race. */
+  flushPromise = null;
   constructor(opts) {
     this.events = opts.events;
     this.registry = opts.registry;
@@ -8127,6 +8651,13 @@ var AgentStatusTracker = class {
         this.markLeaderStarted(p?.at);
         this.captureLeaderContext(p?.ctx);
         if (p?.model) this.leaderModel = p.model;
+        if (p?.inputText?.trim()) {
+          const prompt = boundedText(p.inputText, PROMPT_TEXT_CAP);
+          this.leaderLatestPrompt = prompt;
+          this.leaderLatestPromptAt = p.at ? Date.parse(p.at) : Date.now();
+          if (!Number.isFinite(this.leaderLatestPromptAt)) this.leaderLatestPromptAt = Date.now();
+          this.leaderCurrentTask = boundedText(p.inputText, TASK_TEXT_CAP);
+        }
         this.leaderStatus = "running";
         this.leaderIterations++;
         this.flush();
@@ -8155,6 +8686,7 @@ var AgentStatusTracker = class {
         this.captureLeaderContext(p?.ctx);
         this.leaderStatus = p?.status === "failed" ? "error" : "idle";
         this.leaderCurrentTool = void 0;
+        this.leaderCurrentTask = void 0;
         this.leaderPartialText = "";
         if (this.leaderStatus === "idle") this.leaderStartedAt = void 0;
         this.flush();
@@ -8166,10 +8698,18 @@ var AgentStatusTracker = class {
         this.captureLeaderContext(p?.ctx);
         this.leaderStatus = "error";
         this.leaderCurrentTool = void 0;
+        this.leaderCurrentTask = void 0;
         this.leaderPartialText = "";
         this.flush();
       })
     );
+    this.unsubscribers.push(
+      on("iteration.completed", (_event, payload) => {
+        const p = payload;
+        this.captureLeaderContext(p?.ctx);
+        this.flush();
+      })
+    );
     this.unsubscribers.push(
       on("tool.started", (_event, payload) => {
         const p = payload;
@@ -8177,13 +8717,26 @@ var AgentStatusTracker = class {
           this.markLeaderStarted();
           this.leaderCurrentTool = p.name;
           this.leaderToolCalls++;
+          this.leaderPendingTools.set(p.id ?? p.name, {
+            name: p.name,
+            input: p.input,
+            startedAt: Date.now()
+          });
         }
         this.leaderStatus = "running";
         this.flush();
       })
     );
     this.unsubscribers.push(
-      on("tool.executed", () => {
+      on("tool.executed", (_event, payload) => {
+        const p = payload;
+        if (p?.name) {
+          const key = p.id ?? p.name;
+          const receipt = completedToolReceipt(p, this.leaderPendingTools.get(key));
+          this.leaderRecentTools = [receipt, ...this.leaderRecentTools].slice(0, RECENT_TOOL_LIMIT);
+          this.leaderActivity = addToolActivity(this.leaderActivity, receipt);
+          this.leaderPendingTools.delete(key);
+        }
         this.leaderCurrentTool = void 0;
         this.flush();
       })
@@ -8195,6 +8748,36 @@ var AgentStatusTracker = class {
         this.flush();
       })
     );
+    const recordMail = (direction, payload) => {
+      const p = payload;
+      if (!p?.messageId) return;
+      const seen = direction === "incoming" ? this.seenIncomingMail : this.seenOutgoingMail;
+      if (seen.has(p.messageId)) return;
+      seen.add(p.messageId);
+      const receipt = {
+        id: p.messageId,
+        direction,
+        from: p.from ?? "?",
+        to: p.to ?? (direction === "incoming" ? "leader" : "?"),
+        type: p.type ?? "note",
+        subject: p.subject ?? "Message",
+        at: Date.now()
+      };
+      const directAgentId = direction === "outgoing" ? p.from : p.to;
+      const entry = directAgentId ? this.agents.get(directAgentId) : void 0;
+      if (entry) {
+        entry.recentMail = [receipt, ...entry.recentMail ?? []].slice(0, RECENT_MAIL_LIMIT);
+        entry.activity = addMailTotal(entry.activity, direction);
+      } else {
+        this.leaderRecentMail = [receipt, ...this.leaderRecentMail].slice(0, RECENT_MAIL_LIMIT);
+        this.leaderActivity = addMailTotal(this.leaderActivity, direction);
+      }
+      this.flush();
+    };
+    this.unsubscribers.push(
+      on("mailbox.message_sent", (_event, payload) => recordMail("outgoing", payload)),
+      on("mailbox.received", (_event, payload) => recordMail("incoming", payload))
+    );
     this.unsubscribers.push(
       on("llm.stream_started", () => {
         this.markLeaderStarted();
@@ -8255,7 +8838,15 @@ var AgentStatusTracker = class {
       let entry = this.agents.get(id);
       if (!entry) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
-        entry = { id, name: id, status: "idle", iterations: 0, toolCalls: 0, startedAt: now, lastActivityAt: now };
+        entry = {
+          id,
+          name: id,
+          status: "idle",
+          iterations: 0,
+          toolCalls: 0,
+          startedAt: now,
+          lastActivityAt: now
+        };
         this.agents.set(id, entry);
       }
       entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -8268,6 +8859,8 @@ var AgentStatusTracker = class {
         const entry = touch(p.subagentId);
         entry.name = p.name?.trim() || entry.name;
         if (p.model) entry.model = p.model;
+        if (p.taskId) entry.taskId = p.taskId;
+        if (p.description?.trim()) entry.currentTask = boundedText(p.description, TASK_TEXT_CAP);
         if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.status = "running";
         this.flush();
@@ -8288,19 +8881,41 @@ var AgentStatusTracker = class {
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
         entry.status = "running";
+        if (p.taskId) entry.taskId = p.taskId;
+        if (p.description?.trim()) entry.currentTask = boundedText(p.description, TASK_TEXT_CAP);
         if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.iterations++;
         this.flush();
       })
     );
+    this.unsubscribers.push(
+      on("subagent.tool_started", (_e, payload) => {
+        const p = payload;
+        if (!p?.subagentId || !p.name) return;
+        const entry = touch(p.subagentId);
+        entry.status = "running";
+        entry.currentTool = p.name;
+        this.subagentPendingTools.set(`${p.subagentId}:${p.id ?? p.name}`, {
+          name: p.name,
+          input: p.input,
+          startedAt: Date.now()
+        });
+        this.flush();
+      })
+    );
     this.unsubscribers.push(
       on("subagent.tool_executed", (_e, payload) => {
         const p = payload;
-        if (!p?.subagentId) return;
+        if (!p?.subagentId || !p.name) return;
         const entry = touch(p.subagentId);
         entry.status = "running";
         if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        entry.currentTool = p.name;
+        const key = `${p.subagentId}:${p.id ?? p.name}`;
+        const receipt = completedToolReceipt(p, this.subagentPendingTools.get(key));
+        entry.recentTools = [receipt, ...entry.recentTools ?? []].slice(0, RECENT_TOOL_LIMIT);
+        entry.activity = addToolActivity(entry.activity, receipt);
+        this.subagentPendingTools.delete(key);
+        entry.currentTool = void 0;
         entry.toolCalls++;
         this.flush();
       })
@@ -8330,6 +8945,8 @@ var AgentStatusTracker = class {
         if (!entry) return;
         entry.status = p.status === "failed" || p.status === "timeout" ? "error" : "idle";
         entry.currentTool = void 0;
+        entry.currentTask = void 0;
+        entry.taskId = void 0;
         entry.partialText = void 0;
         if (typeof p.iterations === "number") entry.iterations = p.iterations;
         if (typeof p.toolCalls === "number") entry.toolCalls = p.toolCalls;
@@ -8409,6 +9026,7 @@ var AgentStatusTracker = class {
       startedAt: this.leaderStartedAt,
       status: this.leaderStatus,
       currentTool: this.leaderCurrentTool,
+      currentTask: this.leaderCurrentTask,
       iterations: this.leaderIterations,
       toolCalls: this.leaderToolCalls,
       costUsd: this.leaderCostUsd,
@@ -8417,6 +9035,12 @@ var AgentStatusTracker = class {
       ctxPct: this.leaderCtxPct,
       model: this.leaderModel,
       partialText: this.leaderPartialText || void 0,
+      recentTools: this.leaderRecentTools,
+      recentMail: this.leaderRecentMail,
+      todos: this.leaderTodos,
+      latestPrompt: this.leaderLatestPrompt,
+      latestPromptAt: this.leaderLatestPromptAt,
+      activity: this.leaderActivity,
       lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const allAgents = [leaderEntry, ...this.agents.values()];
@@ -8428,12 +9052,21 @@ var AgentStatusTracker = class {
       });
     } catch {
     }
-    this.registry.updateAgents(allAgents).then(() => {
+    const write = this.registry.updateAgents(allAgents);
+    const chain = write.then(() => {
       try {
         this.onUpdate?.();
       } catch {
       }
-    }).catch(() => void 0);
+    });
+    if (this.flushPromise) {
+      this.flushPromise = this.flushPromise.then(
+        () => chain,
+        () => chain
+      ).catch(() => void 0);
+    } else {
+      this.flushPromise = chain.catch(() => void 0);
+    }
   }
   currentSessionId() {
     return typeof this.sessionId === "function" ? this.sessionId() : this.sessionId;
@@ -8455,6 +9088,8 @@ var AgentStatusTracker = class {
     if (typeof ctx !== "object" || ctx === null) return;
     const c = ctx;
     if (typeof c.model === "string" && c.model.length > 0) this.leaderModel = c.model;
+    const todos = compactTodos(c.todos);
+    if (todos !== void 0) this.leaderTodos = todos;
     const metaLimit = c.meta?.["effectiveMaxContext"];
     const providerMax = c.provider?.capabilities?.maxContext;
     const maxContext = typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : void 0;
@@ -8610,9 +9245,6 @@ var DefaultSessionRewinder = class {
     const snapshotsToRevert = [];
     for (let i = targetIdx + 1; i < events.length; i++) {
       const event = expectDefined(events[i]);
-      if (event.type === "checkpoint") {
-        break;
-      }
       if (event.type === "file_snapshot") {
         const snapshotEvent = event;
         if (snapshotEvent.promptIndex >= checkpointIndex) {
@@ -8634,11 +9266,11 @@ var DefaultSessionRewinder = class {
         checkpoints.push({ promptIndex: event.promptIndex, ts: event.ts });
       }
     }
-    if (checkpoints.length === 0) {
+    if (checkpoints.length === 0 || n <= 0) {
       return { revertedFiles: [], errors: [], toPromptIndex: 0, removedEvents: 0 };
     }
     checkpoints.sort((a, b) => b.promptIndex - a.promptIndex);
-    const targetIndex = checkpoints[n]?.promptIndex ?? 0;
+    const targetIndex = checkpoints[n - 1]?.promptIndex ?? 0;
     const snapshotsToRevert = [];
     let shouldRevert = false;
     for (const event of events) {
@@ -8719,6 +9351,16 @@ async function revertSnapshots(snapshots, projectRoot) {
   return { revertedFiles, errors };
 }
 
+// src/storage/session-rewind-apply.ts
+async function applyRewindToConversation(opts) {
+  const { session, state, sessionsDir, promptIndex, revertedFiles } = opts;
+  const removedEvents = await session.truncateToCheckpoint(promptIndex, revertedFiles ?? []);
+  const store = new DefaultSessionStore({ dir: sessionsDir });
+  const data = await store.load(session.id);
+  state.replaceMessages(data.messages);
+  return { removedEvents, messageCount: data.messages.length };
+}
+
 // src/storage/todos-checkpoint.ts
 import * as fsp9 from "node:fs/promises";
 async function loadTodosCheckpoint(filePath, events, traceId) {
@@ -10028,6 +10670,184 @@ function goalTag(goalFile) {
   return `${GOAL_BOARD_TAG_PREFIX}${goal}`;
 }
 
+// src/storage/goal-coordination.ts
+import { updateTask } from "@wrongstack/kanban";
+var DONE_MARKER = /\[done:\s*([^\]]+)\]/gi;
+var DONE_PREFIX = /^\s*(?:✅|\[[x✓]\]|\(done\))\s*/i;
+function parseCompletedGoalDeliverables(finalText, deliverables) {
+  if (!finalText || deliverables.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const completed = [];
+  for (const match of finalText.matchAll(DONE_MARKER)) {
+    const raw = match[1]?.trim();
+    if (!raw) continue;
+    const numeric = /^\d+$/.test(raw) ? Number.parseInt(raw, 10) : void 0;
+    let index = numeric === void 0 ? -1 : numeric === 0 ? 0 : numeric - 1;
+    if (index < 0 || index >= deliverables.length) {
+      const prefix = raw.toLowerCase();
+      index = deliverables.findIndex(
+        (item) => stripGoalDeliverableMarker(item).toLowerCase().startsWith(prefix)
+      );
+    }
+    if (index < 0 || index >= deliverables.length || seen.has(index)) continue;
+    const source = deliverables[index] ?? "";
+    if (isGoalDeliverableComplete(source)) continue;
+    seen.add(index);
+    completed.push({ index, text: stripGoalDeliverableMarker(source) });
+  }
+  return completed;
+}
+function isGoalDeliverableComplete(value) {
+  return DONE_PREFIX.test(value);
+}
+function stripGoalDeliverableMarker(value) {
+  return value.replace(DONE_PREFIX, "").trim();
+}
+function applyGoalDeliverableCompletions(goal, completed) {
+  if (completed.length === 0) return recomputeGoalProgress(goal);
+  const completedIndices = new Set(completed.map((item) => item.index));
+  let next = {
+    ...goal,
+    deliverables: (goal.deliverables ?? []).map(
+      (item, index) => completedIndices.has(index) && !isGoalDeliverableComplete(item) ? `\u2705 ${item}` : item
+    )
+  };
+  for (const item of completed) {
+    next = appendJournal(next, {
+      source: "deliverable",
+      task: `Deliverable completed: ${item.text}`.slice(0, 240),
+      status: "success",
+      note: `[DONE: ${item.index + 1}]`
+    });
+  }
+  return recomputeGoalProgress(next);
+}
+function recomputeGoalProgress(goal) {
+  const deliverables = goal.deliverables ?? [];
+  if (deliverables.length === 0) return goal;
+  const done = deliverables.filter(isGoalDeliverableComplete).length;
+  const progress = Math.round(done / deliverables.length * 100);
+  return recordProgress(goal, progress, `${done}/${deliverables.length} deliverables complete`);
+}
+async function coordinateGoalIteration(options) {
+  const current = await loadGoal(options.goalPath, options.events);
+  if (!current) return null;
+  const completed = parseCompletedGoalDeliverables(
+    options.finalText,
+    current.deliverables ?? []
+  );
+  let goal = applyGoalDeliverableCompletions(current, completed);
+  await saveGoal(options.goalPath, goal, options.events);
+  const kanbanUpdatedTaskIds = await refreshGoalKanban(
+    options.projectRoot,
+    goal,
+    completed
+  );
+  goal = await recomputeGoalProgressFromKanban(options.projectRoot, goal);
+  let reached = false;
+  const allComplete = (goal.deliverables?.length ?? 0) > 0 && goal.deliverables?.every(isGoalDeliverableComplete) === true;
+  if (allComplete && options.brain) {
+    const decision = await options.brain.decide({
+      id: `goal-reached-${goal.iterations}`,
+      sessionId: options.sessionId,
+      source: "system",
+      question: "Have all goal deliverables been reached and verified?",
+      context: [
+        `Goal: ${goal.refinedGoal ?? goal.goal}`,
+        `Progress: ${goal.progress ?? 0}%`,
+        "Completed deliverables:",
+        ...(goal.deliverables ?? []).map(
+          (item, index) => `${index + 1}. ${stripGoalDeliverableMarker(item)}`
+        )
+      ].join("\n"),
+      risk: "high",
+      fallback: "continue",
+      options: [
+        {
+          id: "goal_reached",
+          label: "Goal reached",
+          consequence: "Persist the completed goal and stop the eternal loop."
+        },
+        {
+          id: "keep_working",
+          label: "Keep working",
+          consequence: "Leave the goal active for another iteration."
+        }
+      ]
+    });
+    reached = decision.type === "answer" && decision.optionId === "goal_reached";
+  }
+  if (reached) {
+    const reachedAt = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+    goal = appendJournal(
+      {
+        ...goal,
+        goalState: "completed",
+        engineState: "stopped",
+        progress: 100,
+        progressNote: "goal reached",
+        reachedAt,
+        reachedNote: "goal reached"
+      },
+      {
+        source: "deliverable",
+        task: "GOAL REACHED",
+        status: "success",
+        note: "goal reached"
+      }
+    );
+  }
+  await saveGoal(options.goalPath, goal, options.events);
+  return { goal, completed, kanbanUpdatedTaskIds, reached };
+}
+async function resolveGoalBoard(projectRoot, goal) {
+  const boardId = goal.kanbanBoardId;
+  if (boardId) {
+    const board = await findGoalKanbanBoard(projectRoot, boardId);
+    if (board) return board;
+  }
+  return findGoalBoardByTag(projectRoot, goal);
+}
+async function refreshGoalKanban(projectRoot, goal, completed) {
+  if (completed.length === 0) return [];
+  const board = await resolveGoalBoard(projectRoot, goal);
+  if (!board) return [];
+  const doneColumn = board.columns.find((column) => column.title.toLowerCase() === "done");
+  if (!doneColumn) return [];
+  const completedTitles = new Set(completed.map((item) => normalizeTitle(item.text)));
+  const updated = [];
+  for (const task of board.tasks) {
+    if (!completedTitles.has(normalizeTitle(task.title))) continue;
+    const result = await updateTask(
+      projectRoot,
+      board.id,
+      task.id,
+      { columnId: doneColumn.id, status: "completed" },
+      {
+        actor: "goal-coordinator",
+        note: "deliverable-completed: Updated from [DONE:] marker."
+      }
+    );
+    if (result) updated.push(task.id);
+  }
+  return updated;
+}
+async function recomputeGoalProgressFromKanban(projectRoot, goal) {
+  const board = await resolveGoalBoard(projectRoot, goal);
+  if (!board || !goal.deliverables?.length) return recomputeGoalProgress(goal);
+  const completedTitles = new Set(
+    board.tasks.filter((task) => task.status === "completed").map((task) => normalizeTitle(task.title))
+  );
+  const deliverables = goal.deliverables.map((item) => {
+    if (isGoalDeliverableComplete(item)) return item;
+    return completedTitles.has(normalizeTitle(item)) ? `\u2705 ${item}` : item;
+  });
+  return recomputeGoalProgress({ ...goal, deliverables });
+}
+function normalizeTitle(value) {
+  return stripGoalDeliverableMarker(value).replace(/\s+/g, " ").trim().toLowerCase();
+}
+
 // src/storage/prompt-store.ts
 import { createHash as createHash7 } from "node:crypto";
 import * as fs14 from "node:fs/promises";
@@ -10646,6 +11466,9 @@ var CORE_RECONSTRUCT_EVENTS = /* @__PURE__ */ new Set([
   "user_input",
   "llm_response",
   "tool_result",
+  "message_appended",
+  "message_updated",
+  "messages_replaced",
   "context_snapshot",
   "checkpoint",
   "file_snapshot",
@@ -10666,11 +11489,22 @@ var STANDARD_AUDIT_EVENTS = /* @__PURE__ */ new Set([
   "provider_retry",
   "provider_error",
   "skill_activated",
-  "skill_deactivated"
-]);
-var FULL_ONLY_EVENTS = /* @__PURE__ */ new Set([
-  "tool_progress"
+  "skill_deactivated",
+  // Resume markers and fleet lifecycle. These reach disk today only because
+  // every producer appends to the raw SessionWriter and bypasses this bridge —
+  // routed through it while absent from both sets, `isAllowed` would drop them
+  // at the DEFAULT level and the resume timeline would lose them silently.
+  "mode_changed",
+  "agent_spawned",
+  "agent_stopped",
+  "agent_error",
+  "task_created",
+  "task_updated",
+  "task_completed",
+  "task_failed",
+  "side_effect"
 ]);
+var FULL_ONLY_EVENTS = /* @__PURE__ */ new Set(["tool_progress"]);
 function isAllowed(type, level) {
   if (CORE_RECONSTRUCT_EVENTS.has(type)) return true;
   if (level === "minimal") return false;
@@ -10725,9 +11559,7 @@ function createSessionEventBridge(writer, level = "standard", options = {}) {
     async appendBatch(events) {
       const target = resolveWriter();
       if (!target || events.length === 0) return;
-      const allowed = events.filter(
-        (e) => isAllowed(e.type, currentLevel) && shouldSample(e)
-      );
+      const allowed = events.filter((e) => isAllowed(e.type, currentLevel) && shouldSample(e));
       if (allowed.length === 0) return;
       try {
         await target.appendBatch(allowed);
@@ -10792,9 +11624,12 @@ export {
   ToolAuditLog,
   addPlanItem,
   appendJournal,
+  applyGoalDeliverableCompletions,
+  applyRewindToConversation,
   attachPlanCheckpoint,
   attachTodosCheckpoint,
   clearPlan,
+  coordinateGoalIteration,
   createGoalKanbanBoard,
   createSessionEventBridge,
   deleteGoalKanbanBoard,
@@ -10815,6 +11650,7 @@ export {
   getSessionRegistry,
   goalFilePath,
   hasSessionRegistry,
+  isGoalDeliverableComplete,
   listPlanTemplates,
   loadCompletedWorkCheckpoint,
   loadDirectorState,
@@ -10826,9 +11662,12 @@ export {
   mutatePlan,
   mutateTasks,
   parseAutonomyChoice,
+  parseCompletedGoalDeliverables,
   parseEntries,
   parseProgressFromText,
   promptChecksum,
+  readProviderSnapshot,
+  recomputeGoalProgress,
   recordProgress,
   removePlanItem,
   resolveAuditLevel,
@@ -10842,6 +11681,7 @@ export {
   saveTodosCheckpoint,
   setPlanItemStatus,
   setProgress,
+  stripGoalDeliverableMarker,
   summarizeUsage,
   watchProviderConfig
 };