@jstn-sdk/rcs 0.1.0

package/dist/scripts/notify-hook/auto-nudge.js

@@ -0,0 +1,696 @@
+// @ts-nocheck
+/**
+ * Auto-nudge: detect Codex "asking for permission" stall patterns and
+ * automatically send a continuation prompt so the agent keeps working.
+ */
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+import { asNumber, safeString } from './utils.js';
+import { getScopedStateDirsForCurrentSession, getScopedStatePath, readJsonIfExists, readScopedJsonIfExists, readdir, writeScopedJson, } from './state-io.js';
+import { runProcess } from './process-runner.js';
+import { logTmuxHookEvent } from './log.js';
+import { evaluatePaneInjectionReadiness, mapPaneInjectionReadinessReason, sendPaneInput } from './team-tmux-guard.js';
+import { stripOrchestrationIntentTags } from './orchestration-intent.js';
+import { buildCapturePaneArgv, DEFAULT_MARKER, tmuxHookExplicitlyDisablesInjection } from '../tmux-hook-engine.js';
+import { readAutoresearchCompletionStatus } from '../../autoresearch/skill-validation.js';
+import { persistDeepInterviewModeState } from '../../hooks/keyword-detector.js';
+import { isManagedRcsSession, resolveManagedCurrentPane, resolveManagedPaneFromAnchor, resolveManagedSessionPane, resolveInvocationSessionId, verifyManagedPaneTarget, } from './managed-tmux.js';
+export const SKILL_ACTIVE_STATE_FILE = 'skill-active-state.json';
+export const DEEP_INTERVIEW_BLOCKED_APPROVAL_INPUTS = ['yes', 'y', 'proceed', 'continue', 'ok', 'sure', 'go ahead', 'next i should'];
+export const DEEP_INTERVIEW_INPUT_LOCK_MESSAGE = 'Deep interview is active; auto-approval shortcuts are blocked until the interview finishes.';
+export const DEFAULT_AUTO_NUDGE_RESPONSE = 'continue with the current task only if it is already authorized';
+const DEEP_INTERVIEW_ERROR_PATTERNS = [' error', ' failed', ' failure', ' exception', 'unable to continue', 'cannot continue', 'could not continue'];
+const DEEP_INTERVIEW_ABORT_PATTERNS = ['aborted', 'cancelled', 'canceled'];
+const DEEP_INTERVIEW_SUCCESS_PATTERNS = ['interview completed', 'interview complete', 'interview finished', 'final summary ready'];
+const DEEP_INTERVIEW_ABORT_INPUTS = new Set(['abort', 'cancel', 'stop']);
+const DEEP_INTERVIEW_BLOCKED_APPROVAL_PREFIXES = new Set(['next i should']);
+const SKILL_PHASES = new Set(['planning', 'executing', 'reviewing', 'completing']);
+const DEFAULT_AUTO_NUDGE_TTL_MS = 30_000;
+function normalizeSkillPhase(phase) {
+    const normalized = safeString(phase).toLowerCase().trim();
+    return SKILL_PHASES.has(normalized) ? normalized : 'planning';
+}
+function normalizeInputLock(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    return {
+        active: raw.active !== false,
+        scope: safeString(raw.scope),
+        acquired_at: safeString(raw.acquired_at),
+        released_at: safeString(raw.released_at),
+        blocked_inputs: Array.isArray(raw.blocked_inputs)
+            ? raw.blocked_inputs.map((value) => safeString(value).toLowerCase()).filter(Boolean)
+            : [...DEEP_INTERVIEW_BLOCKED_APPROVAL_INPUTS],
+        message: safeString(raw.message) || DEEP_INTERVIEW_INPUT_LOCK_MESSAGE,
+        exit_reason: safeString(raw.exit_reason),
+    };
+}
+export function normalizeBlockedAutoApprovalInput(text) {
+    return safeString(text)
+        .toLowerCase()
+        .replace(/\[rcs_tmux_inject\]/gi, '')
+        .replace(/[^a-z]+/g, ' ')
+        .trim();
+}
+function buildBlockedAutoApprovalMatcher(blockedInputs) {
+    const normalizedBlockedInputs = blockedInputs.map((entry) => normalizeBlockedAutoApprovalInput(entry)).filter(Boolean);
+    return {
+        exactMatches: new Set(normalizedBlockedInputs),
+        prefixedMatches: normalizedBlockedInputs.filter((entry) => DEEP_INTERVIEW_BLOCKED_APPROVAL_PREFIXES.has(entry)),
+        blockedTokenSet: new Set(normalizedBlockedInputs.flatMap((entry) => entry.split(/\s+/).filter(Boolean))),
+    };
+}
+export function isBlockedAutoApprovalInput(text, blockedInputs = DEEP_INTERVIEW_BLOCKED_APPROVAL_INPUTS) {
+    const normalized = normalizeBlockedAutoApprovalInput(text);
+    if (!normalized)
+        return false;
+    const { exactMatches, prefixedMatches, blockedTokenSet } = buildBlockedAutoApprovalMatcher(blockedInputs);
+    if (exactMatches.has(normalized))
+        return true;
+    if (prefixedMatches.some((prefix) => normalized.startsWith(`${prefix} `)))
+        return true;
+    const tokens = normalized.split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return false;
+    return tokens.every((token) => blockedTokenSet.has(token));
+}
+function isDeepInterviewAbortInput(text) {
+    return DEEP_INTERVIEW_ABORT_INPUTS.has(normalizeBlockedAutoApprovalInput(text));
+}
+function hasAnySubstring(text, patterns) {
+    const lower = safeString(text).toLowerCase();
+    return patterns.some((pattern) => lower.includes(pattern));
+}
+function looksLikeDeepInterviewSuccess(text) {
+    return hasAnySubstring(text, DEEP_INTERVIEW_SUCCESS_PATTERNS);
+}
+export function isDeepInterviewAutoApprovalLocked(skillState) {
+    return Boolean(skillState
+        && skillState.skill === 'deep-interview'
+        && skillState.input_lock
+        && (safeString(skillState.input_lock.scope) === '' || skillState.input_lock.scope === 'deep-interview-auto-approval')
+        && skillState.input_lock.active === true);
+}
+export function inferDeepInterviewReleaseReason({ skillState, latestUserInput = '', lastMessage = '' }) {
+    if (!isDeepInterviewAutoApprovalLocked(skillState)) {
+        return null;
+    }
+    if (isDeepInterviewAbortInput(latestUserInput) || hasAnySubstring(lastMessage, DEEP_INTERVIEW_ABORT_PATTERNS)) {
+        return 'abort';
+    }
+    if (hasAnySubstring(` ${safeString(lastMessage).toLowerCase()}`, DEEP_INTERVIEW_ERROR_PATTERNS)) {
+        return 'error';
+    }
+    if (skillState.phase === 'completing') {
+        return 'success';
+    }
+    return null;
+}
+function releaseDeepInterviewInputLock(skillState, reason, nowIso) {
+    if (!skillState?.input_lock)
+        return skillState;
+    skillState.input_lock = {
+        ...skillState.input_lock,
+        active: false,
+        released_at: nowIso,
+        exit_reason: reason,
+    };
+    skillState.phase = 'completing';
+    skillState.active = false;
+    skillState.updated_at = nowIso;
+    return skillState;
+}
+export function normalizeSkillActiveState(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    const skill = safeString(raw.skill);
+    if (!skill)
+        return null;
+    return {
+        version: asNumber(raw.version) ?? 1,
+        active: raw.active !== false,
+        skill,
+        keyword: safeString(raw.keyword),
+        phase: normalizeSkillPhase(raw.phase),
+        activated_at: safeString(raw.activated_at),
+        updated_at: safeString(raw.updated_at),
+        source: safeString(raw.source),
+        input_lock: normalizeInputLock(raw.input_lock),
+    };
+}
+export function inferSkillPhaseFromText(text, currentPhase = 'planning') {
+    const lower = safeString(text).toLowerCase();
+    if (!lower)
+        return normalizeSkillPhase(currentPhase);
+    const hasAny = (patterns) => patterns.some((p) => lower.includes(p));
+    if (hasAny(['all tests pass', 'build succeeded', 'completed', 'complete', 'done', 'final summary', 'summary'])) {
+        return 'completing';
+    }
+    if (hasAny(['verify', 'verified', 'verification', 'review', 'reviewed', 'diagnostic', 'typecheck', 'test'])) {
+        return 'reviewing';
+    }
+    if (hasAny(['implement', 'implemented', 'apply patch', 'change', 'fix', 'update', 'refactor'])) {
+        return 'executing';
+    }
+    if (hasAny(['plan', 'approach', 'steps', 'todo'])) {
+        return 'planning';
+    }
+    return normalizeSkillPhase(currentPhase);
+}
+async function loadSkillActiveState(stateDir, sessionId) {
+    const raw = await readScopedJsonIfExists(stateDir, SKILL_ACTIVE_STATE_FILE, sessionId, null);
+    return normalizeSkillActiveState(raw);
+}
+async function persistSkillActiveState(stateDir, sessionId, state) {
+    await writeScopedJson(stateDir, SKILL_ACTIVE_STATE_FILE, sessionId, state).catch(() => { });
+}
+function cloneSkillActiveState(state) {
+    if (!state || typeof state !== 'object')
+        return null;
+    return {
+        ...state,
+        input_lock: state.input_lock
+            ? {
+                ...state.input_lock,
+                blocked_inputs: Array.isArray(state.input_lock.blocked_inputs)
+                    ? [...state.input_lock.blocked_inputs]
+                    : state.input_lock.blocked_inputs,
+            }
+            : state.input_lock,
+    };
+}
+export async function syncSkillStateFromTurn(stateDir, payload) {
+    const lastMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
+    const latestUserInput = latestUserInputFromPayload(payload);
+    const invocationSessionId = resolveInvocationSessionId(payload);
+    let skillState = await loadSkillActiveState(stateDir, invocationSessionId);
+    let releaseReason = null;
+    if (!skillState) {
+        return { invocationSessionId, skillState: null, releaseReason };
+    }
+    const previousSkillState = cloneSkillActiveState(skillState);
+    const previousPhase = normalizeSkillPhase(skillState.phase);
+    const inferredPhase = inferSkillPhaseFromText(lastMessage, previousPhase);
+    const explicitDeepInterviewSuccess = skillState.skill === 'deep-interview' && looksLikeDeepInterviewSuccess(lastMessage);
+    const nextPhase = skillState.skill === 'deep-interview'
+        && inferredPhase === 'completing'
+        && previousPhase !== 'completing'
+        && !explicitDeepInterviewSuccess
+        ? previousPhase
+        : inferredPhase;
+    skillState.phase = nextPhase;
+    skillState.active = nextPhase !== 'completing';
+    if (skillState.skill === 'autoresearch') {
+        const completion = await readAutoresearchCompletionStatus(payload.cwd || process.cwd(), invocationSessionId);
+        skillState.validation_mode = completion.validationMode;
+        skillState.autoresearch_completion_reason = completion.reason;
+        skillState.completion_artifact_path = completion.artifactPath;
+        if (completion.complete) {
+            skillState.phase = 'completing';
+            skillState.active = false;
+        }
+        else if (inferredPhase === 'completing') {
+            skillState.phase = previousPhase === 'completing' ? 'reviewing' : previousPhase;
+            skillState.active = true;
+        }
+    }
+    const nowIso = new Date().toISOString();
+    skillState.updated_at = nowIso;
+    releaseReason = inferDeepInterviewReleaseReason({ skillState, latestUserInput, lastMessage });
+    if (releaseReason && isDeepInterviewAutoApprovalLocked(skillState)) {
+        releaseDeepInterviewInputLock(skillState, releaseReason, nowIso);
+    }
+    await persistSkillActiveState(stateDir, invocationSessionId, skillState);
+    if (skillState.skill === 'deep-interview' || previousSkillState?.skill === 'deep-interview') {
+        await persistDeepInterviewModeState(stateDir, skillState, nowIso, previousSkillState, {
+            sessionId: invocationSessionId,
+            threadId: safeString(payload?.['thread-id'] || payload?.thread_id || ''),
+            turnId: safeString(payload?.['turn-id'] || payload?.turn_id || ''),
+        });
+    }
+    return { invocationSessionId, skillState, releaseReason };
+}
+export async function isDeepInterviewStateActive(stateDir, sessionId) {
+    const modeState = await readScopedJsonIfExists(stateDir, 'deep-interview-state.json', sessionId, null);
+    return Boolean(modeState && modeState.active === true);
+}
+export async function isDeepInterviewInputLockActive(stateDir, sessionId) {
+    const skillState = await loadSkillActiveState(stateDir, sessionId);
+    return isDeepInterviewAutoApprovalLocked(skillState);
+}
+export async function resolveAutoNudgeSignature(stateDir, payload, lastMessage = '') {
+    const normalizedMessage = normalizeAutoNudgeSignatureText(lastMessage);
+    const invocationSessionId = resolveInvocationSessionId(payload);
+    const hudState = await readScopedJsonIfExists(stateDir, 'hud-state.json', invocationSessionId, null);
+    const hudTurnAt = safeString(hudState?.last_turn_at).trim();
+    const hudTurnCount = Number.isFinite(hudState?.turn_count) ? hudState.turn_count : null;
+    const hudMessage = normalizeAutoNudgeSignatureText(hudState?.last_agent_output || hudState?.last_agent_message || '');
+    if (normalizedMessage && hudTurnAt && hudTurnCount !== null && hudMessage === normalizedMessage) {
+        return `hud:${hudTurnCount}|${hudTurnAt}|${normalizedMessage}`;
+    }
+    const threadId = safeString(payload?.['thread-id'] || payload?.thread_id).trim();
+    const turnId = safeString(payload?.['turn-id'] || payload?.turn_id).trim();
+    if (normalizedMessage && (threadId || turnId)) {
+        return `payload:${threadId}|${turnId}|${normalizedMessage}`;
+    }
+    return normalizedMessage ? `message:${normalizedMessage}` : '';
+}
+function latestUserInputFromPayload(payload) {
+    const inputMessages = payload['input-messages'] || payload.input_messages || [];
+    if (!Array.isArray(inputMessages) || inputMessages.length === 0)
+        return '';
+    return safeString(inputMessages[inputMessages.length - 1]);
+}
+export const DEFAULT_STALL_PATTERNS = [
+    'continue with',
+    'continue on',
+    'pick up with',
+    'keep going',
+    'and i\'ll continue',
+    'keep driving',
+    'keep pushing',
+    'move forward',
+    'drive forward',
+    'i\'ll continue from',
+];
+const SEMANTIC_STALL_PROMPT_PATTERNS = [
+    /\bcontinue (?:with|on)\b/g,
+    /\bpick up with\b/g,
+    /\bkeep going\b/g,
+    /\band i'?ll continue\b/g,
+    /\bkeep (?:driving|pushing)\b/g,
+    /\bmove forward\b/g,
+    /\bdrive forward\b/g,
+    /\bi'?ll continue from\b/g,
+];
+const PLANNING_ONLY_STALL_PATTERNS = [
+    'plan',
+    'planning',
+    'approach',
+    'proposal',
+    'options',
+    'review',
+    'feedback',
+    'spec',
+    'design',
+    'next step',
+    'next steps',
+    'ready to proceed',
+];
+const PERMISSION_SEEKING_STALL_PATTERNS = [
+    'if you want',
+    'would you like',
+    'shall i',
+    'should i',
+    'do you want me to',
+    'do you want',
+    'want me to',
+    'let me know if',
+    'let me know',
+    'just let me know',
+    'i can also',
+    'i could also',
+    'next i can',
+    'whenever you',
+    'say go',
+    'say yes',
+    'type continue',
+    'proceed from here',
+];
+function normalizeStallDetectionText(text) {
+    return stripOrchestrationIntentTags(safeString(text))
+        .replace(/\r\n?/g, '\n')
+        .split('\n')
+        .filter((line) => !line.includes(DEFAULT_MARKER))
+        .join('\n')
+        .toLowerCase()
+        .replace(/[’‘`]/g, '\'');
+}
+export function normalizeAutoNudgeSignatureText(text) {
+    const normalized = normalizeStallDetectionText(text)
+        .replace(/[^\w\s']/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!normalized)
+        return '';
+    if (detectStallPattern(normalized, DEFAULT_STALL_PATTERNS)) {
+        let semantic = normalized;
+        for (const pattern of SEMANTIC_STALL_PROMPT_PATTERNS) {
+            semantic = semantic.replace(pattern, ' proceed_intent ');
+        }
+        semantic = semantic
+            .replace(/\b(?:please|just|simply|the|a|an|this|that|these|those|for|from|here|there|now|then|when|you|me|i|can|could|will|would|should|shall|to|with|on|if|also|know)\b/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+        return semantic.includes('proceed_intent') ? 'stall:proceed_intent' : `stall:${semantic || 'detected'}`;
+    }
+    return normalized;
+}
+function normalizePatternList(patterns) {
+    return patterns.map((pattern) => normalizeStallDetectionText(pattern)).filter(Boolean);
+}
+function usesDefaultStallPatterns(patterns) {
+    const normalizedPatterns = normalizePatternList(patterns);
+    const normalizedDefaults = normalizePatternList(DEFAULT_STALL_PATTERNS);
+    return normalizedPatterns.length === normalizedDefaults.length
+        && normalizedPatterns.every((pattern, index) => pattern === normalizedDefaults[index]);
+}
+function matchesNormalizedPatterns(normalizedText, normalizedPatterns) {
+    if (!normalizedText || normalizedPatterns.length === 0)
+        return false;
+    const tail = normalizedText.slice(-800);
+    const lines = tail.split('\n').filter((line) => line.trim());
+    const hotZone = lines.slice(-3).join('\n');
+    if (normalizedPatterns.some((pattern) => hotZone.includes(pattern)))
+        return true;
+    return normalizedPatterns.some((pattern) => tail.includes(pattern));
+}
+function looksLikePlanningOnlyContinuation(normalizedText) {
+    return matchesNormalizedPatterns(normalizedText, normalizePatternList(PLANNING_ONLY_STALL_PATTERNS));
+}
+function looksLikePermissionSeekingContinuation(normalizedText) {
+    return matchesNormalizedPatterns(normalizedText, normalizePatternList(PERMISSION_SEEKING_STALL_PATTERNS));
+}
+/**
+ * Pattern to identify test-runner output lines (status symbols, PASS/FAIL prefixes).
+ * These lines may incidentally contain stall-pattern words inside test names and
+ * should be excluded before running stall detection on pane captures.
+ */
+const CAPTURE_TEST_LINE_RE = /^\s*(?:[✓✗✕×●✔✘▶◆○]|(?:PASS|FAIL|SKIP|ERROR)\s)/u;
+/**
+ * Strip lines that look like test-runner output so stall patterns inside test
+ * names (e.g. "✓ should continue with the next step") do not trigger a nudge.
+ */
+function filterCapturedTestLines(text) {
+    return safeString(text)
+        .split('\n')
+        .filter((line) => !CAPTURE_TEST_LINE_RE.test(line))
+        .join('\n');
+}
+function summarizePaneCaptureForLog(captured, maxLines = 6) {
+    const lines = safeString(captured)
+        .replace(/\r\n?/g, '\n')
+        .split('\n')
+        .map((line) => line.trimEnd())
+        .filter((line) => line.trim() !== '');
+    if (lines.length === 0)
+        return '';
+    return lines.slice(-maxLines).join('\n').slice(0, 600);
+}
+export function normalizeAutoNudgeConfig(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return {
+            enabled: true,
+            patterns: DEFAULT_STALL_PATTERNS,
+            response: 'yes, proceed',
+            delaySec: 3,
+            stallMs: 5000,
+            ttlMs: DEFAULT_AUTO_NUDGE_TTL_MS,
+        };
+    }
+    return {
+        enabled: raw.enabled !== false,
+        patterns: Array.isArray(raw.patterns) && raw.patterns.length > 0
+            ? raw.patterns.filter(p => typeof p === 'string' && p.trim() !== '')
+            : DEFAULT_STALL_PATTERNS,
+        response: typeof raw.response === 'string' && raw.response.trim() !== ''
+            ? raw.response
+            : 'yes, proceed',
+        delaySec: typeof raw.delaySec === 'number' && raw.delaySec >= 0 && raw.delaySec <= 60
+            ? raw.delaySec
+            : 3,
+        stallMs: typeof raw.stallMs === 'number' && raw.stallMs >= 0 && raw.stallMs <= 60_000
+            ? raw.stallMs
+            : 5000,
+        ttlMs: typeof raw.ttlMs === 'number' && raw.ttlMs >= 0 && raw.ttlMs <= 10 * 60_000
+            ? raw.ttlMs
+            : (typeof raw.cooldownMs === 'number' && raw.cooldownMs >= 0 && raw.cooldownMs <= 10 * 60_000
+                ? raw.cooldownMs
+                : DEFAULT_AUTO_NUDGE_TTL_MS),
+    };
+}
+export function resolveEffectiveAutoNudgeResponse(response) {
+    const normalized = safeString(response).trim();
+    if (!normalized)
+        return DEFAULT_AUTO_NUDGE_RESPONSE;
+    return isBlockedAutoApprovalInput(normalized) ? DEFAULT_AUTO_NUDGE_RESPONSE : normalized;
+}
+export async function loadAutoNudgeConfig() {
+    const codexHomePath = process.env.CODEX_HOME || join(homedir(), '.codex');
+    const configPath = join(codexHomePath, '.rcs-config.json');
+    const raw = await readJsonIfExists(configPath, null);
+    if (!raw || typeof raw !== 'object')
+        return normalizeAutoNudgeConfig(null);
+    return normalizeAutoNudgeConfig(raw.autoNudge);
+}
+async function localTmuxInjectionDisabled(cwd) {
+    const normalizedCwd = safeString(cwd).trim();
+    if (!normalizedCwd)
+        return false;
+    const raw = await readJsonIfExists(join(normalizedCwd, '.rcs', 'tmux-hook.json'), null);
+    return tmuxHookExplicitlyDisablesInjection(raw);
+}
+function detectStallPatternWithOptions(text, patterns, currentPhase = '', options = {}) {
+    if (!text || typeof text !== 'string')
+        return false;
+    const normalized = normalizeStallDetectionText(text);
+    if (!normalized)
+        return false;
+    const normalizedPatterns = normalizePatternList(patterns);
+    if (!matchesNormalizedPatterns(normalized, normalizedPatterns))
+        return false;
+    if (!usesDefaultStallPatterns(patterns))
+        return true;
+    if (options.allowPermissionSeeking !== true && looksLikePermissionSeekingContinuation(normalized))
+        return false;
+    if (safeString(currentPhase).trim().toLowerCase() === 'planning')
+        return false;
+    return !looksLikePlanningOnlyContinuation(normalized);
+}
+export function detectStallPattern(text, patterns, currentPhase = '') {
+    return detectStallPatternWithOptions(text, patterns, currentPhase);
+}
+export function detectNativeStopStallPattern(text, patterns, currentPhase = '') {
+    return detectStallPatternWithOptions(text, patterns, currentPhase, {
+        allowPermissionSeeking: true,
+    });
+}
+export async function capturePane(paneId, lines = 10) {
+    try {
+        const result = await runProcess('tmux', buildCapturePaneArgv(paneId, lines), 3000);
+        return result.stdout || '';
+    }
+    catch {
+        return '';
+    }
+}
+export async function resolveNudgePaneTarget(stateDir, cwd = '', payload = undefined) {
+    const allowTeamWorker = safeString(process.env.RCS_TEAM_WORKER || '').trim() !== '';
+    const managedCurrentPane = await resolveManagedCurrentPane(cwd, payload, { allowTeamWorker });
+    if (managedCurrentPane)
+        return managedCurrentPane;
+    const invocationSessionId = resolveInvocationSessionId(payload);
+    const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir, invocationSessionId).catch(() => []);
+    for (const dir of scopedDirs) {
+        const files = await readdir(dir).catch(() => []);
+        for (const f of files) {
+            if (!f.endsWith('-state.json'))
+                continue;
+            const path = join(dir, f);
+            try {
+                const state = JSON.parse(await readFile(path, 'utf-8'));
+                if (!state || !state.active || !state.tmux_pane_id)
+                    continue;
+                const anchoredPane = safeString(state.tmux_pane_id).trim();
+                if (!anchoredPane)
+                    continue;
+                const managedPane = await resolveManagedPaneFromAnchor(anchoredPane, cwd, payload, { allowTeamWorker });
+                if (managedPane)
+                    return managedPane;
+                if (allowTeamWorker) {
+                    const verdict = await verifyManagedPaneTarget(anchoredPane, cwd, payload, { allowTeamWorker });
+                    if (verdict.ok)
+                        return anchoredPane;
+                }
+            }
+            catch {
+                // skip malformed state
+            }
+        }
+    }
+    return await resolveManagedSessionPane(cwd, payload);
+}
+export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
+    const config = await loadAutoNudgeConfig();
+    const effectiveResponse = resolveEffectiveAutoNudgeResponse(config.response);
+    if (!config.enabled)
+        return;
+    if (await localTmuxInjectionDisabled(cwd)) {
+        await logTmuxHookEvent(logsDir, {
+            timestamp: new Date().toISOString(),
+            type: 'auto_nudge_skipped',
+            reason: 'tmux_hook_disabled',
+        }).catch(() => { });
+        return;
+    }
+    const sourceName = safeString(payload?.source || '');
+    const managedSession = await isManagedRcsSession(cwd, payload, { allowTeamWorker: true });
+    if (!managedSession) {
+        if (sourceName === 'notify-fallback-watcher-stall')
+            return;
+        await logTmuxHookEvent(logsDir, {
+            timestamp: new Date().toISOString(),
+            type: 'auto_nudge_skipped',
+            reason: 'unmanaged_session',
+        }).catch(() => { });
+        return;
+    }
+    const lastMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
+    const { invocationSessionId, skillState, releaseReason } = await syncSkillStateFromTurn(stateDir, payload);
+    try {
+        const nudgeStatePath = await getScopedStatePath(stateDir, 'auto-nudge-state.json', invocationSessionId);
+        let nudgeState = await readScopedJsonIfExists(stateDir, 'auto-nudge-state.json', invocationSessionId, null);
+        if (!nudgeState || typeof nudgeState !== 'object') {
+            nudgeState = { nudgeCount: 0, lastNudgeAt: '', lastSignature: '', lastSemanticSignature: '' };
+        }
+        const paneId = await resolveNudgePaneTarget(stateDir, cwd, payload);
+        let detected = detectStallPattern(lastMessage, config.patterns, skillState?.phase);
+        let source = 'payload';
+        let captured = '';
+        if (!detected && paneId) {
+            captured = await capturePane(paneId);
+            detected = detectStallPattern(filterCapturedTestLines(captured), config.patterns, skillState?.phase);
+            source = 'capture-pane';
+        }
+        if (skillState?.phase === 'completing' && !detected)
+            return;
+        if (!detected || !paneId)
+            return;
+        const signatureSourceText = source === 'capture-pane' ? captured : lastMessage;
+        const signature = await resolveAutoNudgeSignature(stateDir, payload, signatureSourceText);
+        const semanticSignature = normalizeAutoNudgeSignatureText(signatureSourceText);
+        if (signature && safeString(nudgeState.lastSignature) === signature) {
+            await logTmuxHookEvent(logsDir, {
+                timestamp: new Date().toISOString(),
+                type: 'auto_nudge_skipped',
+                reason: 'already_nudged_for_signature',
+                source,
+                signature,
+                semantic_signature: semanticSignature,
+            }).catch(() => { });
+            return;
+        }
+        const lastNudgeAtMs = Date.parse(safeString(nudgeState.lastNudgeAt));
+        if (semanticSignature
+            && safeString(nudgeState.lastSemanticSignature) === semanticSignature
+            && config.ttlMs > 0
+            && Number.isFinite(lastNudgeAtMs)
+            && (Date.now() - lastNudgeAtMs) < config.ttlMs) {
+            await logTmuxHookEvent(logsDir, {
+                timestamp: new Date().toISOString(),
+                type: 'auto_nudge_skipped',
+                reason: 'ttl_active',
+                source,
+                ttl_ms: config.ttlMs,
+                signature,
+                semantic_signature: semanticSignature,
+            }).catch(() => { });
+            return;
+        }
+        const isFallbackWatcherSource = sourceName === 'notify-fallback-watcher-stall';
+        if (!isFallbackWatcherSource && config.stallMs > 0) {
+            nudgeState.pendingSignature = signature;
+            nudgeState.pendingSince = new Date().toISOString();
+            await mkdir(dirname(nudgeStatePath), { recursive: true }).catch(() => { });
+            await writeFile(nudgeStatePath, JSON.stringify(nudgeState, null, 2)).catch(() => { });
+            await logTmuxHookEvent(logsDir, {
+                timestamp: new Date().toISOString(),
+                type: 'auto_nudge_skipped',
+                reason: 'stall_window_pending',
+                source,
+                stall_ms: config.stallMs,
+                signature,
+            }).catch(() => { });
+            return;
+        }
+        const paneGuard = await evaluatePaneInjectionReadiness(paneId, { skipIfScrolling: true });
+        if (!paneGuard.ok) {
+            await logTmuxHookEvent(logsDir, {
+                timestamp: new Date().toISOString(),
+                type: 'auto_nudge_skipped',
+                pane_id: paneId,
+                reason: mapPaneInjectionReadinessReason(paneGuard.reason),
+                source,
+                pane_current_command: paneGuard.paneCurrentCommand || undefined,
+                pane_excerpt: summarizePaneCaptureForLog(paneGuard.paneCapture),
+            }).catch(() => { });
+            return;
+        }
+        const blockedAutoApproval = isDeepInterviewAutoApprovalLocked(skillState)
+            && !releaseReason
+            && isBlockedAutoApprovalInput(effectiveResponse, skillState.input_lock?.blocked_inputs);
+        if (blockedAutoApproval) {
+            const blockedMessage = skillState.input_lock?.message || DEEP_INTERVIEW_INPUT_LOCK_MESSAGE;
+            await logTmuxHookEvent(logsDir, {
+                timestamp: new Date().toISOString(),
+                type: 'auto_nudge_blocked',
+                pane_id: paneId,
+                response: effectiveResponse,
+                source,
+                blocked_by: 'deep-interview-lock',
+                block_kind: 'blocked-auto-approval',
+                message: blockedMessage,
+                suppressed: true,
+            }).catch(() => { });
+            return;
+        }
+        if (config.delaySec > 0) {
+            await new Promise(r => setTimeout(r, config.delaySec * 1000));
+        }
+        const nowIso = new Date().toISOString();
+        try {
+            const sendResult = await sendPaneInput({
+                paneTarget: paneId,
+                prompt: `${effectiveResponse} ${DEFAULT_MARKER}`,
+                submitKeyPresses: 2,
+                submitDelayMs: 100,
+            });
+            if (!sendResult.ok) {
+                throw new Error(sendResult.error || sendResult.reason);
+            }
+            nudgeState.nudgeCount = (asNumber(nudgeState.nudgeCount) ?? 0) + 1;
+            nudgeState.lastNudgeAt = nowIso;
+            nudgeState.lastSignature = signature;
+            nudgeState.lastSemanticSignature = semanticSignature;
+            nudgeState.pendingSignature = '';
+            nudgeState.pendingSince = '';
+            await mkdir(dirname(nudgeStatePath), { recursive: true }).catch(() => { });
+            await writeFile(nudgeStatePath, JSON.stringify(nudgeState, null, 2)).catch(() => { });
+            await logTmuxHookEvent(logsDir, {
+                timestamp: nowIso,
+                type: 'auto_nudge',
+                pane_id: paneId,
+                response: effectiveResponse,
+                source,
+                nudge_count: nudgeState.nudgeCount,
+            });
+        }
+        catch (err) {
+            await logTmuxHookEvent(logsDir, {
+                timestamp: nowIso,
+                type: 'auto_nudge',
+                pane_id: paneId,
+                error: err instanceof Error ? err.message : safeString(err),
+            }).catch(() => { });
+        }
+    }
+    finally {
+        if (releaseReason && skillState && isDeepInterviewAutoApprovalLocked(skillState)) {
+            releaseDeepInterviewInputLock(skillState, releaseReason, new Date().toISOString());
+            await persistSkillActiveState(stateDir, invocationSessionId, skillState).catch(() => { });
+        }
+    }
+}
+//# sourceMappingURL=auto-nudge.js.map