@co0ontty/wand 0.2.1 → 0.4.0

package/dist/process-manager.js

@@ -1,15 +1,30 @@
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
-import { spawn } from "node:child_process";
+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";
 import pty from "node-pty";
 import { SessionLogger } from "./session-logger.js";
-/** Check if running as root (uid 0) */
+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;
 }
+export class SessionInputError extends Error {
+    code;
+    sessionId;
+    sessionStatus;
+    constructor(message, code, sessionId, sessionStatus) {
+        super(message);
+        this.code = code;
+        this.sessionId = sessionId;
+        this.sessionStatus = sessionStatus;
+        this.name = "SessionInputError";
+    }
+}
 const PROMPT_PATTERNS = [
     /(?:^|\b)(?:press\s+)?(?:y|yes)\s*(?:\/|\bor\b)\s*(?:n|no)(?:\b|$)/i,
     /\[(?:y|yes)\s*\/\s*(?:n|no)\]/i,
@@ -25,58 +40,788 @@ 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 OUTPUT_WINDOW_SIZE = 4096;
 const CONFIRM_WINDOW_SIZE = 800;
-const OUTPUT_MAX_SIZE = 120000;
 // 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;
     storage;
     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;
         this.storage = storage;
         this.logger = new SessionLogger(configDir || path.join(process.env.HOME || process.cwd(), ".wand"));
+        // Initialize lifecycle manager
+        this.lifecycleManager = new SessionLifecycleManager({
+            onStateChange: (sessionId, oldState, newState) => {
+                this.emitEvent({ type: "status", sessionId, data: { oldState, newState } });
+            },
+            onIdle: (sessionId) => {
+                console.error(`[ProcessManager] Session ${sessionId} is now idle`);
+            },
+            onArchived: (sessionId, reason) => {
+                console.error(`[ProcessManager] Session ${sessionId} archived: ${reason}`);
+            },
+        });
         for (const snapshot of this.storage.loadSessions()) {
-            this.sessions.set(snapshot.id, {
-                ...snapshot,
-                processId: null,
-                ptyProcess: null,
-                stopRequested: false,
-                confirmWindow: "",
-                lastAutoConfirmAt: 0,
-                sessionIdWindow: "",
-                storedOutput: snapshot.output,
-                messages: snapshot.messages ?? [],
-                jsonChatBusy: false,
-                childProcess: null,
-                ptyChatState: "idle",
-                ptyAssistantBuffer: "",
-                ptyLastUserInput: "",
-                ptyEchoSkipped: false
-            });
+            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.
+            if (snapshot.status === "running") {
+                const updated = { ...snapshot, status: "exited", endedAt: new Date().toISOString() };
+                this.storage.saveSession(updated);
+                this.sessions.set(snapshot.id, {
+                    ...updated,
+                    processId: null,
+                    ptyProcess: null,
+                    stopRequested: false,
+                    confirmWindow: "",
+                    ptyPermissionBlocked: false,
+                    lastAutoConfirmAt: 0,
+                    autoApprovePermissions: this.shouldAutoApprovePermissions(snapshot.command, snapshot.mode),
+                    pendingEscalation: snapshot.pendingEscalation ?? null,
+                    lastEscalationResult: snapshot.lastEscalationResult ?? null,
+                    autonomyPolicy: snapshot.autonomyPolicy ?? this.defaultAutonomyPolicy(snapshot.mode),
+                    approvalPolicy: snapshot.approvalPolicy ?? "ask-every-time",
+                    allowedScopes: snapshot.allowedScopes ?? [],
+                    rememberedEscalationScopes: new Set(),
+                    rememberedEscalationTargets: new Set(),
+                    storedOutput: snapshot.output,
+                    messages: snapshot.messages ?? [],
+                    childProcess: null,
+                    ptyBridge: null,
+                    currentTask: null,
+                    taskDebounceTimer: 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)`);
+            }
+            else {
+                this.sessions.set(snapshot.id, {
+                    ...snapshot,
+                    processId: null,
+                    ptyProcess: null,
+                    stopRequested: false,
+                    confirmWindow: "",
+                    ptyPermissionBlocked: false,
+                    lastAutoConfirmAt: 0,
+                    autoApprovePermissions: this.shouldAutoApprovePermissions(snapshot.command, snapshot.mode),
+                    pendingEscalation: snapshot.pendingEscalation ?? null,
+                    lastEscalationResult: snapshot.lastEscalationResult ?? null,
+                    autonomyPolicy: snapshot.autonomyPolicy ?? this.defaultAutonomyPolicy(snapshot.mode),
+                    approvalPolicy: snapshot.approvalPolicy ?? "ask-every-time",
+                    allowedScopes: snapshot.allowedScopes ?? [],
+                    rememberedEscalationScopes: new Set(),
+                    rememberedEscalationTargets: new Set(),
+                    storedOutput: snapshot.output,
+                    messages: snapshot.messages ?? [],
+                    childProcess: null,
+                    ptyBridge: null,
+                    currentTask: null,
+                    taskDebounceTimer: 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) {
@@ -104,86 +849,162 @@ 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 record = {
             id,
             command,
             cwd: resolvedCwd,
             mode,
+            autonomyPolicy: this.defaultAutonomyPolicy(mode),
+            approvalPolicy: "ask-every-time",
+            allowedScopes: [],
             status: "running",
             exitCode: null,
-            startedAt: new Date().toISOString(),
+            startedAt,
             endedAt: null,
             output: "",
             archived: false,
             archivedAt: null,
-            claudeSessionId: null,
+            permissionBlocked: undefined,
+            pendingEscalation: null,
+            lastEscalationResult: null,
+            claudeSessionId: initialClaudeSessionId,
             processId: null,
             ptyProcess: null,
             stopRequested: false,
             confirmWindow: "",
+            ptyPermissionBlocked: false,
             lastAutoConfirmAt: 0,
-            sessionIdWindow: "",
+            autoApprovePermissions: this.shouldAutoApprovePermissions(command, mode),
+            resumedFromSessionId: opts?.resumedFromSessionId ?? null,
+            autoRecovered: opts?.autoRecovered ?? false,
+            rememberedEscalationScopes: new Set(),
+            rememberedEscalationTargets: new Set(),
             storedOutput: "",
             messages: [],
-            jsonChatBusy: false,
             childProcess: null,
-            ptyChatState: "idle",
-            ptyAssistantBuffer: "",
-            ptyLastUserInput: "",
-            ptyEchoSkipped: false
+            ptyBridge: null,
+            currentTask: null,
+            taskDebounceTimer: null,
+            lastEmittedTask: null,
+            knownClaudeTaskIds: knownClaudeTaskIds ?? undefined,
+            claudeTaskDiscoveryTimer: null,
+            knownClaudeProjectMtimes: knownClaudeProjectMtimes ?? undefined
         };
+        // Create PTY bridge for this session
+        record.ptyBridge = new ClaudePtyBridge({
+            sessionId: id,
+            isClaudeCommand: isClaudeCmd,
+            autoApprove: record.autoApprovePermissions,
+            approvalPolicy: record.approvalPolicy,
+        });
+        record.ptyBridge.on("event", (event) => {
+            this.handleBridgeEvent(record, event);
+        });
         this.sessions.set(id, record);
         this.persist(record);
         this.cleanupOldSessions();
-        // Emit started event
-        this.emitEvent({ type: "started", sessionId: id, data: this.snapshot(record) });
-        // For native mode, skip PTY creation — sendInput() will spawn child processes directly
-        if (mode === "native" || mode === "managed") {
-            // If there's an initial input, kick off the first JSON chat turn
-            if (initialInput) {
-                const message = mode === "managed"
-                    ? this.wrapManagedPrompt(initialInput)
-                    : initialInput;
-                this.runJsonChatTurn(record, message);
-            }
-            return this.snapshot(record);
+        // Register lifecycle
+        this.lifecycleManager.register(id, "initializing");
+        // All modes use PTY execution — JSON turns are only used for internal recovery
+        const shellArgs = this.buildShellArgs(processedCommand);
+        let child;
+        try {
+            child = pty.spawn(this.config.shell, shellArgs, {
+                cwd: resolvedCwd,
+                env: {
+                    ...process.env,
+                    WAND_MODE: mode,
+                    WAND_AUTO_CONFIRM: mode === "full-access" ? "1" : "0",
+                    WAND_AUTO_EDIT: mode === "auto-edit" ? "1" : "0"
+                },
+                name: "xterm-color",
+                cols: 120,
+                rows: 36
+            });
         }
-        // For managed mode without initial input, create PTY but don't send anything
-        // (managed mode waits for user input via sendInput)
-        // For default mode with Claude commands and initial input, also use JSON chat turn
-        // This ensures chat view works correctly from the first message
-        if (initialInput && this.isClaudeCommand(command) && this.isRealChatInput(initialInput)) {
-            const cleanInput = initialInput.replace(/[\r\n]+$/, "").trim();
-            this.runJsonChatTurn(record, cleanInput);
+        catch (err) {
+            console.error("[ProcessManager] pty.spawn threw", { sessionId: id, error: String(err) });
+            record.status = "failed";
+            record.exitCode = -1;
+            record.endedAt = new Date().toISOString();
+            record.ptyProcess = null;
+            this.lifecycleManager.archive(id, "Session spawn failed", "error");
+            this.persist(record);
             return this.snapshot(record);
         }
-        const shellArgs = this.buildShellArgs(processedCommand);
-        const child = pty.spawn(this.config.shell, shellArgs, {
-            cwd: resolvedCwd,
-            env: {
-                ...process.env,
-                WAND_MODE: mode,
-                WAND_AUTO_CONFIRM: mode === "full-access" ? "1" : "0",
-                WAND_AUTO_EDIT: mode === "auto-edit" ? "1" : "0"
-            },
-            name: "xterm-color",
-            cols: 120,
-            rows: 36
-        });
         record.processId = child.pid;
         record.ptyProcess = child;
+        record.status = "running";
+        this.lifecycleManager.setState(id, "running");
+        // Register exit handler AFTER ptyProcess is assigned — node-pty's EventEmitter
+        // fires 'exit' synchronously when the child has already exited (e.g. "command
+        // not found"). If we register first, onExit fires with ptyProcess still null and
+        // status never updates. By assigning first, onExit always sees a consistent state.
+        child.onExit(({ exitCode }) => {
+            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.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).
+        // Write directly to record.ptyProcess — the status guard in sendInput() already
+        // ensures no input is sent when the session is not running, so we just guard
+        // the PTY write itself against a null process.
+        if (record.ptyBridge) {
+            record.ptyBridge.setPtyWrite((input) => {
+                if (record.ptyProcess) {
+                    record.ptyProcess.write(input);
+                }
+            });
+        }
+        // Emit started event AFTER PTY is fully set up so clients receive a consistent snapshot.
+        this.emitEvent({ type: "started", sessionId: id, data: this.snapshot(record) });
         let initialInputSent = false;
         const sendInitialInput = () => {
             if (initialInputSent || !initialInput)
@@ -195,100 +1016,91 @@ export class ProcessManager extends EventEmitter {
                 return;
             }
             process.stderr.write(`[wand] Sending initial input: ${initialInput}\n`);
-            // Track initial input as a user message for Chat mode
-            if (this.isRealChatInput(initialInput)) {
-                const cleanInput = initialInput.replace(/[\r\n]+$/, "").trim();
-                current.messages.push({
-                    role: "user",
-                    content: [{ type: "text", text: cleanInput }]
-                });
-                current.messages.push({
-                    role: "assistant",
-                    content: []
-                });
-                current.ptyChatState = "responding";
-                current.ptyAssistantBuffer = "";
-                current.ptyLastUserInput = cleanInput;
-                current.ptyEchoSkipped = false;
+            // Track initial input via bridge for Chat mode
+            if (current.ptyBridge) {
+                current.ptyBridge.onUserInput(initialInput);
             }
             current.ptyProcess.write(initialInput);
             // \n advances to a new line so subsequent output doesn't overwrite this input
             current.ptyProcess.write("\n");
         };
-        // Debounce rapid PTY output events to reduce WebSocket flooding
-        let outputDebounceTimer = null;
-        let pendingChunk = "";
         child.onData((chunk) => {
             const rec = this.sessions.get(id);
             if (!rec)
                 return;
-            rec.output = appendWindow(rec.output, normalizePtyOutput(chunk), OUTPUT_MAX_SIZE);
+            // Route chunk through PTY bridge
+            if (rec.ptyBridge) {
+                rec.ptyBridge.processChunk(chunk);
+            }
+            // Update legacy output field for backward compatibility
+            rec.output = rec.ptyBridge?.getRawOutput() ?? "";
             // Log raw PTY output for analysis
             this.logger.appendPtyOutput(id, chunk);
-            // Capture Claude session ID from output
-            if (!rec.claudeSessionId) {
-                rec.sessionIdWindow = appendWindow(rec.sessionIdWindow, chunk, OUTPUT_WINDOW_SIZE);
-                const match = CLAUDE_SESSION_ID_PATTERN.exec(rec.sessionIdWindow);
-                if (match?.[1]) {
-                    rec.claudeSessionId = match[1];
-                    process.stderr.write(`[wand] Captured Claude session ID: ${match[1]}\n`);
-                    this.persist(rec);
+            // Update Claude session ID from bridge
+            const bridgeSessionId = rec.ptyBridge?.getClaudeSessionId();
+            if (bridgeSessionId && bridgeSessionId !== rec.claudeSessionId) {
+                rec.claudeSessionId = bridgeSessionId;
+                process.stderr.write(`[wand] Captured Claude session ID: ${bridgeSessionId}\n`);
+            }
+            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`);
                 }
             }
-            if (mode === "full-access") {
+            // 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();
             }
-            // Track assistant response for Chat mode (PTY sessions)
-            if (rec.ptyChatState === "responding") {
-                rec.ptyAssistantBuffer += chunk;
-                this.trackPtyAssistantResponse(rec);
-            }
-            // Batch rapid output chunks to reduce WebSocket messages
-            pendingChunk += chunk;
-            if (outputDebounceTimer) {
-                clearTimeout(outputDebounceTimer);
-            }
-            outputDebounceTimer = setTimeout(() => {
-                const finalChunk = pendingChunk;
-                pendingChunk = "";
-                outputDebounceTimer = null;
-                this.persist(rec);
-                this.emitEvent({
-                    type: "output",
-                    sessionId: id,
-                    data: {
-                        chunk: finalChunk,
-                        output: rec.output,
-                        messages: rec.messages.length > 0 ? rec.messages : undefined
-                    }
-                });
-            }, 30); // 30ms debounce for PTY mode
-        });
-        child.onExit(({ exitCode }) => {
-            const current = this.sessions.get(id);
-            if (!current)
-                return;
-            // Finalize any pending assistant response before ending
-            if (current.ptyChatState === "responding") {
-                current.ptyEchoSkipped = true; // Force skip echo on exit
-                this.finalizePtyAssistantMessage(current);
-            }
-            current.status = current.stopRequested ? "stopped" : exitCode === 0 ? "exited" : "failed";
-            current.exitCode = current.stopRequested ? null : exitCode;
-            current.endedAt = new Date().toISOString();
-            current.ptyProcess = null;
-            this.persist(current);
-            this.emitEvent({ type: "ended", sessionId: id, data: this.snapshot(current) });
+            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() {
@@ -297,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);
@@ -311,638 +1149,74 @@ export class ProcessManager extends EventEmitter {
     }
     sendInput(id, input, view) {
         const record = this.mustGet(id);
-        // Native / managed mode: always use JSON chat turn
-        // Strip trailing newlines — input from chat UI includes Enter key as "\n"
-        if (record.mode === "native" || record.mode === "managed") {
-            const cleanInput = input.replace(/[\r\n]+$/, "").trim();
-            if (cleanInput) {
-                const message = record.mode === "managed"
-                    ? this.wrapManagedPrompt(cleanInput)
-                    : cleanInput;
-                return this.runJsonChatTurn(record, message);
-            }
-            return this.snapshot(record);
-        }
-        // Chat view + Claude command → route through native pipeline for structured output
-        // This gives Chat mode the same structured messages as native mode, regardless of session mode
-        if (view === "chat" && this.isClaudeCommand(record.command) && this.isRealChatInput(input)) {
-            return this.runJsonChatTurn(record, input.replace(/[\r\n]+$/, "").trim());
-        }
-        if (!record.ptyProcess || record.status !== "running") {
-            throw new Error("Session is not running.");
-        }
-        // Track user input as a structured message for Chat mode display (PTY fallback)
-        if (this.isRealChatInput(input)) {
-            const cleanInput = input.replace(/[\r\n]+$/, "").trim();
-            record.messages.push({
-                role: "user",
-                content: [{ type: "text", text: cleanInput }]
+        if (record.status !== "running") {
+            console.error("[ProcessManager] Rejecting input for non-running session", {
+                sessionId: id,
+                status: record.status,
+                hasPty: !!record.ptyProcess,
+                inputLength: input.length,
+                view: view ?? "chat"
             });
-            // Add assistant placeholder for streaming updates
-            record.messages.push({
-                role: "assistant",
-                content: []
+            throw new SessionInputError("Session is not running.", "SESSION_NOT_RUNNING", id, record.status);
+        }
+        // Update lifecycle
+        this.lifecycleManager.touch(id);
+        this.lifecycleManager.startThinking(id);
+        if (!record.ptyProcess) {
+            console.error("[ProcessManager] Rejecting input because PTY is missing", {
+                sessionId: id,
+                status: record.status,
+                hasPty: !!record.ptyProcess,
+                inputLength: input.length,
+                view: view ?? "chat"
             });
-            record.ptyChatState = "responding";
-            record.ptyAssistantBuffer = "";
-            record.ptyLastUserInput = cleanInput;
-            record.ptyEchoSkipped = false;
+            throw new SessionInputError("Session is not running.", "SESSION_NO_PTY", id, record.status);
+        }
+        console.error("[ProcessManager] Sending input to session", {
+            sessionId: id,
+            status: record.status,
+            hasPty: !!record.ptyProcess,
+            inputLength: input.length,
+            view: view ?? "chat"
+        });
+        // Track user input via bridge for Chat mode
+        if (record.ptyBridge) {
+            record.ptyBridge.onUserInput(input);
         }
         // Ensure input advances to a new line so subsequent PTY output doesn't overwrite it
         record.ptyProcess.write(input);
-        if (!input.endsWith("\n")) {
+        if (view !== "terminal" && !input.endsWith("\n")) {
             record.ptyProcess.write("\n");
         }
         this.persist(record);
         return this.snapshot(record);
     }
-    runJsonChatTurn(record, message) {
-        if (record.jsonChatBusy) {
-            // Queue or reject — for now just ignore until previous turn finishes
-            process.stderr.write(`[wand] JSON chat turn already in progress for ${record.id}, ignoring\n`);
-            return this.snapshot(record);
-        }
-        record.jsonChatBusy = true;
-        record.status = "running";
-        const baseCommand = record.command.trim();
-        const escapedMessage = message.replace(/'/g, "'\\''");
-        // Build command: claude -p 'message' --output-format stream-json --verbose [--resume sessionId] [--permission-mode bypassPermissions]
-        // Note: --verbose is required when using --output-format stream-json with --print (Claude CLI only)
-        const isClaude = /^claude\b/.test(baseCommand);
-        const parts = [baseCommand, "-p", `'${escapedMessage}'`, "--output-format", "stream-json"];
-        if (isClaude)
-            parts.push("--verbose");
-        if (record.claudeSessionId) {
-            parts.push("--resume", record.claudeSessionId);
-        }
-        // Add permission mode for full-access (skip for root users who have all permissions)
-        if (/^claude(?:\s|$)/.test(baseCommand) && !/--permission-mode\b/.test(baseCommand) && !isRunningAsRoot()) {
-            parts.push("--permission-mode", "bypassPermissions");
-        }
-        const nativeCommand = parts.join(" ");
-        process.stderr.write(`[wand] Running JSON chat turn: ${nativeCommand}\n`);
-        // Add user message to conversation
-        record.messages.push({
-            role: "user",
-            content: [{ type: "text", text: message }]
-        });
-        // Also append to raw output for terminal view
-        record.output = appendWindow(record.output, `\n❯ ${message}\n`, OUTPUT_MAX_SIZE);
-        this.persist(record);
-        this.emitEvent({ type: "output", sessionId: record.id, data: { chunk: `\n❯ ${message}\n`, output: record.output, messages: record.messages } });
-        const child = spawn(nativeCommand, [], {
-            cwd: record.cwd,
-            env: {
-                ...process.env,
-                WAND_MODE: "native",
-                TERM: process.env.TERM || "xterm-256color"
-            },
-            shell: true,
-            stdio: ["ignore", "pipe", "pipe"]
-        });
-        // Store child process reference for cleanup
-        record.childProcess = child;
-        // Collect NDJSON lines from stdout
-        let stdoutBuffer = "";
-        const assistantBlocks = [];
-        let turnSessionId = null;
-        // Store usage data from result event (attached as a property on the blocks array)
-        assistantBlocks._lastUsage = null;
-        // Add assistant placeholder immediately so frontend has both messages during streaming
-        const assistantIndex = record.messages.length;
-        record.messages.push({
-            role: "assistant",
-            content: []
-        });
-        // Debounce rapid output to reduce flicker during streaming
-        let outputDebounceTimer = null;
-        let pendingOutput = false;
-        child.stdout?.on("data", (chunk) => {
-            const text = chunk.toString();
-            stdoutBuffer += text;
-            // Process complete NDJSON lines
-            const lines = stdoutBuffer.split("\n");
-            stdoutBuffer = lines.pop() || ""; // Keep incomplete last line in buffer
-            let hasNewContent = false;
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed)
-                    continue;
-                try {
-                    const event = JSON.parse(trimmed);
-                    this.processJsonEvent(record, event, assistantBlocks);
-                    // Log native mode event for analysis
-                    this.logger.appendStreamEvent(record.id, event);
-                    // Extract session_id from any event that has it
-                    if (event.session_id && !turnSessionId) {
-                        turnSessionId = event.session_id;
-                    }
-                    hasNewContent = true;
-                }
-                catch {
-                    // Not valid JSON — might be debug output, append to raw output
-                    record.output = appendWindow(record.output, trimmed + "\n", OUTPUT_MAX_SIZE);
-                    hasNewContent = true;
-                }
-            }
-            if (hasNewContent) {
-                // Update assistant message content from collected blocks during streaming
-                if (assistantBlocks.length > 0) {
-                    record.messages[assistantIndex].content = this.buildContentBlocks(assistantBlocks);
-                }
-                this.persist(record);
-                pendingOutput = true;
-                // Debounce output events to reduce WebSocket flooding
-                if (outputDebounceTimer) {
-                    clearTimeout(outputDebounceTimer);
-                }
-                outputDebounceTimer = setTimeout(() => {
-                    outputDebounceTimer = null;
-                    if (pendingOutput) {
-                        pendingOutput = false;
-                        this.emitEvent({ type: "output", sessionId: record.id, data: { chunk: "", output: record.output, messages: record.messages } });
-                    }
-                }, 50); // 50ms debounce for native mode
-            }
-        });
-        child.stderr?.on("data", (chunk) => {
-            const text = chunk.toString();
-            record.output = appendWindow(record.output, text, OUTPUT_MAX_SIZE);
-            this.persist(record);
-            this.emitEvent({ type: "output", sessionId: record.id, data: { chunk: text, output: record.output, messages: record.messages } });
-        });
-        child.on("close", (code) => {
-            // Process any remaining buffer
-            if (stdoutBuffer.trim()) {
-                try {
-                    const event = JSON.parse(stdoutBuffer.trim());
-                    this.processJsonEvent(record, event, assistantBlocks);
-                    if (event.session_id && !turnSessionId) {
-                        turnSessionId = event.session_id;
-                    }
-                }
-                catch {
-                    record.output = appendWindow(record.output, stdoutBuffer, OUTPUT_MAX_SIZE);
-                }
-            }
-            // Finalize assistant message - update the placeholder we created
-            if (assistantBlocks.length > 0) {
-                record.messages[assistantIndex].content = this.buildContentBlocks(assistantBlocks);
-            }
-            // Extract and apply token usage from result event
-            const blocksMeta = assistantBlocks;
-            const lastUsage = blocksMeta._lastUsage;
-            if (lastUsage) {
-                record.messages[assistantIndex].usage = {
-                    inputTokens: lastUsage.input_tokens,
-                    outputTokens: lastUsage.output_tokens,
-                    cacheReadInputTokens: lastUsage.cache_read_input_tokens,
-                    cacheCreationInputTokens: lastUsage.cache_creation_input_tokens,
-                    totalCostUsd: lastUsage._totalCostUsd,
-                };
-            }
-            // Update session ID for multi-turn resume
-            if (turnSessionId) {
-                record.claudeSessionId = turnSessionId;
-                process.stderr.write(`[wand] Captured Claude session ID: ${turnSessionId}\n`);
-            }
-            record.jsonChatBusy = false;
-            // Native mode: session stays "running" to accept more turns, unless stop was requested
-            if (record.stopRequested) {
-                record.status = "stopped";
-                record.endedAt = new Date().toISOString();
-            }
-            else if (code !== 0 && code !== null) {
-                // Non-zero exit but don't end the session — just log it
-                process.stderr.write(`[wand] JSON chat turn exited with code ${code}\n`);
-            }
-            // Session stays running for more turns
-            this.persist(record);
-            this.emitEvent({ type: "output", sessionId: record.id, data: { chunk: "", output: record.output, messages: record.messages } });
-        });
-        child.on("error", (err) => {
-            const errMsg = `\n[wand] Error: ${err.message}\n`;
-            record.output = appendWindow(record.output, errMsg, OUTPUT_MAX_SIZE);
-            record.jsonChatBusy = false;
-            this.persist(record);
-            this.emitEvent({ type: "output", sessionId: record.id, data: { chunk: errMsg, output: record.output, messages: record.messages } });
-        });
-        this.persist(record);
-        return this.snapshot(record);
-    }
-    /**
-     * Wrap user message with autonomous completion instructions for managed mode.
-     * The AI is told to complete the task in one shot without asking questions.
-     */
-    wrapManagedPrompt(userMessage) {
-        return `${userMessage}
-
----
-
-You are in **managed (autonomous) mode**. Complete the task above in your response.
-
-Rules:
-- Do NOT ask clarifying questions — make reasonable assumptions and proceed.
-- Do NOT ask for confirmation — use your best judgment.
-- Complete the entire task in one response without stopping for input.
-- If you encounter an error, try alternative approaches automatically.
-- Execute all necessary steps: write code, run commands, fix issues, and verify results.
-- After completing the task, briefly summarize what was done.
-
-Begin now:`;
-    }
-    processJsonEvent(record, event, assistantBlocks) {
-        switch (event.type) {
-            case "assistant": {
-                // Assistant message — may arrive as multiple separate events (e.g. thinking block first, text block second)
-                // Merge new blocks that aren't yet in assistantBlocks
-                const msg = event.message;
-                if (msg?.content && Array.isArray(msg.content)) {
-                    for (const block of msg.content) {
-                        if (block && typeof block === "object" && "type" in block) {
-                            const blockType = block.type;
-                            const blockId = block.id;
-                            // For tool_use/tool_result, match by ID; for others, match by type
-                            let existing = -1;
-                            if (blockId) {
-                                existing = assistantBlocks.findIndex((b) => b.id === blockId);
-                            }
-                            else {
-                                existing = assistantBlocks.findIndex((b) => b.type === blockType);
-                            }
-                            if (existing >= 0) {
-                                // Update existing block — merge fields (e.g. thinking → text transition)
-                                Object.assign(assistantBlocks[existing], block);
-                            }
-                            else {
-                                // New block type — add it
-                                assistantBlocks.push(block);
-                                this.appendBlockToOutput(record, block);
-                            }
-                        }
-                    }
-                }
-                break;
-            }
-            case "content_block_start": {
-                // Streaming: new content block starting
-                if (event.content_block) {
-                    assistantBlocks.push({ ...event.content_block });
-                }
-                break;
-            }
-            case "content_block_delta": {
-                // Streaming: delta for the current block
-                if (event.delta) {
-                    const lastBlock = assistantBlocks[assistantBlocks.length - 1];
-                    if (lastBlock) {
-                        if (event.delta.text) {
-                            lastBlock.text = (lastBlock.text || "") + event.delta.text;
-                            record.output = appendWindow(record.output, event.delta.text, OUTPUT_MAX_SIZE);
-                        }
-                        if (event.delta.partial_json) {
-                            lastBlock._partialJson = (lastBlock._partialJson || "") + event.delta.partial_json;
-                        }
-                        if (event.delta.thinking) {
-                            lastBlock.thinking = (lastBlock.thinking || "") + event.delta.thinking;
-                        }
-                    }
-                }
-                break;
-            }
-            case "result": {
-                // Final result event — `event.result` can be a string or an object with `result` + `content`
-                const resultStr = typeof event.result === "string" ? event.result : event.result?.result;
-                if (typeof event.result === "object" && event.result !== null) {
-                    const result = event.result;
-                    if (result.content && Array.isArray(result.content)) {
-                        for (const block of result.content) {
-                            if (block && typeof block === "object" && "type" in block) {
-                                const blockType = block.type;
-                                const blockId = block.id;
-                                // For tool_use/tool_result, match by ID; for others, match by type
-                                let existing = -1;
-                                if (blockId) {
-                                    existing = assistantBlocks.findIndex((b) => b.id === blockId);
-                                }
-                                else {
-                                    existing = assistantBlocks.findIndex((b) => b.type === blockType);
-                                }
-                                if (existing >= 0) {
-                                    Object.assign(assistantBlocks[existing], block);
-                                }
-                                else {
-                                    assistantBlocks.push(block);
-                                    this.appendBlockToOutput(record, block);
-                                }
-                            }
-                        }
-                    }
-                }
-                // Use the result string as text if no text block exists yet
-                if (resultStr) {
-                    const hasTextBlock = assistantBlocks.some((b) => b.type === "text");
-                    if (!hasTextBlock) {
-                        const textBlock = { type: "text", text: resultStr };
-                        assistantBlocks.push(textBlock);
-                        this.appendBlockToOutput(record, textBlock);
-                    }
-                    else {
-                        // Update existing text block with final result
-                        const textBlock = assistantBlocks.find((b) => b.type === "text");
-                        if (textBlock) {
-                            textBlock.text = resultStr;
-                        }
-                    }
-                }
-                // Capture token usage from result event (store in assistantBlocks metadata)
-                if (event.usage || event.total_cost_usd) {
-                    const usage = {};
-                    if (event.usage)
-                        Object.assign(usage, event.usage);
-                    if (event.total_cost_usd !== undefined) {
-                        usage._totalCostUsd = event.total_cost_usd;
-                    }
-                    assistantBlocks._lastUsage = usage;
-                }
-                break;
-            }
-            case "user": {
-                // User message — contains tool_result blocks from tool execution
-                // These should be appended to the assistant message's content
-                const msg = event.message;
-                if (msg?.content && Array.isArray(msg.content)) {
-                    for (const block of msg.content) {
-                        if (block && typeof block === "object" && "type" in block) {
-                            const blockType = block.type;
-                            // Tool results come as user messages with type "tool_result"
-                            if (blockType === "tool_result") {
-                                assistantBlocks.push(block);
-                                this.appendBlockToOutput(record, block);
-                            }
-                        }
-                    }
-                }
-                break;
-            }
-            // system, error, etc. — just log
-            default:
-                break;
-        }
-    }
-    appendBlockToOutput(record, block) {
-        switch (block.type) {
-            case "text":
-                record.output = appendWindow(record.output, block.text + "\n", OUTPUT_MAX_SIZE);
-                break;
-            case "thinking":
-                record.output = appendWindow(record.output, "[thinking...]\n", OUTPUT_MAX_SIZE);
-                break;
-            case "tool_use":
-                record.output = appendWindow(record.output, `[tool: ${block.name}]\n`, OUTPUT_MAX_SIZE);
-                break;
-            case "tool_result":
-                record.output = appendWindow(record.output, `[tool result: ${(block.content || "").slice(0, 200)}]\n`, OUTPUT_MAX_SIZE);
-                break;
+    /** Emit a task event for a session, debounced to avoid flooding */
+    emitTask(record, task) {
+        // Clear existing debounce timer
+        if (record.taskDebounceTimer) {
+            clearTimeout(record.taskDebounceTimer);
+            record.taskDebounceTimer = null;
         }
-    }
-    buildContentBlocks(blocks) {
-        return blocks.map((b) => {
-            switch (b.type) {
-                case "text":
-                    return { type: "text", text: b.text || "" };
-                case "thinking":
-                    return { type: "thinking", thinking: b.thinking || "" };
-                case "tool_use": {
-                    let input = b.input || {};
-                    if (b._partialJson && typeof b._partialJson === "string") {
-                        try {
-                            input = JSON.parse(b._partialJson);
-                        }
-                        catch { /* keep original */ }
-                    }
-                    return {
-                        type: "tool_use",
-                        id: b.id || "",
-                        name: b.name || "",
-                        description: b.description || "",
-                        input
-                    };
-                }
-                case "tool_result":
-                    return {
-                        type: "tool_result",
-                        tool_use_id: b.tool_use_id || "",
-                        content: b.content || "",
-                        is_error: b.is_error || false
-                    };
-                default:
-                    return { type: "text", text: JSON.stringify(b) };
-            }
-        });
-    }
-    buildAssistantTurn(blocks) {
-        return { role: "assistant", content: this.buildContentBlocks(blocks) };
-    }
-    // ── PTY Chat Tracking helpers ──
-    /** Determine if input looks like a real chat message (not control characters) */
-    isRealChatInput(input) {
-        const trimmed = input.replace(/[\r\n]+$/, "").trim();
-        // Empty or whitespace-only
-        if (!trimmed)
-            return false;
-        // Single control character (Ctrl+C, Ctrl+D, etc.)
-        if (trimmed.length === 1 && trimmed.charCodeAt(0) < 32)
-            return false;
-        // ANSI escape sequences (arrow keys, etc.)
-        if (trimmed.startsWith("\x1b"))
-            return false;
-        // Single "y" or "n" — likely auto-confirm response
-        if (/^[yn]$/i.test(trimmed))
-            return false;
-        // Just Enter/CR
-        if (trimmed === "\r" || trimmed === "\n")
-            return false;
-        return true;
-    }
-    /** Check if a command is a Claude CLI command */
-    isClaudeCommand(command) {
-        const trimmed = command.trim();
-        return /^claude\b/.test(trimmed);
-    }
-    /** Strip ANSI escape sequences from raw PTY output */
-    stripAnsiSequences(text) {
-        // eslint-disable-next-line no-control-regex
-        return text
-            .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "") // CSI sequences
-            .replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, "") // OSC sequences
-            .replace(/\x1b[><=ePX^_]/g, "") // Single-char escapes
-            // eslint-disable-next-line no-control-regex
-            .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "") // Control chars (keep \t \n \r)
-            .replace(/\r\n?/g, "\n");
-    }
-    /** Track and update assistant response from PTY output */
-    trackPtyAssistantResponse(record) {
-        const clean = this.stripAnsiSequences(record.ptyAssistantBuffer);
-        // Phase 1: Skip user input echo
-        if (!record.ptyEchoSkipped) {
-            // Look for the user's input text in the cleaned output (it's the PTY echo)
-            const echoIdx = clean.indexOf(record.ptyLastUserInput);
-            if (echoIdx !== -1) {
-                record.ptyEchoSkipped = true;
-                // Don't try to trim the raw buffer — cleanPtyOutputForChat will filter the echo line.
-                // The echo line starts with ❯ which is already filtered by cleanPtyOutputForChat.
-            }
-            // Don't update assistant content until echo is skipped
+        // Don't re-emit the same task
+        if (task && task.title === record.lastEmittedTask)
             return;
-        }
-        // Phase 2: Check if assistant is done (❯ prompt reappeared)
-        const lines = clean.split("\n");
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const trimmed = lines[i].trim();
-            if (trimmed.startsWith("❯")) {
-                const afterPrompt = trimmed.slice(1).trim();
-                // Standalone ❯ or ❯ with prompt suggestions = assistant done
-                if (!afterPrompt || afterPrompt.startsWith("Try")) {
-                    this.finalizePtyAssistantMessage(record);
-                    return;
-                }
-                break;
-            }
-        }
-        // Phase 3: Update assistant content progressively during streaming
-        this.updatePtyAssistantContent(record);
-    }
-    /** Update the assistant placeholder message with cleaned PTY content */
-    updatePtyAssistantContent(record) {
-        const lastMsg = record.messages[record.messages.length - 1];
-        if (!lastMsg || lastMsg.role !== "assistant")
+        if (task === null) {
+            // Clear task after a delay — allows a brief display of "idle" state
+            record.taskDebounceTimer = setTimeout(() => {
+                record.currentTask = null;
+                record.lastEmittedTask = null;
+                this.emitEvent({ type: "task", sessionId: record.id, data: null });
+            }, 2000);
             return;
-        const text = this.cleanPtyOutputForChat(record.ptyAssistantBuffer);
-        if (text) {
-            lastMsg.content = [{ type: "text", text }];
         }
-    }
-    /** Finalize the assistant message when ❯ prompt is detected */
-    finalizePtyAssistantMessage(record) {
-        const lastMsg = record.messages[record.messages.length - 1];
-        if (!lastMsg || lastMsg.role !== "assistant")
-            return;
-        const text = this.cleanPtyOutputForChat(record.ptyAssistantBuffer);
-        if (text) {
-            lastMsg.content = [{ type: "text", text }];
-        }
-        else if (lastMsg.content.length === 0) {
-            // Remove empty assistant placeholder if no content was captured
-            record.messages.pop();
-        }
-        record.ptyChatState = "idle";
-        record.ptyAssistantBuffer = "";
-        record.ptyLastUserInput = "";
-        record.ptyEchoSkipped = false;
-        process.stderr.write(`[wand] PTY assistant response finalized (${record.messages.length} messages)\n`);
-    }
-    /** Clean raw PTY output into readable chat content */
-    cleanPtyOutputForChat(raw) {
-        const text = this.stripAnsiSequences(raw);
-        const lines = text.split("\n").map(l => l.trim()).filter(Boolean);
-        const cleanLines = lines.filter(line => {
-            // Noise filters (same as frontend parseMessages but server-side)
-            if (line.startsWith("────"))
-                return false;
-            if (line === "❯")
-                return false;
-            if (line.startsWith("❯"))
-                return false;
-            if (line.includes("esc to interrupt"))
-                return false;
-            if (line.includes("Claude Code v"))
-                return false;
-            if (/^Sonnet\b/.test(line))
-                return false;
-            if (line.startsWith("~/"))
-                return false;
-            if (line.includes("● high"))
-                return false;
-            if (line.includes("Failed to install Anthropic"))
-                return false;
-            if (line.includes("Claude Code has switched"))
-                return false;
-            if (line.includes("Fluttering"))
-                return false;
-            if (line.includes("? for shortcuts"))
-                return false;
-            if (line.startsWith("0;") || line.startsWith("9;"))
-                return false;
-            if (line.includes("Claude is waiting"))
-                return false;
-            if (/[✢✳✶✻✽]/.test(line))
-                return false;
-            if (/^[▐▝▘]/.test(line))
-                return false;
-            if (["lu", "ue", "tr", "ti", "g", "n", "i…", "…", "uts", "lt", "rg", "·"].includes(line) && line.length < 4)
-                return false;
-            if (line.startsWith("✽F") || line.startsWith("✻F"))
-                return false;
-            if (line.includes("[wand]"))
-                return false;
-            if (line.includes("Captured Claude session ID"))
-                return false;
-            if (line.includes("⏵"))
-                return false;
-            if (line.includes("acceptedit"))
-                return false;
-            if (line.includes("shift+tab"))
-                return false;
-            if (line.includes("tabtocycle"))
-                return false;
-            if (line.includes("ctrl+g"))
-                return false;
-            if (line.includes("/effort"))
-                return false;
-            if (line.includes("Opus") && line.includes("model"))
-                return false;
-            if (line.includes("Haiku"))
-                return false;
-            if (line.includes("to cycle"))
-                return false;
-            if (/\bhigh\s*·/.test(line) || /\bmedium\s*·/.test(line) || /\blow\s*·/.test(line))
-                return false;
-            if (line.includes("thinking with"))
-                return false;
-            if (/^thought for \d+/.test(line))
-                return false;
-            if (line.includes("Germinating") || line.includes("Doodling") || line.includes("Brewing"))
-                return false;
-            if (line.includes("npm WARN") || line.includes("npm notice"))
-                return false;
-            if (/^Using .* for .* session/.test(line))
-                return false;
-            if (line.includes("Permissions") && line.includes("mode"))
-                return false;
-            if (line.includes("You can use"))
-                return false;
-            if (line.startsWith("Press ") && line.includes(" for"))
-                return false;
-            if (line.startsWith("type ") && line.includes(" to "))
-                return false;
-            if (line.length < 3 && !/^[a-zA-Z]{3}$/.test(line))
-                return false;
-            // Strip bullet prefix and keep content
-            if (line.startsWith("●")) {
-                return line.slice(1).trim().length > 0;
-            }
-            return true;
-        }).map(line => {
-            // Clean bullet prefix
-            if (line.startsWith("●"))
-                return line.slice(1).trim();
-            // Clean ⏺ prefix (Claude TUI response marker)
-            if (line.startsWith("⏺"))
-                return line.slice(1).trim();
-            return line;
-        });
-        return cleanLines.join("\n").trim();
+        // Debounce task changes by 100ms to avoid flickering on rapid tool switches
+        record.taskDebounceTimer = setTimeout(() => {
+            record.taskDebounceTimer = null;
+            record.currentTask = task;
+            record.lastEmittedTask = task.title;
+            this.emitEvent({ type: "task", sessionId: record.id, data: task });
+        }, 100);
     }
     resize(id, cols, rows) {
         const record = this.mustGet(id);
@@ -959,35 +1233,72 @@ Begin now:`;
         if (record.status !== "running") {
             return this.snapshot(record);
         }
-        try {
-            record.stopRequested = true;
-            // For native / managed mode, kill the child process
-            if ((record.mode === "native" || record.mode === "managed") && record.childProcess) {
-                record.childProcess.kill();
-                record.childProcess = null;
-            }
-            // For PTY mode, kill the pty process
-            if (record.ptyProcess) {
-                record.ptyProcess.kill();
-            }
+        // Clear any pending task debounce timer
+        if (record.taskDebounceTimer) {
+            clearTimeout(record.taskDebounceTimer);
+            record.taskDebounceTimer = null;
         }
-        catch {
-            record.status = "failed";
-            record.endedAt = new Date().toISOString();
-            record.output += "\n[wand] Failed to stop session cleanly.\n";
+        if (record.claudeTaskDiscoveryTimer) {
+            clearTimeout(record.claudeTaskDiscoveryTimer);
+            record.claudeTaskDiscoveryTimer = null;
+        }
+        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.
+        // The async onExit handler will re-persist but will find stopRequested already true.
+        record.status = "stopped";
+        record.exitCode = null;
+        record.endedAt = new Date().toISOString();
+        record.ptyProcess = null;
+        if (record.ptyBridge) {
+            record.ptyBridge.removeAllListeners();
+            record.ptyBridge = null;
+        }
+        // Update lifecycle
+        this.lifecycleManager.archive(id, "Session stopped by user", "user");
         this.persist(record);
         return this.snapshot(record);
     }
     delete(id) {
         const record = this.mustGet(id);
+        // Always clear pending timers
+        if (record.taskDebounceTimer) {
+            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 {
                 record.stopRequested = true;
                 // For native mode, kill the child process
                 if ((record.mode === "native" || record.mode === "managed") && record.childProcess) {
                     record.childProcess.kill();
-                    record.childProcess = null;
                 }
                 // For PTY mode, kill the pty process
                 if (record.ptyProcess) {
@@ -998,18 +1309,49 @@ Begin now:`;
                 // Ignore and continue deleting persisted state.
             }
         }
-        this.sessions.delete(id);
+        // Always clean up all state references, regardless of current status
+        record.childProcess = null;
+        record.ptyProcess = null;
+        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);
+    }
+    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
+        }
     }
-    async runStartupCommands() {
+    runStartupCommands() {
         return this.config.startupCommands.map((command) => this.start(command, this.config.defaultCwd, this.config.defaultMode));
     }
     snapshot(record) {
+        // Get messages from bridge if available, otherwise use stored messages
+        const messages = record.ptyBridge?.getMessages() ?? record.messages;
         return {
             id: record.id,
             command: record.command,
             cwd: record.cwd,
             mode: record.mode,
+            autonomyPolicy: record.autonomyPolicy,
+            approvalPolicy: record.approvalPolicy,
+            allowedScopes: record.allowedScopes,
             status: record.status,
             exitCode: record.exitCode,
             startedAt: record.startedAt,
@@ -1017,15 +1359,200 @@ Begin now:`;
             output: record.output,
             archived: record.archived,
             archivedAt: record.archivedAt,
-            claudeSessionId: record.claudeSessionId,
-            messages: record.messages.length > 0 ? record.messages : undefined
+            permissionBlocked: this.isPermissionBlocked(record),
+            pendingEscalation: record.pendingEscalation || undefined,
+            lastEscalationResult: record.lastEscalationResult || undefined,
+            claudeSessionId: record.claudeSessionId || null,
+            messages: messages.length > 0 ? messages : undefined,
+            resumedFromSessionId: record.resumedFromSessionId ?? undefined,
+            resumedToSessionId: record.resumedToSessionId ?? undefined,
+            autoRecovered: record.autoRecovered ?? false
         };
     }
+    isPermissionBlocked(record) {
+        return record.ptyBridge?.isPermissionBlocked() ?? record.pendingEscalation !== null;
+    }
+    defaultAutonomyPolicy(mode) {
+        if (mode === "agent" || mode === "agent-max" || mode === "managed" || mode === "native" || mode === "full-access") {
+            return "agent";
+        }
+        return "assist";
+    }
+    resolveEscalation(id, requestId, resolution) {
+        return this.resolvePermission(id, resolution ?? "approve_once", requestId);
+    }
+    approvePermission(id) {
+        return this.resolvePermission(id, "approve_once");
+    }
+    denyPermission(id) {
+        return this.resolvePermission(id, "deny");
+    }
+    /**
+     * 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, 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") {
+            record.ptyProcess.write(resolution === "deny" ? "n\r" : "\r");
+        }
+        record.ptyPermissionBlocked = false;
+        record.pendingEscalation = null;
+        this.persist(record);
+        return this.snapshot(record);
+    }
     persist(record) {
-        this.storage.saveSession(this.snapshot(record));
-        // Save structured messages to file for analysis
-        if (record.messages.length > 0) {
-            this.logger.saveMessages(record.id, record.messages);
+        // Update messages from bridge before persisting
+        const messages = record.ptyBridge?.getMessages() ?? record.messages;
+        if (messages !== record.messages) {
+            record.messages = messages;
+        }
+        // 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) {
+            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() {
@@ -1053,7 +1580,14 @@ Begin now:`;
             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;
+        }
         record.confirmWindow = appendWindow(record.confirmWindow, output, CONFIRM_WINDOW_SIZE);
         const normalized = normalizePromptText(record.confirmWindow);
         const now = Date.now();
@@ -1064,8 +1598,6 @@ Begin now:`;
         // 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;
@@ -1073,21 +1605,110 @@ Begin now:`;
         const shouldConfirm = trustFolderPrompt || claudeConfirmPrompt || toolPermissionPrompt || PROMPT_PATTERNS.some((pattern) => pattern.test(normalized));
         if (shouldConfirm) {
             record.lastAutoConfirmAt = now;
-            process.stderr.write(`[wand] Auto-confirming prompt in full-access mode\n`);
-            // For Claude Code's selection UI, Enter confirms the selected option
-            // For other prompts, "y" + Enter confirms
-            if (trustFolderPrompt || claudeConfirmPrompt || toolPermissionPrompt || isSelectionPrompt) {
-                ptyProcess.write("\r");
-            }
-            else {
-                ptyProcess.write("y\r");
+            process.stderr.write(`[wand] Auto-confirming prompt for ${record.mode} mode\n`);
+            // Always auto-confirm by sending Enter directly
+            ptyProcess.write("\r");
+        }
+    }
+    /**
+     * Handle events from ClaudePtyBridge
+     */
+    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",
+                    sessionId: event.sessionId,
+                    data: {
+                        chunk: event.data.chunk,
+                        output: record.output,
+                        messages: record.ptyBridge?.getMessages(),
+                        permissionBlocked: this.isPermissionBlocked(record),
+                    },
+                });
+                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",
+                    sessionId: event.sessionId,
+                    data: {
+                        output: record.output,
+                        messages: record.ptyBridge?.getMessages(),
+                        permissionBlocked: this.isPermissionBlocked(record),
+                    },
+                });
+                break;
+            case "permission.prompt": {
+                const data = event.data;
+                record.pendingEscalation = {
+                    requestId: `bridge-${Date.now()}`,
+                    scope: data.scope,
+                    runner: "pty",
+                    source: "tool_permission_request",
+                    target: data.target,
+                    reason: data.prompt,
+                };
+                record.ptyPermissionBlocked = true;
+                // Emit status event with full permission details for UI
+                this.emitEvent({
+                    type: "status",
+                    sessionId: event.sessionId,
+                    data: {
+                        permissionBlocked: true,
+                        permissionRequest: {
+                            scope: data.scope,
+                            target: data.target,
+                            prompt: data.prompt,
+                        },
+                    },
+                });
+                break;
             }
