@wrongstack/core 0.302.2 → 0.305.0

package/dist/storage/index.js

@@ -2152,15 +2152,51 @@ var atomicReplaceWithWriter = primitives.atomicReplaceWithWriter;
 var ensureDir = primitives.ensureDir;
 var withFileLock = primitives.withFileLock;
 
+// src/utils/session-scoped-path.ts
+import * as path6 from "node:path";
+function sessionScopedPath(dir, sessionId, suffix) {
+  if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
+    throw invalid(sessionId);
+  }
+  const resolved = path6.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path6.relative(path6.resolve(dir), resolved);
+  if (rel.startsWith("..") || path6.isAbsolute(rel)) {
+    throw invalid(sessionId);
+  }
+  return resolved;
+}
+var SESSION_SIDECAR_JSONL_SUFFIXES = [
+  ".replay.jsonl",
+  ".audit.jsonl",
+  ".annotations.jsonl"
+];
+var RESERVED_SESSION_JSONL_NAMES = /* @__PURE__ */ new Set([
+  "_index.jsonl",
+  "_mailbox.jsonl"
+]);
+function isSessionTranscriptFileName(name) {
+  if (!name.endsWith(".jsonl")) return false;
+  if (RESERVED_SESSION_JSONL_NAMES.has(name)) return false;
+  return !SESSION_SIDECAR_JSONL_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+function invalid(sessionId) {
+  return new FsError({
+    message: `Invalid sessionId: ${sessionId}`,
+    code: ERROR_CODES.FS_DELETE_FAILED,
+    path: sessionId,
+    context: { reason: "path_traversal" }
+  });
+}
+
 // src/session-registry.ts
 import * as fs6 from "node:fs/promises";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 
 // src/session-registry-atomic-file.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import * as fs5 from "node:fs/promises";
 import { hostname } from "node:os";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 var STALE_LOCK_MS = 1e4;
 var SAME_HOST_STALE_MS = 2 * STALE_LOCK_MS;
 var STALE_TMP_MS = 6e4;
@@ -2240,9 +2276,9 @@ async function breakLockAtomically(lockPath) {
   return true;
 }
 async function writeAtomicFile(filePath, registry) {
-  const tmp = path6.join(
-    path6.dirname(filePath),
-    `.${path6.basename(filePath)}.${randomUUID2().slice(0, 8)}.tmp`
+  const tmp = path7.join(
+    path7.dirname(filePath),
+    `.${path7.basename(filePath)}.${randomUUID2().slice(0, 8)}.tmp`
   );
   let tmpPersisted = false;
   try {
@@ -2283,21 +2319,21 @@ async function writeAtomicFile(filePath, registry) {
 }
 async function pruneStaleTempFiles(filePath) {
   try {
-    const dir = path6.dirname(filePath);
-    const base = path6.basename(filePath);
+    const dir = path7.dirname(filePath);
+    const base = path7.basename(filePath);
     const now = Date.now();
     const stale = [];
     for (const name of await fs5.readdir(dir)) {
       const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
       if (!isTemp) continue;
-      const stat15 = await fs5.stat(path6.join(dir, name)).catch(() => null);
+      const stat15 = await fs5.stat(path7.join(dir, name)).catch(() => null);
       if (!stat15) continue;
       if (now - stat15.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat15.mtimeMs });
     }
     stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
     await Promise.all(
       stale.slice(MAX_STALE_TMP_FILES).map(async ({ name }) => {
-        await fs5.unlink(path6.join(dir, name)).catch(() => void 0);
+        await fs5.unlink(path7.join(dir, name)).catch(() => void 0);
       })
     );
   } catch {
@@ -2361,7 +2397,7 @@ var SessionRegistry = class {
   lastEntry = null;
   ownershipLockWaitMs;
   constructor(globalRoot, options = {}) {
-    this.filePath = path7.join(globalRoot, REGISTRY_FILE);
+    this.filePath = path8.join(globalRoot, REGISTRY_FILE);
     this.ownershipLockWaitMs = Math.max(0, options.ownershipLockWaitMs ?? OWNERSHIP_LOCK_WAIT_MS);
   }
   // ── Public API ──────────────────────────────────────────────────────────
@@ -2671,7 +2707,7 @@ var SessionRegistry = class {
     const deadline = Date.now() + waitBudgetMs;
     let attempt = 0;
     try {
-      await fs6.mkdir(path7.dirname(this.filePath), { recursive: true });
+      await fs6.mkdir(path8.dirname(this.filePath), { recursive: true });
       await this.maybePruneStaleTempFiles();
     } catch (err) {
       if (required) {
@@ -2815,28 +2851,6 @@ function expectDefined(value, label) {
   return value;
 }
 
-// src/utils/session-scoped-path.ts
-import * as path8 from "node:path";
-function sessionScopedPath(dir, sessionId, suffix) {
-  if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
-    throw invalid(sessionId);
-  }
-  const resolved = path8.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path8.relative(path8.resolve(dir), resolved);
-  if (rel.startsWith("..") || path8.isAbsolute(rel)) {
-    throw invalid(sessionId);
-  }
-  return resolved;
-}
-function invalid(sessionId) {
-  return new FsError({
-    message: `Invalid sessionId: ${sessionId}`,
-    code: ERROR_CODES.FS_DELETE_FAILED,
-    path: sessionId,
-    context: { reason: "path_traversal" }
-  });
-}
-
 // src/storage/annotations-store.ts
 var FILE_VERSION = 1;
 var MAX_TEXT_LENGTH = 2e3;
@@ -4628,6 +4642,9 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   disabledTools: Object.freeze([]),
   autoExtendLimit: true,
   restrictToProjectRoot: true,
+  // Off by default: the board is a record of the work, not a permit for it.
+  // See ToolsConfig.kanbanGovernance for what turning it on costs and gates.
+  kanbanGovernance: false,
   loopDetection: Object.freeze({
     mode: "steer-then-cut",
     steerThreshold: 3,
@@ -4685,6 +4702,7 @@ var CONFIG_BEHAVIOR_DEFAULTS = {
     disabledTools: DEFAULT_TOOLS_CONFIG.disabledTools,
     autoExtendLimit: DEFAULT_TOOLS_CONFIG.autoExtendLimit,
     restrictToProjectRoot: DEFAULT_TOOLS_CONFIG.restrictToProjectRoot,
+    kanbanGovernance: DEFAULT_TOOLS_CONFIG.kanbanGovernance,
     loopDetection: DEFAULT_TOOLS_CONFIG.loopDetection
   },
   log: { level: "info" },
@@ -5109,6 +5127,14 @@ var IN_PROJECT_DENIED_PATHS = [
   {
     path: "tools.restrictToProjectRoot",
     reason: "The other half of the filesystem confinement switch."
+  },
+  {
+    // Denied for the direction that loosens: the flag defaults to false, so a
+    // repo can only ever use it to turn OFF a gate the user deliberately
+    // enabled. Same class as `tools.restrictToProjectRoot` — a control the
+    // operator owns, not the checked-out repository.
+    path: "tools.kanbanGovernance",
+    reason: "Repo-committed config could disable a Kanban governance gate the operator switched on, letting product mutations run outside any managed card."
   }
 ];
 function deleteNestedPath(target, path34) {
@@ -7682,10 +7708,38 @@ var SessionMemoryConsolidator = class {
         process.stderr.write(`[memory] Session consolidation: ${added} added
 `);
       }
+      if (this.Sage?.rememberSage) {
+        try {
+          const digestBody = buildSessionDigestText(_finalText, _iterations, added);
+          if (digestBody) {
+            const expires = new Date(Date.now() + 14 * 24 * 60 * 6e4).toISOString();
+            await this.Sage.rememberSage({
+              text: digestBody,
+              scope: "session",
+              kind: "session_digest",
+              importance: 0.4,
+              confidence: 0.65,
+              persistence: "short_lived",
+              tags: ["session_digest", "auto"],
+              anchors: [],
+              sources: [{ type: "session", sessionId: _sessionId }],
+              ownerSessionId: _sessionId,
+              expiresAt: expires
+            });
+          }
+        } catch {
+        }
+      }
     } catch {
     }
   };
 };
+function buildSessionDigestText(finalText, iterations, factsAdded) {
+  const cleaned = finalText.replace(/\s+/g, " ").trim();
+  if (cleaned.length < 40) return void 0;
+  const summary2 = cleaned.slice(0, 400);
+  return `Session digest (${iterations} iter${factsAdded > 0 ? `, ${factsAdded} facts added` : ""}): ` + summary2 + (cleaned.length > 400 ? "\u2026" : "");
+}
 
 // src/storage/memory-graph-backend.ts
 import * as fs14 from "node:fs/promises";
@@ -8039,8 +8093,31 @@ function simpleHash(s) {
 }
 
 // src/storage/plan-store.ts
-import * as fsp5 from "node:fs/promises";
 import { randomUUID as randomUUID5 } from "node:crypto";
+import * as fsp5 from "node:fs/promises";
+function assertPlanMutationInvariants(previous, updated) {
+  const ids = updated.items.map((item) => item.id);
+  const uniqueIds = new Set(ids);
+  if (uniqueIds.size !== ids.length) {
+    throw new SessionError({
+      message: "Plan mutation rejected: plan item IDs must be unique.",
+      code: "SESSION_WRITE_FAILED",
+      sessionId: updated.sessionId,
+      context: { operation: "mutatePlan", invariant: "unique_plan_item_ids" }
+    });
+  }
+  const omittedUnfinished = previous.items.filter(
+    (item) => item.status !== "done" && !uniqueIds.has(item.id)
+  );
+  if (omittedUnfinished.length > 0) {
+    throw new SessionError({
+      message: `Plan mutation rejected: unfinished items cannot be omitted: ${omittedUnfinished.map((item) => item.id).join(", ")}. Complete them first.`,
+      code: "SESSION_WRITE_FAILED",
+      sessionId: updated.sessionId,
+      context: { operation: "mutatePlan", invariant: "unfinished_plan_coverage" }
+    });
+  }
+}
 async function loadPlan(filePath, events) {
   const t0 = Date.now();
   let raw;
@@ -8222,7 +8299,9 @@ function deriveTodosFromPlanItem(plan, idOrIndex, subtasks) {
 async function mutatePlan(filePath, sessionId, fn) {
   return withFileLock(filePath, async () => {
     const plan = await loadPlan(filePath) ?? emptyPlan(sessionId);
+    const previous = structuredClone(plan);
     const updated = await fn(plan);
+    assertPlanMutationInvariants(previous, updated);
     const persisted = await savePlan(filePath, updated);
     if (!persisted) {
       throw new SessionError({
@@ -9252,11 +9331,15 @@ function sortKeys(value) {
   }
   return value;
 }
+function semanticMessage(message) {
+  const { ts: _ts, _estTokens: _estimate, origin: _origin, ...semantic } = message;
+  return semantic;
+}
 function hashRequest(request) {
   const payload = {
     model: request.model,
     system: request.system,
-    messages: request.messages,
+    messages: request.messages.map(semanticMessage),
     tools: request.tools,
     maxTokens: request.maxTokens,
     temperature: request.temperature,
@@ -11005,9 +11088,6 @@ import * as path25 from "node:path";
 function shouldSkipSessionDirectoryEntry(name) {
   return name.startsWith(".") && name !== ".wrongstack" || name === "shared" || name === "subagents" || name === "attachments";
 }
-function isSessionJsonlFileName(name) {
-  return name.endsWith(".jsonl") && name !== "_index.jsonl";
-}
 
 // src/storage/session-store/directory-session-files.ts
 function sessionIdForFile(prefix, name) {
@@ -11030,7 +11110,7 @@ async function collectSessionFiles(dir, prefix = "", depth = 0) {
     if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
     if (entry.isDirectory()) {
       dirEntries.push(entry);
-    } else if (entry.isFile() && isSessionJsonlFileName(entry.name)) {
+    } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
       files.push({ id: sessionIdForFile(prefix, entry.name), filePath: path25.join(dir, entry.name) });
     }
   }
@@ -11054,7 +11134,7 @@ async function collectSessionIds(dir, prefix = "", depth = 0) {
     if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
     if (entry.isDirectory()) {
       dirEntries.push(entry);
-    } else if (entry.isFile() && isSessionJsonlFileName(entry.name)) {
+    } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
       fileIds.push(sessionIdForFile(prefix, entry.name));
     }
   }
@@ -11218,11 +11298,8 @@ var SessionRecovery = class _SessionRecovery {
           }
           continue;
         }
-        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-        if (entry.name === "_index.jsonl" || entry.name === "_mailbox.jsonl") continue;
+        if (!entry.isFile() || !isSessionTranscriptFileName(entry.name)) continue;
         const base = entry.name.slice(0, -".jsonl".length);
-        if (base.includes(".replay") || base.includes(".annotations") || base.includes(".audit"))
-          continue;
         const sessionId = prefix ? `${prefix}/${base}` : base;
         const stale = await this.detectStaleExact(sessionId);
         if (stale) out.push(stale);
@@ -12580,6 +12657,15 @@ async function validateResumeFileObservations(events, projectRoot) {
     staleFiles: results.filter((entry) => entry !== null)
   };
 }
+var RESUME_NOTICE_HEADERS = [
+  "[SESSION RESUME FILE VALIDATION]",
+  "[SESSION RESUME INTERRUPTED WORK]"
+];
+function isResumeNoticeMessage(message) {
+  if (message.role !== "system" || typeof message.content !== "string") return false;
+  return RESUME_NOTICE_HEADERS.some((header) => message.content === header || message.content.startsWith(`${header}
+`));
+}
 function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
   const root = path28.resolve(projectRoot);
@@ -12776,13 +12862,13 @@ function inheritsIntoFork(event) {
 
 // src/storage/session-store/fork-session.ts
 async function forkSession(host, id, opts = {}) {
-  const parent = await host.load(id);
-  let boundary = parent.events.length - 1;
+  const parentEvents = await host.readRawEvents(id);
+  let boundary = parentEvents.length - 1;
   let targetCheckpoint;
   if (opts.checkpointPromptIndex !== void 0) {
     boundary = -1;
-    for (let i = 0; i < parent.events.length; i++) {
-      const event = parent.events[i];
+    for (let i = 0; i < parentEvents.length; i++) {
+      const event = parentEvents[i];
       if (event?.type === "checkpoint" && event.promptIndex === opts.checkpointPromptIndex) {
         boundary = i;
         targetCheckpoint = event;
@@ -12792,15 +12878,18 @@ async function forkSession(host, id, opts = {}) {
       throw new Error(`Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`);
     }
   }
-  const parentPrefix = parent.events.slice(0, boundary + 1);
+  const parentPrefix = parentEvents.slice(0, boundary + 1);
   const workspaceCheckpoint = targetCheckpoint?.workspaceCheckpoint;
   const checkpointHash = createHash9("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
   const inherited = parentPrefix.filter(inheritsIntoFork);
+  const start = parentEvents.find(
+    (event) => event.type === "session_start"
+  );
   const writer = await host.create({
     id: "",
-    title: parent.metadata.title,
-    model: parent.metadata.model,
-    provider: parent.metadata.provider
+    title: "",
+    model: start?.model,
+    provider: start?.provider
   });
   try {
     await writer.append({
@@ -12906,6 +12995,17 @@ var SessionLoadCache = class {
     this.entries.clear();
     this.bytes = 0;
   }
+  /**
+   * A hit hands back fresh `messages` / `events` arrays over the cached
+   * contents.
+   *
+   * The entry outlives every caller, and callers treat what they get as their
+   * own: `resume()` passes `messages` straight into a live conversation, and
+   * anything walking `events` may splice it. Returning the cached arrays
+   * themselves let one caller's edit rewrite what the next one loads. The
+   * elements are still shared — copying them would defeat the cache — so
+   * entries remain read-only *contents* behind private containers.
+   */
   getFresh(id, stat15, full) {
     const cached = this.entries.get(id);
     if (!cached || cached.mtimeMs !== stat15.mtimeMs || cached.size !== stat15.size) {
@@ -12913,8 +13013,11 @@ var SessionLoadCache = class {
     }
     this.entries.delete(id);
     this.entries.set(id, cached);
-    if (full) return cached.data;
-    return { ...cached.data, messages: [] };
+    return {
+      ...cached.data,
+      messages: full ? [...cached.data.messages] : [],
+      events: [...cached.data.events]
+    };
   }
   set(id, stat15, data) {
     this.delete(id);
@@ -13103,6 +13206,9 @@ function stripSnapshotPayload(event) {
   event.messagesOmitted = event.messages.length;
   event.messages = [];
 }
+function isStrippedSnapshot(event) {
+  return event.messages.length === 0 && typeof event.messagesOmitted === "number" && event.messagesOmitted > 0;
+}
 function isSessionEventLike(value) {
   return value !== null && typeof value === "object" && typeof value.type === "string" && typeof value.ts === "string";
 }
@@ -13132,7 +13238,12 @@ function replaySessionEvent(params) {
       emitDamaged(params, `Ignored malformed message_updated event at index ${ev.index}`);
     }
   } else if (ev.type === "messages_replaced" && ev.version === 1) {
-    if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
+    if (isStrippedSnapshot(ev)) {
+      emitDamaged(
+        params,
+        `Ignored messages_replaced event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
+      );
+    } else if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
       exactJournalActive = true;
     } else {
       emitDamaged(params, "Ignored malformed messages_replaced event");
@@ -13148,9 +13259,16 @@ function replaySessionEvent(params) {
       emitDamaged(params, `Ignored malformed messages_dropped event (count ${String(ev.count)})`);
     }
   } else if (ev.type === "context_snapshot") {
-    if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
+    if (isStrippedSnapshot(ev)) {
+      emitDamaged(
+        params,
+        `Ignored context_snapshot event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
+      );
+    } else if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
       emitDamaged(params, "Ignored malformed context_snapshot event");
     }
+  } else if (ev.type === "messages_replaced" || ev.type === "message_appended" || ev.type === "message_updated" || ev.type === "messages_dropped") {
+    emitDamaged(params, `Ignored ${ev.type} event with unsupported version`);
   } else if (!exactJournalActive && ev.type === "user_input") {
     openToolUses.clear();
     messages.push({ role: "user", content: ev.content, ts: ev.ts });
@@ -13203,7 +13321,7 @@ function emitDamaged(params, detail) {
 import * as fsp15 from "node:fs/promises";
 import * as path31 from "node:path";
 function isPrunableSessionJsonl(name) {
-  return name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
+  return isSessionTranscriptFileName(name);
 }
 async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
   const cutoff = Date.now() - maxAgeDays * 864e5;
@@ -13726,6 +13844,21 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async fork(id, opts = {}) {
     return forkSession(this, id, opts);
   }
+  /**
+   * Implements {@link SessionForkHost.readRawEvents} — the parent stream a fork
+   * inherits, unmodified.
+   *
+   * Deliberately NOT `load()`: that loader empties superseded snapshot payloads
+   * in place and front-drops events past its retention budget, both of which
+   * are correct for reconstructing a conversation and wrong for copying a
+   * journal prefix into a child. Streaming with an accept-everything predicate
+   * keeps the scrubbing contract (`searchEvents` scrubs each line the same way
+   * `load()` does) without either transformation.
+   */
+  async readRawEvents(id) {
+    const hits = await this.searchEvents(id, () => true);
+    return hits.map((hit) => hit.event);
+  }
   /**
    * Capture the deterministic post-tool workspace identity through the store-owned CAS.
    */
@@ -13814,14 +13947,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
         ts: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
+    const carriedMessages = data.messages.filter((message) => !isResumeNoticeMessage(message));
     const resumedData = {
       ...data,
       ...resumeValidation ? { resumeValidation } : {},
-      ...noticeMessages.length > 0 ? { messages: [...data.messages, ...noticeMessages] } : {}
+      messages: [...carriedMessages, ...noticeMessages]
     };
     let handle;
     try {
-      handle = await fsp19.open(file, "a", 384);
+      handle = await openSessionForAppend(file);
     } catch (err) {
       emitSessionStoreError(this.events, canonicalId, file, "resume", toErrorMessage(err), false);
       throw new Error(
@@ -14000,10 +14134,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = criteria.limit ?? 100;
     if (this.catalogClient) {
       const records = await this.catalogClient.call("list_catalog", {
-        limit: Math.min(1e3, Math.max(limit, 100)),
-        ...criteria.titleContains ? { search: criteria.titleContains } : {}
+        limit,
+        ...criteria
       });
-      return this.scrubSummaries(records).filter((summary2) => matchesSessionFilter(summary2, criteria)).slice(0, limit);
+      return this.scrubSummaries(records);
     }
     try {
       const indexed = await this.readIndex();
@@ -14228,11 +14362,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return shardKeys;
   }
   async readOrBuildShardManifest(shardKey) {
-    const cached = this.shardManifestCache.get(shardKey);
-    if (cached) return cached;
     const manifestPath = this.shardManifestPath(shardKey);
+    const cached = await this.freshShardManifestCacheEntry(shardKey, manifestPath);
+    if (cached) return cached;
     return withFileLock(manifestPath, async () => {
-      const lockedCached = this.shardManifestCache.get(shardKey);
+      const lockedCached = await this.freshShardManifestCacheEntry(shardKey, manifestPath);
       if (lockedCached) return lockedCached;
       const entry = await readOrBuildShardManifestEntry({
         shardKey,
@@ -14243,10 +14377,38 @@ var DefaultSessionStore = class _DefaultSessionStore {
         summaryHeaderFor: (ref) => this.summaryHeaderFor(ref),
         summaryFor: (id) => this.summaryFor(id)
       });
-      this.shardManifestCache.set(shardKey, entry);
+      try {
+        const stat15 = await fsp19.stat(manifestPath);
+        this.shardManifestCache.set(shardKey, {
+          entry,
+          mtimeMs: stat15.mtimeMs,
+          size: stat15.size,
+          ino: stat15.ino
+        });
+      } catch {
+        this.shardManifestCache.delete(shardKey);
+      }
       return entry;
     });
   }
+  /**
+   * Shard manifests are invalidated by other store processes via atomic
+   * delete/rebuild. Validate the in-memory projection against the persisted
+   * file so one long-lived process cannot retain another process's stale view.
+   */
+  async freshShardManifestCacheEntry(shardKey, manifestPath) {
+    const cached = this.shardManifestCache.get(shardKey);
+    if (!cached) return void 0;
+    try {
+      const stat15 = await fsp19.stat(manifestPath);
+      if (stat15.mtimeMs === cached.mtimeMs && stat15.size === cached.size && stat15.ino === cached.ino) {
+        return cached.entry;
+      }
+    } catch {
+    }
+    this.shardManifestCache.delete(shardKey);
+    return void 0;
+  }
   async collectSessionFilesInShard(shardKey) {
     const dir = shardKey ? path32.join(this.dir, shardKey) : this.dir;
     const entries = await this.collectSessionFiles(dir, shardKey);
@@ -14441,7 +14603,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const maintenance = this.catalogClient ? await this.catalogClient.call("acquire_maintenance", {
       sessionId: canonical,
       operation: "clear",
-      holderId: this.maintenanceHolderId
+      holderId: this.maintenanceHolderId,
+      // The catalog store runs inside the detached project daemon; without
+      // our pid it cannot tell "this TUI clearing its own session" from
+      // "another running wstack" and refuses every /clear as `is live`.
+      holderPid: process.pid
     }) : void 0;
     await this.ensureShardDir(canonical);
     const file = this.sessionPath(canonical, ".jsonl");
@@ -14522,6 +14688,23 @@ var DefaultSessionStore = class _DefaultSessionStore {
     });
   }
 };
+async function openSessionForAppend(file) {
+  const handle = await fsp19.open(file, "a+", 384);
+  try {
+    const stat15 = await handle.stat();
+    if (stat15.size > 0) {
+      const tail = Buffer.allocUnsafe(1);
+      const { bytesRead } = await handle.read(tail, 0, 1, stat15.size - 1);
+      if (bytesRead === 1 && tail[0] !== 10) {
+        await handle.appendFile("\n", "utf8");
+      }
+    }
+    return handle;
+  } catch (err) {
+    await handle.close().catch(() => void 0);
+    throw err;
+  }
+}
 
 // src/storage/session-rewind-apply.ts
 async function applyRewindToConversation(opts) {
@@ -14634,17 +14817,20 @@ var DefaultSessionRewinder = class {
     const targetIndex = checkpoints[n - 1]?.promptIndex ?? 0;
     const snapshotsToRevert = [];
     let shouldRevert = false;
+    let removedEvents = 0;
     for await (const event of this.readEvents(file)) {
       if (event.type === "checkpoint" && event.promptIndex === targetIndex) {
         shouldRevert = true;
         continue;
       }
-      if (shouldRevert && event.type === "file_snapshot") {
+      if (!shouldRevert) continue;
+      removedEvents++;
+      if (event.type === "file_snapshot") {
         snapshotsToRevert.push({ promptIndex: event.promptIndex, files: event.files });
       }
     }
     const result = await revertSnapshots(snapshotsToRevert, this.projectRoot);
-    return { ...result, toPromptIndex: targetIndex, removedEvents: snapshotsToRevert.length };
+    return { ...result, toPromptIndex: targetIndex, removedEvents };
   }
   async rewindToStart(sessionId) {
     const file = this.sessionFile(sessionId);
@@ -14698,6 +14884,54 @@ async function revertSnapshots(snapshots, projectRoot) {
 
 // src/storage/task-store.ts
 import * as fsp21 from "node:fs/promises";
+function assertTaskMutationInvariants(previous, updated) {
+  const ids = updated.tasks.map((task) => task.id);
+  const uniqueIds = new Set(ids);
+  if (uniqueIds.size !== ids.length) {
+    throw new SessionError({
+      message: "Task mutation rejected: task IDs must be unique.",
+      code: "SESSION_WRITE_FAILED",
+      sessionId: updated.sessionId,
+      context: { operation: "mutateTasks", invariant: "unique_task_ids" }
+    });
+  }
+  const omittedUnfinished = previous.tasks.filter(
+    (task) => task.status !== "completed" && !uniqueIds.has(task.id)
+  );
+  if (omittedUnfinished.length > 0) {
+    throw new SessionError({
+      message: `Task mutation rejected: unfinished tasks cannot be omitted: ${omittedUnfinished.map((task) => task.id).join(", ")}. Complete them first.`,
+      code: "SESSION_WRITE_FAILED",
+      sessionId: updated.sessionId,
+      context: { operation: "mutateTasks", invariant: "unfinished_task_coverage" }
+    });
+  }
+  const byId = new Map(updated.tasks.map((task) => [task.id, task]));
+  for (const task of updated.tasks) {
+    const missing = (task.dependsOn ?? []).filter((dependencyId) => !byId.has(dependencyId));
+    if (missing.length > 0) {
+      throw new SessionError({
+        message: `Task mutation rejected: task "${task.id}" references missing dependencies: ${missing.join(", ")}.`,
+        code: "SESSION_WRITE_FAILED",
+        sessionId: updated.sessionId,
+        context: { operation: "mutateTasks", invariant: "dependency_identity" }
+      });
+    }
+    if (task.status === "in_progress" || task.status === "review" || task.status === "completed") {
+      const unmet = (task.dependsOn ?? []).filter(
+        (dependencyId) => byId.get(dependencyId)?.status !== "completed"
+      );
+      if (unmet.length > 0) {
+        throw new SessionError({
+          message: `Task mutation rejected: task "${task.id}" cannot be ${task.status} before dependencies complete: ${unmet.join(", ")}.`,
+          code: "SESSION_WRITE_FAILED",
+          sessionId: updated.sessionId,
+          context: { operation: "mutateTasks", invariant: "dependency_completion" }
+        });
+      }
+    }
+  }
+}
 function emptyTaskFile(sessionId) {
   return {
     version: 1,
@@ -14802,7 +15036,9 @@ async function saveTasks(filePath, tasks, events, traceId, warn) {
 async function mutateTasks(filePath, sessionId, fn, events, traceId) {
   return withFileLock(filePath, async () => {
     const file = await loadTasks(filePath, events, traceId) ?? emptyTaskFile(sessionId);
+    const previous = structuredClone(file);
     const updated = await fn(file);
+    assertTaskMutationInvariants(previous, updated);
     const persisted = await saveTasks(filePath, updated, events, traceId);
     if (!persisted) {
       throw new SessionError({