@co0ontty/wand 0.2.1 → 0.3.0

package/dist/process-manager.js

@@ -1,15 +1,28 @@
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
-import { spawn } from "node:child_process";
 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";
+/** 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,
@@ -38,9 +51,7 @@ const SELECTION_PROMPT_PATTERNS = [
 ];
 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. */
@@ -53,29 +64,86 @@ export class ProcessManager extends EventEmitter {
     storage;
     sessions = new Map();
     logger;
+    lifecycleManager;
     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());
+            // 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
+                });
+                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
+                });
+                this.lifecycleManager.register(snapshot.id, "archived");
+            }
         }
         this.archiveExpiredSessions();
     }
@@ -116,11 +184,15 @@ export class ProcessManager extends EventEmitter {
         // For full-access mode with claude, add permission flags
         const processedCommand = this.processCommandForMode(command, mode);
         const id = randomUUID();
+        const isClaudeCmd = this.isClaudeCommand(command);
         const record = {
             id,
             command,
             cwd: resolvedCwd,
             mode,
+            autonomyPolicy: this.defaultAutonomyPolicy(mode),
+            approvalPolicy: "ask-every-time",
+            allowedScopes: [],
             status: "running",
             exitCode: null,
             startedAt: new Date().toISOString(),
@@ -128,62 +200,105 @@ export class ProcessManager extends EventEmitter {
             output: "",
             archived: false,
             archivedAt: null,
+            permissionBlocked: undefined,
+            pendingEscalation: null,
+            lastEscalationResult: null,
             claudeSessionId: null,
             processId: null,
             ptyProcess: null,
             stopRequested: false,
             confirmWindow: "",
+            ptyPermissionBlocked: false,
             lastAutoConfirmAt: 0,
-            sessionIdWindow: "",
+            autoApprovePermissions: this.shouldAutoApprovePermissions(command, mode),
+            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
         };
+        // 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.ptyBridge) {
+                current.ptyBridge.onExit(exitCode);
+            }
+            current.status = current.stopRequested ? "stopped" : exitCode === 0 ? "exited" : "failed";
+            current.exitCode = current.stopRequested ? null : exitCode;
+            current.endedAt = new Date().toISOString();
+            current.ptyProcess = null;
+            this.lifecycleManager.archive(id, `Session ${current.status}`, current.stopRequested ? "user" : "error");
+            this.persist(current);
+            this.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,93 +310,40 @@ 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);
-                }
-            }
-            if (mode === "full-access") {
+            // 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`);
+            }
+            // Auto-confirm for full-access mode
+            if (rec.autoApprovePermissions) {
                 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.persist(rec);
         });
         if (initialInput) {
             setTimeout(() => {
@@ -311,638 +373,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;
-        }
-    }
-    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
-            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;
-            }
+    /** 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;
         }
-        // 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")
+        // Don't re-emit the same task
+        if (task && task.title === record.lastEmittedTask)
             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")
+        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 }];
-        }
-        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,14 +457,19 @@ Begin now:`;
         if (record.status !== "running") {
             return this.snapshot(record);
         }
+        // Clear any pending task debounce timer
+        if (record.taskDebounceTimer) {
+            clearTimeout(record.taskDebounceTimer);
+            record.taskDebounceTimer = null;
+        }
         try {
             record.stopRequested = true;
-            // For native / managed mode, kill the child process
-            if ((record.mode === "native" || record.mode === "managed") && record.childProcess) {
+            // Kill any running child process (from JSON chat turns)
+            if (record.childProcess) {
                 record.childProcess.kill();
                 record.childProcess = null;
             }
-            // For PTY mode, kill the pty process
+            // Kill the PTY process
             if (record.ptyProcess) {
                 record.ptyProcess.kill();
             }
@@ -976,18 +479,33 @@ Begin now:`;
             record.endedAt = new Date().toISOString();
             record.output += "\n[wand] Failed to stop session cleanly.\n";
         }
+        // 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;
+        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;
+        }
+        // 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,6 +516,10 @@ Begin now:`;
                 // Ignore and continue deleting persisted state.
             }
         }
+        // Always clean up all state references, regardless of current status
+        record.childProcess = null;
+        record.ptyProcess = null;
+        record.ptyBridge = null;
         this.sessions.delete(id);
         this.storage.deleteSession(id);
     }
@@ -1005,11 +527,16 @@ Begin now:`;
         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 +544,117 @@ 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
         };
     }
+    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) {
+        const record = this.mustGet(id);
+        const escalation = record.pendingEscalation;
+        if (!escalation || escalation.requestId !== requestId) {
+            throw new Error("Escalation request not found.");
+        }
+        const finalResolution = resolution ?? "approve_once";
+        record.lastEscalationResult = {
+            requestId,
+            resolution: finalResolution,
+            reason: escalation.reason
+        };
+        if (finalResolution === "deny") {
+            record.pendingEscalation = null;
+            if (record.ptyProcess && record.status === "running") {
+                record.ptyProcess.write("n\r");
+            }
+            record.ptyPermissionBlocked = false;
+            this.persist(record);
+            return this.snapshot(record);
+        }
+        if (finalResolution === "approve_turn") {
+            record.rememberedEscalationScopes.add(escalation.scope);
+            if (escalation.target) {
+                record.rememberedEscalationTargets.add(escalation.target);
+            }
+        }
+        record.pendingEscalation = null;
+        record.ptyPermissionBlocked = false;
+        if (record.ptyProcess && record.status === "running") {
+            record.ptyProcess.write("\r");
+        }
+        this.persist(record);
+        return this.snapshot(record);
+    }
+    approvePermission(id) {
+        const record = this.mustGet(id);
+        // Use bridge for permission resolution
+        if (record.ptyBridge) {
+            record.ptyBridge.resolvePermission("approve_once");
+        }
+        else if (record.ptyProcess && record.status === "running") {
+            record.ptyProcess.write("\r");
+        }
+        record.ptyPermissionBlocked = false;
+        record.pendingEscalation = null;
+        this.persist(record);
+        return this.snapshot(record);
+    }
+    denyPermission(id) {
+        const record = this.mustGet(id);
+        // Use bridge for permission resolution
+        if (record.ptyBridge) {
+            record.ptyBridge.resolvePermission("deny");
+        }
+        else if (record.ptyProcess && record.status === "running") {
+            record.ptyProcess.write("n\r");
+        }
+        record.ptyPermissionBlocked = false;
+        record.pendingEscalation = null;
+        this.persist(record);
+        return this.snapshot(record);
+    }
+    /**
+     * Resolve permission with specific resolution type.
+     * @param resolution - "approve_once", "approve_turn", or "deny"
+     */
+    resolvePermission(id, resolution) {
+        const record = this.mustGet(id);
+        if (record.ptyBridge) {
+            record.ptyBridge.resolvePermission(resolution);
+        }
+        else if (record.ptyProcess && record.status === "running") {
+            if (resolution === "deny") {
+                record.ptyProcess.write("n\r");
+            }
+            else {
+                record.ptyProcess.write("\r");
+            }
+        }
+        record.ptyPermissionBlocked = false;
+        record.pendingEscalation = null;
+        this.persist(record);
+        return this.snapshot(record);
+    }
     persist(record) {
+        // Update messages from bridge before persisting
+        const messages = record.ptyBridge?.getMessages() ?? record.messages;
+        if (messages !== record.messages) {
+            record.messages = messages;
+        }
         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);
+        if (messages.length > 0) {
+            this.logger.saveMessages(record.id, messages);
         }
     }
     archiveExpiredSessions() {
@@ -1054,6 +683,9 @@ Begin now:`;
         }
     }
     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();
@@ -1073,21 +705,101 @@ 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":
+                // 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":
+                // 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 messages
+                record.messages = record.ptyBridge?.getMessages() ?? record.messages;
+                this.lifecycleManager.stopThinking(record.id);
+                this.lifecycleManager.waitingInput(record.id);
+                this.persist(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,20 +807,34 @@ 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;
     }
 }
@@ -1121,9 +847,6 @@ function normalizePromptText(value) {
         .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;