+            case "permission.resolved":
+                record.pendingEscalation = null;
+                record.ptyPermissionBlocked = false;
+                this.emitEvent({
+                    type: "status",
+                    sessionId: event.sessionId,
+                    data: { permissionBlocked: false },
+                });
+                break;
+            case "session.id":
+                // Claude session ID captured - already handled in onData
+                break;
+            case "chat.turn":
+                // 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
+                break;
         }
     }
+    /** Check if a command is a Claude CLI command */
+    isClaudeCommand(command) {
+        const trimmed = command.trim();
+        return /^claude\b/.test(trimmed);
+    }
     mustGet(id) {
         const record = this.sessions.get(id);
         if (!record) {
-            throw new Error("Session not found.");
+            console.error("[ProcessManager] Session lookup failed", { sessionId: id });
+            throw new SessionInputError("Session not found.", "SESSION_NOT_FOUND", id);
         }
         return record;
     }
@@ -1095,35 +1716,37 @@ Begin now:`;
         if (os.platform() === "win32") {
             return ["/d", "/s", "/c", command];
         }
-        return ["-ic", command];
+        // -l: login shell — sources ~/.bash_profile, ~/.profile, etc., ensuring PATH
+        //      and other env vars set by profile files are available.
+        // -c: run the following command.
+        // Using -ic (interactive + command) skips login-shell initialization on many
+        // platforms, which causes commands that depend on profile-set env vars to fail
+        // immediately with "command not found" — a silent exit before onExit is ready.
+        return ["-lc", command];
     }
-    processCommandForMode(command, mode) {
-        // For full-access mode with claude commands, add permission flags (skip for root)
-        if (mode === "full-access" && /^claude(?:\s|$)/.test(command) && !isRunningAsRoot()) {
-            // Check if permission-mode is already specified
-            if (!/--permission-mode\b/.test(command)) {
-                // Add --permission-mode bypassPermissions for full-access mode
-                if (command === "claude") {
-                    return "claude --permission-mode bypassPermissions";
-                }
-                return command.replace(/^claude\s/, "claude --permission-mode bypassPermissions ");
-            }
+    shouldAutoApprovePermissions(command, mode) {
+        if (!/^claude(?:\s|$)/.test(command)) {
+            return false;
+        }
+        // Root mode: always auto-approve (Claude CLI refuses --permission-mode bypassPermissions under root)
+        if (isRunningAsRoot()) {
+            return true;
+        }
+        if (mode === "full-access" || mode === "auto-edit") {
+            return true;
         }
+        if (mode === "managed" || mode === "native") {
+            return true;
+        }
+        return false;
+    }
+    processCommandForMode(command, _mode) {
+        // Don't automatically add --enable-auto-mode as it may not be available
+        // for all plans and can cause issues with normal interactive mode.
+        // Let users specify it explicitly if they want auto mode.
         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 normalizePtyOutput(value) {
-    return value.replace(/\r\r\n/g, "\r\n");
-}
 function clampDimension(value, min, max) {
     if (!Number.isFinite(value)) {
         return min;