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

package/dist/services/extract-memories.js

@@ -23,22 +23,31 @@ ${existingList}
 ${conversationText.slice(0, 30000)}
 
 ## Instructions
-Identify NEW information that should be saved as persistent memories. Categories:
+Identify NEW information that should be saved as persistent memories. Categories (type):
 - **user**: Information about the user's role, preferences, or expertise
 - **feedback**: Guidance about how to approach work (corrections or confirmations)
 - **project**: Non-obvious facts about ongoing work, goals, or decisions
 - **reference**: Pointers to external resources or systems
 
+Also decide each memory's storage SCOPE. **Be VERY conservative about "global" — default to "project".**
+- **global** (RARE — strong bar): ONLY a general working principle, durable user preference, or fact about WHO THE USER IS that would be useful in literally ANY project or task. Examples that qualify: "the user prefers Chinese replies", "always grep for consumers before declaring code dead", "git subprocess args need a -- separator".
+  - A concrete task's setup or domain data is NOT global even though it isn't tied to a code repo. Counter-examples that are **project, NOT global**: a specific daily-news / morning-briefing workflow and its data sources; how to log into a specific website; a particular model's config parameters; one integration's auth choice. These are task/domain specifics → "project".
+- **project** (DEFAULT): anything specific to this repo, this task, or this domain — including the counter-examples above.
+- The test for global: "is this a general way-of-working or who-the-user-is that applies across EVERY project?" Only then global. When in any doubt → project.
+
 Rules:
 - Extract AT MOST 2 memories per session. Prefer 0 to a marginal one — most sessions are noise.
+- AT MOST 1 of the extracted memories may be "global". The global layer is injected every session, so keep it tiny and high-value. If two candidates both seem global, keep the single most universal one global and make the other "project".
 - Only extract information that would be useful in FUTURE conversations
 - Do not duplicate existing memories (re-read the "Existing Memories" list above carefully)
 - Do not extract code patterns, file structures, or git history (derivable from code)
 - Do not extract ephemeral task details, progress snapshots, or in-flight work state — those belong in the conversation, not memory
 - Do not extract one-off research products (news reports, AI industry summaries, slide deck content, daily progress dumps) — they're done and not "durable, reusable information"
+- NEVER include secrets: API keys, tokens, passwords, private URLs with credentials. If the durable fact involves a credential, describe WHERE it lives (e.g. "key is in .env as FOO_KEY"), never the value itself
 - Each memory should have a clear, specific description
 
-Respond with a JSON array of objects with fields: type, name, description, content
+Respond with a JSON array of objects with fields: type, scope, name, description, content
+(scope must be "global" or "project")
 If nothing worth remembering, respond with an empty array: []`;
 }
 /** Max memories to accept from a single extraction pass. Code-side cap that
@@ -47,8 +56,16 @@ If nothing worth remembering, respond with an empty array: []`;
 export const MAX_MEMORIES_PER_EXTRACTION = 2;
 /**
  * Parse extracted memories from LLM response.
+ *
+ * `maxCount` caps how many memories are accepted from one pass (the code-side
+ * guarantee of the prompt rule). Defaults to MAX_MEMORIES_PER_EXTRACTION; a
+ * caller can pass `settings.memories.maxCount` to tune it. Non-positive or
+ * absent → the default.
  */
