@wrongstack/core 0.286.0 → 0.287.0

package/dist/storage/index.js

@@ -7,7 +7,8 @@ import { createInterface } from "node:readline";
 
 // src/utils/atomic-write.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import * as fs from "node:fs/promises";
+import * as fs2 from "node:fs/promises";
+import { watch as watchDir } from "node:fs";
 import * as path3 from "node:path";
 
 // src/utils/child-env.ts
@@ -453,14 +454,34 @@ function ulid(seedTime = Date.now()) {
 
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
+import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path2 from "node:path";
+function canonicalProjectRoot(absRoot) {
+  const checkoutRoot = path2.resolve(absRoot);
+  const dotGit = path2.join(checkoutRoot, ".git");
+  try {
+    if (!fs.statSync(dotGit).isFile()) return checkoutRoot;
+    const gitDirLine = fs.readFileSync(dotGit, "utf8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
+    if (!match?.[1]) return checkoutRoot;
+    const gitDir = path2.resolve(checkoutRoot, match[1].trim());
+    const commonDirFile = path2.join(gitDir, "commondir");
+    if (!fs.statSync(commonDirFile).isFile()) return checkoutRoot;
+    const commonDir = path2.resolve(gitDir, fs.readFileSync(commonDirFile, "utf8").trim());
+    if (path2.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
+    return path2.dirname(commonDir);
+  } catch {
+    return checkoutRoot;
+  }
+}
 function projectHash(absRoot) {
-  return createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 12);
+  return createHash("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
 }
 function projectSlug(absRoot) {
-  const base = slugify2(path2.basename(absRoot));
-  const hash = createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 6);
+  const identityRoot = canonicalProjectRoot(absRoot);
+  const base = slugify2(path2.basename(identityRoot));
+  const hash = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify2(name) {
@@ -661,16 +682,16 @@ var FsError = class extends WrongStackError {
 // src/utils/atomic-write.ts
 async function atomicWrite(targetPath, content, opts = {}) {
   const dir = path3.dirname(targetPath);
-  await fs.mkdir(dir, { recursive: true });
+  await fs2.mkdir(dir, { recursive: true });
   const tmp = path3.join(dir, `.${path3.basename(targetPath)}.${randomBytes2(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
-      await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+      await fs2.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
     } else {
-      await fs.writeFile(tmp, content, { flag: "wx" });
+      await fs2.writeFile(tmp, content, { flag: "wx" });
     }
     try {
-      const fh = await fs.open(tmp, "r+");
+      const fh = await fs2.open(tmp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -680,35 +701,35 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat13 = await fs.stat(targetPath);
+      const stat13 = await fs2.stat(targetPath);
       mode = stat13.mode & 511;
     } catch {
       mode = opts.mode;
     }
     if (mode !== void 0) {
-      await fs.chmod(tmp, mode);
+      await fs2.chmod(tmp, mode);
     }
     await renameWithRetry(tmp, targetPath);
     if (mode !== void 0 && process.platform === "win32") {
       try {
-        await fs.chmod(targetPath, mode);
+        await fs2.chmod(targetPath, mode);
       } catch {
       }
     }
   } catch (err) {
     try {
-      await fs.unlink(tmp);
+      await fs2.unlink(tmp);
     } catch {
     }
     throw err;
   }
 }
 async function ensureDir(dir) {
-  await fs.mkdir(dir, { recursive: true });
+  await fs2.mkdir(dir, { recursive: true });
 }
 async function withFileLock(targetPath, fn, opts = {}) {
   const dir = path3.dirname(targetPath);
-  await fs.mkdir(dir, { recursive: true });
+  await fs2.mkdir(dir, { recursive: true });
   const lockPath = path3.join(dir, `.${path3.basename(targetPath)}.lock`);
   const timeoutMs = opts.timeoutMs ?? 5e3;
   const staleMs = opts.staleMs ?? 3e4;
@@ -716,26 +737,27 @@ async function withFileLock(targetPath, fn, opts = {}) {
   let handle;
   for (; ; ) {
     try {
-      handle = await fs.open(lockPath, "wx");
+      handle = await fs2.open(lockPath, "wx");
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
-        await fs.mkdir(dir, { recursive: true });
+        await fs2.mkdir(dir, { recursive: true });
         continue;
       }
-      if (code !== "EEXIST") throw err;
+      if (code !== "EEXIST" && code !== "EPERM") throw err;
       try {
-        const stat13 = await fs.stat(lockPath);
+        const stat13 = await fs2.stat(lockPath);
         if (Date.now() - stat13.mtimeMs > staleMs) {
-          await fs.unlink(lockPath);
+          await fs2.unlink(lockPath);
           continue;
         }
       } catch {
         continue;
       }
-      if (Date.now() - started >= timeoutMs) {
+      const elapsed = Date.now() - started;
+      if (elapsed >= timeoutMs) {
         throw new FsError({
           message: `Timed out waiting for file lock: ${targetPath}`,
           code: "FS_ATOMIC_WRITE_FAILED",
@@ -743,7 +765,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
           context: { timeoutMs }
         });
       }
-      await new Promise((resolve11) => setTimeout(resolve11, 25));
+      await waitForLockRelease(lockPath, timeoutMs - elapsed);
     }
   }
   try {
@@ -754,22 +776,66 @@ async function withFileLock(targetPath, fn, opts = {}) {
     } catch {
     }
     try {
-      await fs.unlink(lockPath);
+      await fs2.unlink(lockPath);
     } catch {
     }
   }
 }
+async function waitForLockRelease(lockPath, remainingMs) {
+  const parentDir = path3.dirname(lockPath);
+  const lockName = path3.basename(lockPath);
+  const intervalMs = Math.min(remainingMs, 100);
+  return new Promise((resolve11) => {
+    let settled = false;
+    let watcher = null;
+    const timer = setTimeout(() => {
+      settled = true;
+      watcher?.close();
+      resolve11();
+    }, intervalMs);
+    try {
+      watcher = watchDir(parentDir, (eventType, filename) => {
+        if (settled) return;
+        if (filename === lockName && (eventType === "rename" || eventType === "change")) {
+          settled = true;
+          clearTimeout(timer);
+          watcher?.close();
+          resolve11();
+        }
+      });
+    } catch {
+      clearTimeout(timer);
+      if (!settled) {
+        settled = true;
+        setTimeout(resolve11, Math.min(remainingMs, 25));
+      }
+      return;
+    }
+    fs2.access(lockPath).then(
+      () => {
+      },
+      () => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          watcher?.close();
+          resolve11();
+        }
+      }
+    );
+  });
+}
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
-    await fs.rename(from, to);
+    await fs2.rename(from, to);
     return;
   }
   const delays = [10, 25, 60, 120, 250];
   let lastErr;
   for (let i = 0; i <= delays.length; i++) {
     try {
-      await fs.rename(from, to);
+      await fs2.rename(from, to);
       return;
     } catch (err) {
       lastErr = err;
@@ -3700,7 +3766,7 @@ function mergeAdjacentText(blocks) {
 
 // src/storage/memory-backend.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs2 from "node:fs/promises";
+import * as fs3 from "node:fs/promises";
 import * as path10 from "node:path";
 
 // src/types/memory.ts
@@ -3868,7 +3934,7 @@ var FileMemoryBackend = class {
   }
   async getMtime(file) {
     try {
-      const stat13 = await fs2.stat(file);
+      const stat13 = await fs3.stat(file);
       return stat13.mtimeMs;
     } catch {
       return 0;
@@ -3918,7 +3984,7 @@ var FileMemoryBackend = class {
     await ensureDir(path10.dirname(file));
     let existing = "";
     try {
-      existing = await fs2.readFile(file, "utf8");
+      existing = await fs3.readFile(file, "utf8");
     } catch {
     }
     const id = `mem_${Date.now()}_${randomUUID2().slice(0, 8)}`;
@@ -3936,7 +4002,7 @@ ${line}`;
     return withFileLock(file, async () => {
       let existing;
       try {
-        existing = await fs2.readFile(file, "utf8");
+        existing = await fs3.readFile(file, "utf8");
       } catch {
         return 0;
       }
@@ -3973,7 +4039,7 @@ ${line}`;
   async readAll(scope, filePath) {
     const file = this.resolveFile(filePath, scope);
     try {
-      return await fs2.readFile(file, "utf8");
+      return await fs3.readFile(file, "utf8");
     } catch {
       return "";
     }
@@ -3997,7 +4063,7 @@ ${line}`;
     const file = this.resolveFile(filePath, scope);
     let existing;
     try {
-      existing = await fs2.readFile(file, "utf8");
+      existing = await fs3.readFile(file, "utf8");
     } catch {
       return 0;
     }
@@ -4017,7 +4083,7 @@ ${line}`;
     const next = lines.join("\n");
     const backup = `${file}.bak.${Date.now()}`;
     try {
-      await fs2.copyFile(file, backup);
+      await fs3.copyFile(file, backup);
       await pruneConsolidateBackups(file);
     } catch {
     }
@@ -4034,11 +4100,11 @@ async function pruneConsolidateBackups(file) {
   const dir = path10.dirname(file);
   const base = path10.basename(file);
   const prefix = `${base}.bak.`;
-  const backups = (await fs2.readdir(dir)).filter((name) => name.startsWith(prefix)).sort().reverse();
+  const backups = (await fs3.readdir(dir)).filter((name) => name.startsWith(prefix)).sort().reverse();
   await Promise.all(
     backups.slice(MAX_MEMORY_CONSOLIDATE_BACKUPS).map(async (name) => {
       try {
-        await fs2.unlink(path10.join(dir, name));
+        await fs3.unlink(path10.join(dir, name));
       } catch {
       }
     })
@@ -4053,582 +4119,8 @@ function parseEntries(raw, scope = "project-memory") {
   return entries.reverse();
 }
 
-// src/storage/memory-store.ts
-var MAX_BYTES_TOTAL = 32e3;
-var DefaultMemoryStore = class {
-  files;
-  events;
-  traceId;
-  backend;
-  /**
-   * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
-   * `clear` are read-modify-write against a single file; without a lock,
-   * two concurrent calls on the same scope can read the same baseline and
-   * the later write silently drops the earlier entry. We chain each
-   * mutation onto the prior promise for the same scope so they run in
-   * issue order. Different scopes still proceed in parallel.
-   *
-   * The chain tracks only the last pending write. If a write fails, its
-   * error is caught and swallowed so the chain stays alive for subsequent
-   * calls. The error is stored in `writeErrors` so callers can learn about
-   * it on the next read operation.
-   */
-  writeChain = /* @__PURE__ */ new Map();
-  /** Last write error per scope — surfaced as warnings on the next readAll(). */
-  writeErrors = /* @__PURE__ */ new Map();
-  /**
-   * When the global root is a temporary directory (opencode, CI sandboxes),
-   * memory files are also mirrored to the project tree so they survive
-   * session cleanup. The primary path stays in the temp root for isolation;
-   * this backup ensures memory is never lost.
-   */
-  persistBackup;
-  backupDir;
-  /**
-   * Per-scope tracked byte sizes — incremented on `remember()`, decremented on
-   * `forget()`, recalculated after `consolidate()`. Eliminates the redundant
-   * readAll() call that previously checked the file size after every write.
-   */
-  _trackedByteSizes = {};
-  /** Result cache for scoreRelevant() — keyed by scope + context hash, TTL 30s. */
-  _scoreCache = /* @__PURE__ */ new Map();
-  /**
-   * Per-entry cached lowercase strings — lazily allocated once and reused
-   * across scoreRelevant() calls so repeated scoring of the same entries skips
-   * re-lowercasing. Keyed by entry object identity; cleared (set to null) on
-   * every mutation (remember/forget/consolidate/clear) via invalidateScoreCaches().
-   */
-  _cachedLower = null;
-  constructor(opts) {
-    this.files = {
-      "project-agents": opts.paths.inProjectAgentsFile,
-      "project-memory": opts.paths.projectMemory,
-      "user-memory": opts.paths.globalMemory
-    };
-    this.events = opts.events;
-    this.backend = opts.backend ?? new FileMemoryBackend({ paths: opts.paths });
-    const root = opts.paths.globalRoot.toLowerCase();
-    this.persistBackup = /[/\\](tmp|temp|cache)[/\\]/.test(root);
-    this.backupDir = this.persistBackup ? opts.paths.inProjectAgentsFile.replace(/AGENTS\.md$/, "memory-persist") : "";
-  }
-  /** Expose the backend for plugin introspection and advanced queries. */
-  getBackend() {
-    return this.backend;
-  }
-  async runSerialized(scope, work) {
-    const prior = this.writeChain.get(scope) ?? Promise.resolve();
-    const next = prior.catch((err) => {
-      this.writeErrors.set(scope, err);
-    }).then(() => work());
-    this.writeChain.set(scope, next);
-    try {
-      return await next;
-    } catch (err) {
-      this.writeErrors.set(scope, err);
-      throw err;
-    } finally {
-      if (this.writeChain.get(scope) === next) {
-        this.writeChain.delete(scope);
-      }
-    }
-  }
-  /**
-   * Recalculate the tracked byte size for a scope by re-reading the file and
-   * summing the serialized byte length of each line. Called after consolidate()
-   * (which modifies the file) to keep the tracker accurate.
-   */
-  async _recalcTrackedByteSize(scope) {
-    const raw = await this.backend.readAll(scope, this.files[scope]);
-    let total = 0;
-    for (const line of raw.split("\n")) {
-      if (line.trim()) total += Buffer.byteLength(line, "utf8");
-    }
-    this._trackedByteSizes[scope] = total;
-    return total;
-  }
-  async readAll() {
-    const parts = [];
-    for (const scope of ["project-agents", "project-memory", "user-memory"]) {
-      const writeErr = this.writeErrors.get(scope);
-      if (writeErr) {
-        parts.push(`> \u26A0\uFE0F Memory write error (${labelOf(scope)}): ${writeErr.message}`);
-      }
-      const t0 = Date.now();
-      const filePath = this.files[scope];
-      try {
-        const body = await this.backend.readAll(scope, filePath);
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.read", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "readAll",
-          outcome: "success",
-          durationMs: dur,
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-        if (body.trim()) parts.push(`## ${labelOf(scope)}
-
-${body.trim()}`);
-      } catch (err) {
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.read", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "readAll",
-          outcome: "failure",
-          durationMs: dur,
-          error: toErrorMessage(err),
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-        throw err;
-      }
-    }
-    return parts.join("\n\n");
-  }
-  async read(scope) {
-    const t0 = Date.now();
-    const filePath = this.files[scope];
-    try {
-      const body = await this.backend.readAll(scope, filePath);
-      const dur = Date.now() - t0;
-      this.events?.emit("storage.read", {
-        sessionId: "~memory~",
-        store: "memory",
-        filePath,
-        operation: "read",
-        outcome: "success",
-        durationMs: dur,
-        ...this.traceId !== void 0 && { traceId: this.traceId }
-      });
-      return body;
-    } catch (err) {
-      const dur = Date.now() - t0;
-      this.events?.emit("storage.read", {
-        sessionId: "~memory~",
-        store: "memory",
-        filePath,
-        operation: "read",
-        outcome: "failure",
-        durationMs: dur,
-        error: toErrorMessage(err),
-        ...this.traceId !== void 0 && { traceId: this.traceId }
-      });
-      throw err;
-    }
-  }
-  /**
-   * List entries from a scope, newest first. Delegates to the backend
-   * so graph/semantic backends can return enriched or filtered results.
-   */
-  async list(scope = "project-memory", limit) {
-    return this.backend.list(scope, this.files[scope], limit);
-  }
-  /**
-   * Find memories related to the given text via graph traversal.
-   * Falls back to content search when no graph backend is available.
-   */
-  async findRelated(text, scope = "project-memory", limit = 5) {
-    if (this.backend.findRelated) {
-      return this.backend.findRelated(scope, this.files[scope], text, limit);
-    }
-    return this.search(text, scope, limit);
-  }
-  async search(query, scope = "project-memory", limit) {
-    return this.backend.search(scope, query, this.files[scope], limit);
-  }
-  async remember(text, scope = "project-memory", metadata) {
-    const ts = (/* @__PURE__ */ new Date()).toISOString();
-    return this.runSerialized(scope, async () => {
-      const entry = { scope, text, ts, ...metadata };
-      const filePath = this.files[scope];
-      const t0 = Date.now();
-      try {
-        await this.backend.remember(scope, entry, filePath);
-        this.invalidateScoreCaches();
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "remember",
-          outcome: "success",
-          durationMs: dur,
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-      } catch (err) {
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "remember",
-          outcome: "failure",
-          durationMs: dur,
-          error: toErrorMessage(err),
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-        throw err;
-      }
-      let trackedSize = this._trackedByteSizes[scope];
-      if (trackedSize === void 0) {
-        trackedSize = await this._recalcTrackedByteSize(scope);
-      }
-      if (trackedSize > MAX_BYTES_TOTAL) {
-        const removed = await this.backend.consolidate(scope, this.files[scope]);
-        if (removed > 0) {
-          this.events?.emit("memory.consolidated", {
-            scope,
-            removed
-          });
-          await this._recalcTrackedByteSize(scope);
-        }
-      }
-      this._trackedByteSizes[scope] = (this._trackedByteSizes[scope] ?? 0) + Buffer.byteLength(JSON.stringify(entry), "utf8");
-      await this.mirrorBackup(scope);
-      this.events?.emit("memory.remembered", {
-        scope,
-        text,
-        ts,
-        type: entry.type,
-        tags: entry.tags,
-        priority: entry.priority
-      });
-    });
-  }
-  /**
-   * Drop the relevance caches after a mutation. Both the per-context score
-   * cache and the per-entry lowercase cache are keyed on entry objects that a
-   * mutation invalidates, so they must be cleared together when entries change.
-   */
-  invalidateScoreCaches() {
-    this._scoreCache.clear();
-    this._cachedLower = null;
-  }
-  /**
-   * Score and rank memories by relevance to the current context.
-   * Returns entries with score >= MIN_RELEVANCE_SCORE, sorted highest first.
-   */
-  async scoreRelevant(ctx, scope = "project-memory", limit = 8) {
-    const all = await this.list(scope);
-    if (all.length === 0) return [];
-    const ctxHash = `${scope}|${ctx.currentTask}|${(ctx.activeSkills ?? []).join(",")}|${(ctx.toolNames ?? []).join(",")}`;
-    const now = Date.now();
-    const TTL_MS = 3e4;
-    const cached = this._scoreCache.get(ctxHash);
-    if (cached && cached.expiresAt > now && cached.entries === all) {
-      return cached.scored.slice(0, Math.min(limit, 15));
-    }
-    const taskWords = ctx.currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
-    const skillWords = (ctx.activeSkills ?? []).flatMap((s) => s.split("-"));
-    const toolWords = (ctx.toolNames ?? []).flatMap((t) => t.toLowerCase().split("_"));
-    this._cachedLower ??= /* @__PURE__ */ new WeakMap();
-    const lowerCache = this._cachedLower;
-    const scored = [];
-    for (const entry of all) {
-      let score = 0;
-      const reasons = [];
-      let cachedLower = lowerCache.get(entry);
-      if (!cachedLower) {
-        cachedLower = {
-          textLower: entry.text.toLowerCase(),
-          tagsLower: (entry.tags ?? []).map((t) => t.toLowerCase())
-        };
-        lowerCache.set(entry, cachedLower);
-      }
-      const { textLower, tagsLower } = cachedLower;
-      let taskHits = 0;
-      for (const w of taskWords) {
-        if (textLower.includes(w)) {
-          taskHits++;
-          score += 2;
-        }
-        if (tagsLower.some((t) => t.includes(w))) {
-          taskHits++;
-          score += 3;
-        }
-      }
-      if (taskHits > 0) reasons.push(`task match (${taskHits})`);
-      let skillHits = 0;
-      for (const w of skillWords) {
-        if (w.length > 2 && (textLower.includes(w) || tagsLower.some((t) => t.includes(w)))) {
-          skillHits++;
-        }
-      }
-      score += skillHits;
-      if (skillHits > 0) reasons.push(`skill match (${skillHits})`);
-      for (const w of toolWords) {
-        if (w.length > 2 && (textLower.includes(w) || tagsLower.some((t) => t.includes(w)))) {
-          score += 1;
-          reasons.push(`tool mention: ${w}`);
-        }
-      }
-      switch (entry.priority) {
-        case "critical":
-          score += 5;
-          reasons.push("critical");
-          break;
-        case "high":
-          score += 3;
-          reasons.push("high priority");
-          break;
-        case "medium":
-          score += 1;
-          break;
-        case "low":
-          score -= 2;
-          reasons.push("low priority");
-          break;
-      }
-      switch (entry.type) {
-        case "decision":
-          score += 2;
-          reasons.push("decision");
-          break;
-        case "convention":
-          score += 2;
-          reasons.push("convention");
-          break;
-        case "anti_pattern":
-          score += 3;
-          reasons.push("anti-pattern");
-          break;
-        case "preference":
-          score += 1;
-          reasons.push("preference");
-          break;
-        case "reference":
-          break;
-        case "fact":
-          break;
-      }
-      const ageDays = (now - new Date(entry.ts).getTime()) / (1e3 * 60 * 60 * 24);
-      if (ageDays < 1) score += 1;
-      else if (ageDays > 30) score -= 1;
-      if (entry.confidence !== void 0 && entry.confidence < 0.5) {
-        score -= 2;
-        reasons.push("low confidence");
-      }
-      if (entry.lastAccessed) {
-        const hoursSinceAccess = (now - new Date(entry.lastAccessed).getTime()) / (1e3 * 60 * 60);
-        if (hoursSinceAccess < 1) score -= 1;
-      }
-      if (score > 0) {
-        scored.push({
-          ...entry,
-          score,
-          matchReason: reasons.join(", ") || "keyword match"
-        });
-      }
-    }
-    scored.sort((a, b) => b.score - a.score);
-    const threshold = 2;
-    const relevant = scored.filter(
-      (s) => s.score >= threshold || s.priority === "critical" || s.priority === "high"
-    );
-    this._scoreCache.set(ctxHash, { entries: all, scored: relevant, expiresAt: now + TTL_MS });
-    return relevant.slice(0, Math.min(limit, 15));
-  }
-  async forget(query, scope = "project-memory") {
-    return this.runSerialized(scope, async () => {
-      const filePath = this.files[scope];
-      const t0 = Date.now();
-      let removed = 0;
-      try {
-        removed = await this.backend.forget(scope, query, filePath);
-        this.invalidateScoreCaches();
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "forget",
-          outcome: "success",
-          durationMs: dur,
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-      } catch (err) {
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "forget",
-          outcome: "failure",
-          durationMs: dur,
-          error: toErrorMessage(err),
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-        throw err;
-      }
-      if (removed > 0) {
-        this.events?.emit("memory.forgotten", {
-          scope,
-          query,
-          removed
-        });
-        await this.mirrorBackup(scope);
-        await this._recalcTrackedByteSize(scope);
-      }
-      return removed;
-    });
-  }
-  async consolidate(scope) {
-    return this.runSerialized(scope, async () => {
-      const filePath = this.files[scope];
-      const t0 = Date.now();
-      let removed = 0;
-      try {
-        removed = await this.backend.consolidate(scope, filePath);
-        this.invalidateScoreCaches();
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "consolidate",
-          outcome: "success",
-          durationMs: dur,
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-      } catch (err) {
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "consolidate",
-          outcome: "failure",
-          durationMs: dur,
-          error: toErrorMessage(err),
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-        throw err;
-      }
-      if (removed > 0) {
-        this.events?.emit("memory.consolidated", {
-          scope,
-          removed
-        });
-        await this.mirrorBackup(scope);
-        await this._recalcTrackedByteSize(scope);
-      }
-    });
-  }
-  async clear(scope) {
-    if (scope) {
-      await this.runSerialized(scope, async () => {
-        const filePath = this.files[scope];
-        const t0 = Date.now();
-        try {
-          await this.backend.clear(scope, filePath);
-          this.invalidateScoreCaches();
-          const dur = Date.now() - t0;
-          this.events?.emit("storage.write", {
-            sessionId: "~memory~",
-            store: "memory",
-            filePath,
-            operation: "clear",
-            outcome: "success",
-            durationMs: dur,
-            ...this.traceId !== void 0 && { traceId: this.traceId }
-          });
-        } catch (err) {
-          const dur = Date.now() - t0;
-          this.events?.emit("storage.write", {
-            sessionId: "~memory~",
-            store: "memory",
-            filePath,
-            operation: "clear",
-            outcome: "failure",
-            durationMs: dur,
-            error: toErrorMessage(err),
-            ...this.traceId !== void 0 && { traceId: this.traceId }
-          });
-          throw err;
-        }
-        this.events?.emit("memory.cleared", { scope });
-        await this.mirrorBackup(scope);
-        this._trackedByteSizes[scope] = 0;
-      });
-      return;
-    }
-    await Promise.all(
-      ["project-agents", "project-memory", "user-memory"].map(
-        async (s) => this.runSerialized(s, async () => {
-          const filePath = this.files[s];
-          const t0 = Date.now();
-          try {
-            await this.backend.clear(s, filePath);
-            const dur = Date.now() - t0;
-            this.events?.emit("storage.write", {
-              sessionId: "~memory~",
-              store: "memory",
-              filePath,
-              operation: "clear",
-              outcome: "success",
-              durationMs: dur,
-              ...this.traceId !== void 0 && { traceId: this.traceId }
-            });
-          } catch (err) {
-            const dur = Date.now() - t0;
-            this.events?.emit("storage.write", {
-              sessionId: "~memory~",
-              store: "memory",
-              filePath,
-              operation: "clear",
-              outcome: "failure",
-              durationMs: dur,
-              error: toErrorMessage(err),
-              ...this.traceId !== void 0 && { traceId: this.traceId }
-            });
-            throw err;
-          }
-          this.events?.emit("memory.cleared", { scope: s });
-          await this.mirrorBackup(s);
-        })
-      )
-    );
-    this.invalidateScoreCaches();
-  }
-  /**
-   * Return a new MemoryStore proxy that carries `traceId` on every storage
-   * event. The original store is left unchanged — callers that need a
-   * trace-decorated view (e.g. session-run tools) receive the proxy while
-   * the singleton remains trace-free for boot-time use.
-   *
-   * The proxy implements the full `MemoryStore` interface; all other
-   * properties (backend, etc.) are delegated to the original store.
-   */
-  withTraceId(traceId) {
-    this.traceId = traceId;
-    return this;
-  }
-  async mirrorBackup(scope) {
-    if (!this.persistBackup || scope === "project-agents") return;
-    try {
-      const content = await this.backend.readAll(scope, this.files[scope]);
-      const { writeFile: writeFile7, mkdir: mkdir7 } = await import("node:fs/promises");
-      await mkdir7(this.backupDir, { recursive: true });
-      await writeFile7(`${this.backupDir}/${scope}.md`, content, "utf8");
-    } catch {
-    }
-  }
-};
-function labelOf(scope) {
-  switch (scope) {
-    case "project-agents":
-      return "Project AGENTS.md";
-    case "project-memory":
-      return "Project memory";
-    case "user-memory":
-      return "User memory";
-  }
-}
-
 // src/storage/memory-graph-backend.ts
-import * as fs3 from "node:fs/promises";
+import * as fs4 from "node:fs/promises";
 var GraphMemoryBackend = class _GraphMemoryBackend {
   kind = "graph";
   file;
@@ -4796,7 +4288,7 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
     this.loadedScope = scope;
     this.loaded = true;
     try {
-      await fs3.unlink(this.graphFile);
+      await fs4.unlink(this.graphFile);
     } catch {
     }
   }
@@ -4836,7 +4328,7 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
   async loadGraph(scope) {
     if (this.loaded && this.loadedScope === scope) return;
     try {
-      const raw = await fs3.readFile(this.graphFile, "utf8");
+      const raw = await fs4.readFile(this.graphFile, "utf8");
       const data = JSON.parse(raw);
       this.nodes = new Map(data.nodes);
       this.edges = data.edges;
@@ -4858,10 +4350,10 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
         edges: this.edges
       };
       const dir = this.graphFile.substring(0, this.graphFile.lastIndexOf("/"));
-      await fs3.mkdir(dir, { recursive: true });
+      await fs4.mkdir(dir, { recursive: true });
       const tmp = `${this.graphFile}.tmp`;
-      await fs3.writeFile(tmp, JSON.stringify(data));
-      await fs3.rename(tmp, this.graphFile);
+      await fs4.writeFile(tmp, JSON.stringify(data));
+      await fs4.rename(tmp, this.graphFile);
     } catch {
     }
   }
@@ -4979,7 +4471,7 @@ function simpleHash(s) {
 }
 
 // src/utils/instruction-file.ts
-import { readFileSync, statSync } from "node:fs";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import * as path11 from "node:path";
 import { fileURLToPath } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
@@ -4990,7 +4482,7 @@ function readBundledInstructionText(relativePath) {
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      resolved = readFileSync(path11.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync2(path11.join(root, relativePath), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -5017,7 +4509,7 @@ function instructionRootCandidates() {
 }
 function isDirectory(candidate) {
   try {
-    return statSync(candidate).isDirectory();
+    return statSync2(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -5043,12 +4535,14 @@ var SessionMemoryConsolidator = class {
   model;
   minIterations;
   maxExistingEntries;
+  oneShotOrchestrator;
   constructor(opts) {
     this.memoryStore = opts.memoryStore;
     this.provider = opts.provider;
     this.model = opts.model;
     this.minIterations = opts.minIterations ?? 2;
     this.maxExistingEntries = opts.maxExistingEntries ?? 15;
+    this.oneShotOrchestrator = opts.oneShotOrchestrator;
   }
   afterRun = (ctx, result) => {
     if (result.status !== "done") return;
@@ -5067,19 +4561,32 @@ var SessionMemoryConsolidator = class {
           _iterations,
           existingEntries
         );
-        const signal = AbortSignal.timeout(15e3);
-        const response = await provider.complete(
-          {
-            model: _model,
-            system: [{ type: "text", text: prompt }],
-            messages: [
-              { role: "user", content: "Review the session and return memory operations as JSON." }
-            ],
-            maxTokens: 500
-          },
-          { signal }
-        );
-        const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+        let text;
+        if (this.oneShotOrchestrator) {
+          const oneShotResult = await this.oneShotOrchestrator.call({
+            system: prompt,
+            userPrompt: "Review the session and return memory operations as JSON.",
+            model: _model ?? "deepseek-chat",
+            maxTokens: 500,
+            timeoutMs: 15e3,
+            fallbackProfile: "memory"
+          });
+          text = oneShotResult.text;
+        } else {
+          const signal = AbortSignal.timeout(15e3);
+          const response = await provider.complete(
+            {
+              model: _model,
+              system: [{ type: "text", text: prompt }],
+              messages: [
+                { role: "user", content: "Review the session and return memory operations as JSON." }
+              ],
+              maxTokens: 500
+            },
+            { signal }
+          );
+          text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+        }
         if (!text) return;
         const jsonMatch = text.match(/\{[\s\S]*\}/);
         if (!jsonMatch) return;
@@ -5209,7 +4716,7 @@ function deepFreeze(obj) {
 
 // src/storage/provider-config-watcher.ts
 import * as syncFs from "node:fs";
-import * as fs4 from "node:fs/promises";
+import * as fs5 from "node:fs/promises";
 import * as path12 from "node:path";
 
 // src/security/config-secrets.ts
@@ -5244,7 +4751,7 @@ function walk(node, vault, transform) {
   }
   return out;
 }
-var SECRET_KEY_PATTERN = /(?:apikey|api_key|authtoken|auth_token|bearer|secret|password|passwd|pwd|refreshtoken|refresh_token|sessionkey|session_key|access[_-]?token|private[_-]?key)/i;
+var SECRET_KEY_PATTERN = /(?:apikey|api_key|authtoken|auth_token|bearer|secret|password|passwd|pwd|refreshtoken|refresh_token|sessionkey|session_key|access[_-]?token|private[_-]?key|token\b)/i;
 var NON_SECRET_OVERRIDES = /* @__PURE__ */ new Set(["publickey", "public_key"]);
 function isSecretField(name) {
   const lc = name.toLowerCase();
@@ -5256,7 +4763,7 @@ function isSecretField(name) {
 async function readProviderSnapshot(configPath, vault, warn) {
   let raw;
   try {
-    raw = await fs4.readFile(configPath, "utf8");
+    raw = await fs5.readFile(configPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       warn?.(`Could not read ${configPath}: ${err.message}`);
@@ -5345,24 +4852,24 @@ function watchProviderConfig(configPath, vault, onChange, opts = {}) {
 }
 
 // src/storage/config-loader.ts
-import * as fs5 from "node:fs/promises";
+import * as fs6 from "node:fs/promises";
 import * as path13 from "node:path";
 
 // src/types/config.ts
 var DEFAULT_TUI_THINKING_WORD = "thinking";
 
 // src/types/context-window.ts
-var DEFAULT_CONTEXT_WINDOW_MODE_ID = "balanced";
+var DEFAULT_CONTEXT_WINDOW_MODE_ID = "frugal";
 var CONTEXT_WINDOW_MODES = Object.freeze([
   {
     id: "balanced",
     name: "Balanced",
     description: "Default rolling compaction: recent work stays verbatim, old tool output is trimmed.",
-    thresholds: { warn: 0.6, soft: 0.75, hard: 0.9 },
+    thresholds: { warn: 0.5, soft: 0.65, hard: 0.8 },
     aggressiveOn: "soft",
-    preserveK: 10,
-    eliseThreshold: 2e3,
-    targetLoad: 0.65
+    preserveK: 8,
+    eliseThreshold: 1e3,
+    targetLoad: 0.55
   },
   {
     id: "frugal",
@@ -5413,7 +4920,7 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   descriptionMode: Object.freeze({}),
   disabledTools: Object.freeze([]),
   autoExtendLimit: true,
-  restrictToProjectRoot: false,
+  restrictToProjectRoot: true,
   loopDetection: Object.freeze({
     mode: "steer-then-cut",
     steerThreshold: 3,
@@ -5423,8 +4930,8 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   })
 });
 var DEFAULT_CONTEXT_CONFIG = Object.freeze({
-  preserveK: 10,
-  eliseThreshold: 2e3
+  preserveK: 8,
+  eliseThreshold: 1e3
 });
 var DEFAULT_AUTONOMY_CONFIG = Object.freeze({
   autoProceedDelayMs: 45e3
@@ -5516,12 +5023,11 @@ var BEHAVIOR_DEFAULTS = {
   mcpServers: {},
   fallbackAuto: true,
   maxConcurrent: 4,
-  // YOLO on by default: auto-approve non-denied tool calls without a per-call
-  // prompt. Users
-  // who want the per-call prompts set `yolo: false`. Existing installs whose
-  // config lacks this key pick it up via fillMissingDefaults; an explicit
-  // `false` is preserved by the deep-merge (opt-out respected).
-  yolo: true,
+  // YOLO opt-in: users who want auto-approve behaviour set `yolo: true`.
+  // Off by default so prompt injection in repository content, fetched
+  // content, or mailbox messages cannot induce arbitrary shell calls or
+  // write operations without human confirmation.
+  yolo: false,
   nextPrediction: false,
   hints: true,
   debugStream: false,
@@ -5546,7 +5052,7 @@ var BEHAVIOR_DEFAULTS = {
     terminalTitleAnimation: true,
     // Mirrored from the top-level yolo default so the autonomy subsystem
     // (which reads autonomy.yolo) stays consistent with config.yolo.
-    yolo: true,
+    yolo: false,
     streamFleet: true,
     chime: false,
     confirmExit: true,
@@ -5998,7 +5504,7 @@ var DefaultConfigLoader = class {
       await withFileLock(fp, async () => {
         let parsed;
         try {
-          const raw = await fs5.readFile(fp, "utf8");
+          const raw = await fs6.readFile(fp, "utf8");
           const result = safeParse(raw);
           if (!result.ok || !isPlainRecord(result.value)) {
             return;
@@ -6107,7 +5613,7 @@ var DefaultConfigLoader = class {
     const fp = this.paths.syncConfig;
     const t0 = Date.now();
     try {
-      const raw = await fs5.readFile(fp, "utf8");
+      const raw = await fs6.readFile(fp, "utf8");
       const parsed = safeParse(raw);
       if (!parsed.ok || !parsed.value) {
         this.events?.emit("storage.read", {
@@ -6169,7 +5675,7 @@ var DefaultConfigLoader = class {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat13 = await fs5.stat(file);
+      const stat13 = await fs6.stat(file);
       mtimeMs = stat13.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
@@ -6198,7 +5704,7 @@ var DefaultConfigLoader = class {
     }
     let raw;
     try {
-      raw = await fs5.readFile(file, "utf8");
+      raw = await fs6.readFile(file, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         this.events?.emit("storage.read", {
@@ -6500,7 +6006,7 @@ function defaultIsPidAlive(pid) {
 }
 
 // src/storage/session-reader.ts
-import * as fs6 from "node:fs/promises";
+import * as fs7 from "node:fs/promises";
 var DefaultSessionReader = class _DefaultSessionReader {
   store;
   eventCache = /* @__PURE__ */ new Map();
@@ -6518,7 +6024,7 @@ var DefaultSessionReader = class _DefaultSessionReader {
     const sessionPath = sessionScopedPath(rootDir, sessionId, ".jsonl");
     let mtimeMs = null;
     try {
-      const stat13 = await fs6.stat(sessionPath);
+      const stat13 = await fs7.stat(sessionPath);
       mtimeMs = stat13.mtimeMs;
     } catch {
       this.eventCache.delete(sessionId);
@@ -6882,7 +6388,7 @@ function renderPlainText(meta, events) {
 
 // src/storage/annotations-store.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import * as fs7 from "node:fs/promises";
+import * as fs8 from "node:fs/promises";
 var FILE_VERSION = 1;
 var MAX_TEXT_LENGTH = 2e3;
 var MAX_ANNOTATIONS = 1e3;
@@ -7109,7 +6615,7 @@ var AnnotationsStore = class {
     const fp = this.filePath(sessionId);
     let raw;
     try {
-      raw = await fs7.readFile(fp, "utf8");
+      raw = await fs8.readFile(fp, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -7146,7 +6652,7 @@ var AnnotationsStore = class {
 };
 
 // src/storage/replay-log-store.ts
-import * as fs8 from "node:fs/promises";
+import * as fs9 from "node:fs/promises";
 import * as path15 from "node:path";
 
 // src/replay/hash.ts
@@ -7236,12 +6742,12 @@ var ReplayLogStore = class {
             const line = JSON.stringify(entry) + "\n";
             let offset2 = 0;
             try {
-              const stat13 = await fs8.stat(fp);
+              const stat13 = await fs9.stat(fp);
               offset2 = stat13.size;
             } catch (err) {
               if (err.code !== "ENOENT") throw err;
             }
-            await fs8.appendFile(fp, line, "utf8");
+            await fs9.appendFile(fp, line, "utf8");
             cache.set(hash, { entry, offset: offset2, length: Buffer.byteLength(line, "utf8") });
             this.diskCount.set(input.sessionId, currentCount + 1);
             this.events?.emit("storage.write", {
@@ -7369,7 +6875,7 @@ var ReplayLogStore = class {
     const scan = async (dir, prefix, depth) => {
       let entries;
       try {
-        entries = await fs8.readdir(dir, { withFileTypes: true });
+        entries = await fs9.readdir(dir, { withFileTypes: true });
       } catch (err) {
         if (depth === 0 && err.code !== "ENOENT") {
           console.warn(JSON.stringify({
@@ -7407,7 +6913,7 @@ var ReplayLogStore = class {
     return sessionScopedPath(this.dir, sessionId, ".replay.jsonl");
   }
   async countEntries(filePath) {
-    const handle = await fs8.open(filePath, "r");
+    const handle = await fs9.open(filePath, "r");
     const buffer = Buffer.allocUnsafe(64 * 1024);
     let count = 0;
     let hasNonWhitespace2 = false;
@@ -7448,7 +6954,7 @@ var ReplayLogStore = class {
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
-      const raw = await fs8.readFile(fp, "utf8");
+      const raw = await fs9.readFile(fp, "utf8");
       const out = [];
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
@@ -7484,7 +6990,7 @@ var ReplayLogStore = class {
     const fp = this.filePath(sessionId);
     cache = /* @__PURE__ */ new Map();
     try {
-      const handle = await fs8.open(fp, "r");
+      const handle = await fs9.open(fp, "r");
       const CHUNK = 64 * 1024;
       const buffer = Buffer.alloc(CHUNK);
       let leftover = "";
@@ -7535,7 +7041,7 @@ var ReplayLogStore = class {
   async hydrateEntry(sessionId, hash, location) {
     if (location.entry) return location.entry;
     const fp = this.filePath(sessionId);
-    const handle = await fs8.open(fp, "r");
+    const handle = await fs9.open(fp, "r");
     try {
       const buffer = Buffer.alloc(location.length);
       const { bytesRead } = await handle.read(buffer, 0, location.length, location.offset);
@@ -7562,7 +7068,7 @@ var ReplayLogStore = class {
 };
 
 // src/storage/session-recovery.ts
-import * as fs9 from "node:fs/promises";
+import * as fs10 from "node:fs/promises";
 import * as path16 from "node:path";
 var SessionRecovery = class {
   constructor(dir) {
@@ -7589,7 +7095,7 @@ var SessionRecovery = class {
     const fp = this.filePath(sessionId);
     let stat13;
     try {
-      stat13 = await fs9.stat(fp);
+      stat13 = await fs10.stat(fp);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
@@ -7623,7 +7129,7 @@ var SessionRecovery = class {
     const fp = this.filePath(sessionId);
     let raw;
     try {
-      raw = await fs9.readFile(fp, "utf8");
+      raw = await fs10.readFile(fp, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
@@ -7668,7 +7174,7 @@ var SessionRecovery = class {
     const collect = async (dir, prefix, depth) => {
       let entries;
       try {
-        entries = await fs9.readdir(dir, { withFileTypes: true });
+        entries = await fs10.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -7719,7 +7225,7 @@ function hasNonWhitespace(line) {
 }
 async function scanLatestLifecycleBoundary(filePath, size) {
   const CHUNK_SIZE = 64 * 1024;
-  const handle = await fs9.open(filePath, "r");
+  const handle = await fs10.open(filePath, "r");
   let position = size;
   let laterLineFragment = Buffer.alloc(0);
   let latestBoundary = null;
@@ -7758,7 +7264,7 @@ async function scanLatestLifecycleBoundary(filePath, size) {
 
 // src/storage/tool-audit-log.ts
 import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
-import * as fs10 from "node:fs/promises";
+import * as fs11 from "node:fs/promises";
 var GENESIS_PREV = "0".repeat(64);
 var DEFAULT_FSYNC_EVERY = 100;
 var ToolAuditLog = class {
@@ -7828,9 +7334,9 @@ var ToolAuditLog = class {
             isError: input.isError,
             index
           };
-          await fs10.appendFile(fp, JSON.stringify(entry) + "\n", "utf8");
+          await fs11.appendFile(fp, JSON.stringify(entry) + "\n", "utf8");
           try {
-            const st = await fs10.stat(fp);
+            const st = await fs11.stat(fp);
             this.tailStat.set(input.sessionId, { mtimeMs: st.mtimeMs, size: st.size });
           } catch {
           }
@@ -7877,7 +7383,7 @@ var ToolAuditLog = class {
     const cachedStat = this.tailStat.get(sessionId);
     if (cachedHash !== void 0 && cachedIndex !== void 0 && cachedStat) {
       try {
-        const st = await fs10.stat(fp);
+        const st = await fs11.stat(fp);
         if (st.mtimeMs === cachedStat.mtimeMs && st.size === cachedStat.size) {
           return { prevHash: cachedHash, nextIndex: cachedIndex };
         }
@@ -7898,7 +7404,7 @@ var ToolAuditLog = class {
     this.tailHash.set(sessionId, prevHash);
     this.tailIndex.set(sessionId, nextIndex);
     try {
-      const st = await fs10.stat(fp);
+      const st = await fs11.stat(fp);
       this.tailStat.set(sessionId, { mtimeMs: st.mtimeMs, size: st.size });
     } catch {
     }
@@ -8019,7 +7525,7 @@ var ToolAuditLog = class {
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
-      const raw = await fs10.readFile(fp, "utf8");
+      const raw = await fs11.readFile(fp, "utf8");
       const out = [];
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
@@ -8057,7 +7563,7 @@ var ToolAuditLog = class {
   }
   async sync(sessionId, fp) {
     try {
-      const fh = await fs10.open(fp, "r+");
+      const fh = await fs11.open(fp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -8195,7 +7701,7 @@ var SessionAnalyzer = class {
 };
 
 // src/session-registry.ts
-import * as fs11 from "node:fs/promises";
+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";
@@ -8392,7 +7898,7 @@ var SessionRegistry = class {
   }
   async readAndPrune() {
     try {
-      const raw = await fs11.readFile(this.filePath, "utf8");
+      const raw = await fs12.readFile(this.filePath, "utf8");
       const registry = parseRegistry(raw);
       const now = Date.now();
       let pruned = false;
@@ -8445,11 +7951,11 @@ var SessionRegistry = class {
     const retryDelayMs = 20;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       try {
-        await fs11.mkdir(path17.dirname(this.filePath), { recursive: true });
-        let lockHandle = await fs11.open(lockPath, "wx").catch(() => null);
+        await fs12.mkdir(path17.dirname(this.filePath), { recursive: true });
+        let lockHandle = await fs12.open(lockPath, "wx").catch(() => null);
         if (!lockHandle) {
           if (await this.breakStaleLock(lockPath)) {
-            lockHandle = await fs11.open(lockPath, "wx").catch(() => null);
+            lockHandle = await fs12.open(lockPath, "wx").catch(() => null);
           }
           if (!lockHandle) {
             await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
@@ -8458,14 +7964,14 @@ var SessionRegistry = class {
         }
         try {
           await lockHandle.writeFile(String(process.pid)).catch(() => void 0);
-          const raw = await fs11.readFile(this.filePath, "utf8").catch(() => "{}");
+          const raw = await fs12.readFile(this.filePath, "utf8").catch(() => "{}");
           const registry = parseRegistry(raw);
           fn(registry);
           await this.writeAtomicLocked(registry);
           return;
         } finally {
           await lockHandle.close();
-          await fs11.unlink(lockPath).catch(() => void 0);
+          await fs12.unlink(lockPath).catch(() => void 0);
         }
       } catch {
         return;
@@ -8482,16 +7988,16 @@ var SessionRegistry = class {
   async breakStaleLock(lockPath) {
     try {
       const [stat13, content] = await Promise.all([
-        fs11.stat(lockPath),
+        fs12.stat(lockPath),
         /* v8 ignore start -- best-effort lock-content read; .catch only fires if the lock vanished */
-        fs11.readFile(lockPath, "utf8").catch(() => "")
+        fs12.readFile(lockPath, "utf8").catch(() => "")
         /* v8 ignore stop */
       ]);
       const ageMs = Date.now() - stat13.mtimeMs;
       const ownerPid = Number.parseInt(content.trim(), 10);
       const ownerDead = Number.isInteger(ownerPid) && ownerPid > 0 && ownerPid !== process.pid && !pidAlive(ownerPid);
       if (ownerDead || ageMs > STALE_LOCK_MS) {
-        await fs11.unlink(lockPath).catch(() => void 0);
+        await fs12.unlink(lockPath).catch(() => void 0);
         return true;
       }
       return false;
@@ -8514,16 +8020,16 @@ var SessionRegistry = class {
       `.${path17.basename(this.filePath)}.${randomUUID5().slice(0, 8)}.tmp`
     );
     try {
-      const handle = await fs11.open(tmp, "w");
+      const handle = await fs12.open(tmp, "w");
       try {
         await handle.writeFile(JSON.stringify(registry, null, 2), "utf8");
         await handle.sync().catch(() => void 0);
       } finally {
         await handle.close();
       }
-      await fs11.rename(tmp, this.filePath);
+      await fs12.rename(tmp, this.filePath);
     } catch (err) {
-      await fs11.unlink(tmp).catch(() => void 0);
+      await fs12.unlink(tmp).catch(() => void 0);
       throw err;
     }
   }
@@ -8533,17 +8039,17 @@ var SessionRegistry = class {
       const base = path17.basename(this.filePath);
       const now = Date.now();
       const stale = [];
-      for (const name of await fs11.readdir(dir)) {
+      for (const name of await fs12.readdir(dir)) {
         const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
         if (!isTemp) continue;
-        const stat13 = await fs11.stat(path17.join(dir, name)).catch(() => null);
+        const stat13 = await fs12.stat(path17.join(dir, name)).catch(() => null);
         if (!stat13) continue;
         if (now - stat13.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat13.mtimeMs });
       }
       stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
       await Promise.all(
         stale.slice(MAX_STALE_TMP_FILES).map(async ({ name }) => {
-          await fs11.unlink(path17.join(dir, name)).catch(() => void 0);
+          await fs12.unlink(path17.join(dir, name)).catch(() => void 0);
         })
       );
     } catch {
@@ -8959,7 +8465,7 @@ var AgentStatusTracker = class {
 };
 
 // src/fleet-notifier.ts
-import * as fs12 from "node:fs/promises";
+import * as fs13 from "node:fs/promises";
 import * as path18 from "node:path";
 var INSTANCES_FILE = "webui-instances.json";
 var DISCOVERY_TTL_MS = 2500;
@@ -9022,7 +8528,7 @@ var FleetNotifier = class {
   }
   async discover() {
     try {
-      const raw = await fs12.readFile(path18.join(this.baseDir, INSTANCES_FILE), "utf8");
+      const raw = await fs13.readFile(path18.join(this.baseDir, INSTANCES_FILE), "utf8");
       const data = JSON.parse(raw);
       const list = Array.isArray(data?.instances) ? data.instances : [];
       return list.filter((i) => i && typeof i.httpPort === "number").filter((i) => i.pid !== this.selfPid).filter((i) => normRoot(i.projectRoot) === this.projectRoot).filter((i) => pidAlive2(i.pid)).map((i) => {
@@ -10327,9 +9833,204 @@ function computeTrend(history) {
   return "steady";
 }
 
+// src/storage/goal-kanban.ts
+import {
+  addColumn,
+  addTask,
+  createBoard,
+  getBoard,
+  listBoards,
+  removeBoard
+} from "@wrongstack/kanban";
+var GOAL_BOARD_TAG_PREFIX = "goal:";
+var DEFAULT_COLUMNS = [
+  { title: "Backlog", order: 0 },
+  { title: "In Progress", order: 1 },
+  { title: "Done", order: 2 }
+];
+async function createGoalKanbanBoard(projectRoot, goalFile) {
+  if (!projectRoot) return null;
+  const existingId = goalFile.kanbanBoardId;
+  if (existingId) {
+    const existing = await getBoard(projectRoot, existingId).catch(() => null);
+    if (existing) return existingId;
+  }
+  const displayGoal = (goalFile.refinedGoal || goalFile.goal).replace(/\s+/g, " ").trim();
+  const titleSuffix = displayGoal.length > 80 ? displayGoal.slice(0, 77) + "\u2026" : displayGoal;
+  const board = await createBoard(projectRoot, {
+    title: `\u{1F3AF} ${titleSuffix}`,
+    description: `Kanban board auto-created for goal: ${displayGoal}`,
+    tags: [goalTag(goalFile)]
+  });
+  const backlogCol = board.columns.find(
+    (c) => ["backlog", "todo", "open"].includes(c.id.toLowerCase())
+  );
+  const existingColumnIds = new Set(board.columns.map((c) => c.id));
+  for (const col of DEFAULT_COLUMNS) {
+    if (!existingColumnIds.has(col.title.toLowerCase().replace(/\s+/g, "-"))) {
+      const result = await addColumn(projectRoot, board.id, { title: col.title });
+      if (result?.column && backlogCol) {
+      }
+    }
+  }
+  const targetColumnId = board.columns[0]?.id ?? "backlog";
+  if (goalFile.deliverables && goalFile.deliverables.length > 0) {
+    for (const d of goalFile.deliverables) {
+      const cleaned = d.replace(/^\[[x✓]\]|✅|\(done\)\s*/i, "").trim();
+      if (cleaned) {
+        await addTask(projectRoot, board.id, {
+          title: cleaned,
+          columnId: targetColumnId,
+          description: `Deliverable for goal: ${displayGoal}`,
+          priority: "medium"
+        }).catch(() => {
+        });
+      }
+    }
+  }
+  goalFile.kanbanBoardId = board.id;
+  return board.id;
+}
+async function findGoalKanbanBoard(projectRoot, boardId) {
+  if (!projectRoot || !boardId) return null;
+  try {
+    return await getBoard(projectRoot, boardId);
+  } catch {
+    return null;
+  }
+}
+async function deleteGoalKanbanBoard(projectRoot, boardId) {
+  if (!projectRoot || !boardId) return;
+  await removeBoard(projectRoot, boardId).catch(() => {
+  });
+}
+async function findGoalBoardByTag(projectRoot, goalFile) {
+  if (!projectRoot) return null;
+  const tag = goalTag(goalFile);
+  const boards = await listBoards(projectRoot);
+  const matched = boards.find((b) => b.tags?.includes(tag));
+  if (!matched) return null;
+  return getBoard(projectRoot, matched.id).catch(() => null);
+}
+function formatGoalKanbanPreview(goalFile, boardId, taskCount) {
+  const lines = [];
+  const displayGoal = (goalFile.refinedGoal || goalFile.goal).replace(/\s+/g, " ").trim();
+  lines.push("");
+  lines.push(color.bold(color.cyan("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550")));
+  lines.push(color.bold(color.cyan("  \u{1F3AF} GOAL KANBAN \u2014 Mission Board")));
+  lines.push(color.bold(color.cyan("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550")));
+  lines.push("");
+  lines.push(`  ${color.bold("Mission:")} ${color.bold(displayGoal)}`);
+  if (boardId) {
+    lines.push(`  ${color.dim(`Board: ${boardId.slice(0, 12)}\u2026`)}`);
+  }
+  if (typeof taskCount === "number") {
+    lines.push(`  ${color.dim(`${taskCount} task(s)`)}`);
+  }
+  lines.push("");
+  const deliverables = goalFile.deliverables ?? [];
+  const doneDeliverables = deliverables.filter(
+    (d) => /^\[[x✓]\]|✅|\(done\)/i.test(d)
+  ).length;
+  const totalDeliverables = deliverables.length;
+  if (totalDeliverables > 0) {
+    const backlog = deliverables.filter(
+      (d) => !/^\[[x✓]\]|✅|\(done\)|🔄|in.progress/i.test(d)
+    );
+    const inProgress = deliverables.filter((d) => /🔄|in.progress/i.test(d));
+    const done = deliverables.filter((d) => /^\[[x✓]\]|✅|\(done\)/i.test(d));
+    const renderColumn = (title, items, icon, accent) => {
+      if (items.length === 0) {
+        lines.push(`  ${accent(color.bold(`${icon} ${title}`))}  ${color.dim("(empty)")}`);
+        return;
+      }
+      lines.push(`  ${accent(color.bold(`${icon} ${title} (${items.length})`))}`);
+      for (const item of items) {
+        const cleaned = item.replace(/^\[[x✓]\]|✅|\(done\)|🔄|in.progress\s*/gi, "").trim();
+        lines.push(`    \u25CB ${cleaned}`);
+      }
+    };
+    renderColumn("Backlog", backlog, "\u{1F4CB}", (s) => color.dim(s));
+    renderColumn("In Progress", inProgress, "\u{1F504}", (s) => color.cyan(s));
+    renderColumn("Done", done, "\u2705", (s) => color.green(s));
+    lines.push("");
+    lines.push(
+      `  ${color.dim(`Progress: ${doneDeliverables}/${totalDeliverables} deliverables complete`)}`
+    );
+  }
+  if (typeof goalFile.progress === "number") {
+    const pct = Math.min(100, Math.max(0, Math.round(goalFile.progress)));
+    const filled = Math.round(pct / 5);
+    const empty = 20 - filled;
+    const bar = color.green("\u2588".repeat(filled)) + color.dim("\u2591".repeat(empty));
+    lines.push(`  ${color.dim("Overall:")} ${bar} ${color.bold(`${pct}%`)}`);
+    if (goalFile.progressNote) {
+      lines.push(`  ${color.dim(goalFile.progressNote)}`);
+    }
+  }
+  if (typeof goalFile.progress === "undefined" && totalDeliverables > 0) {
+    const pct = Math.round(doneDeliverables / totalDeliverables * 100);
+    const filled = Math.round(pct / 5);
+    const empty = 20 - filled;
+    const bar = (pct > 0 ? color.green("\u2588".repeat(filled)) : "") + color.dim("\u2591".repeat(empty));
+    lines.push(`  ${color.dim("Overall:")} ${bar} ${color.bold(`${pct}%`)}`);
+  }
+  lines.push("");
+  lines.push(color.bold(color.cyan("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550")));
+  return lines.join("\n");
+}
+function formatGoalEvent(goalFile, boardId) {
+  const lines = [];
+  lines.push("");
+  lines.push(color.bold(color.green("\u250C\u2500\u2500\u2500 Goal Event \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510")));
+  lines.push(color.bold(color.green("\u2502")) + "  \u{1F3AF} Mission locked and ready");
+  if (boardId) {
+    lines.push(
+      color.bold(color.green("\u2502")) + `  \u{1F4CB} Kanban board created: ${color.cyan(boardId.slice(0, 12) + "\u2026")}`
+    );
+  }
+  const deliverables = goalFile.deliverables ?? [];
+  lines.push(
+    color.bold(color.green("\u2502")) + `  \u{1F4E6} ${deliverables.length} deliverable${deliverables.length !== 1 ? "s" : ""} extracted`
+  );
+  if (typeof goalFile.progress === "number") {
+    lines.push(
+      color.bold(color.green("\u2502")) + `  \u{1F4CA} Progress: ${goalFile.progress}%`
+    );
+  }
+  lines.push(color.bold(color.green("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518")));
+  return lines.join("\n");
+}
+function formatGoalAutonomyChoice() {
+  const lines = [];
+  lines.push("");
+  lines.push(color.bold(color.magenta("\u2550\u2550\u2550 Choose Autonomy Mode \u2550\u2550\u2550")));
+  lines.push("");
+  lines.push(
+    `  ${color.bold("1")}. ${color.red("Autonomy Eternal")}  ${color.dim("\u2014 Single-agent sense/decide/execute/reflect loop")}`
+  );
+  lines.push(
+    `  ${color.bold("2")}. ${color.magenta("Eternal Parallel")}  ${color.dim("\u2014 Multi-agent fan-out (4-8 subagents per tick)")}`
+  );
+  lines.push("");
+  lines.push(`  ${color.dim("Enter 1 or 2 (or press Enter to skip):")}`);
+  return lines.join("\n");
+}
+function parseAutonomyChoice(input) {
+  const trimmed = input.trim().toLowerCase();
+  if (trimmed === "1" || trimmed === "eternal" || trimmed === "e") return "eternal";
+  if (trimmed === "2" || trimmed === "parallel" || trimmed === "p") return "eternal-parallel";
+  if (trimmed === "" || trimmed === "skip" || trimmed === "s" || trimmed === "0") return null;
+  return null;
+}
+function goalTag(goalFile) {
+  const goal = (goalFile.refinedGoal || goalFile.goal).replace(/\s+/g, "-").slice(0, 24).toLowerCase();
+  return `${GOAL_BOARD_TAG_PREFIX}${goal}`;
+}
+
 // src/storage/prompt-store.ts
 import { createHash as createHash7 } from "node:crypto";
-import * as fs13 from "node:fs/promises";
+import * as fs14 from "node:fs/promises";
 import * as path20 from "node:path";
 var SCHEMA_VERSION = 2;
 function promptChecksum(content) {
@@ -10394,12 +10095,12 @@ var DefaultPromptStore = class {
     await ensureDir(this.dir);
     const entries = [];
     try {
-      const files = await fs13.readdir(this.dir);
+      const files = await fs14.readdir(this.dir);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fs13.readFile(path20.join(this.dir, file), "utf8")
+            await fs14.readFile(path20.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -10415,7 +10116,7 @@ var DefaultPromptStore = class {
   async get(id) {
     const file = path20.join(this.dir, `${id}.json`);
     try {
-      const raw = JSON.parse(await fs13.readFile(file, "utf8"));
+      const raw = JSON.parse(await fs14.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
     } catch {
       return null;
@@ -10430,7 +10131,7 @@ var DefaultPromptStore = class {
   async delete(id) {
     const file = path20.join(this.dir, `${id}.json`);
     try {
-      await fs13.unlink(file);
+      await fs14.unlink(file);
       return true;
     } catch {
       return false;
@@ -10469,7 +10170,7 @@ var DefaultPromptStore = class {
 };
 
 // src/storage/prompt-usage-store.ts
-import * as fs14 from "node:fs/promises";
+import * as fs15 from "node:fs/promises";
 import * as path21 from "node:path";
 var PromptUsageStore = class {
   constructor(file) {
@@ -10478,7 +10179,7 @@ var PromptUsageStore = class {
   file;
   async load() {
     try {
-      const raw = JSON.parse(await fs14.readFile(this.file, "utf8"));
+      const raw = JSON.parse(await fs15.readFile(this.file, "utf8"));
       if (raw && typeof raw === "object" && raw.usage && typeof raw.usage === "object") {
         return raw.usage;
       }
@@ -10515,7 +10216,7 @@ var PromptUsageStore = class {
 };
 
 // src/storage/input-history-store.ts
-import * as fs15 from "node:fs/promises";
+import * as fs16 from "node:fs/promises";
 import * as path22 from "node:path";
 var INPUT_HISTORY_DEFAULT_MAX = 100;
 var InputHistoryStore = class {
@@ -10538,7 +10239,7 @@ var InputHistoryStore = class {
    */
   async load() {
     try {
-      const raw = JSON.parse(await fs15.readFile(this.file, "utf8"));
+      const raw = JSON.parse(await fs16.readFile(this.file, "utf8"));
       if (raw && typeof raw === "object" && Array.isArray(raw.entries) && raw.entries.every((e) => typeof e === "string")) {
         return raw.entries.slice(0, this.maxEntries);
       }
@@ -10595,7 +10296,7 @@ var InputHistoryStore = class {
 };
 
 // src/storage/cloud-sync.ts
-import * as fs16 from "node:fs/promises";
+import * as fs17 from "node:fs/promises";
 import * as path23 from "node:path";
 import { createHash as createHash8 } from "node:crypto";
 var ALL_SYNC_CATEGORIES = ["settings", "skills", "prompts", "memory", "history"];
@@ -10679,7 +10380,7 @@ var CloudSync = class {
       lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
       localRev: rev
     };
-    await fs16.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    await fs17.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
     this.state = syncState;
     return {
       ok: true,
@@ -10711,8 +10412,8 @@ var CloudSync = class {
       const rel = segments.slice(2).join("/");
       const destPath = resolvePulledCategoryPath(cat, localPath, rel, entry.path);
       const blobData = await this.getBlob(token, owner, repoName, entry.sha);
-      await fs16.mkdir(path23.dirname(destPath), { recursive: true });
-      await fs16.writeFile(destPath, Buffer.from(blobData, "base64"));
+      await fs17.mkdir(path23.dirname(destPath), { recursive: true });
+      await fs17.writeFile(destPath, Buffer.from(blobData, "base64"));
     }
     const localRev = await this.hashLocalCategories(cfg.categories);
     const syncState = {
@@ -10721,7 +10422,7 @@ var CloudSync = class {
       lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
       localRev
     };
-    await fs16.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    await fs17.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
     this.state = syncState;
     return {
       ok: true,
@@ -10740,7 +10441,7 @@ var CloudSync = class {
   }
   async loadState() {
     try {
-      const raw = await fs16.readFile(this.statePath, "utf8");
+      const raw = await fs17.readFile(this.statePath, "utf8");
       this.state = JSON.parse(raw);
     } catch {
       this.state = null;
@@ -10818,17 +10519,17 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat13 = await fs16.stat(localPath);
+        const stat13 = await fs17.stat(localPath);
         if (stat13.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fs16.readFile(file, "utf8");
+            const content = await fs17.readFile(file, "utf8");
             const rel = path23.relative(localPath, file).replace(/\\/g, "/");
             entries.push({ path: `data/${cat}/${rel}`, content, mode: "100644" });
             hashes.push(content);
           }
         } else {
-          const content = await fs16.readFile(localPath, "utf8");
+          const content = await fs17.readFile(localPath, "utf8");
           entries.push({ path: `data/${cat}`, content, mode: "100644" });
           hashes.push(content);
         }
@@ -10844,15 +10545,15 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat13 = await fs16.stat(localPath);
+        const stat13 = await fs17.stat(localPath);
         if (stat13.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fs16.readFile(file);
+            const content = await fs17.readFile(file);
             hashes.push(content.toString("base64") + file);
           }
         } else {
-          const content = await fs16.readFile(localPath);
+          const content = await fs17.readFile(localPath);
           hashes.push(content.toString("base64") + localPath);
         }
       } catch {
@@ -10879,7 +10580,7 @@ var CloudSync = class {
   }
   async walkDir(dir, base) {
     const results = [];
-    const entries = await fs16.readdir(dir, { withFileTypes: true });
+    const entries = await fs17.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const full = path23.join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -11066,7 +10767,6 @@ export {
   DefaultAttachmentStore,
   DefaultConfigLoader,
   DefaultConfigStore,
-  DefaultMemoryStore,
   DefaultPromptStore,
   DefaultSessionReader,
   DefaultSessionRewinder,
@@ -11095,12 +10795,19 @@ export {
   attachPlanCheckpoint,
   attachTodosCheckpoint,
   clearPlan,
+  createGoalKanbanBoard,
   createSessionEventBridge,
+  deleteGoalKanbanBoard,
   deriveTodosFromPlanItem,
   emptyGoal,
   emptyPlan,
   emptyTaskFile,
+  findGoalBoardByTag,
+  findGoalKanbanBoard,
   formatGoal,
+  formatGoalAutonomyChoice,
+  formatGoalEvent,
+  formatGoalKanbanPreview,
   formatPlan,
   formatPlanTemplates,
   generateSessionId,
@@ -11118,6 +10825,7 @@ export {
   migratePromptEntry,
   mutatePlan,
   mutateTasks,
+  parseAutonomyChoice,
   parseEntries,
   parseProgressFromText,
   promptChecksum,