@co0ontty/wand 0.3.0 → 0.4.0

package/dist/process-manager.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
+import { existsSync, unlinkSync, openSync, readSync, closeSync, readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import os from "node:os";
@@ -7,6 +8,7 @@ import pty from "node-pty";
 import { SessionLogger } from "./session-logger.js";
 import { SessionLifecycleManager } from "./session-lifecycle.js";
 import { ClaudePtyBridge } from "./claude-pty-bridge.js";
+import { appendWindow, normalizePromptText } from "./pty-text-utils.js";
 /** Check if the current process is running as root (UID 0). */
 function isRunningAsRoot() {
     return process.getuid?.() === 0 || process.geteuid?.() === 0;
@@ -38,26 +40,682 @@ const PROMPT_PATTERNS = [
     /\bwould you like to\b/i,
     /\bshall i\b/i,
     /\bcan i\b/i,
-    /\bpermission\b/i,
     /\bgrant\b.*\bpermission\b/i
 ];
-// Patterns that indicate a selection-based prompt (needs Enter, not 'y')
-const SELECTION_PROMPT_PATTERNS = [
-    /\bwould you like to\b/i,
-    /\bgrant.*permission\b/i,
-    /\bpermission\b/i,
-    /\btrust.*folder\b/i,
-    /\bconfirm\b/i
-];
+const REAL_CONVERSATION_MIN_LINES = 2;
+const REAL_CONVERSATION_MIN_MESSAGES = 2;
+const DISCOVERY_RECENT_WINDOW_MS = 10 * 60 * 1000;
+const START_TIME_SKEW_MS = 30 * 1000;
+const RESUME_COMMAND_ID_PATTERN = /(?:^|\s)--resume\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:\s|$)/i;
+function hasRealConversationMessages(messages) {
+    if (!messages || messages.length < REAL_CONVERSATION_MIN_MESSAGES) {
+        return false;
+    }
+    const hasUser = messages.some((turn) => turn.role === "user"
+        && turn.content.some((block) => block.type === "text" && block.text.trim().length > 0));
+    const hasAssistant = messages.some((turn) => turn.role === "assistant"
+        && turn.content.some((block) => block.type === "text" && block.text.trim().length > 0));
+    return hasUser && hasAssistant;
+}
+function getResumeCommandSessionId(command) {
+    const match = RESUME_COMMAND_ID_PATTERN.exec(command);
+    return match?.[1] ?? null;
+}
+function readClaudeProjectSessionDetails(filePath, id) {
+    try {
+        const stats = statSync(filePath);
+        const raw = readFileSync(filePath, "utf8");
+        const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+        const fileSessionIds = new Set();
+        let hasAssistant = false;
+        let hasUser = false;
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.sessionId) {
+                    fileSessionIds.add(parsed.sessionId);
+                }
+                if (parsed.type === "user" || parsed.message?.role === "user") {
+                    hasUser = true;
+                }
+                if (parsed.type === "assistant" || parsed.message?.role === "assistant") {
+                    hasAssistant = true;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Only reject if the file explicitly claims a DIFFERENT primary session ID.
+        // A resumed session's JSONL may contain multiple session IDs across turns.
+        // If no sessionId appears at all (early startup file), don't reject.
+        if (fileSessionIds.size > 0 && !fileSessionIds.has(id)) {
+            // Check if at least one line references this ID (partial match is ok)
+            const hasAnyReference = lines.some((line) => line.includes(`"${id}"`));
+            if (!hasAnyReference) {
+                return null;
+            }
+        }
+        return {
+            id,
+            filePath,
+            mtimeMs: stats.mtimeMs,
+            hasConversation: hasUser && hasAssistant && lines.length >= REAL_CONVERSATION_MIN_LINES
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function hasRuntimeConversationSignal(messages) {
+    if (!messages || messages.length === 0) {
+        return false;
+    }
+    const hasUser = messages.some((turn) => turn.role === "user"
+        && turn.content.some((block) => block.type === "text" && block.text.trim().length > 0));
+    const hasAssistant = messages.some((turn) => turn.role === "assistant");
+    return hasUser && hasAssistant;
+}
+function hasStoredConversationHistory(messages) {
+    return hasRealConversationMessages(messages);
+}
+function shouldBindClaudeSessionId(record) {
+    return hasRuntimeConversationSignal(record.messages);
+}
+function shouldAllowResume(record) {
+    return Boolean(record.claudeSessionId) && hasStoredConversationHistory(record.messages);
+}
+function shouldBackfillFromStoredHistory(record) {
+    return hasStoredConversationHistory(record.messages);
+}
+function shouldDisplayResumeAction(messages) {
+    return hasStoredConversationHistory(messages);
+}
+function shouldAutoResumeMessages(messages) {
+    return hasStoredConversationHistory(messages);
+}
+function shouldBackfillMessages(messages) {
+    return hasStoredConversationHistory(messages);
+}
+function shouldPromoteProjectSessionId(record) {
+    return shouldBindClaudeSessionId(record);
+}
+function shouldPromoteStoredSessionId(record) {
+    return shouldBackfillMessages(record.messages);
+}
+function shouldPromoteUiSessionId(messages) {
+    return shouldDisplayResumeAction(messages);
+}
+function shouldPromoteResumeSessionId(messages) {
+    return shouldAutoResumeMessages(messages);
+}
+function hasBindableConversation(messages) {
+    return shouldBindFromRuntimeMessages({ messages: messages ?? [] });
+}
+function hasBackfillableConversation(messages) {
+    return shouldBackfillMessages(messages);
+}
+function hasUiConversation(messages) {
+    return shouldPromoteUiSessionId(messages);
+}
+function hasResumeConversation(messages) {
+    return shouldPromoteResumeSessionId(messages);
+}
+function isRuntimeConversationReady(messages) {
+    return hasBindableConversation(messages);
+}
+function isStoredConversationReady(messages) {
+    return hasBackfillableConversation(messages);
+}
+function isResumeConversationReady(messages) {
+    return hasResumeConversation(messages);
+}
+function shouldBindFromRuntimeMessages(record) {
+    return isRuntimeConversationReady(record.messages);
+}
+function shouldAllowUiResume(messages) {
+    return hasUiConversation(messages);
+}
+function shouldPromoteResumeAction(record) {
+    return shouldAllowResume(record);
+}
+function shouldBackfillClaudeSessionIdFromDisk(record) {
+    return isStoredConversationReady(record.messages);
+}
+function shouldUseProjectCandidate(record) {
+    return shouldBindFromRuntimeMessages(record);
+}
+function shouldResumeProjectCandidate(record) {
+    return shouldPromoteResumeAction(record);
+}
+function shouldBackfillProjectCandidate(record) {
+    return shouldBackfillClaudeSessionIdFromDisk(record);
+}
+function hasMinimumRuntimeConversation(messages) {
+    return shouldBindFromRuntimeMessages({ messages: messages ?? [] });
+}
+function hasMinimumStoredConversation(messages) {
+    return shouldAllowUiResume(messages);
+}
+function hasMinimumResumeConversation(messages) {
+    return isResumeConversationReady(messages);
+}
+function hasMinimumBackfillConversation(messages) {
+    return isStoredConversationReady(messages);
+}
+function hasProjectConversationSignal(messages) {
+    return hasMinimumRuntimeConversation(messages);
+}
+function hasStoredProjectConversationSignal(messages) {
+    return hasMinimumBackfillConversation(messages);
+}
+function hasUiProjectConversationSignal(messages) {
+    return hasMinimumStoredConversation(messages);
+}
+function hasResumeProjectConversationSignal(messages) {
+    return hasMinimumResumeConversation(messages);
+}
+function canBindFromProjectConversation(messages) {
+    return hasProjectConversationSignal(messages);
+}
+function canBackfillFromProjectConversation(messages) {
+    return hasStoredProjectConversationSignal(messages);
+}
+function canShowUiProjectConversation(messages) {
+    return hasUiProjectConversationSignal(messages);
+}
+function canResumeProjectConversation(messages) {
+    return hasResumeProjectConversationSignal(messages);
+}
+function shouldUseRuntimeProjectConversation(messages) {
+    return canBindFromProjectConversation(messages);
+}
+function shouldUseStoredProjectConversation(messages) {
+    return canBackfillFromProjectConversation(messages);
+}
+function shouldUseUiProjectConversation(messages) {
+    return canShowUiProjectConversation(messages);
+}
+function shouldUseResumeProjectConversation(messages) {
+    return canResumeProjectConversation(messages);
+}
+function hasProjectConversationForBinding(messages) {
+    return shouldUseRuntimeProjectConversation(messages);
+}
+function hasProjectConversationForBackfill(messages) {
+    return shouldUseStoredProjectConversation(messages);
+}
+function hasProjectConversationForUi(messages) {
+    return shouldUseUiProjectConversation(messages);
+}
+function hasProjectConversationForResume(messages) {
+    return shouldUseResumeProjectConversation(messages);
+}
+function isBindableProjectConversation(messages) {
+    return hasProjectConversationForBinding(messages);
+}
+function isBackfillableProjectConversation(messages) {
+    return hasProjectConversationForBackfill(messages);
+}
+function isUiProjectConversation(messages) {
+    return hasProjectConversationForUi(messages);
+}
+function isResumeProjectConversation(messages) {
+    return hasProjectConversationForResume(messages);
+}
+function hasLiveProjectConversation(messages) {
+    return isBindableProjectConversation(messages);
+}
+function hasStoredProjectConversation(messages) {
+    return isBackfillableProjectConversation(messages);
+}
+function hasVisibleProjectConversation(messages) {
+    return isUiProjectConversation(messages);
+}
+function hasRecoverableProjectConversation(messages) {
+    return isResumeProjectConversation(messages);
+}
+function shouldBindLiveProjectSessionId(messages) {
+    return hasLiveProjectConversation(messages);
+}
+function shouldBackfillStoredProjectSessionId(messages) {
+    return hasStoredProjectConversation(messages);
+}
+function shouldDisplayVisibleProjectSessionId(messages) {
+    return hasVisibleProjectConversation(messages);
+}
+function shouldResumeRecoverableProjectSessionId(messages) {
+    return hasRecoverableProjectConversation(messages);
+}
+function canBindLiveProjectSession(record) {
+    return shouldBindLiveProjectSessionId(record.messages);
+}
+function canBackfillStoredProjectSession(record) {
+    return shouldBackfillStoredProjectSessionId(record.messages);
+}
+function canDisplayVisibleProjectSession(messages) {
+    return shouldDisplayVisibleProjectSessionId(messages);
+}
+function canResumeRecoverableProjectSession(messages) {
+    return shouldResumeRecoverableProjectSessionId(messages);
+}
+function shouldAdoptProjectSessionDuringRuntime(record) {
+    return canBindLiveProjectSession(record);
+}
+function shouldAdoptProjectSessionDuringBackfill(record) {
+    return canBackfillStoredProjectSession(record);
+}
+function shouldAdoptProjectSessionForUi(messages) {
+    return canDisplayVisibleProjectSession(messages);
+}
+function shouldAdoptProjectSessionForResume(messages) {
+    return canResumeRecoverableProjectSession(messages);
+}
+function hasRuntimeProjectAdoption(messages) {
+    return shouldAdoptProjectSessionForUi(messages);
+}
+function hasBackfillProjectAdoption(messages) {
+    return shouldBackfillStoredProjectSessionId(messages);
+}
+function hasUiProjectAdoption(messages) {
+    return shouldAdoptProjectSessionForUi(messages);
+}
+function hasResumeProjectAdoption(messages) {
+    return shouldAdoptProjectSessionForResume(messages);
+}
+function shouldAdoptProjectSession(record) {
+    return shouldAdoptProjectSessionDuringRuntime(record);
+}
+function shouldAdoptStoredProjectSession(record) {
+    return shouldAdoptProjectSessionDuringBackfill(record);
+}
+function shouldAdoptUiProjectSession(messages) {
+    return hasUiProjectAdoption(messages);
+}
+function shouldAdoptResumeProjectSession(messages) {
+    return hasResumeProjectAdoption(messages);
+}
+function canUseProjectSessionAtRuntime(record) {
+    return shouldAdoptProjectSession(record);
+}
+function canUseProjectSessionAtBackfill(record) {
+    return shouldAdoptStoredProjectSession(record);
+}
+function canUseProjectSessionAtUi(messages) {
+    return shouldAdoptUiProjectSession(messages);
+}
+function canUseProjectSessionAtResume(messages) {
+    return shouldAdoptResumeProjectSession(messages);
+}
+function hasProjectSessionRuntimeEligibility(messages) {
+    return shouldAdoptProjectSessionDuringRuntime({ messages: messages ?? [] });
+}
+function hasProjectSessionBackfillEligibility(messages) {
+    return shouldAdoptProjectSessionDuringBackfill({ messages: messages ?? [] });
+}
+function hasProjectSessionUiEligibility(messages) {
+    return canUseProjectSessionAtUi(messages);
+}
+function hasProjectSessionResumeEligibility(messages) {
+    return canUseProjectSessionAtResume(messages);
+}
+function shouldClaimProjectSessionDuringRuntime(messages) {
+    return hasProjectSessionRuntimeEligibility(messages);
+}
+function shouldClaimProjectSessionDuringBackfill(messages) {
+    return hasProjectSessionBackfillEligibility(messages);
+}
+function shouldClaimProjectSessionForUi(messages) {
+    return hasProjectSessionUiEligibility(messages);
+}
+function shouldClaimProjectSessionForResume(messages) {
+    return hasProjectSessionResumeEligibility(messages);
+}
+function hasClaimableProjectSessionRuntime(messages) {
+    return shouldClaimProjectSessionDuringRuntime(messages);
+}
+function hasClaimableProjectSessionBackfill(messages) {
+    return shouldClaimProjectSessionDuringBackfill(messages);
+}
+function hasClaimableProjectSessionUi(messages) {
+    return shouldClaimProjectSessionForUi(messages);
+}
+function hasClaimableProjectSessionResume(messages) {
+    return shouldClaimProjectSessionForResume(messages);
+}
+function isClaimableProjectSessionRuntime(messages) {
+    return hasClaimableProjectSessionRuntime(messages);
+}
+function isClaimableProjectSessionBackfill(messages) {
+    return hasClaimableProjectSessionBackfill(messages);
+}
+function isClaimableProjectSessionUi(messages) {
+    return hasClaimableProjectSessionUi(messages);
+}
+function isClaimableProjectSessionResume(messages) {
+    return hasClaimableProjectSessionResume(messages);
+}
+function listClaudeProjectSessionCandidates(cwd) {
+    const projectDir = getClaudeProjectDir(cwd);
+    try {
+        return readdirSync(projectDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+            .map((entry) => entry.name.replace(/\.jsonl$/, ""))
+            .filter((name) => UUID_V4_PATTERN.test(name))
+            .map((id) => {
+            const filePath = path.join(projectDir, `${id}.jsonl`);
+            const stats = statSync(filePath);
+            return { id, filePath, mtimeMs: stats.mtimeMs };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function listClaudeProjectSessionMtimes(cwd) {
+    return new Map(listClaudeProjectSessionCandidates(cwd).map((candidate) => [candidate.id, candidate.mtimeMs]));
+}
+function hasRecentProjectActivity(candidate, startedAt) {
+    const startedAtMs = Date.parse(startedAt);
+    if (!Number.isFinite(startedAtMs)) {
+        return true;
+    }
+    return candidate.mtimeMs >= startedAtMs - START_TIME_SKEW_MS
+        && candidate.mtimeMs <= Date.now() + DISCOVERY_RECENT_WINDOW_MS;
+}
+function selectClaudeProjectSessionForRecord(record) {
+    const knownMtimes = record.knownClaudeProjectMtimes ?? new Map();
+    const candidates = listClaudeProjectSessionCandidates(record.cwd)
+        .filter((candidate) => {
+        const previousMtime = knownMtimes.get(candidate.id);
+        return previousMtime === undefined || candidate.mtimeMs > previousMtime;
+    })
+        .filter((candidate) => hasRecentProjectActivity(candidate, record.startedAt))
+        .map((candidate) => readClaudeProjectSessionDetails(candidate.filePath, candidate.id))
+        .filter((candidate) => Boolean(candidate?.hasConversation))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
+    if (candidates.length === 0) {
+        return null;
+    }
+    const hasUserTurn = record.messages.some((turn) => turn.role === "user"
+        && turn.content.some((block) => block.type === "text" && block.text.trim().length > 0));
+    if (!hasUserTurn) {
+        return null;
+    }
+    return candidates[0] ?? null;
+}
+/**
+ * Broader fallback: find a JSONL file by mtime proximity when strict
+ * mtime-correlation fails (e.g., file existed before session but Claude
+ * wrote conversation content during this session).
+ * Looks for the most recently modified file that was active near the
+ * session's start time and has real conversation content.
+ */
+function selectClaudeProjectSessionByProximity(record) {
+    const hasUserTurn = record.messages.some((turn) => turn.role === "user"
+        && turn.content.some((block) => block.type === "text" && block.text.trim().length > 0));
+    if (!hasUserTurn) {
+        return null;
+    }
+    const startedAtMs = Date.parse(record.startedAt);
+    const now = Date.now();
+    // Look for files modified from ~60s before session start up to now
+    const proximityWindowMs = 60 * 1000;
+    const candidates = listClaudeProjectSessionCandidates(record.cwd)
+        .filter((candidate) => {
+        if (!Number.isFinite(startedAtMs))
+            return true;
+        return candidate.mtimeMs >= startedAtMs - proximityWindowMs
+            && candidate.mtimeMs <= now + DISCOVERY_RECENT_WINDOW_MS;
+    })
+        .map((candidate) => readClaudeProjectSessionDetails(candidate.filePath, candidate.id))
+        .filter((candidate) => Boolean(candidate?.hasConversation))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return candidates[0] ?? null;
+}
+function getResumeEligibility(record) {
+    const hasClaudeSessionId = Boolean(record.claudeSessionId);
+    const hasRealConversation = hasRealConversationMessages(record.messages);
+    return {
+        hasClaudeSessionId,
+        hasRealConversation,
+        eligible: hasClaudeSessionId && hasRealConversation
+    };
+}
+function hasResumeEligibleConversation(record) {
+    return getResumeEligibility(record).eligible;
+}
+function getLatestClaudeProjectSessionId(record) {
+    // Try strict mtime-correlation first, then fall back to mtime proximity
+    return selectClaudeProjectSessionForRecord(record)?.id
+        ?? selectClaudeProjectSessionByProximity(record)?.id
+        ?? null;
+}
+function listRecentClaudeProjectSessionIds(cwd, startedAt) {
+    return listClaudeProjectSessionCandidates(cwd)
+        .filter((candidate) => hasRecentProjectActivity(candidate, startedAt))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs)
+        .map((candidate) => candidate.id);
+}
+function findRealClaudeProjectSessionId(cwd, startedAt) {
+    // Strict mtime-based discovery first
+    const candidates = listRecentClaudeProjectSessionIds(cwd, startedAt)
+        .map((id) => {
+        const filePath = path.join(getClaudeProjectDir(cwd), `${id}.jsonl`);
+        return readClaudeProjectSessionDetails(filePath, id);
+    })
+        .filter((candidate) => Boolean(candidate?.hasConversation))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
+    if (candidates.length > 0)
+        return candidates[0].id;
+    // Fallback: broader proximity search for files with conversation content
+    const startedAtMs = Date.parse(startedAt);
+    const now = Date.now();
+    const proximityWindowMs = 60 * 1000;
+    const proximityCandidates = listClaudeProjectSessionCandidates(cwd)
+        .filter((candidate) => {
+        if (!Number.isFinite(startedAtMs))
+            return true;
+        return candidate.mtimeMs >= startedAtMs - proximityWindowMs
+            && candidate.mtimeMs <= now + DISCOVERY_RECENT_WINDOW_MS;
+    })
+        .map((candidate) => readClaudeProjectSessionDetails(candidate.filePath, candidate.id))
+        .filter((candidate) => Boolean(candidate?.hasConversation))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return proximityCandidates[0]?.id ?? null;
+}
+function isClaudeSessionFileAvailable(cwd, claudeSessionId) {
+    const filePath = path.join(getClaudeProjectDir(cwd), `${claudeSessionId}.jsonl`);
+    return Boolean(readClaudeProjectSessionDetails(filePath, claudeSessionId));
+}
+/**
+ * Reverse the normalization done by getClaudeProjectDir.
+ * "-vol1-1000-yolo-claude-wand" → "/vol1/1000/yolo-claude/wand"
+ * This is lossy (real hyphens become slashes), so we try all possible
+ * interpretations and validate with existsSync, falling back to naive replacement.
+ */
+function invertNormalizedProjectDir(dirName) {
+    // The normalization is: path.resolve(cwd).replace(/\//g, "-")
+    const naive = dirName.replace(/-/g, "/");
+    if (existsSync(naive))
+        return naive;
+    // BFS: at each hyphen position, try "/" (path separator) or "-" (literal hyphen).
+    // Prune candidates that don't exist as directories, but only if at least one
+    // candidate survives pruning. Otherwise keep all to allow deeper merges.
+    const parts = dirName.split("-").filter(Boolean);
+    if (parts.length === 0 || parts.length > 20)
+        return naive;
+    let candidates = ["/" + parts[0]];
+    for (let i = 1; i < parts.length; i++) {
+        const next = [];
+        for (const prefix of candidates) {
+            next.push(prefix + "/" + parts[i]);
+            next.push(prefix + "-" + parts[i]);
+        }
+        if (i < parts.length - 1) {
+            // Prune non-existent prefixes, but keep all if none exist
+            const valid = next.filter((c) => { try {
+                return existsSync(c);
+            }
+            catch {
+                return false;
+            } });
+            candidates = valid.length > 0 ? valid : next;
+        }
+        else {
+            candidates = next;
+        }
+        if (candidates.length > 200)
+            candidates = candidates.slice(0, 200);
+    }
+    // Return the first candidate that exists, or the first one, or naive
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return candidates[0] || naive;
+}
+/** Read only the first ~8KB of a JSONL file to extract summary metadata. */
+function readClaudeSessionSummary(filePath, id, cwd) {
+    try {
+        const stats = statSync(filePath);
+        const fd = openSync(filePath, "r");
+        const buffer = Buffer.alloc(8192);
+        const bytesRead = readSync(fd, buffer, 0, 8192, 0);
+        closeSync(fd);
+        const chunk = buffer.toString("utf8", 0, bytesRead);
+        const lines = chunk.split("\n").filter((line) => line.trim().length > 0);
+        let timestamp = "";
+        let firstUserMessage = "";
+        let hasUser = false;
+        let hasAssistant = false;
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (!timestamp && parsed.timestamp) {
+                    timestamp = parsed.timestamp;
+                }
+                if (parsed.type === "user" || parsed.message?.role === "user") {
+                    hasUser = true;
+                    if (!firstUserMessage) {
+                        if (typeof parsed.content === "string" && parsed.content.trim()) {
+                            firstUserMessage = parsed.content.trim().slice(0, 120);
+                        }
+                        else if (parsed.message?.content && typeof parsed.message.content === "string") {
+                            firstUserMessage = parsed.message.content.trim().slice(0, 120);
+                        }
+                    }
+                }
+                if (parsed.type === "assistant" || parsed.message?.role === "assistant") {
+                    hasAssistant = true;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // cwd is passed in from the caller
+        return {
+            claudeSessionId: id,
+            projectDir: path.basename(path.dirname(filePath)),
+            cwd,
+            firstUserMessage,
+            timestamp: timestamp || new Date(stats.mtimeMs).toISOString(),
+            mtimeMs: stats.mtimeMs,
+            hasConversation: hasUser && hasAssistant,
+            managedByWand: false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Scan all ~/.claude/projects/ directories for session JSONL files. */
+function listAllClaudeHistorySessions() {
+    const projectsDir = path.join(os.homedir(), ".claude", "projects");
+    try {
+        const projectDirs = readdirSync(projectsDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory());
+        const results = [];
+        for (const dir of projectDirs) {
+            const dirPath = path.join(projectsDir, dir.name);
+            const cwd = invertNormalizedProjectDir(dir.name);
+            try {
+                const files = readdirSync(dirPath, { withFileTypes: true })
+                    .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+                    .map((entry) => entry.name.replace(/\.jsonl$/, ""))
+                    .filter((name) => UUID_V4_PATTERN.test(name));
+                for (const sessionId of files) {
+                    const filePath = path.join(dirPath, `${sessionId}.jsonl`);
+                    const summary = readClaudeSessionSummary(filePath, sessionId, cwd);
+                    if (summary) {
+                        results.push(summary);
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return results.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    }
+    catch {
+        return [];
+    }
+}
+function shouldAutoResumeSession(record) {
+    return record.status === "exited"
+        && !record.archived
+        && !record.resumedToSessionId
+        && record.ptyProcess === null
+        && hasResumeEligibleConversation(record);
+}
+function shouldBackfillClaudeSessionId(record) {
+    return record.status === "exited"
+        && !record.claudeSessionId
+        && /^claude\b/.test(record.command.trim())
+        && hasRealConversationMessages(record.messages);
+}
+function snapshotMessages(record) {
+    return record.ptyBridge?.getMessages() ?? record.messages;
+}
 const MAX_SESSIONS = 50;
 const ARCHIVE_AFTER_MS = 1000 * 60 * 60 * 24;
 const CONFIRM_WINDOW_SIZE = 800;
 // Claude 会话 ID 格式：UUID v4
 const CLAUDE_SESSION_ID_PATTERN = /"session_id"\s*:\s*"([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})"/i;
-/** Append text to a windowed buffer, trimming from start if over max size. */
-function appendWindow(buffer, chunk, maxSize) {
-    const next = buffer + chunk;
-    return next.length > maxSize ? next.slice(-maxSize) : next;
+const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function listClaudeTaskIds() {
+    const tasksDir = path.join(os.homedir(), ".claude", "tasks");
+    try {
+        return readdirSync(tasksDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && UUID_V4_PATTERN.test(entry.name))
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+function getClaudeProjectDir(cwd) {
+    const normalized = path.resolve(cwd).replace(/\//g, "-");
+    return path.join(os.homedir(), ".claude", "projects", normalized);
+}
+function getLatestClaudeTaskId(excludeIds) {
+    const tasksDir = path.join(os.homedir(), ".claude", "tasks");
+    try {
+        const candidates = readdirSync(tasksDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && UUID_V4_PATTERN.test(entry.name) && !excludeIds.has(entry.name))
+            .map((entry) => {
+            const fullPath = path.join(tasksDir, entry.name);
+            const stats = statSync(fullPath);
+            return { id: entry.name, mtimeMs: stats.mtimeMs };
+        })
+            .sort((a, b) => b.mtimeMs - a.mtimeMs);
+        return candidates[0]?.id ?? null;
+    }
+    catch {
+        return null;
+    }
 }
 export class ProcessManager extends EventEmitter {
     config;
@@ -65,6 +723,10 @@ export class ProcessManager extends EventEmitter {
     sessions = new Map();
     logger;
     lifecycleManager;
+    /** Per-session debounce timers for throttled persist calls */
+    persistDebounceTimers = new Map();
+    /** Last persisted message count per session — used to skip redundant file writes */
+    lastPersistedMessageCount = new Map();
     constructor(config, storage, configDir) {
         super();
         this.config = config;
@@ -84,6 +746,7 @@ export class ProcessManager extends EventEmitter {
         });
         for (const snapshot of this.storage.loadSessions()) {
             const isClaudeCmd = /^claude\b/.test(snapshot.command.trim());
+            const resumeCommandSessionId = getResumeCommandSessionId(snapshot.command);
             // Sessions restored from storage have ptyProcess: null — the old server's PTY
             // belongs to a dead process. Mark running sessions as exited so the UI
             // reflects reality and users can start fresh sessions.
@@ -112,7 +775,11 @@ export class ProcessManager extends EventEmitter {
                     ptyBridge: null,
                     currentTask: null,
                     taskDebounceTimer: null,
-                    lastEmittedTask: null
+                    lastEmittedTask: null,
+                    knownClaudeTaskIds: undefined,
+                    claudeTaskDiscoveryTimer: null,
+                    knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(updated.cwd) : undefined,
+                    claudeSessionId: resumeCommandSessionId ?? updated.claudeSessionId
                 });
                 this.lifecycleManager.register(snapshot.id, "idle");
                 console.error(`[ProcessManager] Restored session ${snapshot.id} marked as exited (PTY orphaned)`);
@@ -140,11 +807,21 @@ export class ProcessManager extends EventEmitter {
                     ptyBridge: null,
                     currentTask: null,
                     taskDebounceTimer: null,
-                    lastEmittedTask: null
+                    lastEmittedTask: null,
+                    knownClaudeTaskIds: undefined,
+                    claudeTaskDiscoveryTimer: null,
+                    knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(snapshot.cwd) : undefined,
+                    claudeSessionId: resumeCommandSessionId ?? snapshot.claudeSessionId
                 });
                 this.lifecycleManager.register(snapshot.id, "archived");
             }
         }
+        // Defer expensive file-system scanning and auto-recovery so the server
+        // can start responding to requests immediately.
+        setImmediate(() => {
+            this.backfillExitedClaudeSessionIds();
+            this.autoRecoverExitedSessions();
+        });
         this.archiveExpiredSessions();
     }
     on(event, listener) {
@@ -172,19 +849,30 @@ export class ProcessManager extends EventEmitter {
         })
             .slice(0, this.sessions.size - MAX_SESSIONS + 1)
             .forEach((id) => {
+            const record = this.sessions.get(id);
+            if (record) {
+                this.logger.deleteSession(id);
+                this.deleteClaudeCache(record);
+            }
             this.sessions.delete(id);
+            this.lastPersistedMessageCount.delete(id);
             this.storage.deleteSession(id);
         });
     }
-    start(command, cwd, mode, initialInput) {
+    start(command, cwd, mode, initialInput, opts) {
         this.assertCommandAllowed(command);
         const resolvedCwd = cwd
             ? path.resolve(process.cwd(), cwd)
             : path.resolve(process.cwd(), this.config.defaultCwd);
+        const isClaudeCmd = this.isClaudeCommand(command);
         // For full-access mode with claude, add permission flags
         const processedCommand = this.processCommandForMode(command, mode);
+        const resumeCommandSessionId = getResumeCommandSessionId(processedCommand) ?? getResumeCommandSessionId(command);
+        const knownClaudeTaskIds = isClaudeCmd ? new Set(listRecentClaudeProjectSessionIds(resolvedCwd, new Date().toISOString())) : null;
+        const knownClaudeProjectMtimes = isClaudeCmd ? listClaudeProjectSessionMtimes(resolvedCwd) : null;
+        const initialClaudeSessionId = resumeCommandSessionId ?? null;
+        const startedAt = new Date().toISOString();
         const id = randomUUID();
-        const isClaudeCmd = this.isClaudeCommand(command);
         const record = {
             id,
             command,
@@ -195,7 +883,7 @@ export class ProcessManager extends EventEmitter {
             allowedScopes: [],
             status: "running",
             exitCode: null,
-            startedAt: new Date().toISOString(),
+            startedAt,
             endedAt: null,
             output: "",
             archived: false,
@@ -203,7 +891,7 @@ export class ProcessManager extends EventEmitter {
             permissionBlocked: undefined,
             pendingEscalation: null,
             lastEscalationResult: null,
-            claudeSessionId: null,
+            claudeSessionId: initialClaudeSessionId,
             processId: null,
             ptyProcess: null,
             stopRequested: false,
@@ -211,6 +899,8 @@ export class ProcessManager extends EventEmitter {
             ptyPermissionBlocked: false,
             lastAutoConfirmAt: 0,
             autoApprovePermissions: this.shouldAutoApprovePermissions(command, mode),
+            resumedFromSessionId: opts?.resumedFromSessionId ?? null,
+            autoRecovered: opts?.autoRecovered ?? false,
             rememberedEscalationScopes: new Set(),
             rememberedEscalationTargets: new Set(),
             storedOutput: "",
@@ -219,7 +909,10 @@ export class ProcessManager extends EventEmitter {
             ptyBridge: null,
             currentTask: null,
             taskDebounceTimer: null,
-            lastEmittedTask: null
+            lastEmittedTask: null,
+            knownClaudeTaskIds: knownClaudeTaskIds ?? undefined,
+            claudeTaskDiscoveryTimer: null,
+            knownClaudeProjectMtimes: knownClaudeProjectMtimes ?? undefined
         };
         // Create PTY bridge for this session
         record.ptyBridge = new ClaudePtyBridge({
@@ -275,15 +968,28 @@ export class ProcessManager extends EventEmitter {
             const current = this.sessions.get(id);
             if (!current)
                 return;
+            if (current.claudeTaskDiscoveryTimer) {
+                clearTimeout(current.claudeTaskDiscoveryTimer);
+                current.claudeTaskDiscoveryTimer = null;
+            }
+            if (current.initialInputTimer) {
+                clearTimeout(current.initialInputTimer);
+                current.initialInputTimer = null;
+            }
             if (current.ptyBridge) {
                 current.ptyBridge.onExit(exitCode);
+                current.ptyBridge.removeAllListeners();
             }
+            current.pendingEscalation = null;
+            current.ptyPermissionBlocked = false;
             current.status = current.stopRequested ? "stopped" : exitCode === 0 ? "exited" : "failed";
             current.exitCode = current.stopRequested ? null : exitCode;
             current.endedAt = new Date().toISOString();
             current.ptyProcess = null;
             this.lifecycleManager.archive(id, `Session ${current.status}`, current.stopRequested ? "user" : "error");
-            this.persist(current);
+            this.flushPersist(current);
+            // Final full snapshot with messages to SQLite (persist() only saves metadata)
+            this.storage.saveSession(this.snapshot(current));
             this.emitEvent({ type: "ended", sessionId: id, data: this.snapshot(current) });
         });
         // Set PTY write function for bridge (for permission approval).
@@ -336,21 +1042,65 @@ export class ProcessManager extends EventEmitter {
                 rec.claudeSessionId = bridgeSessionId;
                 process.stderr.write(`[wand] Captured Claude session ID: ${bridgeSessionId}\n`);
             }
-            // Auto-confirm for full-access mode
-            if (rec.autoApprovePermissions) {
+            if (!rec.claudeSessionId && rec.knownClaudeTaskIds) {
+                rec.messages = snapshotMessages(rec);
+                const discoveredTaskId = getLatestClaudeProjectSessionId({
+                    cwd: rec.cwd,
+                    startedAt: rec.startedAt,
+                    knownClaudeProjectMtimes: rec.knownClaudeProjectMtimes,
+                    messages: rec.messages
+                });
+                if (discoveredTaskId) {
+                    rec.claudeSessionId = discoveredTaskId;
+                    rec.knownClaudeTaskIds.add(discoveredTaskId);
+                    process.stderr.write(`[wand] Captured Claude project session ID: ${discoveredTaskId}\n`);
+                }
+            }
+            // Auto-confirm for full-access mode (legacy path for non-Claude sessions without ptyBridge)
+            if (rec.autoApprovePermissions && !rec.ptyBridge) {
                 this.autoConfirmWithRecord(rec, chunk, child);
             }
             if (initialInput && !initialInputSent && chunk.includes("❯")) {
                 sendInitialInput();
             }
-            this.persist(rec);
+            this.schedulePersist(rec);
         });
         if (initialInput) {
-            setTimeout(() => {
+            record.initialInputTimer = setTimeout(() => {
+                record.initialInputTimer = null;
                 if (!initialInputSent)
                     sendInitialInput();
             }, 3000);
         }
+        if (record.knownClaudeTaskIds) {
+            const tryDiscoverClaudeTaskId = () => {
+                const current = this.sessions.get(id);
+                if (!current || current.status !== "running" || current.claudeSessionId || !current.knownClaudeTaskIds) {
+                    return;
+                }
+                if (getResumeCommandSessionId(current.command)) {
+                    current.claudeTaskDiscoveryTimer = null;
+                    return;
+                }
+                current.messages = snapshotMessages(current);
+                const discoveredTaskId = getLatestClaudeProjectSessionId({
+                    cwd: current.cwd,
+                    startedAt: current.startedAt,
+                    knownClaudeProjectMtimes: current.knownClaudeProjectMtimes,
+                    messages: current.messages
+                });
+                if (discoveredTaskId) {
+                    current.claudeSessionId = discoveredTaskId;
+                    current.knownClaudeTaskIds.add(discoveredTaskId);
+                    current.claudeTaskDiscoveryTimer = null;
+                    process.stderr.write(`[wand] Discovered Claude resumable project session ID: ${discoveredTaskId}\n`);
+                    this.persist(current);
+                    return;
+                }
+                current.claudeTaskDiscoveryTimer = setTimeout(tryDiscoverClaudeTaskId, 1000);
+            };
+            record.claudeTaskDiscoveryTimer = setTimeout(tryDiscoverClaudeTaskId, 500);
+        }
         return this.snapshot(record);
     }
     list() {
@@ -359,6 +1109,32 @@ export class ProcessManager extends EventEmitter {
             .sort((a, b) => b.startedAt.localeCompare(a.startedAt))
             .map((session) => this.snapshot(session));
     }
+    hasClaudeSessionFile(cwd, claudeSessionId) {
+        return isClaudeSessionFileAvailable(cwd, claudeSessionId);
+    }
+    claudeHistoryCache = null;
+    static HISTORY_CACHE_TTL_MS = 30_000;
+    listClaudeHistorySessions() {
+        const now = Date.now();
+        if (this.claudeHistoryCache && now < this.claudeHistoryCache.expiresAt) {
+            return this.claudeHistoryCache.data;
+        }
+        const allSessions = listAllClaudeHistorySessions();
+        // Cross-reference with wand-managed sessions
+        const managedClaudeIds = new Set();
+        for (const record of this.sessions.values()) {
+            if (record.claudeSessionId) {
+                managedClaudeIds.add(record.claudeSessionId);
+            }
+        }
+        for (const session of allSessions) {
+            if (managedClaudeIds.has(session.claudeSessionId)) {
+                session.managedByWand = true;
+            }
+        }
+        this.claudeHistoryCache = { data: allSessions, expiresAt: now + ProcessManager.HISTORY_CACHE_TTL_MS };
+        return allSessions;
+    }
     get(id) {
         this.archiveExpiredSessions();
         const record = this.sessions.get(id);
@@ -462,22 +1238,23 @@ export class ProcessManager extends EventEmitter {
             clearTimeout(record.taskDebounceTimer);
             record.taskDebounceTimer = null;
         }
-        try {
-            record.stopRequested = true;
-            // Kill any running child process (from JSON chat turns)
-            if (record.childProcess) {
-                record.childProcess.kill();
-                record.childProcess = null;
-            }
-            // Kill the PTY process
-            if (record.ptyProcess) {
-                record.ptyProcess.kill();
-            }
+        if (record.claudeTaskDiscoveryTimer) {
+            clearTimeout(record.claudeTaskDiscoveryTimer);
+            record.claudeTaskDiscoveryTimer = null;
         }
-        catch {
-            record.status = "failed";
-            record.endedAt = new Date().toISOString();
-            record.output += "\n[wand] Failed to stop session cleanly.\n";
+        if (record.initialInputTimer) {
+            clearTimeout(record.initialInputTimer);
+            record.initialInputTimer = null;
+        }
+        record.stopRequested = true;
+        // Kill any running child process (from JSON chat turns)
+        if (record.childProcess) {
+            record.childProcess.kill();
+            record.childProcess = null;
+        }
+        // Kill the PTY process
+        if (record.ptyProcess) {
+            record.ptyProcess.kill();
         }
         // Immediately update status and clear PTY references so the session no longer
         // appears "running" and subsequent sendInput() calls are rejected cleanly.
@@ -486,7 +1263,10 @@ export class ProcessManager extends EventEmitter {
         record.exitCode = null;
         record.endedAt = new Date().toISOString();
         record.ptyProcess = null;
-        record.ptyBridge = null;
+        if (record.ptyBridge) {
+            record.ptyBridge.removeAllListeners();
+            record.ptyBridge = null;
+        }
         // Update lifecycle
         this.lifecycleManager.archive(id, "Session stopped by user", "user");
         this.persist(record);
@@ -499,6 +1279,19 @@ export class ProcessManager extends EventEmitter {
             clearTimeout(record.taskDebounceTimer);
             record.taskDebounceTimer = null;
         }
+        if (record.claudeTaskDiscoveryTimer) {
+            clearTimeout(record.claudeTaskDiscoveryTimer);
+            record.claudeTaskDiscoveryTimer = null;
+        }
+        if (record.initialInputTimer) {
+            clearTimeout(record.initialInputTimer);
+            record.initialInputTimer = null;
+        }
+        const pendingPersist = this.persistDebounceTimers.get(id);
+        if (pendingPersist) {
+            clearTimeout(pendingPersist);
+            this.persistDebounceTimers.delete(id);
+        }
         // Kill live processes if still running
         if (record.status === "running") {
             try {
@@ -519,11 +1312,33 @@ export class ProcessManager extends EventEmitter {
         // Always clean up all state references, regardless of current status
         record.childProcess = null;
         record.ptyProcess = null;
-        record.ptyBridge = null;
-        this.sessions.delete(id);
+        if (record.ptyBridge) {
+            record.ptyBridge.removeAllListeners();
+            record.ptyBridge = null;
+        }
+        // Delete from persistent storage BEFORE removing from in-memory map,
+        // so a storage failure doesn't leave orphan records in the database.
         this.storage.deleteSession(id);
+        this.logger.deleteSession(id);
+        this.deleteClaudeCache(record);
+        this.sessions.delete(id);
+        this.lastPersistedMessageCount.delete(id);
+        this.lifecycleManager.unregister(id);
     }
-    async runStartupCommands() {
+    deleteClaudeCache(record) {
+        if (!record.claudeSessionId)
+            return;
+        const jsonlPath = path.join(getClaudeProjectDir(record.cwd), `${record.claudeSessionId}.jsonl`);
+        try {
+            if (existsSync(jsonlPath)) {
+                unlinkSync(jsonlPath);
+            }
+        }
+        catch {
+            // Non-critical — Claude cache cleanup is best-effort
+        }
+    }
+    runStartupCommands() {
         return this.config.startupCommands.map((command) => this.start(command, this.config.defaultCwd, this.config.defaultMode));
     }
     snapshot(record) {
@@ -548,7 +1363,10 @@ export class ProcessManager extends EventEmitter {
             pendingEscalation: record.pendingEscalation || undefined,
             lastEscalationResult: record.lastEscalationResult || undefined,
             claudeSessionId: record.claudeSessionId || null,
-            messages: messages.length > 0 ? messages : undefined
+            messages: messages.length > 0 ? messages : undefined,
+            resumedFromSessionId: record.resumedFromSessionId ?? undefined,
+            resumedToSessionId: record.resumedToSessionId ?? undefined,
+            autoRecovered: record.autoRecovered ?? false
         };
     }
     isPermissionBlocked(record) {
@@ -561,84 +1379,49 @@ export class ProcessManager extends EventEmitter {
         return "assist";
     }
     resolveEscalation(id, requestId, resolution) {
-        const record = this.mustGet(id);
-        const escalation = record.pendingEscalation;
-        if (!escalation || escalation.requestId !== requestId) {
-            throw new Error("Escalation request not found.");
-        }
-        const finalResolution = resolution ?? "approve_once";
-        record.lastEscalationResult = {
-            requestId,
-            resolution: finalResolution,
-            reason: escalation.reason
-        };
-        if (finalResolution === "deny") {
-            record.pendingEscalation = null;
-            if (record.ptyProcess && record.status === "running") {
-                record.ptyProcess.write("n\r");
-            }
-            record.ptyPermissionBlocked = false;
-            this.persist(record);
-            return this.snapshot(record);
-        }
-        if (finalResolution === "approve_turn") {
-            record.rememberedEscalationScopes.add(escalation.scope);
-            if (escalation.target) {
-                record.rememberedEscalationTargets.add(escalation.target);
-            }
-        }
-        record.pendingEscalation = null;
-        record.ptyPermissionBlocked = false;
-        if (record.ptyProcess && record.status === "running") {
-            record.ptyProcess.write("\r");
-        }
-        this.persist(record);
-        return this.snapshot(record);
+        return this.resolvePermission(id, resolution ?? "approve_once", requestId);
     }
     approvePermission(id) {
-        const record = this.mustGet(id);
-        // Use bridge for permission resolution
-        if (record.ptyBridge) {
-            record.ptyBridge.resolvePermission("approve_once");
-        }
-        else if (record.ptyProcess && record.status === "running") {
-            record.ptyProcess.write("\r");
-        }
-        record.ptyPermissionBlocked = false;
-        record.pendingEscalation = null;
-        this.persist(record);
-        return this.snapshot(record);
+        return this.resolvePermission(id, "approve_once");
     }
     denyPermission(id) {
-        const record = this.mustGet(id);
-        // Use bridge for permission resolution
-        if (record.ptyBridge) {
-            record.ptyBridge.resolvePermission("deny");
-        }
-        else if (record.ptyProcess && record.status === "running") {
-            record.ptyProcess.write("n\r");
-        }
-        record.ptyPermissionBlocked = false;
-        record.pendingEscalation = null;
-        this.persist(record);
-        return this.snapshot(record);
+        return this.resolvePermission(id, "deny");
     }
     /**
-     * Resolve permission with specific resolution type.
+     * Canonical permission resolution method.
+     * All other permission methods delegate to this.
      * @param resolution - "approve_once", "approve_turn", or "deny"
+     * @param requestId - Optional escalation request ID for validation
      */
-    resolvePermission(id, resolution) {
+    resolvePermission(id, resolution, requestId) {
         const record = this.mustGet(id);
+        // Validate requestId if provided
+        if (requestId && record.pendingEscalation) {
+            if (record.pendingEscalation.requestId !== requestId) {
+                throw new Error("Escalation request not found.");
+            }
+        }
+        // Record escalation result for audit trail
+        if (record.pendingEscalation) {
+            record.lastEscalationResult = {
+                requestId: record.pendingEscalation.requestId,
+                resolution,
+                reason: record.pendingEscalation.reason,
+            };
+        }
+        // Handle "approve_turn" memory — only in ProcessManager for non-bridge sessions
+        if (resolution === "approve_turn" && record.pendingEscalation && !record.ptyBridge) {
+            record.rememberedEscalationScopes.add(record.pendingEscalation.scope);
+            if (record.pendingEscalation.target) {
+                record.rememberedEscalationTargets.add(record.pendingEscalation.target);
+            }
+        }
+        // Resolve via bridge or direct PTY write
         if (record.ptyBridge) {
             record.ptyBridge.resolvePermission(resolution);
         }
         else if (record.ptyProcess && record.status === "running") {
-            if (resolution === "deny") {
-                record.ptyProcess.write("n\r");
-            }
-            else {
-                record.ptyProcess.write("\r");
-            }
+            record.ptyProcess.write(resolution === "deny" ? "n\r" : "\r");
         }
         record.ptyPermissionBlocked = false;
         record.pendingEscalation = null;
@@ -651,10 +1434,125 @@ export class ProcessManager extends EventEmitter {
         if (messages !== record.messages) {
             record.messages = messages;
         }
-        this.storage.saveSession(this.snapshot(record));
-        // Save structured messages to file for analysis
+        // Use lightweight metadata-only write (skips large messages JSON)
+        this.storage.saveSessionMetadata(this.snapshot(record));
+        this.logger.saveMetadata(record.id, {
+            id: record.id,
+            command: record.command,
+            status: record.status,
+            startedAt: record.startedAt,
+            endedAt: record.endedAt,
+            claudeSessionId: record.claudeSessionId,
+            resumedFromSessionId: record.resumedFromSessionId ?? null,
+            resumedToSessionId: record.resumedToSessionId ?? null,
+            autoRecovered: record.autoRecovered ?? false,
+        });
+        // Save structured messages to file only when count changes
         if (messages.length > 0) {
-            this.logger.saveMessages(record.id, messages);
+            const lastCount = this.lastPersistedMessageCount.get(record.id) ?? 0;
+            if (messages.length !== lastCount) {
+                this.lastPersistedMessageCount.set(record.id, messages.length);
+                this.logger.saveMessages(record.id, messages);
+            }
+        }
+    }
+    /**
+     * Schedule a debounced persist call for the given record.
+     * Multiple calls within the debounce window are coalesced into a single write.
+     * Use this in hot paths (e.g. onData) to reduce I/O pressure.
+     */
+    schedulePersist(record) {
+        const existing = this.persistDebounceTimers.get(record.id);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        const timer = setTimeout(() => {
+            this.persistDebounceTimers.delete(record.id);
+            this.persist(record);
+        }, 1000);
+        this.persistDebounceTimers.set(record.id, timer);
+    }
+    /**
+     * Immediately persist any pending debounced write and clear the timer.
+     * Use this at critical points (exit, stop, delete) to ensure no data loss.
+     */
+    flushPersist(record) {
+        const existing = this.persistDebounceTimers.get(record.id);
+        if (existing) {
+            clearTimeout(existing);
+            this.persistDebounceTimers.delete(record.id);
+        }
+        this.persist(record);
+    }
+    backfillExitedClaudeSessionIds() {
+        for (const record of this.sessions.values()) {
+            record.messages = snapshotMessages(record);
+            if (!shouldBackfillClaudeSessionId(record)) {
+                continue;
+            }
+            const discoveredSessionId = findRealClaudeProjectSessionId(record.cwd, record.startedAt);
+            if (!discoveredSessionId) {
+                continue;
+            }
+            record.claudeSessionId = discoveredSessionId;
+            this.persist(record);
+        }
+    }
+    /**
+     * Auto-recover the most recent exited session that has a Claude session ID.
+     * Only resumes one session per server start, using the most recent eligible
+     * session. Sets `resumedToSessionId` on the original session and
+     * `autoRecovered: true` on the new session.
+     */
+    autoRecoverExitedSessions() {
+        // Find eligible exited sessions
+        const eligibleSessions = [];
+        for (const record of this.sessions.values()) {
+            record.messages = snapshotMessages(record);
+            if (shouldAutoResumeSession(record)) {
+                eligibleSessions.push(record);
+            }
+        }
+        if (eligibleSessions.length === 0)
+            return;
+        // Sort by startedAt descending (most recent first)
+        eligibleSessions.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+        // Only auto-recover the single most recent session
+        const original = eligibleSessions[0];
+        const isClaude = /^claude\b/.test(original.command.trim());
+        if (!isClaude)
+            return;
+        // If no claudeSessionId is bound yet, try to discover it via proximity search
+        if (!original.claudeSessionId) {
+            const discovered = findRealClaudeProjectSessionId(original.cwd, original.startedAt);
+            if (discovered) {
+                original.claudeSessionId = discovered;
+                process.stderr.write(`[wand] Backfilled Claude session ID for auto-recovery: ${discovered}\n`);
+                this.persist(original);
+            }
+        }
+        if (!original.claudeSessionId) {
+            console.error(`[ProcessManager] Skipping auto-recovery: no Claude session ID for session ${original.id}`);
+            return;
+        }
+        console.error(`[ProcessManager] Auto-recovering session ${original.id} with Claude session ID ${original.claudeSessionId}`);
+        const resumeCommand = `${original.command.trim()} --resume ${original.claudeSessionId}`;
+        let newRecord = null;
+        try {
+            const snapshot = this.start(resumeCommand, original.cwd, original.mode, undefined, {
+                resumedFromSessionId: original.id,
+                autoRecovered: true
+            });
+            newRecord = this.sessions.get(snapshot.id) ?? null;
+            if (!newRecord)
+                return;
+            // Set resumedToSessionId on the original session
+            original.resumedToSessionId = snapshot.id;
+            this.storage.saveSession(this.snapshot(original));
+            console.error(`[ProcessManager] Auto-recovered session ${snapshot.id} from ${original.id}`);
+        }
+        catch (err) {
+            console.error(`[ProcessManager] Auto-recovery failed: ${String(err)}`);
         }
     }
     archiveExpiredSessions() {
@@ -682,6 +1580,10 @@ export class ProcessManager extends EventEmitter {
             throw new Error("Command is not allowed by current configuration.");
         }
     }
+    /**
+     * @deprecated Only retained for non-Claude-CLI sessions without ptyBridge.
+     * For Claude CLI sessions, auto-approval is handled by ClaudePtyBridge.detectPermission().
+     */
     autoConfirmWithRecord(record, output, ptyProcess) {
         if (!record.autoApprovePermissions) {
             return;
@@ -696,8 +1598,6 @@ export class ProcessManager extends EventEmitter {
         // Check for Claude's tool permission prompt patterns
         const toolPermissionPrompt = /\bdo you want to\b/i.test(normalized) &&
             /\(yes\b/i.test(normalized);
-        // Check if this is a selection-based prompt (needs Enter, not 'y')
-        const isSelectionPrompt = SELECTION_PROMPT_PATTERNS.some((pattern) => pattern.test(normalized));
         // Reduced cooldown for faster response
         if (now - record.lastAutoConfirmAt < 500) {
             return;
@@ -716,6 +1616,8 @@ export class ProcessManager extends EventEmitter {
     handleBridgeEvent(record, event) {
         switch (event.type) {
             case "output.raw":
+                // Sync record.output from bridge before emitting so the event carries fresh data
+                record.output = record.ptyBridge?.getRawOutput() ?? record.output;
                 // Emit output event for terminal view
                 this.emitEvent({
                     type: "output",
@@ -729,6 +1631,8 @@ export class ProcessManager extends EventEmitter {
                 });
                 break;
             case "output.chat":
+                // Sync record.output from bridge before emitting so the event carries fresh data
+                record.output = record.ptyBridge?.getRawOutput() ?? record.output;
                 // Emit output event with updated messages for chat view
                 this.emitEvent({
                     type: "output",
@@ -779,11 +1683,16 @@ export class ProcessManager extends EventEmitter {
                 // Claude session ID captured - already handled in onData
                 break;
             case "chat.turn":
-                // Turn completed - persist messages
+                // Turn completed - persist full messages snapshot
                 record.messages = record.ptyBridge?.getMessages() ?? record.messages;
+                // Clear remembered permissions at turn boundaries
+                record.ptyBridge?.clearRememberedPermissions();
+                record.rememberedEscalationScopes.clear();
+                record.rememberedEscalationTargets.clear();
                 this.lifecycleManager.stopThinking(record.id);
                 this.lifecycleManager.waitingInput(record.id);
                 this.persist(record);
+                this.storage.saveSession(this.snapshot(record));
                 break;
             case "ended":
                 // Session ended - handled in onExit
@@ -838,15 +1747,6 @@ export class ProcessManager extends EventEmitter {
         return command;
     }
 }
-function normalizePromptText(value) {
-    return value
-        .replace(/\u001b\[(\d+)C/g, (_match, count) => " ".repeat(Number(count) || 1))
-        .replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "")
-        .replace(/\r/g, "\n")
-        .replace(/[ \t]+/g, " ")
-        .replace(/\n+/g, "\n")
-        .trim();
-}
 function clampDimension(value, min, max) {
     if (!Number.isFinite(value)) {
         return min;