codekin 0.5.0 → 0.5.1

package/server/dist/session-manager.js

@@ -24,6 +24,7 @@ import { homedir } from 'os';
 import path from 'path';
 import { promisify } from 'util';
 import { ClaudeProcess } from './claude-process.js';
+import { PlanManager } from './plan-manager.js';
 import { SessionArchive } from './session-archive.js';
 import { cleanupWorkspace } from './webhook-workspace.js';
 import { PORT } from './config.js';
@@ -36,8 +37,6 @@ import { evaluateRestart } from './session-restart-scheduler.js';
 const execFileAsync = promisify(execFile);
 /** Max messages retained in a session's output history buffer. */
 const MAX_HISTORY = 2000;
-/** No-output duration before emitting a stall warning (5 minutes). */
-const STALL_TIMEOUT_MS = 5 * 60 * 1000;
 /** Max API error retries per turn before giving up. */
 const MAX_API_RETRIES = 3;
 /** Base delay for API error retry (doubles each attempt: 3s, 6s, 12s). */
@@ -91,6 +90,10 @@ export class SessionManager {
             rename: (sessionId, newName) => this.rename(sessionId, newName),
         });
         this.sessionPersistence.restoreFromDisk();
+        // Wire PlanManager events for restored sessions
+        for (const session of this.sessions.values()) {
+            this.wirePlanManager(session);
+        }
     }
     // ---------------------------------------------------------------------------
     // Approval — direct accessor (callers use sessions.approvalManager.xxx)
