@co0ontty/wand 1.3.3 → 1.3.6

package/dist/process-manager.js

@@ -9,7 +9,7 @@ import { SessionLogger } from "./session-logger.js";
 import { SessionLifecycleManager } from "./session-lifecycle.js";
 import { ClaudePtyBridge } from "./claude-pty-bridge.js";
 import { appendWindow, hasExplicitConfirmSyntax, hasPermissionActionContext, normalizePromptText } from "./pty-text-utils.js";
-import { getResumeCommandSessionId, hasLiveProjectConversation, hasRealConversationMessages, hasStoredProjectConversation, shouldAllowResume, shouldDisplayResumeAction, } from "./resume-policy.js";
+import { getResumeCommandSessionId, hasRealConversationMessages, } from "./resume-policy.js";
 /** Check if the current process is running as root (UID 0). */
 function isRunningAsRoot() {
     return process.getuid?.() === 0 || process.geteuid?.() === 0;
@@ -26,20 +26,6 @@ export class SessionInputError extends Error {
         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,
-    /\((?:y|yes)\s*\/\s*(?:n|no)\)/i,
-    /\((?:y|yes)\s*\/\s*(?:n|no)\s*\/\s*always\)/i,
-    /\bcontinue\?\s*(?:\((?:y|yes)\s*\/\s*(?:n|no)\))?/i,
-    /\bare you sure\??/i,
-    /\bdo you want to continue\??/i,
-    /\bdo you want to (?:create|write|delete|modify|execute)\b/i,
-    /\bconfirm(?:\s+execution|\s+changes|\s+action)?\??/i,
-    /\bproceed\?\s*(?:\((?:y|yes)\s*\/\s*(?:n|no)\))?/i,
-    /\benter to confirm\b/i,
-    /\bgrant\b.*\bpermission\b/i,
-];
 const REAL_CONVERSATION_MIN_LINES = 2;
 const DISCOVERY_RECENT_WINDOW_MS = 10 * 60 * 1000;
 const START_TIME_SKEW_MS = 30 * 1000;
@@ -89,132 +75,6 @@ function readClaudeProjectSessionDetails(filePath, id) {
         return null;
     }
 }
