@cjhyy/code-shell-core 0.5.0-rc.2 → 0.6.0-rc.1

package/dist/session/memory.js

@@ -22,13 +22,32 @@
 import { mkdirSync, existsSync, readFileSync, writeFileSync, readdirSync, renameSync, statSync, } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+/**
+ * Drop memories older than `maxAgeDays` (by file mtime) for context injection
+ * (TODO 8.1). A non-positive/undefined maxAge means no filtering. Entries with
+ * an unknown mtime (updatedAt 0/undefined) are KEPT — we never hide a memory
+ * just because we couldn't read its timestamp. Pure + testable.
+ */
+export function filterByAge(entries, maxAgeDays, now = Date.now()) {
+    if (!maxAgeDays || maxAgeDays <= 0)
+        return entries;
+    const cutoff = now - maxAgeDays * 24 * 60 * 60 * 1000;
+    // Pinned memories never age out of injection — that's the point of the pin.
+    return entries.filter((e) => e.pinned || !e.updatedAt || e.updatedAt >= cutoff);
+}
 export function resolveMemoryBaseDir(override) {
     if (override)
         return override;
     const fromEnv = process.env.CODE_SHELL_HOME;
     if (fromEnv && fromEnv.length > 0)
         return fromEnv;
-    return join(homedir(), ".code-shell");
+    // `process.env.HOME ?? homedir()` (NOT raw homedir()): bun caches homedir()
+    // at process start and never re-reads it, so a test's HOME override — and any
+    // code that relies on $HOME — would be ignored, and memory would read the
+    // REAL ~/.code-shell (leaking global memories into isolated tests). See the
+    // homedir()-cache trap; mirrors settings/manager.ts userHome().
+    const home = process.env.HOME ?? homedir();
+    return join(home, ".code-shell");
 }
 export class MemoryManager {
     baseDir;
@@ -72,10 +91,29 @@ export class MemoryManager {
     save(entry) {
         const fileName = this.slugify(entry.name) + ".md";
         const filePath = join(this.memoryDir, fileName);
+        const nowIso = new Date().toISOString();
+        // Overwrite = UPDATE: preserve the original `created` and accumulated
+        // `usageCount` of the file being replaced (only `created` is load-bearing
+        // for TTL; carrying usageCount avoids resetting a popular memory's score).
+        // explicit entry fields win over the existing file (lets callers force a value).
+        const existing = existsSync(filePath) ? this.loadFile(fileName) : null;
+        const created = entry.created ?? existing?.created ?? nowIso;
+        const usageCount = entry.usageCount ?? existing?.usageCount ?? 0;
+        const lastUsed = entry.lastUsed ?? existing?.lastUsed ?? created;
+        const originProject = entry.originProject ?? existing?.originProject;
+        // pinned/origin are written only when meaningful so legacy-shaped files
+        // stay byte-identical for unpinned manual saves. Lifecycle fields are
+        // always written now (created/lastUsed/usageCount) — they're how TTL works.
         const content = `---\n` +
             `name: ${entry.name}\n` +
             `description: ${entry.description}\n` +
             `type: ${entry.type}\n` +
+            (entry.pinned ? `pinned: true\n` : "") +
+            (entry.origin ? `origin: ${entry.origin}\n` : "") +
+            (originProject ? `originProject: ${originProject}\n` : "") +
+            `created: ${created}\n` +
+            `lastUsed: ${lastUsed}\n` +
+            `usageCount: ${usageCount}\n` +
             `---\n\n` +
             `${entry.content}\n`;
         writeFileSync(filePath, content, "utf-8");
@@ -107,6 +145,17 @@ export class MemoryManager {
      */
     loadFile(fileName) {
         const filePath = join(this.memoryDir, fileName);
+        if (!existsSync(filePath))
+            return null;
+        return this.loadFileFromDir(this.memoryDir, fileName, this.scope);
+    }
+    /**
+     * Parse a memory file's frontmatter + body into a MemoryEntry. Shared by both
+     * loadFile (own scope) and loadScope (cross-scope) so the parsing of every
+     * field — including the lifecycle fields — lives in exactly one place.
+     * Returns null on missing file / unparseable frontmatter.
+     */
+    parseMemoryFile(filePath, fileName, scope) {
         if (!existsSync(filePath))
             return null;
         try {
@@ -119,7 +168,30 @@ export class MemoryManager {
             const name = frontmatter.match(/name:\s*(.+)/)?.[1]?.trim() ?? fileName;
             const description = frontmatter.match(/description:\s*(.+)/)?.[1]?.trim() ?? "";
             const type = (frontmatter.match(/type:\s*(.+)/)?.[1]?.trim() ?? "project");
-            return { name, description, type, content, fileName, scope: this.scope };
+            const pinned = frontmatter.match(/pinned:\s*(.+)/)?.[1]?.trim() === "true";
+            // Anchor with ^…/m so `origin:` doesn't accidentally match the
+            // `originProject:` line (and vice-versa).
+            const originRaw = frontmatter.match(/^origin:\s*(.+)/m)?.[1]?.trim();
+            const origin = originRaw === "auto" || originRaw === "manual" ? originRaw : undefined;
+            const originProject = frontmatter.match(/^originProject:\s*(.+)/m)?.[1]?.trim() || undefined;
+            let updatedAt = 0;
+            try {
+                updatedAt = statSync(filePath).mtimeMs;
+            }
+            catch {
+                // mtime best-effort; 0 = unknown (never filtered out by maxAge).
+            }
+            // Lifecycle fields. Legacy files lack them → fall back to mtime so a TTL
+            // sweep treats them as "last used = file age" rather than "never used".
+            const mtimeIso = updatedAt > 0 ? new Date(updatedAt).toISOString() : undefined;
+            const created = frontmatter.match(/created:\s*(.+)/)?.[1]?.trim() || mtimeIso;
+            const lastUsed = frontmatter.match(/lastUsed:\s*(.+)/)?.[1]?.trim() || created;
+            const usageRaw = frontmatter.match(/usageCount:\s*(\d+)/)?.[1];
+            const usageCount = usageRaw ? parseInt(usageRaw, 10) : 0;
+            return {
+                name, description, type, content, fileName, scope,
+                updatedAt, pinned, origin, usageCount, lastUsed, created, originProject,
+            };
         }
         catch {
             return null;
@@ -149,6 +221,129 @@ export class MemoryManager {
             return false;
         }
     }
+    /**
+     * Record a recall: a MemoryRead hit this entry. Bumps usageCount and sets
+     * lastUsed=now, rewriting only the frontmatter (content untouched). This is
+     * the signal that drives recall-based TTL — a memory that keeps getting read
+     * never ages out. Idempotent-safe: missing entry → false, no throw.
+     */
+    recordRecall(nameOrFile, now = new Date()) {
+        const entry = this.loadAll().find((e) => e.name === nameOrFile || e.fileName === nameOrFile);
+        if (!entry)
+            return false;
+        try {
+            this.save({
+                name: entry.name,
+                description: entry.description,
+                type: entry.type,
+                content: entry.content,
+                pinned: entry.pinned,
+                origin: entry.origin,
+                created: entry.created,
+                usageCount: (entry.usageCount ?? 0) + 1,
+                lastUsed: now.toISOString(),
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Recall-based TTL sweep. Soft-deletes `project`-type memories not read for
+     * more than `ttlDays` (by lastUsed). Stable types (user/feedback/reference)
+     * and pinned entries are NEVER pruned — only ephemeral project events age out.
+     * Returns the names pruned. ttlDays<=0 disables the sweep.
+     */
+    pruneByRecall(ttlDays, now = new Date()) {
+        if (!ttlDays || ttlDays <= 0)
+            return [];
+        const cutoff = now.getTime() - ttlDays * 24 * 60 * 60 * 1000;
+        const pruned = [];
+        for (const e of this.loadAll()) {
+            if (e.type !== "project")
+                continue; // stable types are exempt
+            if (e.pinned)
+                continue; // pinned exempt
+            const lastUsedMs = e.lastUsed ? new Date(e.lastUsed).getTime() : NaN;
+            // Unknown lastUsed (unparseable) → keep, never prune on missing data.
+            if (!Number.isFinite(lastUsedMs))
+                continue;
+            if (lastUsedMs < cutoff) {
+                if (this.delete(e.name))
+                    pruned.push(e.name);
+            }
+        }
+        return pruned;
+    }
+    /**
+     * Approve a pending memory: move it from the pending scope into the user scope
+     * of the SAME memory root (pending only ever exists at the global root — the
+     * approval门 only gates global writes). Must be called on a pending-scope
+     * manager. Returns the new user filename, or null if not found / wrong scope.
+     *
+     * 审批门 (用户拍板): the only path that moves an auto-extracted memory into the
+     * curated, injected global user store.
+     */
+    approvePending(nameOrFile) {
+        return this.movePending(nameOrFile, "global");
+    }
+    /**
+     * Demote a pending memory: 不批准升全局,但它仍是有用记忆 → 落回它来源项目的
+     * user store (originProject)。无 originProject 时落全局 user(兜底,不丢)。
+     */
+    demotePending(nameOrFile) {
+        return this.movePending(nameOrFile, "project");
+    }
+    /** Shared move for approve(→global user)/demote(→origin-project user). */
+    movePending(nameOrFile, dest) {
+        if (this.scope !== "pending")
+            return null;
+        const entry = this.loadAll().find((e) => e.name === nameOrFile || e.fileName === nameOrFile);
+        if (!entry)
+            return null;
+        const targetMgr = dest === "project" && entry.originProject
+            ? new MemoryManager({ baseDir: this.baseDir, projectDir: entry.originProject, scope: "user" })
+            : new MemoryManager({ baseDir: this.baseDir, scope: "user" }); // global, or fallback
+        const fileName = targetMgr.save({
+            name: entry.name,
+            description: entry.description,
+            type: entry.type,
+            content: entry.content,
+            origin: entry.origin ?? "auto",
+            created: entry.created,
+            lastUsed: entry.lastUsed,
+            usageCount: entry.usageCount,
+            // originProject is no longer needed once it has landed in a real store.
+        });
+        this.delete(entry.name); // soft-delete the pending copy
+        return fileName;
+    }
+    /**
+     * Promote a project-level user memory to the GLOBAL user store (用户手动点
+     * "提升到全局")。Must be called on a project-scoped user manager. Copies the
+     * entry into global user/ and soft-deletes the project copy. Returns the new
+     * global filename, or null if not found.
+     */
+    promoteToGlobal(nameOrFile) {
+        const entry = this.loadAll().find((e) => e.name === nameOrFile || e.fileName === nameOrFile);
+        if (!entry)
+            return null;
+        const globalMgr = new MemoryManager({ baseDir: this.baseDir, scope: "user" });
+        const fileName = globalMgr.save({
+            name: entry.name,
+            description: entry.description,
+            type: entry.type,
+            content: entry.content,
+            origin: entry.origin,
+            pinned: entry.pinned,
+            created: entry.created,
+            lastUsed: entry.lastUsed,
+            usageCount: entry.usageCount,
+        });
+        this.delete(entry.name); // remove from the project store
+        return fileName;
+    }
     /**
      * Get the MEMORY.md index content for injection into prompts.
      */
@@ -164,20 +359,20 @@ export class MemoryManager {
      * tagged with their origin so the model can tell user-owned from
      * dream-generated.
      */
-    buildMemoryContext() {
-        const userEntries = this.scope === "user"
-            ? this.loadAll()
-            : this.loadScope("user");
-        const dreamEntries = this.scope === "dream"
-            ? this.loadAll()
-            : this.loadScope("dream");
+    buildMemoryContext(opts) {
+        const userEntries = filterByAge(this.scope === "user" ? this.loadAll() : this.loadScope("user"), opts?.maxAgeDays, opts?.now);
+        const dreamEntries = filterByAge(this.scope === "dream" ? this.loadAll() : this.loadScope("dream"), opts?.maxAgeDays, opts?.now);
         if (userEntries.length === 0 && dreamEntries.length === 0)
             return "";
+        // Pinned memories lead the list so the user's hand-picked context is what
+        // the model reads first (sort is stable — unpinned keep their order).
+        const pinnedFirst = (a, b) => Number(b.pinned ?? false) - Number(a.pinned ?? false);
+        userEntries.sort(pinnedFirst);
         const lines = [];
         if (userEntries.length > 0) {
             lines.push("## User memories (you own these — needs permission to modify)");
             for (const e of userEntries) {
-                lines.push(`- [${e.type}] ${e.name}: ${e.description}`);
+                lines.push(`- ${e.pinned ? "[pinned] " : ""}[${e.type}] ${e.name}: ${e.description}`);
             }
         }
         if (dreamEntries.length > 0) {
@@ -193,6 +388,50 @@ export class MemoryManager {
             lines.join("\n") +
             `\n\nTo read a specific memory, look under ${this.memoryRoot}/{user,dream}/`);
     }
+    /**
+     * Two-layer injection index (用户拍板). Merges GLOBAL (cross-project
+     * experience) + PROJECT (this repo's facts) memories into a compact index —
+     * one line per entry, name + description only, NO body. The model reads a
+     * specific entry's full content on demand via MemoryRead (which records a
+     * recall → drives TTL + UI visibility).
+     *
+     * This is what fixes "global memory never shows up": global memories are now
+     * injected alongside project ones, every session, regardless of cwd.
+     *
+     * Static because it must construct two managers (global = no projectDir,
+     * project = with projectDir). `projectDir` undefined → only global is shown.
+     */
+    static buildInjectionIndex(opts) {
+        const global = new MemoryManager({ baseDir: opts.baseDir });
+        const project = opts.projectDir
+            ? new MemoryManager({ baseDir: opts.baseDir, projectDir: opts.projectDir })
+            : null;
+        const pinnedFirst = (a, b) => Number(b.pinned ?? false) - Number(a.pinned ?? false);
+        const collect = (mm) => filterByAge([...mm.loadScope("user"), ...mm.loadScope("dream")], opts.maxAgeDays, opts.now).sort(pinnedFirst);
+        const globalEntries = collect(global);
+        const projectEntries = project ? collect(project) : [];
+        if (globalEntries.length === 0 && projectEntries.length === 0)
+            return "";
+        const fmt = (e) => `- ${e.pinned ? "[pinned] " : ""}[${e.type}] ${e.name}: ${e.description}`;
+        const lines = [];
+        if (globalEntries.length > 0) {
+            lines.push("## Global memories (apply across all projects)");
+            for (const e of globalEntries)
+                lines.push(fmt(e));
+        }
+        if (projectEntries.length > 0) {
+            if (lines.length > 0)
+                lines.push("");
+            lines.push("## Project memories (this repo)");
+            for (const e of projectEntries)
+                lines.push(fmt(e));
+        }
+        return (`# Persistent Memory (index)\n\n` +
+            `These are summaries of memories from previous sessions. Only the summary is shown here.\n` +
+            `When a memory looks relevant to the current task, read its full content with the ` +
+            `MemoryRead tool (scope = user or dream; location = global or project) before relying on it.\n\n` +
+            lines.join("\n"));
+    }
     /**
      * Load every entry belonging to the given scope, without changing the
      * manager's own scope. Used by buildMemoryContext to merge user + dream
@@ -212,24 +451,7 @@ export class MemoryManager {
         return entries;
     }
     loadFileFromDir(dir, fileName, scope) {
-        const filePath = join(dir, fileName);
-        if (!existsSync(filePath))
-            return null;
-        try {
-            const raw = readFileSync(filePath, "utf-8");
-            const frontmatterMatch = raw.match(/^---\n([\s\S]*?)\n---\n\n?([\s\S]*)$/);
-            if (!frontmatterMatch)
-                return null;
-            const frontmatter = frontmatterMatch[1];
-            const content = frontmatterMatch[2].trim();
-            const name = frontmatter.match(/name:\s*(.+)/)?.[1]?.trim() ?? fileName;
-            const description = frontmatter.match(/description:\s*(.+)/)?.[1]?.trim() ?? "";
-            const type = (frontmatter.match(/type:\s*(.+)/)?.[1]?.trim() ?? "project");
-            return { name, description, type, content, fileName, scope };
-        }
-        catch {
-            return null;
-        }
+        return this.parseMemoryFile(join(dir, fileName), fileName, scope);
     }
     /**
      * Move pre-scope flat-layout entries (entries that lived directly under

package/dist/session/session-manager.d.ts

@@ -46,6 +46,46 @@ export declare class SessionManager {
      * without catching SessionError.
      */
     exists(sessionId: string): boolean;
+    /**
+     * Cheap "what cwd is this session bound to?" probe — reads only state.json,
+     * NOT the transcript (unlike resume()). engine.run uses this to recover a
+     * resumed session's project directory when the caller omits options.cwd
+     * (e.g. a desktop host whose sidebar repo selection has drifted to null),
+     * so a project-bound session keeps loading its own agents/settings/memory
+     * instead of falling back to process.cwd(). Returns undefined for an
+     * unknown, malformed, or traversal-shaped id rather than throwing — the
+     * caller treats "no recoverable cwd" the same as "not given".
+     */
+    readCwd(sessionId: string): string | undefined;
+    /**
+     * Cheap "does this session have a persisted goal?" probe — reads only
+     * state.json, NOT the transcript (like readCwd). A persistent goal lives ONLY
+     * in state.activeGoal; it is never appended to the transcript as an event, so
+     * a session rebuilt from disk (e.g. localStorage wiped) can't recover the
+     * goal from its messages. The desktop host calls this on session load to
+     * re-surface the active-goal block + its Cancel button, which would otherwise
+     * be invisible (and thus uncancellable) after a reload of an aborted goal
+     * run. Returns undefined for an unknown / malformed / traversal-shaped id, or
+     * a session with no active goal — never throws.
+     */
+    readActiveGoal(sessionId: string): import("../engine/goal.js").GoalConfig | undefined;
+    /**
+     * Disk-only "wipe this session's persistent goal" — the counterpart to
+     * readActiveGoal. Reads state.json, removes state.activeGoal, and rewrites it
+     * atomically (via saveState). Returns true only if a goal was actually
+     * present (idempotent — clearing a session with no goal is a no-op returning
+     * false). Never throws on an unknown / malformed / traversal-shaped id
+     * (returns false), matching readActiveGoal's tolerance.
+     *
+     * Why it lives here and not only on Engine: a persistent goal can strand a
+     * session whose worker is NOT live (aborted/reloaded) — Engine.clearGoal
+     * needs a resumed in-RAM session and a matching in-flight hook, neither of
+     * which exists once the worker has exited. Hosts (the desktop bridge) call
+     * THIS to clear such a goal off disk without spinning up a full Engine.
+     * Engine.clearGoal also delegates its disk write here so the wipe logic lives
+     * in exactly one place.
+     */
+    clearActiveGoal(sessionId: string): boolean;
     resume(sessionId: string): SessionBundle;
     saveState(state: SessionState): void;
     /**

package/dist/session/session-manager.js

@@ -93,7 +93,12 @@ export class SessionManager {
             parentSessionId: parentSessionId ?? null,
             ...(origin ? { origin } : {}),
         };
-        writeFileSync(join(sessionDir, "state.json"), JSON.stringify(state, null, 2), "utf-8");
+        // Atomic write (tmp+rename) like saveState, so a crash during this one-time
+        // create can't leave a torn state.json that resume() then fails to parse.
+        const stateTarget = join(sessionDir, "state.json");
+        const stateTmp = `${stateTarget}.${process.pid}.${Date.now()}.create.tmp`;
+        writeFileSync(stateTmp, JSON.stringify(state, null, 2), "utf-8");
+        renameSync(stateTmp, stateTarget);
         const transcript = new Transcript(join(sessionDir, "transcript.jsonl"));
         transcript.append("session_meta", {
             sessionId,
@@ -121,6 +126,102 @@ export class SessionManager {
         }
         return existsSync(join(this.sessionsDir, sessionId));
     }
+    /**
+     * Cheap "what cwd is this session bound to?" probe — reads only state.json,
+     * NOT the transcript (unlike resume()). engine.run uses this to recover a
+     * resumed session's project directory when the caller omits options.cwd
+     * (e.g. a desktop host whose sidebar repo selection has drifted to null),
+     * so a project-bound session keeps loading its own agents/settings/memory
+     * instead of falling back to process.cwd(). Returns undefined for an
+     * unknown, malformed, or traversal-shaped id rather than throwing — the
+     * caller treats "no recoverable cwd" the same as "not given".
+     */
+    readCwd(sessionId) {
+        try {
+            assertSafeSessionId(sessionId);
+        }
+        catch {
+            return undefined;
+        }
+        const stateFile = join(this.sessionsDir, sessionId, "state.json");
+        if (!existsSync(stateFile))
+            return undefined;
+        try {
+            const state = JSON.parse(readFileSync(stateFile, "utf-8"));
+            return typeof state.cwd === "string" && state.cwd.length > 0 ? state.cwd : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Cheap "does this session have a persisted goal?" probe — reads only
+     * state.json, NOT the transcript (like readCwd). A persistent goal lives ONLY
+     * in state.activeGoal; it is never appended to the transcript as an event, so
+     * a session rebuilt from disk (e.g. localStorage wiped) can't recover the
+     * goal from its messages. The desktop host calls this on session load to
+     * re-surface the active-goal block + its Cancel button, which would otherwise
+     * be invisible (and thus uncancellable) after a reload of an aborted goal
+     * run. Returns undefined for an unknown / malformed / traversal-shaped id, or
+     * a session with no active goal — never throws.
+     */
+    readActiveGoal(sessionId) {
+        try {
+            assertSafeSessionId(sessionId);
+        }
+        catch {
+            return undefined;
+        }
+        const stateFile = join(this.sessionsDir, sessionId, "state.json");
+        if (!existsSync(stateFile))
+            return undefined;
+        try {
+            const state = JSON.parse(readFileSync(stateFile, "utf-8"));
+            return state.activeGoal;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Disk-only "wipe this session's persistent goal" — the counterpart to
+     * readActiveGoal. Reads state.json, removes state.activeGoal, and rewrites it
+     * atomically (via saveState). Returns true only if a goal was actually
+     * present (idempotent — clearing a session with no goal is a no-op returning
+     * false). Never throws on an unknown / malformed / traversal-shaped id
+     * (returns false), matching readActiveGoal's tolerance.
+     *
+     * Why it lives here and not only on Engine: a persistent goal can strand a
+     * session whose worker is NOT live (aborted/reloaded) — Engine.clearGoal
+     * needs a resumed in-RAM session and a matching in-flight hook, neither of
+     * which exists once the worker has exited. Hosts (the desktop bridge) call
+     * THIS to clear such a goal off disk without spinning up a full Engine.
+     * Engine.clearGoal also delegates its disk write here so the wipe logic lives
+     * in exactly one place.
+     */
+    clearActiveGoal(sessionId) {
+        try {
+            assertSafeSessionId(sessionId);
+        }
+        catch {
+            return false;
+        }
+        const stateFile = join(this.sessionsDir, sessionId, "state.json");
+        if (!existsSync(stateFile))
+            return false;
+        let state;
+        try {
+            state = JSON.parse(readFileSync(stateFile, "utf-8"));
+        }
+        catch {
+            return false;
+        }
+        if (state.activeGoal === undefined)
+            return false;
+        state.activeGoal = undefined;
+        this.saveState(state);
+        return true;
+    }
     resume(sessionId) {
         assertSafeSessionId(sessionId);
         const sessionDir = join(this.sessionsDir, sessionId);
@@ -131,7 +232,16 @@ export class SessionManager {
         if (!existsSync(stateFile)) {
             throw new SessionError(`Session state file not found: ${sessionId}`);
         }
-        const state = JSON.parse(readFileSync(stateFile, "utf-8"));
+        let state;
+        try {
+            state = JSON.parse(readFileSync(stateFile, "utf-8"));
+        }
+        catch (err) {
+            // A corrupt state.json (external tampering, disk corruption, or a crash
+            // during the one-time create() write) must surface as a clean SessionError
+            // — not a raw SyntaxError that escapes callers expecting SessionError.
+            throw new SessionError(`Session state is corrupt for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
         const transcriptFile = join(sessionDir, "transcript.jsonl");
         const transcript = Transcript.loadFromFile(transcriptFile);
         state.status = "active";
@@ -165,7 +275,7 @@ export class SessionManager {
         newBundle.state.parentSessionId = sourceSessionId;
         // Copy events up to the fork point
         for (const event of events) {
-            if (event.type === "turn_boundary" && event.data.turnNumber > forkTurn) {
+            if (event.type === "turn_boundary" && (event.data.turnNumber ?? -1) > forkTurn) {
                 break;
             }
             newBundle.transcript.append(event.type, event.data);

package/dist/session/simple-diff.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal, dependency-free unified-diff for human-readable previews (e.g. the
+ * /undo confirmation). NOT a patch generator — it's for showing a user "here's
+ * what restoring will change" before they confirm. Uses a standard LCS so the
+ * output reads like a normal diff (unchanged context, -removed, +added).
+ *
+ * `from` is the content currently on disk; `to` is the snapshot we'd restore.
+ * So the preview answers "if I undo, these lines change."
+ */
+/** A single diff line with its marker. */
+export interface DiffLine {
+    marker: " " | "-" | "+";
+    text: string;
+}
+/** Longest-common-subsequence table → minimal -/+ line diff (Myers-equivalent
+ *  result via classic LCS; fine for preview-sized files). */
+export declare function diffLines(from: string, to: string): DiffLine[];
+/**
+ * Render a compact unified-diff string for a preview. Collapses long runs of
+ * unchanged context to at most `context` lines around each change so a small
+ * edit in a big file doesn't print the whole file. Returns "" when identical.
+ */
+export declare function renderDiffPreview(from: string, to: string, context?: number): string;

package/dist/session/simple-diff.js

@@ -0,0 +1,84 @@
+/**
+ * Minimal, dependency-free unified-diff for human-readable previews (e.g. the
+ * /undo confirmation). NOT a patch generator — it's for showing a user "here's
+ * what restoring will change" before they confirm. Uses a standard LCS so the
+ * output reads like a normal diff (unchanged context, -removed, +added).
+ *
+ * `from` is the content currently on disk; `to` is the snapshot we'd restore.
+ * So the preview answers "if I undo, these lines change."
+ */
+/** Longest-common-subsequence table → minimal -/+ line diff (Myers-equivalent
+ *  result via classic LCS; fine for preview-sized files). */
+export function diffLines(from, to) {
+    // Normalize CRLF → LF before splitting so a Windows (CRLF) snapshot vs. an
+    // LF edit doesn't render as every-line-changed in the /undo preview.
+    const a = from.replace(/\r\n/g, "\n").split("\n");
+    const b = to.replace(/\r\n/g, "\n").split("\n");
+    const n = a.length;
+    const m = b.length;
+    // LCS length table.
+    const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            out.push({ marker: " ", text: a[i] });
+            i++;
+            j++;
+        }
+        else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+            out.push({ marker: "-", text: a[i] });
+            i++;
+        }
+        else {
+            out.push({ marker: "+", text: b[j] });
+            j++;
+        }
+    }
+    while (i < n)
+        out.push({ marker: "-", text: a[i++] });
+    while (j < m)
+        out.push({ marker: "+", text: b[j++] });
+    return out;
+}
+/**
+ * Render a compact unified-diff string for a preview. Collapses long runs of
+ * unchanged context to at most `context` lines around each change so a small
+ * edit in a big file doesn't print the whole file. Returns "" when identical.
+ */
+export function renderDiffPreview(from, to, context = 3) {
+    const lines = diffLines(from, to);
+    if (lines.every((l) => l.marker === " "))
+        return "";
+    // Mark which lines are within `context` of a change; drop the rest, inserting
+    // a "⋯" gap marker where we elide.
+    const keep = new Array(lines.length).fill(false);
+    for (let k = 0; k < lines.length; k++) {
+        if (lines[k].marker !== " ") {
+            for (let d = -context; d <= context; d++) {
+                const idx = k + d;
+                if (idx >= 0 && idx < lines.length)
+                    keep[idx] = true;
+            }
+        }
+    }
+    const rows = [];
+    let elided = false;
+    for (let k = 0; k < lines.length; k++) {
+        if (keep[k]) {
+            rows.push(`${lines[k].marker}${lines[k].text}`);
+            elided = false;
+        }
+        else if (!elided) {
+            rows.push("⋯");
+            elided = true;
+        }
+    }
+    return rows.join("\n");
+}