-export function parseExtractionResponse(response) {
+export function parseExtractionResponse(response, maxCount) {
+    const cap = typeof maxCount === "number" && maxCount > 0
+        ? Math.floor(maxCount)
+        : MAX_MEMORIES_PER_EXTRACTION;
     try {
         // Find JSON array in response
         const jsonMatch = response.match(/\[[\s\S]*\]/);
@@ -57,13 +74,35 @@ export function parseExtractionResponse(response) {
         const parsed = JSON.parse(jsonMatch[0]);
         if (!Array.isArray(parsed))
             return [];
-        const valid = parsed.filter((m) => typeof m === "object" &&
+        const valid = parsed
+            .filter((m) => typeof m === "object" &&
             m !== null &&
             typeof m.type === "string" &&
             typeof m.name === "string" &&
             typeof m.content === "string" &&
-            ["user", "feedback", "project", "reference"].includes(m.type));
-        return valid.slice(0, MAX_MEMORIES_PER_EXTRACTION);
+            ["user", "feedback", "project", "reference"].includes(m.type))
+            // Normalize scope: only "global" survives as global; everything else
+            // (absent, "project", typos) → "project" — never promote to global by accident.
+            .map((m) => ({
+            type: m.type,
+            scope: m.scope === "global" ? "global" : "project",
+            name: m.name,
+            description: m.description,
+            content: m.content,
+        }));
+        // Hard cap (用户拍板 克制): at most 1 global per extraction. The prompt asks
+        // for this, but the model may ignore it — enforce in code. Keep the first
+        // global as-is; demote any further globals to project.
+        let globalSeen = false;
+        const capped = valid.map((m) => {
+            if (m.scope !== "global")
+                return m;
+            if (globalSeen)
+                return { ...m, scope: "project" };
+            globalSeen = true;
+            return m;
+        });
+        return capped.slice(0, cap);
     }
     catch {
         return [];

package/dist/services/memory-orchestrator.d.ts

@@ -35,12 +35,33 @@ export interface MemoryOrchestratorOptions {
     projectDir?: string;
     /** Optional pre-constructed MemoryManager (avoids re-creating for every call). */
     memoryManager?: MemoryManager;
+    /**
+     * Max memories to accept per extraction pass. From settings.memories.maxCount;
+     * undefined → the built-in MAX_MEMORIES_PER_EXTRACTION default.
+     */
+    maxCount?: number;
+    /**
+     * From settings.memories.autoExtract. `false` skips step 1 (LLM memory
+     * extraction) entirely — the user-curated store stops accumulating
+     * extractor noise — while session summaries and auto-dream keep running.
+     * Absent/true = extract (default behavior).
+     */
+    autoExtract?: boolean;
+    /**
+     * Recall-based TTL in days (用户拍板 C). A `project`-type memory not read for
+     * this many days is soft-deleted (moved to memory-trash). Stable types
+     * (user/feedback/reference) and pinned entries are never pruned. From
+     * settings.memories.recallTtlDays; undefined/<=0 → no sweep.
+     */
+    recallTtlDays?: number;
 }
 export interface MemoryOrchestratorResult {
     /** Number of new memory entries extracted and saved. */
     extracted: number;
     /** Whether the auto-dream consolidation was triggered. */
     dreamTriggered: boolean;
+    /** Names of memories pruned by the recall-TTL sweep. */
+    pruned: string[];
 }
 export declare class MemoryOrchestrator {
     private readonly options;

package/dist/services/memory-orchestrator.js

@@ -15,6 +15,8 @@
 import { MemoryManager } from "../session/memory.js";
 import { buildExtractionPrompt, parseExtractionResponse } from "./extract-memories.js";
 import { saveSessionMemory, buildSessionMemoryPrompt } from "./session-memory.js";
+import { extractJSON } from "../utils/json.js";
+import { redactSecrets } from "../logging/sanitize-messages.js";
 import { shouldAutoDream, recordSession, recordDreamComplete, buildDreamSystemPrompt, buildDreamUserPrompt } from "./auto-dream.js";
 import { logger } from "../logging/logger.js";
 export class MemoryOrchestrator {
@@ -34,51 +36,83 @@ export class MemoryOrchestrator {
         const mm = this.options.memoryManager ?? new MemoryManager({ projectDir: this.options.projectDir });
         const startTime = Date.now();
         // --------------- 1. Extract durable memories ---------------
+        // settings.memories.autoExtract=false skips the extractor entirely (the
+        // curated store stops accumulating noise); summaries + dream still run.
         let extracted = 0;
-        try {
-            let t = Date.now();
-            const existing = mm.loadAll();
-            const loadMs = Date.now() - t;
-            t = Date.now();
-            const extractionPrompt = buildExtractionPrompt(transcript, existing);
-            const promptMs = Date.now() - t;
-            t = Date.now();
-            const response = await this.options.callLLM("You are a memory extraction assistant. Extract only durable, reusable information worth carrying into future sessions.", extractionPrompt);
-            const llmMs = Date.now() - t;
-            t = Date.now();
-            const entries = parseExtractionResponse(response);
-            const parseMs = Date.now() - t;
-            t = Date.now();
-            for (const entry of entries) {
-                mm.save({
-                    type: entry.type,
-                    name: entry.name,
-                    description: entry.description,
-                    content: entry.content,
+        if (this.options.autoExtract === false) {
+            logger.info("memory.extraction_skipped", { sessionId, reason: "autoExtract=false" });
+        }
+        else
+            try {
+                let t = Date.now();
+                const existing = mm.loadAll();
+                const loadMs = Date.now() - t;
+                t = Date.now();
+                const extractionPrompt = buildExtractionPrompt(transcript, existing);
+                const promptMs = Date.now() - t;
+                t = Date.now();
+                const response = await this.options.callLLM("You are a memory extraction assistant. Extract only durable, reusable information worth carrying into future sessions.", extractionPrompt);
+                const llmMs = Date.now() - t;
+                t = Date.now();
+                const entries = parseExtractionResponse(response, this.options.maxCount);
+                const parseMs = Date.now() - t;
+                t = Date.now();
+                // Route by scope (用户拍板 审批门): "project" memories auto-land in the
+                // per-project store (`mm`). "global" memories do NOT auto-land global —
+                // they go to the GLOBAL pending scope and wait for the user to approve in
+                // the settings panel. Nothing auto-writes the injected global store.
+                let pendingMm = null;
+                let globalCount = 0;
+                for (const entry of entries) {
+                    const isGlobal = entry.scope === "global";
+                    const target = isGlobal
+                        ? (pendingMm ??= new MemoryManager({ scope: "pending" }))
+                        : mm;
+                    target.save({
+                        type: entry.type,
+                        name: entry.name,
+                        // Defense-in-depth: the extraction prompt forbids secrets, but a prompt
+                        // is not a guarantee. An auto-extracted memory is persisted with no user
+                        // review, so run the model-authored strings through the same
+                        // redactSecrets the logging path uses — a leaked key never lands on disk.
+                        description: redactSecrets(entry.description),
+                        content: redactSecrets(entry.content),
+                        // Provenance mark (feedback#18 方案 C): extractor writes are "auto"
+                        // so the UI can tell curated memories from extractor noise.
+                        origin: "auto",
+                        // 审批门: stamp the source project on pending entries so "不批准/降级"
+                        // can fall them back to the project they were extracted in.
+                        ...(isGlobal && this.options.projectDir
+                            ? { originProject: this.options.projectDir }
+                            : {}),
+                    });
+                    if (isGlobal)
+                        globalCount++;
+                }
+                const saveMs = Date.now() - t;
+                extracted = entries.length;
+                logger.info("memory.extraction_done", {
+                    sessionId,
+                    extracted,
+                    pendingGlobalCount: globalCount, // global candidates queued for approval
+                    projectCount: extracted - globalCount,
+                    elapsedMs: Date.now() - startTime,
+                    loadMs,
+                    promptMs,
+                    llmMs,
+                    parseMs,
+                    saveMs,
+                    existingCount: existing.length,
+                    transcriptMessages: transcript.length,
+                    responseChars: response.length,
+                });
+            }
+            catch (err) {
+                logger.warn("memory.extraction_failed", {
+                    sessionId,
+                    error: err.message,
                 });
             }
-            const saveMs = Date.now() - t;
-            extracted = entries.length;
-            logger.info("memory.extraction_done", {
-                sessionId,
-                extracted,
-                elapsedMs: Date.now() - startTime,
-                loadMs,
-                promptMs,
-                llmMs,
-                parseMs,
-                saveMs,
-                existingCount: existing.length,
-                transcriptMessages: transcript.length,
-                responseChars: response.length,
-            });
-        }
-        catch (err) {
-            logger.warn("memory.extraction_failed", {
-                sessionId,
-                error: err.message,
-            });
-        }
         // --------------- 2. Session summary ---------------
         try {
             // Only summarise sessions with enough content to be meaningful.
@@ -86,9 +120,23 @@ export class MemoryOrchestrator {
             if (messageCount >= 3) {
                 const smPrompt = buildSessionMemoryPrompt(transcript);
                 const smResponse = await this.options.callLLM("You are a session summariser. Output only valid JSON.", smPrompt);
-                const jsonMatch = smResponse.match(/\{[\s\S]*\}/);
-                if (jsonMatch) {
-                    const parsed = JSON.parse(jsonMatch[0]);
+                // LLM 摘要常带 markdown 围栏 / 围栏外解释文字 / 末尾逗号 → 裸 JSON.parse 易碎。
+                // 复用 utils/json 的 extractJSON(剥围栏 + 花括号配平,识别字符串/转义)拿到候选,
+                // 解析失败再修一次常见错误(末尾逗号),都不行才放弃(走 catch,该 session 无摘要)。
+                const candidate = extractJSON(smResponse);
+                let parsed = null;
+                try {
+                    parsed = JSON.parse(candidate);
+                }
+                catch {
+                    try {
+                        parsed = JSON.parse(candidate.replace(/,(\s*[}\]])/g, "$1"));
+                    }
+                    catch {
+                        parsed = null;
+                    }
+                }
+                if (parsed) {
                     saveSessionMemory({
                         sessionId,
                         summary: String(parsed.summary ?? "").slice(0, 1000),
@@ -117,14 +165,17 @@ export class MemoryOrchestrator {
         let dreamTriggered = false;
         try {
             if (shouldAutoDream() && this.options.runDream) {
-                // Dream sees BOTH scopes — user/ is read-only context so it can spot
-                // duplicates spanning scopes, dream/ is the workspace it edits.
+                // Dream sees project user/ (read-only context) + project dream/
+                // (workspace) + global dream/ (cross-project workspace it also cleans).
                 const userMems = mm.loadScope("user");
                 const dreamMems = mm.loadScope("dream");
-                if (userMems.length + dreamMems.length > 0) {
+                const globalDreamMems = this.options.projectDir
+                    ? new MemoryManager({ scope: "dream" }).loadScope("dream")
+                    : [];
+                if (userMems.length + dreamMems.length + globalDreamMems.length > 0) {
                     const ran = await this.options.runDream({
                         systemPrompt: buildDreamSystemPrompt(),
-                        userPrompt: buildDreamUserPrompt(userMems, dreamMems),
+                        userPrompt: buildDreamUserPrompt(userMems, dreamMems, globalDreamMems),
                         projectDir: this.options.projectDir,
                     });
                     if (ran) {
@@ -146,6 +197,30 @@ export class MemoryOrchestrator {
                 error: err.message,
             });
         }
-        return { extracted, dreamTriggered };
+        // --------------- 5. Recall-based TTL sweep (用户拍板 C) ---------------
+        // Soft-delete project-type memories not read for recallTtlDays. Runs on
+        // both the project store and the global store (global also accumulates
+        // project-type events if the LLM mis-scopes). Never throws into the result.
+        const pruned = [];
+        try {
+            const ttl = this.options.recallTtlDays;
+            if (ttl && ttl > 0) {
+                pruned.push(...mm.pruneByRecall(ttl));
+                // Only sweep the global store when we're not already it (projectDir set).
+                if (this.options.projectDir) {
+                    pruned.push(...new MemoryManager({ scope: "user" }).pruneByRecall(ttl));
+                }
+                if (pruned.length > 0) {
+                    logger.info("memory.recall_ttl_pruned", { sessionId, pruned, ttlDays: ttl });
+                }
+            }
+        }
+        catch (err) {
+            logger.warn("memory.recall_ttl_failed", {
+                sessionId,
+                error: err.message,
+            });
+        }
+        return { extracted, dreamTriggered, pruned };
     }
 }

package/dist/services/session-memory.js

@@ -6,22 +6,28 @@
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
+import { userHome } from "../settings/manager.js";
 import { sortSessionMemoriesByRecency } from "./session-memory-sort.js";
-const MEMORY_DIR = join(homedir(), ".code-shell", "session-memories");
+// Resolve per-call (NOT a module const): userHome() reads $HOME live, so a
+// relocated/test HOME redirects writes instead of pinning the real ~/.code-shell
+// at import time (bun freezes a module-level homedir() and never re-reads it).
+function memoryDir() {
+    return join(userHome(), ".code-shell", "session-memories");
+}
 /**
  * Save a session memory entry.
  */
 export function saveSessionMemory(entry) {
-    mkdirSync(MEMORY_DIR, { recursive: true });
-    const file = join(MEMORY_DIR, `${entry.sessionId}.json`);
+    const dir = memoryDir();
+    mkdirSync(dir, { recursive: true });
+    const file = join(dir, `${entry.sessionId}.json`);
     writeFileSync(file, JSON.stringify(entry, null, 2), "utf-8");
 }
 /**
  * Load a session memory by session ID.
  */
 export function loadSessionMemory(sessionId) {
-    const file = join(MEMORY_DIR, `${sessionId}.json`);
+    const file = join(memoryDir(), `${sessionId}.json`);
     if (!existsSync(file))
         return null;
     try {
@@ -35,18 +41,22 @@ export function loadSessionMemory(sessionId) {
  * List all session memories, most recent first.
  */
 export function listSessionMemories(limit = 50) {
-    if (!existsSync(MEMORY_DIR))
+    const dir = memoryDir();
+    if (!existsSync(dir))
         return [];
     // Read all entries, then order by createdAt (not by filename — the filename
     // is the sessionId, which has no chronological meaning), then take `limit`.
     const entries = [];
-    for (const file of readdirSync(MEMORY_DIR)) {
+    for (const file of readdirSync(dir)) {
         if (!file.endsWith(".json"))
             continue;
         try {
-            entries.push(JSON.parse(readFileSync(join(MEMORY_DIR, file), "utf-8")));
+            entries.push(JSON.parse(readFileSync(join(dir, file), "utf-8")));
+        }
+        catch {
+            /* intentional: skip a corrupt/torn memory file rather than failing the
+               whole listing — one bad entry must not hide all the others. */
         }
-        catch { }
     }
     return sortSessionMemoriesByRecency(entries).slice(0, limit);
 }
@@ -71,10 +81,12 @@ export function buildSessionMemoryPrompt(messages) {
 
 ${text.slice(0, 30000)}
 
-Respond with JSON:
+Respond with ONLY a single JSON object — no markdown code fence, no text before
+or after. Keep every value on one line (escape any newline as \\n) and escape
+any double quote inside a string as \\". Shape:
 {
   "summary": "One paragraph summarizing what was discussed and accomplished",
-  "keyTopics": ["topic1", "topic2", ...],
-  "decisions": ["decision1", "decision2", ...]
+  "keyTopics": ["topic1", "topic2"],
+  "decisions": ["decision1", "decision2"]
 }`;
 }

package/dist/session/file-history.d.ts

@@ -10,16 +10,84 @@ export interface FileSnapshot {
     backupPath: string;
     hash: string;
     size: number;
+    /**
+     * The conversation turn (one user message = one turn) this snapshot was taken
+     * in. Powers turn-level undo (`latestTurnUndoTargets`). Optional so snapshots
+     * written before this feature still load; absent ones share the "undefined"
+     * bucket and degrade to whole-session undo.
+     */
+    turnSeq?: number;
+    /**
+     * Set when this turn has been undone (by `undoLatestTurn`). Undone turns are
+     * SKIPPED by undo target selection (so the next undo peels the prior turn)
+     * but kept on disk so the turn can be re-applied via `redoLatestTurn`. Cleared
+     * on redo. Replaces the earlier "delete on undo" approach so redo has material.
+     */
+    undone?: boolean;
+}
+/**
+ * Redo material captured when a turn is undone: the file's content AT THE TIME
+ * OF UNDO (i.e. the turn's result), so `redoLatestTurn` can re-apply it.
+ * Stored separately from `snapshots` so it never pollutes undo selection
+ * (latestUndoTarget / earliestSnapshotsPerFile / latestTurnUndoTargets).
+ */
+export interface RedoRecord {
+    filePath: string;
+    /** The turn this redo restores (matches the undone snapshots' turnSeq). */
+    turnSeq: number;
+    /** Backup of the post-turn content to re-apply on redo. */
+    backupPath: string;
+    /**
+     * Whether the file EXISTED before this turn (had a pre-turn snapshot). False
+     * means the turn CREATED it — undo deleted it, so redo must recreate it (and
+     * conversely undo of a created file means "remove", handled by the caller).
+     */
+    existedBefore: boolean;
+}
+/**
+ * Marks that a file was CREATED in a given turn (it did not exist before the
+ * turn's first edit). Recorded by `recordCreated` from the engine hook when the
+ * pre-edit `saveSnapshot` returns null (file absent). Drives the "undo deletes a
+ * newly-created file / redo recreates it" behaviour. Like snapshots, a created
+ * marker is flipped `undone` on undo and cleared on redo rather than deleted, so
+ * the create/delete can round-trip.
+ */
+export interface CreatedMarker {
+    filePath: string;
+    turnSeq: number;
+    undone?: boolean;
 }
 export declare class FileHistory {
     private readonly historyDir;
     private snapshots;
+    /**
+     * Redo material for undone turns, kept SEPARATE from `snapshots` so it never
+     * pollutes undo selection (latestTurnUndoTargets / earliestSnapshotsPerFile).
+     */
+    private redoRecords;
+    /** Per-turn "this file was created" markers (see CreatedMarker). */
+    private created;
     constructor(sessionDir: string);
     /**
      * Save a snapshot of a file before it is modified.
      * Returns the snapshot record, or null if the file doesn't exist.
+     *
+     * `turnSeq` tags the snapshot with the current conversation turn so a later
+     * `/undo` can revert exactly the files that turn changed (see
+     * latestTurnUndoTargets). Omit it for callers without turn context.
+     */
+    saveSnapshot(filePath: string, turnSeq?: number): FileSnapshot | null;
+    /**
+     * Record that `filePath` was CREATED in `turnSeq` — called by the engine hook
+     * when the pre-edit saveSnapshot returns null (file did not exist yet). Idempotent
+     * per (path, turn): a file built then edited again in the same turn is recorded
+     * once, so undo deletes it (rather than restoring an intra-turn snapshot). A
+     * marker already flipped `undone` from a prior undo is reused as-is (not
+     * re-armed) — only fresh turns create new markers.
      */
-    saveSnapshot(filePath: string): FileSnapshot | null;
+    recordCreated(filePath: string, turnSeq: number): void;
+    /** Redo material captured by past undos (see RedoRecord). Returns a copy. */
+    getRedoRecords(): RedoRecord[];
     /**
      * Get all snapshots for a specific file.
      */
@@ -36,6 +104,61 @@ export declare class FileHistory {
      * Get all tracked files.
      */
     getTrackedFiles(): string[];
+    /**
+     * Restore EVERY tracked file to its earliest snapshot — the state before the
+     * first AI edit this session. Powers `/undo all`. Targets are computed up
+     * front (restore() appends a new snapshot, so reading them lazily mid-loop
+     * would be unstable). Returns a per-file result so a partial failure doesn't
+     * hide which files reverted.
+     */
+    restoreAllToEarliest(): Array<{
+        filePath: string;
+        ok: boolean;
+    }>;
+    /**
+     * Capture the file's CURRENT on-disk content into a fresh redo backup and
+     * append a RedoRecord. `existedBefore` distinguishes a modified file (true,
+     * redo re-applies content) from a turn-created file (false, redo recreates it).
+     * Returns false if the file can't be read (then no record is added).
+     */
+    private captureRedoBackup;
+    /**
+     * Turn-level undo: revert every file the most recent conversation turn changed
+     * back to its pre-turn state. Unlike the earlier "delete on undo" approach this
+     * now (a) captures the turn's RESULT as redo material so `redoLatestTurn` can
+     * re-apply it, and (b) MARKS the turn's snapshots `undone` rather than deleting
+     * them — `latestTurnUndoTargets` skips undone turns, so a subsequent `/undo`
+     * still peels the previous turn ("onion"). Powers `/undo`.
+     *
+     * Files the turn CREATED (recorded via recordCreated) are DELETED on undo (with
+     * existedBefore:false redo material) instead of restored. `targets` come from
+     * latestTurnUndoTargets so preview and restore agree. Returns per-file results.
+     */
+    undoLatestTurn(targets: FileSnapshot[]): Array<{
+        filePath: string;
+        ok: boolean;
+    }>;
+    /** Greatest turnSeq among not-yet-undone created markers, or undefined. */
+    private latestLiveCreatedTurn;
+    /**
+     * Turn-level redo: re-apply a previously undone turn. For each redo target,
+     * write the stashed post-turn content back to disk (existedBefore:false
+     * records RECREATE a turn-created file). Then clear the `undone` flags on that
+     * turn's snapshots and created markers, and drop the consumed redo records.
+     *
+     * `redoTargets` come from latestRedoTargets (which guarantees they are the
+     * latest still-undone turn). Returns per-file results.
+     */
+    redoLatestTurn(redoTargets: RedoRecord[]): Array<{
+        filePath: string;
+        ok: boolean;
+    }>;
+    /**
+     * All snapshots in record (chronological) order. Used by undo to pick the
+     * single most-recent modification across every file (see latestUndoTarget).
+     * Returns a copy so callers can't mutate the internal list.
+     */
+    getAllSnapshots(): FileSnapshot[];
     private saveIndex;
     static loadFromDir(sessionDir: string): FileHistory;
 }