-function hasVisibleProjectConversation(messages) {
-    return shouldDisplayResumeAction(messages);
-}
-function hasRecoverableProjectConversation(messages) {
-    return shouldAllowResume({ claudeSessionId: "resume-candidate", 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 {
@@ -499,7 +359,7 @@ function shouldBackfillClaudeSessionId(record) {
 function snapshotMessages(record) {
     return record.ptyBridge?.getMessages() ?? record.messages;
 }
-const MAX_SESSIONS = 50;
+const MAX_SESSIONS = 200;
 const ARCHIVE_AFTER_MS = 1000 * 60 * 60 * 24;
 const CONFIRM_WINDOW_SIZE = 800;
 // Claude 会话 ID 格式：UUID v4
@@ -557,9 +417,7 @@ export class ProcessManager extends EventEmitter {
             onStateChange: (sessionId, oldState, newState) => {
                 this.emitEvent({ type: "status", sessionId, data: { oldState, newState } });
             },
-            onIdle: (sessionId) => {
-                console.error(`[ProcessManager] Session ${sessionId} is now idle`);
-            },
+            onIdle: (_sessionId) => { },
             onArchived: (sessionId, reason) => {
                 console.error(`[ProcessManager] Session ${sessionId} archived: ${reason}`);
             },
@@ -599,7 +457,8 @@ export class ProcessManager extends EventEmitter {
                     knownClaudeTaskIds: undefined,
                     claudeTaskDiscoveryTimer: null,
                     knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(updated.cwd) : undefined,
-                    claudeSessionId: resumeCommandSessionId ?? updated.claudeSessionId
+                    claudeSessionId: resumeCommandSessionId ?? updated.claudeSessionId,
+                    approvalStats: { tool: 0, command: 0, file: 0, total: 0 }
                 });
                 this.lifecycleManager.register(snapshot.id, "idle");
                 console.error(`[ProcessManager] Restored session ${snapshot.id} marked as exited (PTY orphaned)`);
@@ -631,7 +490,8 @@ export class ProcessManager extends EventEmitter {
                     knownClaudeTaskIds: undefined,
                     claudeTaskDiscoveryTimer: null,
                     knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(snapshot.cwd) : undefined,
-                    claudeSessionId: resumeCommandSessionId ?? snapshot.claudeSessionId
+                    claudeSessionId: resumeCommandSessionId ?? snapshot.claudeSessionId,
+                    approvalStats: { tool: 0, command: 0, file: 0, total: 0 }
                 });
                 this.lifecycleManager.register(snapshot.id, "archived");
             }
@@ -651,24 +511,33 @@ export class ProcessManager extends EventEmitter {
         this.emit("process", event);
     }
     cleanupOldSessions() {
-        // Remove oldest finished sessions if we're at the limit
+        // Only clean up when well over the limit
         if (this.sessions.size < MAX_SESSIONS)
             return;
-        const finishedIds = [];
+        const now = Date.now();
+        const STALE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+        const removable = [];
         for (const [id, record] of this.sessions) {
-            if (record.status !== "running") {
-                finishedIds.push(id);
+            // Only remove archived, non-running sessions older than 7 days
+            if (record.status === "running")
+                continue;
+            if (!record.archived)
+                continue;
+            const ref = record.endedAt ?? record.startedAt;
+            const refMs = Date.parse(ref);
+            if (Number.isFinite(refMs) && now - refMs > STALE_MS) {
+                removable.push(id);
             }
         }
-        // Remove oldest finished sessions first
-        finishedIds
+        // Sort oldest first and remove enough to get back under the limit
+        const toRemove = removable
             .sort((a, b) => {
             const ra = this.sessions.get(a);
             const rb = this.sessions.get(b);
             return (ra?.endedAt || "").localeCompare(rb?.endedAt || "");
         })
-            .slice(0, this.sessions.size - MAX_SESSIONS + 1)
-            .forEach((id) => {
+            .slice(0, this.sessions.size - MAX_SESSIONS + 1);
+        for (const id of toRemove) {
             const record = this.sessions.get(id);
             if (record) {
                 this.logger.deleteSession(id);
@@ -677,7 +546,7 @@ export class ProcessManager extends EventEmitter {
             this.sessions.delete(id);
             this.lastPersistedMessageCount.delete(id);
             this.storage.deleteSession(id);
-        });
+        }
     }
     start(command, cwd, mode, initialInput, opts) {
         this.assertCommandAllowed(command);
@@ -732,7 +601,8 @@ export class ProcessManager extends EventEmitter {
             lastEmittedTask: null,
             knownClaudeTaskIds: knownClaudeTaskIds ?? undefined,
             claudeTaskDiscoveryTimer: null,
-            knownClaudeProjectMtimes: knownClaudeProjectMtimes ?? undefined
+            knownClaudeProjectMtimes: knownClaudeProjectMtimes ?? undefined,
+            approvalStats: { tool: 0, command: 0, file: 0, total: 0 }
         };
         // Create PTY bridge for this session
         record.ptyBridge = new ClaudePtyBridge({
@@ -835,7 +705,7 @@ export class ProcessManager extends EventEmitter {
                 process.stderr.write(`[wand] Cannot send initial input: session not ready\n`);
                 return;
             }
-            process.stderr.write(`[wand] Sending initial input: ${initialInput}\n`);
+            process.stderr.write(`[wand] Sending initial input (${initialInput.length} chars)\n`);
             // Track initial input via bridge for Chat mode
             if (current.ptyBridge) {
                 current.ptyBridge.onUserInput(initialInput);
@@ -989,8 +859,10 @@ export class ProcessManager extends EventEmitter {
     get(id) {
         this.archiveExpiredSessions();
         const record = this.sessions.get(id);
-        if (!record)
-            return null;
+        if (!record) {
+            // Fallback: check SQLite for sessions that were evicted from memory
+            return this.storage.getSession(id) ?? null;
+        }
         // For sessions loaded from storage on startup, in-memory output starts empty.
         // Prefer in-memory output (live PTY data), fall back to stored output.
         if (!record.output && record.storedOutput) {
@@ -1001,35 +873,16 @@ export class ProcessManager extends EventEmitter {
     sendInput(id, input, view, shortcutKey) {
         const record = this.mustGet(id);
         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"
-            });
+            console.error(`[ProcessManager] Rejecting input: session ${id} not running (${record.status})`);
             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"
-            });
+            console.error(`[ProcessManager] Rejecting input: session ${id} has no PTY`);
             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"
-        });
         // Log shortcut key interactions for auto-confirm and mode analysis
         if (shortcutKey) {
             const outputLines = record.output.split("\n");
@@ -1242,7 +1095,8 @@ export class ProcessManager extends EventEmitter {
             messages: messages.length > 0 ? messages : undefined,
             resumedFromSessionId: record.resumedFromSessionId ?? undefined,
             resumedToSessionId: record.resumedToSessionId ?? undefined,
-            autoRecovered: record.autoRecovered ?? false
+            autoRecovered: record.autoRecovered ?? false,
+            approvalStats: record.approvalStats.total > 0 ? record.approvalStats : undefined
         };
     }
     isPermissionBlocked(record) {
@@ -1482,11 +1336,9 @@ export class ProcessManager extends EventEmitter {
             || claudeConfirmPrompt
             || toolPermissionPrompt
             || (hasExplicitConfirmSyntax(normalized)
-                && hasPermissionActionContext(normalized)
-                && PROMPT_PATTERNS.some((pattern) => pattern.test(normalized)));
+                && hasPermissionActionContext(normalized));
         if (shouldConfirm) {
             record.lastAutoConfirmAt = now;
-            process.stderr.write(`[wand] Auto-confirming prompt for ${record.mode} mode\n`);
             // Always auto-confirm by sending Enter directly
             ptyProcess.write("\r");
         }
@@ -1551,15 +1403,50 @@ export class ProcessManager extends EventEmitter {
                 });
                 break;
             }
-            case "permission.resolved":
+            case "permission.resolved": {
+                // Increment approval stats before clearing pendingEscalation
+                const resolvedScope = record.pendingEscalation?.scope;
+                if (resolvedScope) {
+                    if (resolvedScope === "run_command" || resolvedScope === "dangerous_shell") {
+                        record.approvalStats.command++;
+                    }
+                    else if (resolvedScope === "write_file") {
+                        record.approvalStats.file++;
+                    }
+                    else {
+                        record.approvalStats.tool++;
+                    }
+                    record.approvalStats.total++;
+                }
                 record.pendingEscalation = null;
                 record.ptyPermissionBlocked = false;
                 this.emitEvent({
                     type: "status",
                     sessionId: event.sessionId,
-                    data: { permissionBlocked: false },
+                    data: {
+                        permissionBlocked: false,
+                        approvalStats: record.approvalStats,
+                    },
                 });
+                // Log auto-approve events to shortcut-interactions.jsonl for analysis
+                const resolvedData = event.data;
+                if (resolvedData?.autoApproved) {
+                    const outputLines = record.output.split("\n");
+                    const tailLines = outputLines.slice(-8).join("\n");
+                    this.logger.appendShortcutLog(record.id, "auto_approve", tailLines, {
+                        mode: record.mode,
+                        scope: resolvedScope ?? "unknown",
+                        autoApprove: record.autoApprovePermissions,
+                        permissionBlocked: true,
+                        input: "\r",
+                        approveType: resolvedData.approveType,
+                        score: resolvedData.score,
+                        matched: resolvedData.matched,
+                        falsePositive: resolvedData.falsePositive,
+                    });
+                }
                 break;
+            }
             case "session.id":
                 // Claude session ID captured - already handled in onData
                 break;
@@ -1622,15 +1509,25 @@ export class ProcessManager extends EventEmitter {
         return false;
     }
     processCommandForMode(command, mode) {
+        const isClaudeCmd = /^(?:claude|npx\s+claude|[^\s]+\/claude)(?:\s|$)/.test(command);
+        if (!isClaudeCmd)
+            return command;
+        let result = command;
+        // When running as root, Claude CLI refuses --permission-mode bypassPermissions.
+        // Use acceptEdits to let Claude auto-accept edits natively, reducing the number
+        // of permission prompts wand has to auto-approve.
+        if (isRunningAsRoot() && (mode === "managed" || mode === "full-access" || mode === "auto-edit")) {
+            result += " --permission-mode acceptEdits";
+        }
         // In managed mode, append a system prompt instructing Claude to act autonomously
         // without asking the user for confirmation, since the user may not be monitoring.
-        if (mode === "managed" && /^(?:claude|npx\s+claude|[^\s]+\/claude)(?:\s|$)/.test(command)) {
+        if (mode === "managed") {
             const autonomousPrompt = "You are running in a fully managed, autonomous mode. The user may not be available to respond to questions or confirmations in a timely manner. You MUST make all decisions independently — choose the best approach yourself instead of asking the user for preferences, confirmations, or clarifications. If multiple approaches are viable, pick the one you judge most appropriate and proceed. Never block on user input unless the task is fundamentally ambiguous and cannot be reasonably inferred. Be decisive and self-directed.";
             // Escape single quotes for shell safety
             const escaped = autonomousPrompt.replace(/'/g, "'\\''");
-            return `${command} --append-system-prompt '${escaped}'`;
+            result += ` --append-system-prompt '${escaped}'`;
         }
-        return command;
+        return result;
     }
 }
 function clampDimension(value, min, max) {

package/dist/pty-text-utils.d.ts

@@ -11,5 +11,17 @@ export declare function isNoiseLine(line: string): boolean;
 export declare function appendWindow(buffer: string, chunk: string, maxSize: number): string;
 export declare function hasExplicitConfirmSyntax(normalized: string): boolean;
 export declare function hasPermissionActionContext(normalized: string): boolean;
+interface PermissionScore {
+    score: number;
+    matched: string[];
+}
+/** Minimum score threshold for fallback permission detection */
+export declare const FALLBACK_SCORE_THRESHOLD = 8;
+/**
+ * Score how likely the recent output contains a permission prompt.
+ * Evaluates the last few lines of normalized text against weighted keywords.
+ */
+export declare function scorePermissionLikelihood(normalized: string): PermissionScore;
 /** Normalize prompt text for permission detection (strip ANSI, collapse whitespace). */
 export declare function normalizePromptText(value: string): string;
+export {};

package/dist/pty-text-utils.js

@@ -77,8 +77,10 @@ const EXPLICIT_CONFIRM_PATTERNS = [
     /\[(?:y|yes)\s*\/\s*(?:n|no)\]/i,
     /\((?:y|yes)\s*\/\s*(?:n|no)\)/i,
     /\((?:y|yes)\s*\/\s*(?:n|no)\s*\/\s*always\)/i,
-    /\byes\b.*\bno\b/i,
+    /\byes\b[\s\S]*\bno\b/i,
     /\benter to confirm\b/i,
+    // Claude CLI numbered selection menus: "❯ 1. Yes" + "N. No"
+    /❯\s*1\.\s*yes\b/i,
 ];
 const PERMISSION_ACTION_PATTERNS = [
     /\bgrant\b.*\bpermission\b/i,
@@ -92,6 +94,40 @@ export function hasExplicitConfirmSyntax(normalized) {
 export function hasPermissionActionContext(normalized) {
     return PERMISSION_ACTION_PATTERNS.some((pattern) => pattern.test(normalized));
 }
+const PERMISSION_KEYWORD_WEIGHTS = [
+    { pattern: /\bdo you want to proceed\b/i, weight: 5, label: "do you want to proceed" },
+    { pattern: /\bwould you like to proceed\b/i, weight: 5, label: "would you like to proceed" },
+    { pattern: /\bdo you want to\b/i, weight: 4, label: "do you want to" },
+    { pattern: /\bwould you like to\b/i, weight: 4, label: "would you like to" },
+    { pattern: /\benter to confirm\b/i, weight: 4, label: "enter to confirm" },
+    { pattern: /\bgrant\b[\s\S]*\bpermission\b/i, weight: 4, label: "grant permission" },
+    { pattern: /❯\s*1\./i, weight: 3, label: "❯ 1." },
+    { pattern: /\b1\.\s*yes\b/i, weight: 3, label: "1. yes" },
+    { pattern: /\bdon'?t ask again\b/i, weight: 2, label: "don't ask again" },
+    { pattern: /\b(?:bash|shell)\s*command\b/i, weight: 2, label: "bash/shell command" },
+    { pattern: /\b(?:run|read|write|edit)\s+(?:file|command|shell)\b/i, weight: 2, label: "run/read/write action" },
+    { pattern: /\ballow\b.*\breading\b/i, weight: 2, label: "allow reading" },
+];
+/** Minimum score threshold for fallback permission detection */
+export const FALLBACK_SCORE_THRESHOLD = 8;
+/**
+ * Score how likely the recent output contains a permission prompt.
+ * Evaluates the last few lines of normalized text against weighted keywords.
+ */
+export function scorePermissionLikelihood(normalized) {
+    // Take the last ~5 lines
+    const lines = normalized.split("\n");
+    const tail = lines.slice(-8).join("\n");
+    let score = 0;
+    const matched = [];
+    for (const { pattern, weight, label } of PERMISSION_KEYWORD_WEIGHTS) {
+        if (pattern.test(tail)) {
+            score += weight;
+            matched.push(label);
+        }
+    }
+    return { score, matched };
+}
 /** Normalize prompt text for permission detection (strip ANSI, collapse whitespace). */
 export function normalizePromptText(value) {
     return value

package/dist/server-session-routes.d.ts

@@ -2,5 +2,6 @@ import { Express } from "express";
 import { ProcessManager } from "./process-manager.js";
 import { WandStorage } from "./storage.js";
 import { ExecutionMode } from "./types.js";
+export declare function getErrorMessage(error: unknown, fallback: string): string;
 export declare function registerSessionRoutes(app: Express, processes: ProcessManager, storage: WandStorage, defaultMode: ExecutionMode): void;
 export declare function registerClaudeHistoryRoutes(app: Express, processes: ProcessManager, storage: WandStorage): void;

package/dist/server-session-routes.js

@@ -1,7 +1,7 @@
 import express from "express";
 import { parseMessages } from "./message-parser.js";
 import { SessionInputError } from "./process-manager.js";
-function getErrorMessage(error, fallback) {
+export function getErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
 function getInputErrorResponse(error, sessionId) {
@@ -184,10 +184,8 @@ export function registerSessionRoutes(app, processes, storage, defaultMode) {
         const input = body.input ?? "";
         const view = body.view;
         const shortcutKey = body.shortcutKey;
-        console.error("[wand] Input request received", { sessionId, inputLength: input.length, view: view ?? "chat" });
         try {
             const snapshot = processes.sendInput(sessionId, input, view, shortcutKey);
-            console.error("[wand] Input request succeeded", { sessionId, status: snapshot.status, inputLength: input.length, view: view ?? "chat" });
             res.json(snapshot);
         }
         catch (error) {

package/dist/server.js

@@ -58,16 +58,12 @@ import { ensureCertificates } from "./cert.js";
 import { isExecutionMode, resolveConfigDir, saveConfig } from "./config.js";
 import { ProcessManager } from "./process-manager.js";
 import { generatePwaManifest, generateServiceWorker } from "./pwa.js";
-import { registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-session-routes.js";
+import { getErrorMessage, registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-session-routes.js";
 import { resolveDatabasePath, WandStorage } from "./storage.js";
 import { renderApp } from "./web-ui/index.js";
 import { WsBroadcastManager } from "./ws-broadcast.js";
 import { checkRateLimit, recordFailedLogin, resetRateLimit } from "./middleware/rate-limit.js";
 import { isPathWithinBase, isBlockedFolderPath, normalizeFolderPath } from "./middleware/path-safety.js";
-// ── Error helpers ──
-function getErrorMessage(error, fallback) {
-    return error instanceof Error ? error.message : fallback;
-}
 // ── Git helpers ──
 async function isGitRepo(dirPath) {
     try {
@@ -221,23 +217,6 @@ function parseStoredPathList(raw) {
         return [];
     }
 }
-const HIDDEN_CLAUDE_SESSIONS_KEY = "hidden_claude_sessions";
-function getHiddenClaudeSessionIds(storage) {
-    return new Set(parseStoredPathList(storage.getConfigValue(HIDDEN_CLAUDE_SESSIONS_KEY)));
-}
-function saveHiddenClaudeSessionIds(storage, hidden) {
-    storage.setConfigValue(HIDDEN_CLAUDE_SESSIONS_KEY, JSON.stringify(Array.from(hidden)));
-}
-function removeFromHiddenClaudeSessionIds(storage, idsToRemove) {
-    const hidden = getHiddenClaudeSessionIds(storage);
-    let changed = false;
-    for (const id of idsToRemove) {
-        if (hidden.delete(id))
-            changed = true;
-    }
-    if (changed)
-        saveHiddenClaudeSessionIds(storage, hidden);
-}
 const MAX_RECENT_PATHS = 10;
 // ── File language detection ──
 function getLanguageFromExt(ext, filePath) {
@@ -289,18 +268,14 @@ export async function startServer(config, configPath) {
         res.setHeader("Content-Type", "application/manifest+json");
         res.send(generatePwaManifest());
     });
-    app.get("/icon.svg", (_req, res) => {
-        res.type("image/svg+xml").send(getAvatarSvg(avatarSeed, 192));
-    });
+    for (const [route, size] of [["/icon.svg", 192], ["/icon-192.png", 192], ["/icon-512.png", 512]]) {
+        app.get(route, (_req, res) => {
+            res.type("image/svg+xml").send(getAvatarSvg(avatarSeed, size));
+        });
+    }
     const iconsDir = path.resolve(existsSync(path.join(SERVER_MODULE_DIR, "web-ui", "content"))
         ? path.join(SERVER_MODULE_DIR, "web-ui", "content")
         : path.join(RUNTIME_ROOT_DIR, "src", "web-ui", "content"));
-    app.get("/icon-192.png", (_req, res) => {
-        res.type("image/svg+xml").send(getAvatarSvg(avatarSeed, 192));
-    });
-    app.get("/icon-512.png", (_req, res) => {
-        res.type("image/svg+xml").send(getAvatarSvg(avatarSeed, 512));
-    });
     app.get("/sw.js", (_req, res) => {
         res.setHeader("Content-Type", "application/javascript");
         res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");

package/dist/session-lifecycle.js

@@ -25,7 +25,6 @@ export class SessionLifecycleManager {
             lastActivityAt: Date.now(),
         };
         this.sessions.set(sessionId, lifecycle);
-        console.error(`[Lifecycle] Session ${sessionId} registered with state: ${initialState}`);
     }
     /**
      * Update session state
@@ -33,7 +32,6 @@ export class SessionLifecycleManager {
     setState(sessionId, newState) {
         const lifecycle = this.sessions.get(sessionId);
         if (!lifecycle) {
-            console.error(`[Lifecycle] Session ${sessionId} not found`);
             return;
         }
         const oldState = lifecycle.state;
@@ -43,7 +41,6 @@ export class SessionLifecycleManager {
         lifecycle.state = newState;
         lifecycle.stateSince = Date.now();
         lifecycle.lastActivityAt = Date.now();
-        console.error(`[Lifecycle] Session ${sessionId} state changed: ${oldState} -> ${newState}`);
         // Emit state change event
         this.events.onStateChange?.(sessionId, oldState, newState);
     }
@@ -89,7 +86,6 @@ export class SessionLifecycleManager {
         lifecycle.stateSince = Date.now();
         lifecycle.archivedBy = by;
         lifecycle.archiveReason = reason;
-        console.error(`[Lifecycle] Session ${sessionId} archived: ${reason} (by: ${by})`);
         // Emit archived event
         this.events.onArchived?.(sessionId, reason);
     }
@@ -98,7 +94,6 @@ export class SessionLifecycleManager {
      */
     unregister(sessionId) {
         this.sessions.delete(sessionId);
-        console.error(`[Lifecycle] Session ${sessionId} unregistered`);
     }
     /**
      * Get session lifecycle

package/dist/session-logger.d.ts

@@ -3,12 +3,22 @@ import type { ConversationTurn, ExecutionMode } from "./types.js";
 export interface ShortcutLogContext {
     /** Execution mode the session is running in (e.g. "managed", "full-access") */
     mode: ExecutionMode;
+    /** Permission scope that was approved (e.g. "run_command", "write_file") */
+    scope?: string;
     /** Whether auto-approve is active for this session */
     autoApprove: boolean;
     /** Whether a permission prompt was blocking at the time of the keypress */
     permissionBlocked: boolean;
     /** The actual input string sent to PTY */
     input: string;
+    /** Auto-approve detection type: "strict" | "fallback" | "idle_probe" */
+    approveType?: string;
+    /** Fallback detection score */
+    score?: number;
+    /** Fallback detection matched keywords */
+    matched?: string[];
+    /** Whether the auto-approve was a false positive */
+    falsePositive?: boolean;
 }
 /**
  * SessionLogger saves raw session content to local files for debugging and analysis.

package/dist/types.d.ts

@@ -160,6 +160,13 @@ export interface SessionSnapshot {
     resumedToSessionId?: string | null;
     /** 服务器重启时是否自动恢复 */
     autoRecovered?: boolean;
+    /** 自动批准统计（按类别分） */
+    approvalStats?: {
+        tool: number;
+        command: number;
+        file: number;
+        total: number;
+    };
 }
 export type SessionLifecycleState = "initializing" | "running" | "idle" | "thinking" | "waiting-input" | "archived";
 export interface SessionLifecycle {