@@ -143,7 +146,6 @@ export class SessionManager {
             restartCount: 0,
             lastRestartAt: null,
             _stoppedByUser: false,
-            _stallTimer: null,
             _wasActiveBeforeRestart: false,
             _apiRetryCount: 0,
             _turnCount: 0,
@@ -152,7 +154,9 @@ export class SessionManager {
             pendingControlRequests: new Map(),
             pendingToolApprovals: new Map(),
             _leaveGraceTimer: null,
+            planManager: new PlanManager(),
         };
+        this.wirePlanManager(session);
         this.sessions.set(id, session);
         this.persistToDisk();
         this._globalBroadcast?.({ type: 'sessions_updated' });
@@ -327,6 +331,11 @@ export class SessionManager {
      *  The `willRestart` flag indicates whether the session will be auto-restarted. */
     onSessionExit(listener) {
         this._exitListeners.push(listener);
+        return () => {
+            const idx = this._exitListeners.indexOf(listener);
+            if (idx >= 0)
+                this._exitListeners.splice(idx, 1);
+        };
     }
     /** Register a listener called when any session emits a prompt (permission request or question). */
     onSessionPrompt(listener) {
@@ -335,6 +344,11 @@ export class SessionManager {
     /** Register a listener called when any session completes a turn (result event). */
     onSessionResult(listener) {
         this._resultListeners.push(listener);
+        return () => {
+            const idx = this._resultListeners.indexOf(listener);
+            if (idx >= 0)
+                this._resultListeners.splice(idx, 1);
+        };
     }
     get(id) {
         return this.sessions.get(id);
@@ -488,7 +502,6 @@ export class SessionManager {
             return false;
         // Prevent auto-restart when deleting
         session._stoppedByUser = true;
-        this.clearStallTimer(session);
         if (session._apiRetryTimer)
             clearTimeout(session._apiRetryTimer);
         if (session._namingTimer)
@@ -603,7 +616,6 @@ export class SessionManager {
         this.wireClaudeEvents(cp, session, sessionId);
         cp.start();
         session.claudeProcess = cp;
-        this.resetStallTimer(session);
         this._globalBroadcast?.({ type: 'sessions_updated' });
         const startMsg = { type: 'claude_started', sessionId };
         this.addToHistory(session, startMsg);
@@ -622,11 +634,23 @@ export class SessionManager {
         cp.on('image', (base64Data, mediaType) => this.onImageEvent(session, base64Data, mediaType));
         cp.on('tool_active', (toolName, toolInput) => this.onToolActiveEvent(session, toolName, toolInput));
         cp.on('tool_done', (toolName, summary) => this.onToolDoneEvent(session, toolName, summary));
-        cp.on('planning_mode', (active) => { this.broadcastAndHistory(session, { type: 'planning_mode', active }); });
+        cp.on('planning_mode', (active) => {
+            // Route EnterPlanMode through PlanManager for UI state tracking.
+            // ExitPlanMode (active=false) is ignored here — the PreToolUse hook
+            // is the enforcement gate, and it calls handleExitPlanModeApproval()
+            // which transitions PlanManager to 'reviewing'.
+            if (active) {
+                session.planManager.onEnterPlanMode();
+            }
+            // ExitPlanMode stream event intentionally ignored — hook handles it.
+        });
         cp.on('todo_update', (tasks) => { this.broadcastAndHistory(session, { type: 'todo_update', tasks }); });
         cp.on('prompt', (...args) => this.onPromptEvent(session, ...args));
         cp.on('control_request', (requestId, toolName, toolInput) => this.onControlRequestEvent(cp, session, sessionId, requestId, toolName, toolInput));
-        cp.on('result', (result, isError) => { this.resetStallTimer(session); this.handleClaudeResult(session, sessionId, result, isError); });
+        cp.on('result', (result, isError) => {
+            session.planManager.onTurnEnd();
+            this.handleClaudeResult(session, sessionId, result, isError);
+        });
         cp.on('error', (message) => this.broadcast(session, { type: 'error', message }));
         cp.on('exit', (code, signal) => { cp.removeAllListeners(); this.handleClaudeExit(session, sessionId, code, signal); });
     }
@@ -635,6 +659,20 @@ export class SessionManager {
         this.addToHistory(session, msg);
         this.broadcast(session, msg);
     }
+    /**
+     * Wire PlanManager events for a session.
+     * Called once at session creation (not per-process, since PlanManager outlives restarts).
+     * Idempotent — guards against double-wiring on restore + restart.
+     */
+    wirePlanManager(session) {
+        if (session._planManagerWired)
+            return;
+        session._planManagerWired = true;
+        const pm = session.planManager;
+        pm.on('planning_mode', (active) => {
+            this.broadcastAndHistory(session, { type: 'planning_mode', active });
+        });
+    }
     onSystemInit(cp, session, model) {
         session.claudeSessionId = cp.getSessionId();
         // Only show model message on first init or when model actually changes
@@ -644,30 +682,24 @@ export class SessionManager {
         }
     }
     onTextEvent(session, sessionId, text) {
-        this.resetStallTimer(session);
         this.broadcastAndHistory(session, { type: 'output', data: text });
         if (session.name.startsWith('hub:') && !session._namingTimer) {
             this.scheduleSessionNaming(sessionId);
         }
     }
     onThinkingEvent(session, summary) {
-        this.resetStallTimer(session);
         this.broadcast(session, { type: 'thinking', summary });
     }
     onToolOutputEvent(session, content, isError) {
-        this.resetStallTimer(session);
         this.broadcastAndHistory(session, { type: 'tool_output', content, isError });
     }
     onImageEvent(session, base64, mediaType) {
-        this.resetStallTimer(session);
         this.broadcastAndHistory(session, { type: 'image', base64, mediaType });
     }
     onToolActiveEvent(session, toolName, toolInput) {
-        this.resetStallTimer(session);
         this.broadcastAndHistory(session, { type: 'tool_active', toolName, toolInput });
     }
     onToolDoneEvent(session, toolName, summary) {
-        this.resetStallTimer(session);
         this.broadcastAndHistory(session, { type: 'tool_done', toolName, summary });
     }
     onPromptEvent(session, promptType, question, options, multiSelect, toolName, toolInput, requestId, questions) {
@@ -806,6 +838,16 @@ export class SessionManager {
                 this.broadcast(session, msg);
             }
         }
+        // Suppress noise from orchestrator/agent sessions: if the entire turn's
+        // text output is a short, low-value phrase, strip it from history so it
+        // doesn't pollute the chat or replay on rejoin.
+        if ((session.source === 'orchestrator' || session.source === 'agent') && !isError) {
+            const turnText = this.extractCurrentTurnText(session);
+            if (turnText && turnText.length < 80 && /^(no response requested|please approve|nothing to do|no action needed|acknowledged)[.!]?$/i.test(turnText.trim())) {
+                this.stripCurrentTurnOutput(session);
+                console.log(`[noise-filter] suppressed orchestrator noise: "${turnText.trim().slice(0, 60)}"`);
+            }
+        }
         const resultMsg = { type: 'result' };
         this.addToHistory(session, resultMsg);
         this.broadcast(session, resultMsg);
@@ -835,7 +877,7 @@ export class SessionManager {
     handleClaudeExit(session, sessionId, code, signal) {
         session.claudeProcess = null;
         session.isProcessing = false;
-        this.clearStallTimer(session);
+        session.planManager.reset();
         this._globalBroadcast?.({ type: 'sessions_updated' });
         const action = evaluateRestart({
             restartCount: session.restartCount,
@@ -965,6 +1007,8 @@ export class SessionManager {
         const session = this.sessions.get(sessionId);
         if (!session)
             return;
+        // ExitPlanMode approvals are handled through the normal pendingToolApprovals
+        // path (routed via the PreToolUse hook). No special plan_review_ prefix needed.
         // Check for pending tool approval from PreToolUse hook
         if (!requestId) {
             const totalPending = session.pendingToolApprovals.size + session.pendingControlRequests.size;
@@ -1045,6 +1089,27 @@ export class SessionManager {
             this.broadcast(session, { type: 'prompt_dismiss', requestId: approval.requestId });
             return;
         }
+        // ExitPlanMode: route through PlanManager for state tracking.
+        // The hook will convert allow→deny-with-approval-message (CLI workaround).
+        if (approval.toolName === 'ExitPlanMode') {
+            const first = Array.isArray(value) ? value[0] : value;
+            const isDeny = first === 'deny';
+            if (isDeny) {
+                // Extract feedback text if present (value may be ['deny', 'feedback text'])
+                const feedback = Array.isArray(value) && value.length > 1 ? value[1] : undefined;
+                const reason = session.planManager.deny(approval.requestId, feedback);
+                console.log(`[plan-approval] denied: ${reason}`);
+                approval.resolve({ allow: false, always: false });
+            }
+            else {
+                session.planManager.approve(approval.requestId);
+                console.log(`[plan-approval] approved`);
+                approval.resolve({ allow: true, always: false });
+            }
+            session.pendingToolApprovals.delete(approval.requestId);
+            this.broadcast(session, { type: 'prompt_dismiss', requestId: approval.requestId });
+            return;
+        }
         const { isDeny, isAlwaysAllow, isApprovePattern } = this.decodeApprovalValue(value);
         if (isAlwaysAllow && !isDeny) {
             this._approvalManager.saveAlwaysAllow(session.groupDir ?? session.workingDir, approval.toolName, approval.toolInput);
@@ -1056,12 +1121,6 @@ export class SessionManager {
         approval.resolve({ allow: !isDeny, always: isAlwaysAllow || isApprovePattern });
         session.pendingToolApprovals.delete(approval.requestId);
         this.broadcast(session, { type: 'prompt_dismiss', requestId: approval.requestId });
-        // When ExitPlanMode is approved via the PreToolUse hook, immediately clear
-        // pending state and emit planning_mode:false. The control_request path may
-        // never arrive (or arrive as is_error=true), so this ensures plan mode exits.
-        if (approval.toolName === 'ExitPlanMode' && !isDeny) {
-            session.claudeProcess?.clearPendingExitPlanMode();
-        }
     }
     /**
      * Send an AskUserQuestion control response, mapping the user's answer(s) into
@@ -1132,6 +1191,11 @@ export class SessionManager {
             return Promise.resolve({ allow: true, always: false });
         }
         console.log(`[tool-approval] requesting approval: session=${sessionId} tool=${toolName} clients=${session.clients.size}`);
+        // ExitPlanMode: route through PlanManager state machine for plan-specific
+        // approval UI. The hook blocks until we resolve the promise.
+        if (toolName === 'ExitPlanMode') {
+            return this.handleExitPlanModeApproval(session, sessionId);
+        }
         // Prevent double-gating: if a control_request already created a pending
         // entry for this tool, auto-approve the control_request and let the hook
         // take over as the sole approval gate.  This is the reverse of the check
@@ -1167,7 +1231,7 @@ export class SessionManager {
                     this.broadcast(session, { type: 'prompt_dismiss', requestId: approvalRequestId });
                     resolve({ allow: false, always: false });
                 }
-            }, isQuestion || toolName === 'ExitPlanMode' ? 300_000 : (session.source === 'agent' ? 300_000 : 60_000)); // 5 min for questions, plan exit & agent children, 1 min for interactive
+            }, isQuestion ? 300_000 : (session.source === 'agent' ? 300_000 : 60_000)); // 5 min for questions & agent children, 1 min for interactive
             let promptMsg;
             if (isQuestion) {
                 // AskUserQuestion: extract structured questions from toolInput.questions
@@ -1242,6 +1306,66 @@ export class SessionManager {
             }
         });
     }
+    /**
+     * Handle ExitPlanMode approval through PlanManager.
+     * Shows a plan-specific approval prompt (Approve/Reject) and blocks the hook
+     * until the user responds. On approve, returns allow:true (the hook will use
+     * the deny-with-approval-message workaround). On deny, returns allow:false.
+     */
+    handleExitPlanModeApproval(session, sessionId) {
+        const reviewId = session.planManager.onExitPlanModeRequested();
+        if (!reviewId) {
+            // Not in planning state — fall through to allow (CLI handles natively)
+            console.log(`[plan-approval] ExitPlanMode but PlanManager not in planning state, allowing`);
+            return Promise.resolve({ allow: true, always: false });
+        }
+        return new Promise((resolve) => {
+            const timer = { id: null };
+            const wrappedResolve = (result) => {
+                if (timer.id)
+                    clearTimeout(timer.id);
+                resolve(result);
+            };
+            // Timeout: auto-deny after 5 minutes to prevent leaked promises
+            timer.id = setTimeout(() => {
+                if (session.pendingToolApprovals.has(reviewId)) {
+                    console.log(`[plan-approval] timed out, auto-denying`);
+                    session.pendingToolApprovals.delete(reviewId);
+                    session.planManager.deny(reviewId);
+                    this.broadcast(session, { type: 'prompt_dismiss', requestId: reviewId });
+                    resolve({ allow: false, always: false });
+                }
+            }, 300_000);
+            const promptMsg = {
+                type: 'prompt',
+                promptType: 'permission',
+                question: 'Approve plan and start implementation?',
+                options: [
+                    { label: 'Approve', value: 'allow' },
+                    { label: 'Reject', value: 'deny' },
+                ],
+                toolName: 'ExitPlanMode',
+                requestId: reviewId,
+            };
+            session.pendingToolApprovals.set(reviewId, {
+                resolve: wrappedResolve,
+                toolName: 'ExitPlanMode',
+                toolInput: {},
+                requestId: reviewId,
+                promptMsg,
+            });
+            this.broadcast(session, promptMsg);
+            if (session.clients.size === 0) {
+                this._globalBroadcast?.({ ...promptMsg, sessionId, sessionName: session.name });
+            }
+            for (const listener of this._promptListeners) {
+                try {
+                    listener(sessionId, 'permission', 'ExitPlanMode', reviewId);
+                }
+                catch { /* listener error */ }
+            }
+        });
+    }
     /**
      * Check if a tool invocation can be auto-approved without prompting the user.
      * Returns 'registry' if matched by auto-approval rules, 'session' if matched
@@ -1301,8 +1425,6 @@ export class SessionManager {
                 const filePath = String(toolInput.file_path || '');
                 return `Allow Read? \`${filePath}\``;
             }
-            case 'ExitPlanMode':
-                return 'Approve plan and start implementation?';
             default:
                 return `Allow ${toolName}?`;
         }
@@ -1359,7 +1481,6 @@ export class SessionManager {
         const session = this.sessions.get(sessionId);
         if (session?.claudeProcess) {
             session._stoppedByUser = true;
-            this.clearStallTimer(session);
             if (session._apiRetryTimer)
                 clearTimeout(session._apiRetryTimer);
             session.claudeProcess.removeAllListeners();
@@ -1379,7 +1500,6 @@ export class SessionManager {
             return;
         const cp = session.claudeProcess;
         session._stoppedByUser = true;
-        this.clearStallTimer(session);
         if (session._apiRetryTimer)
             clearTimeout(session._apiRetryTimer);
         cp.removeAllListeners();
@@ -1396,6 +1516,32 @@ export class SessionManager {
     isRetryableApiError(text) {
         return API_RETRY_PATTERNS.some((pattern) => pattern.test(text));
     }
+    /** Extract the concatenated text output from the current turn (after the last 'result' in history). */
+    extractCurrentTurnText(session) {
+        let text = '';
+        for (let i = session.outputHistory.length - 1; i >= 0; i--) {
+            const msg = session.outputHistory[i];
+            if (msg.type === 'result')
+                break;
+            if (msg.type === 'output')
+                text = msg.data + text;
+        }
+        return text;
+    }
+    /** Remove output messages from the current turn in history (after the last 'result'). */
+    stripCurrentTurnOutput(session) {
+        let cutIndex = session.outputHistory.length;
+        for (let i = session.outputHistory.length - 1; i >= 0; i--) {
+            const msg = session.outputHistory[i];
+            if (msg.type === 'result')
+                break;
+            if (msg.type === 'output') {
+                cutIndex = i;
+            }
+        }
+        // Remove output entries from cutIndex onwards (keep non-output entries like tool events)
+        session.outputHistory = session.outputHistory.filter((msg, idx) => idx < cutIndex || msg.type !== 'output');
+    }
     /**
      * Build a condensed text summary of a session's conversation history.
      * Used as context when auto-starting Claude for sessions without a saved
@@ -1459,27 +1605,6 @@ export class SessionManager {
         }
         return `[This session was interrupted by a server restart. Here is the previous conversation for context:]\n${context}\n[End of previous context. The user's new message follows.]`;
     }
-    resetStallTimer(session) {
-        this.clearStallTimer(session);
-        session._stallTimer = setTimeout(() => {
-            session._stallTimer = null;
-            if (!session.claudeProcess?.isAlive())
-                return;
-            const msg = {
-                type: 'system_message',
-                subtype: 'stall',
-                text: 'No output for 5 minutes. The process may be stalled.',
-            };
-            this.addToHistory(session, msg);
-            this.broadcast(session, msg);
-        }, STALL_TIMEOUT_MS);
-    }
-    clearStallTimer(session) {
-        if (session._stallTimer) {
-            clearTimeout(session._stallTimer);
-            session._stallTimer = null;
-        }
-    }
     /**
      * Append a message to a session's output history for replay.
      * Merges consecutive 'output' chunks into a single entry to save space.
@@ -1571,7 +1696,6 @@ export class SessionManager {
                     session.claudeProcess.stop();
                 }));
             }
-            this.clearStallTimer(session);
         }
         this.archive.shutdown();
         if (exitPromises.length === 0)