refactor: centralize permission prompt detection and clean up resume state

waterdrop86 · claude · waterdrop86 · commit 6adfa8b5ce67 · 2026-03-30T10:18:33.000+08:00
Extract hasPermissionPrompt() into prompt-detect.ts and add permission
detection polling to codex, copilot, and gemini runtimes. Reset stale
last_tool, attention_level, and attention_reason fields on session resume.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/main/session/agent-runtimes/claude-runtime.ts b/src/main/session/agent-runtimes/claude-runtime.ts
@@ -1,7 +1,6 @@
 import { basename, join } from 'node:path';
 import { existsSync } from 'node:fs';
-import { stripAnsi } from '../../../shared/strip-ansi';
-import { isAtClaudePrompt, isAtUserChoice } from '../prompt-detect';
+import { isAtClaudePrompt, isAtUserChoice, hasPermissionPrompt } from '../prompt-detect';
 import { USER_CHOICE_TOOLS } from '../session-state-machine';
 import type {
   AgentCreateContext,
@@ -13,12 +12,6 @@ import type {
   StateUpdate,
 } from '../agent-runtime';
 
-const PERMISSION_PATTERNS = [
-  /Allow\s+once/,
-  /Deny\s+once/,
-  /Allow\s+always/,
-];
-
 /**
  * Poll-based state detection for Claude Code sessions.
  *
@@ -27,15 +20,13 @@ const PERMISSION_PATTERNS = [
  * unavailable) this is the only detection mechanism.
  */
 export function claudePollState(ctx: PtyPollContext): StateUpdate | null {
-  const tail = stripAnsi(ctx.buffer.slice(-2000));
   const rawTail = ctx.buffer.slice(-2000);
-  const hasPermissionPrompt = PERMISSION_PATTERNS.some((re) => re.test(tail));
 
   if (
     (ctx.status === 'active' || ctx.status === 'idle') &&
     ctx.attentionLevel !== 'action' &&
-    hasPermissionPrompt &&
-    ctx.isQuiescent
+    ctx.isQuiescent &&
+    hasPermissionPrompt(rawTail)
   ) {
     // Permission prompt detected: quiescent + pattern visible
     return {
diff --git a/src/main/session/agent-runtimes/codex-runtime.ts b/src/main/session/agent-runtimes/codex-runtime.ts
@@ -2,6 +2,7 @@ import { basename } from 'node:path';
 import { getDb } from '../../db';
 import { logger } from '../../logger';
 import { findCodexThreadMatch } from '../codex-session-store';
+import { hasPermissionPrompt } from '../prompt-detect';
 import type {
   AgentCreateContext,
   AgentPostCreateContext,
@@ -140,6 +141,18 @@ export function buildCodexResumePlan(ctx: AgentPrepareResumeContext): PreparedRe
  * this polling is just a safety net.
  */
 export function codexPollState(ctx: PtyPollContext): StateUpdate | null {
+  if (
+    (ctx.status === 'active' || ctx.status === 'idle') &&
+    ctx.attentionLevel !== 'action' &&
+    ctx.isQuiescent &&
+    hasPermissionPrompt(ctx.buffer)
+  ) {
+    return {
+      status: 'waiting',
+      attention: { level: 'action', reason: 'Permission prompt detected' },
+    };
+  }
+
   if (ctx.status === 'active' && ctx.isQuiescent) {
     return {
       status: 'idle',
@@ -170,4 +183,4 @@ export function createCodexRuntimeAdapter(deps: {
     },
     pollState: codexPollState,
   };
-}
+}
diff --git a/src/main/session/agent-runtimes/copilot-runtime.ts b/src/main/session/agent-runtimes/copilot-runtime.ts
@@ -2,6 +2,7 @@ import { basename } from 'node:path';
 import { getDb } from '../../db';
 import { logger } from '../../logger';
 import { findCopilotSessionId } from '../copilot-session-store';
+import { hasPermissionPrompt } from '../prompt-detect';
 import type {
   AgentCreateContext,
   AgentPostCreateContext,
@@ -133,6 +134,18 @@ export function scheduleCopilotSessionCapture(
  * In Phase 1, hooks are not available so this is the primary detection method.
  */
 export function copilotPollState(ctx: PtyPollContext): StateUpdate | null {
+  if (
+    (ctx.status === 'active' || ctx.status === 'idle') &&
+    ctx.attentionLevel !== 'action' &&
+    ctx.isQuiescent &&
+    hasPermissionPrompt(ctx.buffer)
+  ) {
+    return {
+      status: 'waiting',
+      attention: { level: 'action', reason: 'Permission prompt detected' },
+    };
+  }
+
   if (ctx.status === 'active' && ctx.isQuiescent) {
     return {
       status: 'idle',
diff --git a/src/main/session/agent-runtimes/gemini-runtime.ts b/src/main/session/agent-runtimes/gemini-runtime.ts
@@ -8,6 +8,7 @@ import {
   selectGeminiSessionCandidate,
   type GeminiListedSession,
 } from '../gemini-session-store';
+import { hasPermissionPrompt } from '../prompt-detect';
 import type {
   AgentCreateContext,
   AgentPostCreateContext,
@@ -176,6 +177,18 @@ export function buildGeminiCreatePlan(ctx: AgentCreateContext): PreparedCreate {
  * this polling is just a safety net.
  */
 export function geminiPollState(ctx: PtyPollContext): StateUpdate | null {
+  if (
+    (ctx.status === 'active' || ctx.status === 'idle') &&
+    ctx.attentionLevel !== 'action' &&
+    ctx.isQuiescent &&
+    hasPermissionPrompt(ctx.buffer)
+  ) {
+    return {
+      status: 'waiting',
+      attention: { level: 'action', reason: 'Permission prompt detected' },
+    };
+  }
+
   if (ctx.status === 'active' && ctx.isQuiescent) {
     return {
       status: 'idle',
diff --git a/src/main/session/prompt-detect.ts b/src/main/session/prompt-detect.ts
@@ -1,5 +1,11 @@
 import { stripAnsi } from '../../shared/strip-ansi';
 
+const PERMISSION_PATTERNS = [
+  /Allow\s+once/i,
+  /Deny\s+once/i,
+  /Allow\s+always/i,
+] as const;
+
 /**
  * Check if the terminal buffer tail shows Claude Code's idle prompt (❯).
  * The raw ring buffer is a linear stream — cursor-repositioned content
@@ -19,6 +25,17 @@ export function isAtClaudePrompt(rawBufferTail: string): boolean {
   return after.length < 800 && (after.match(/\n/g) || []).length <= 5;
 }
 
+/**
+ * Check whether the terminal buffer tail contains a known permission prompt.
+ *
+ * These prompts can surface when hook transport is unavailable, so PTY polling
+ * needs a text-based fallback to put the session into `waiting`.
+ */
+export function hasPermissionPrompt(rawBufferTail: string): boolean {
+  const clean = stripAnsi(rawBufferTail.slice(-2000));
+  return PERMISSION_PATTERNS.some((re) => re.test(clean));
+}
+
 /**
  * Check if the terminal buffer tail shows a Claude Code user-choice menu
  * (e.g. ExitPlanMode or AskUserQuestion).  These menus use ❯ as a cursor
diff --git a/src/main/session/session-manager.ts b/src/main/session/session-manager.ts
@@ -417,7 +417,16 @@ export class SessionManager {
   private resumeWithPreparedPlan(sessionId: string, prepared: PreparedResume): SessionInfo {
     const db = getDb();
     db.prepare(
-      `UPDATE sessions SET status = 'starting', ended_at = NULL, hook_mode = ?, auto_close = 0 WHERE session_id = ?`,
+      `UPDATE sessions
+         SET status = 'starting',
+             ended_at = NULL,
+             hook_mode = ?,
+             auto_close = 0,
+             last_tool = NULL,
+             last_event_at = NULL,
+             attention_level = 'none',
+             attention_reason = NULL
+       WHERE session_id = ?`,
     ).run(prepared.hookMode, sessionId);
 
     try {
@@ -1400,4 +1409,3 @@ export function registerSessionIpc(sessionManager: SessionManager): void {
     return sessionManager.importExternal(claudeSessionId, cwd, label);
   });
 }
-
diff --git a/tests/unit/main/codex-runtime.test.ts b/tests/unit/main/codex-runtime.test.ts
@@ -222,6 +222,29 @@ describe('codexPollState', () => {
     });
   });
 
+  it('detects permission prompts before idle fallback', () => {
+    expect(codexPollState(ctx({
+      status: 'active',
+      buffer: 'Allow once\nDeny once\nAllow always\n',
+      isQuiescent: true,
+    }))).toEqual({
+      status: 'waiting',
+      attention: { level: 'action', reason: 'Permission prompt detected' },
+    });
+  });
+
+  it('does not re-trigger permission detection when action attention is already set', () => {
+    expect(codexPollState(ctx({
+      status: 'active',
+      attentionLevel: 'action',
+      buffer: 'Allow once\nDeny once\nAllow always\n',
+      isQuiescent: true,
+    }))).toEqual({
+      status: 'idle',
+      attention: { level: 'action', reason: 'Codex finished — awaiting input' },
+    });
+  });
+
   it('returns null when active but not quiescent', () => {
     expect(codexPollState(ctx({ status: 'active', isQuiescent: false }))).toBeNull();
   });
@@ -233,4 +256,4 @@ describe('codexPollState', () => {
   it('returns null when waiting', () => {
     expect(codexPollState(ctx({ status: 'waiting', isQuiescent: true }))).toBeNull();
   });
-});
+});
diff --git a/tests/unit/main/copilot-runtime.test.ts b/tests/unit/main/copilot-runtime.test.ts
@@ -228,6 +228,29 @@ describe('copilotPollState', () => {
     });
   });
 
+  it('detects permission prompts before idle fallback', () => {
+    expect(copilotPollState(makePollCtx({
+      status: 'active',
+      buffer: 'Allow once\nDeny once\nAllow always\n',
+      isQuiescent: true,
+    }))).toEqual({
+      status: 'waiting',
+      attention: { level: 'action', reason: 'Permission prompt detected' },
+    });
+  });
+
+  it('does not re-trigger permission detection when action attention is already set', () => {
+    expect(copilotPollState(makePollCtx({
+      status: 'active',
+      attentionLevel: 'action',
+      buffer: 'Allow once\nDeny once\nAllow always\n',
+      isQuiescent: true,
+    }))).toEqual({
+      status: 'idle',
+      attention: { level: 'action', reason: 'Copilot finished — awaiting input' },
+    });
+  });
+
   it('returns null when active but not quiescent', () => {
     expect(copilotPollState(makePollCtx({ status: 'active', isQuiescent: false }))).toBeNull();
   });
diff --git a/tests/unit/main/gemini-runtime.test.ts b/tests/unit/main/gemini-runtime.test.ts
@@ -347,6 +347,29 @@ describe('geminiPollState', () => {
     });
   });
 
+  it('detects permission prompts before idle fallback', () => {
+    expect(geminiPollState(ctx({
+      status: 'active',
+      buffer: 'Allow once\nDeny once\nAllow always\n',
+      isQuiescent: true,
+    }))).toEqual({
+      status: 'waiting',
+      attention: { level: 'action', reason: 'Permission prompt detected' },
+    });
+  });
+
+  it('does not re-trigger permission detection when action attention is already set', () => {
+    expect(geminiPollState(ctx({
+      status: 'active',
+      attentionLevel: 'action',
+      buffer: 'Allow once\nDeny once\nAllow always\n',
+      isQuiescent: true,
+    }))).toEqual({
+      status: 'idle',
+      attention: { level: 'action', reason: 'Gemini finished — awaiting input' },
+    });
+  });
+
   it('returns null when active but not quiescent', () => {
     expect(geminiPollState(ctx({ status: 'active', isQuiescent: false }))).toBeNull();
   });
diff --git a/tests/unit/main/prompt-detect.test.ts b/tests/unit/main/prompt-detect.test.ts
@@ -1,5 +1,10 @@
 import { describe, it, expect } from 'vitest';
-import { isAtClaudePrompt, isAtUserChoice, parseUserChoices } from '../../../src/main/session/prompt-detect';
+import {
+  hasPermissionPrompt,
+  isAtClaudePrompt,
+  isAtUserChoice,
+  parseUserChoices,
+} from '../../../src/main/session/prompt-detect';
 
 describe('isAtClaudePrompt', () => {
   it('detects a clean prompt', () => {
@@ -95,6 +100,20 @@ describe('isAtUserChoice', () => {
   });
 });
 
+describe('hasPermissionPrompt', () => {
+  it('detects the known permission prompt copy', () => {
+    expect(hasPermissionPrompt('Allow once\nDeny once\nAllow always\n')).toBe(true);
+  });
+
+  it('handles ANSI sequences in the prompt', () => {
+    expect(hasPermissionPrompt('\x1b[32mAllow once\x1b[0m\nDeny once')).toBe(true);
+  });
+
+  it('returns false for unrelated output', () => {
+    expect(hasPermissionPrompt('regular model output\nno permission prompt here')).toBe(false);
+  });
+});
+
 describe('parseUserChoices', () => {
   it('parses numbered options from a menu', () => {
     const menu = `
diff --git a/tests/unit/main/task-queue-auto-close.test.ts b/tests/unit/main/task-queue-auto-close.test.ts
@@ -221,8 +221,16 @@ describe('auto-close: resume clears auto_close flag', () => {
 
   // SQL mirroring the updated session-manager.ts resume() method
   const RESUME_SQL = `
-    UPDATE sessions SET status = 'starting', ended_at = NULL, hook_mode = 'live', auto_close = 0
-    WHERE session_id = ?
+    UPDATE sessions
+       SET status = 'starting',
+           ended_at = NULL,
+           hook_mode = 'live',
+           auto_close = 0,
+           last_tool = NULL,
+           last_event_at = NULL,
+           attention_level = 'none',
+           attention_reason = NULL
+     WHERE session_id = ?
   `;
 
   it('resume clears auto_close so the session is not immediately re-killed', () => {
@@ -250,6 +258,31 @@ describe('auto-close: resume clears auto_close flag', () => {
     expect(status).toBe('starting');
     expect(autoClose).toBe(0);
   });
+
+  it('resume clears stale last tool and attention state', () => {
+    db.run(
+      `INSERT INTO sessions (
+         session_id, label, cwd, status, started_at, session_type, auto_close,
+         claude_session_id, last_tool, last_event_at, attention_level, attention_reason
+       )
+       VALUES (
+         'resume-cleanup', 'test', '/tmp', 'ended', datetime('now'), 'claude', 1,
+         'abc789', 'ExitPlanMode', '2026-01-01T00:00:00.000Z', 'action', 'Waiting for your response'
+       )`,
+    );
+
+    db.run(RESUME_SQL, ['resume-cleanup']);
+
+    const [result] = db.exec(
+      `SELECT last_tool, last_event_at, attention_level, attention_reason
+         FROM sessions WHERE session_id = 'resume-cleanup'`,
+    );
+    const [lastTool, lastEventAt, attentionLevel, attentionReason] = result.values[0];
+    expect(lastTool).toBeNull();
+    expect(lastEventAt).toBeNull();
+    expect(attentionLevel).toBe('none');
+    expect(attentionReason).toBeNull();
+  });
 });
 
 describe('auto-close: idle guard (Fix 1)', () => {
