@scotthuang/agent-knock-knock 0.11.3 → 0.11.5

package/dist/src/terminal-agent-bridge.d.ts

@@ -1,5 +1,5 @@
 import type { ExecutorKind } from "./executors.js";
-import { type ActiveTerminalProcess, type TerminalAgentAdapter, type TerminalAgentAdapterCapabilities, type TerminalAgentAdapterRegistry, type TerminalCompletionEvidence, type TerminalControlRef, type TerminalDurableCompletionRequest, type TerminalProcessSnapshot, type TerminalRuntimeIdentity, type TerminalScreenInspection } from "./terminal-agent-adapter.js";
+import { type ActiveTerminalProcess, type TerminalAgentAdapter, type TerminalAgentAdapterCapabilities, type TerminalAgentAdapterRegistry, type TerminalCompletionEvidence, type TerminalControlRef, type TerminalDurableCompletionRequest, type TerminalNativeInspectionEvidenceInventoryEntry, type TerminalNativeInspectionObservation, type TerminalNativeInspectionObservationRequest, type TerminalNativeInspectionPlan, type TerminalProcessSnapshot, type TerminalRuntimeIdentity, type TerminalScreenInspection } from "./terminal-agent-adapter.js";
 import { type TerminalControlProvider } from "./terminal-control-provider.js";
 /** A terminal send failed at a boundary that proves input never started. */
 export declare class TerminalInputNotStartedError extends Error {
@@ -8,6 +8,30 @@ export declare class TerminalInputNotStartedError extends Error {
         cause?: unknown;
     });
 }
+export type NativeInspectionSubmissionStage = "not_started" | "text_injected" | "enter_uncertain";
+/**
+ * A fail-closed native-inspection submission result.
+ *
+ * Only `not_started` proves that a caller may safely retry. Once text has
+ * reached the composer, or Enter has been attempted, automated retries could
+ * duplicate input or execute a different command after terminal drift.
+ */
+export declare class NativeInspectionSubmissionError extends Error {
+    readonly stage: NativeInspectionSubmissionStage;
+    readonly code = "AKK_NATIVE_INSPECTION_SUBMISSION_FAILED";
+    readonly doNotRetry: boolean;
+    constructor(stage: NativeInspectionSubmissionStage, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** A verified modal could not be dismissed across one exact key attempt. */
+export declare class NativeInspectionDismissalError extends Error {
+    readonly code = "AKK_NATIVE_INSPECTION_DISMISSAL_FAILED";
+    readonly doNotRetry = true;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
 export interface TerminalBridgeStatus {
     provider: "tmux";
     target: string;
@@ -105,6 +129,65 @@ export interface TerminalSendResult {
     terminalControl: TerminalControlRef;
     multiline: boolean;
 }
+export type TerminalNativeInspectionMaterializationKind = "exact_slash_composer" | "exact_slash_popup";
+export interface TerminalNativeInspectionMaterializationEvidence {
+    kind: TerminalNativeInspectionMaterializationKind;
+    digest: string;
+    stableForMs: number;
+    stableCaptures: number;
+}
+export interface TerminalNativeInspectionBeforeEnterContext {
+    agent: ExecutorKind;
+    terminalControl: TerminalControlRef;
+    plan: TerminalNativeInspectionPlan;
+    preEnterScreenDigest: string;
+    materialization: TerminalNativeInspectionMaterializationEvidence;
+}
+export interface TerminalNativeInspectionOptions {
+    runtime?: TerminalRuntimeIdentity;
+    /**
+     * Gives the CLI one final in-lock authorization point for its Store binding
+     * and action-token fences. The bridge recaptures the exact composer and
+     * revalidates terminal identity again after this hook before pressing Enter.
+     */
+    beforeEnter?: (context: TerminalNativeInspectionBeforeEnterContext) => void | Promise<void>;
+}
+export interface TerminalNativeInspectionResult {
+    stage: "enter_dispatched";
+    agent: ExecutorKind;
+    terminalControl: TerminalControlRef;
+    command: string;
+    behaviorProfile: string;
+    preEnterScreenDigest: string;
+    preEnterEvidenceInventory: readonly TerminalNativeInspectionEvidenceInventoryEntry[];
+    materialization: TerminalNativeInspectionMaterializationEvidence;
+    enterCount: 1;
+}
+export interface TerminalNativeInspectionBeforeDismissContext {
+    agent: ExecutorKind;
+    terminalControl: TerminalControlRef;
+    plan: TerminalNativeInspectionPlan;
+    evidenceFingerprint: string;
+}
+export interface TerminalNativeInspectionDismissalOptions {
+    runtime?: TerminalRuntimeIdentity;
+    scrollbackLines?: number;
+    beforeDismiss?: (context: TerminalNativeInspectionBeforeDismissContext) => void | Promise<void>;
+}
+export interface TerminalNativeInspectionDismissalResult {
+    stage: "dismiss_dispatched";
+    agent: ExecutorKind;
+    terminalControl: TerminalControlRef;
+    keys: readonly string[];
+    dismissCount: 1;
+}
+export interface TerminalNativeInspectionObservationResult {
+    terminalControl: TerminalControlRef;
+    status: TerminalBridgeStatus;
+    /** Same raw-screen fingerprint format used by adapter stale checks. */
+    screenDigest: string;
+    observation: TerminalNativeInspectionObservation;
+}
 export interface TerminalApprovalAuthorizationContext {
     agent: ExecutorKind;
     terminalControl: TerminalControlRef;
@@ -152,6 +235,26 @@ export declare class TerminalAgentBridge {
         runtime?: TerminalRuntimeIdentity;
     }): Promise<TerminalBridgeStatus>;
     send(agent: ExecutorKind, terminalControl: TerminalControlRef, text: string, options?: TerminalSendOptions): Promise<TerminalSendResult>;
+    /**
+     * Submit one closed, adapter-owned native inspection command.
+     *
+     * This intentionally does not use `send()`: native slash commands need a
+     * stricter composer proof, and failures after text injection must leave the
+     * draft untouched instead of issuing the legacy best-effort C-u cleanup.
+     */
+    submitNativeInspection(agent: ExecutorKind, terminalControl: TerminalControlRef, plan: TerminalNativeInspectionPlan, options?: TerminalNativeInspectionOptions): Promise<TerminalNativeInspectionResult>;
+    observeNativeInspection(agent: ExecutorKind, terminalControl: TerminalControlRef, request: TerminalNativeInspectionObservationRequest, options?: {
+        runtime?: TerminalRuntimeIdentity;
+        scrollbackLines?: number;
+    }): Promise<TerminalNativeInspectionObservationResult>;
+    /**
+     * Dismiss one exact adapter-owned modal result after re-observing the same
+     * evidence under the terminal identity fence. There is exactly one key
+     * attempt and no automated retry across an uncertain dismissal boundary.
+     */
+    dismissNativeInspection(agent: ExecutorKind, terminalControl: TerminalControlRef, plan: TerminalNativeInspectionPlan, request: TerminalNativeInspectionObservationRequest, expectedEvidenceFingerprint: string, options?: TerminalNativeInspectionDismissalOptions): Promise<TerminalNativeInspectionDismissalResult>;
+    private settleNativeInspectionComposer;
+    private revalidateNativeInspectionComposer;
     private settleCodexMultilineComposer;
     /**
      * Prove that the exact managed draft is still present after Enter dispatch.
@@ -210,6 +313,12 @@ export declare class TerminalAgentBridge {
     private captureInspection;
     private verifyTerminalIdentity;
 }
+/**
+ * Prove the exact idle input frame from the verified Claude Code 2.1.218
+ * profile. A loose or historical `❯` prompt is not enough to authorize even
+ * the initial literal `/status` injection.
+ */
+export declare function isExactClaudeNativeInspectionIdleComposer(screen: string): boolean;
 export declare function terminalApprovalFingerprint(agent: ExecutorKind, terminalControl: TerminalControlRef, inspection: TerminalScreenInspection, options?: {
     screen?: string;
     runtime?: TerminalRuntimeIdentity;

package/dist/src/terminal-agent-bridge.js

@@ -11,6 +11,21 @@ const CODEX_MULTILINE_STABLE_CAPTURES = 2;
 const CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES = 240;
 const CODEX_COMPOSER_MARKER = /^[›»](?:\s|$)/u;
 const CODEX_COMPOSER_FOOTER = /^(?:gpt-[\w.-]+(?:\s|$)|[-\w.]+ default ·)/u;
+// Codex 0.146.0 and 0.146.1 render the same verified slash-completion row.
+// Keep it closed per behavior profile so changed text cannot silently become
+// a newly authorized native command surface.
+const CODEX_NATIVE_STATUS_POPUP_BY_PROFILE = {
+    "codex-tui-0.146.0": "  /status  show current session configuration and token usage",
+    "codex-tui-0.146.1": "  /status  show current session configuration and token usage"
+};
+const CLAUDE_NATIVE_STATUS_POPUP_BY_PROFILE = {
+    "claude-code-2.1.218-native-status": [
+        "/status Show Claude Code status including version, model, account, API connectivity, and tool statuses",
+        "/statusline Set up Claude Code's status line UI",
+        "/ide Manage IDE integrations and show status",
+        "/usage Show session cost, plan usage, and activity stats"
+    ]
+};
 const CODEX_LARGE_PASTE_CHAR_THRESHOLD = 1_000;
 /** A terminal send failed at a boundary that proves input never started. */
 export class TerminalInputNotStartedError extends Error {
@@ -20,6 +35,33 @@ export class TerminalInputNotStartedError extends Error {
         this.name = "TerminalInputNotStartedError";
     }
 }
+/**
+ * A fail-closed native-inspection submission result.
+ *
+ * Only `not_started` proves that a caller may safely retry. Once text has
+ * reached the composer, or Enter has been attempted, automated retries could
+ * duplicate input or execute a different command after terminal drift.
+ */
+export class NativeInspectionSubmissionError extends Error {
+    stage;
+    code = "AKK_NATIVE_INSPECTION_SUBMISSION_FAILED";
+    doNotRetry;
+    constructor(stage, message, options = {}) {
+        super(message, options);
+        this.stage = stage;
+        this.name = "NativeInspectionSubmissionError";
+        this.doNotRetry = stage !== "not_started";
+    }
+}
+/** A verified modal could not be dismissed across one exact key attempt. */
+export class NativeInspectionDismissalError extends Error {
+    code = "AKK_NATIVE_INSPECTION_DISMISSAL_FAILED";
+    doNotRetry = true;
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "NativeInspectionDismissalError";
+    }
+}
 export class TerminalAgentBridge {
     registry;
     terminalProvider;
@@ -219,6 +261,265 @@ export class TerminalAgentBridge {
             multiline
         };
     }
+    /**
+     * Submit one closed, adapter-owned native inspection command.
+     *
+     * This intentionally does not use `send()`: native slash commands need a
+     * stricter composer proof, and failures after text injection must leave the
+     * draft untouched instead of issuing the legacy best-effort C-u cleanup.
+     */
+    async submitNativeInspection(agent, terminalControl, plan, options = {}) {
+        const adapter = this.registry.require(agent);
+        try {
+            assertClosedStatusInspectionPlan(adapter, terminalControl, plan);
+        }
+        catch (error) {
+            throw nativeInspectionSubmissionError("not_started", error);
+        }
+        let verifiedForText;
+        try {
+            verifiedForText = await this.verifyTerminalIdentity(adapter.agent, terminalControl, options.runtime);
+        }
+        catch (error) {
+            throw nativeInspectionSubmissionError("not_started", error);
+        }
+        try {
+            await this.terminalProvider.sendText(verifiedForText.target, plan.command, { socketPath: verifiedForText.socketPath });
+        }
+        catch (error) {
+            if (error instanceof TerminalControlInputNotSentError) {
+                throw nativeInspectionSubmissionError("not_started", error);
+            }
+            // The transport cannot prove whether an untyped failure happened before
+            // or after tmux accepted the literal input. Fail closed as injected.
+            throw nativeInspectionSubmissionError("text_injected", error);
+        }
+        let settled;
+        try {
+            settled = await this.settleNativeInspectionComposer(adapter, terminalControl, plan, options.runtime);
+            await options.beforeEnter?.({
+                agent: adapter.agent,
+                terminalControl: settled.terminalControl,
+                plan,
+                preEnterScreenDigest: settled.screenDigest,
+                materialization: settled.materialization
+            });
+            settled = await this.revalidateNativeInspectionComposer(adapter, settled.terminalControl, plan, settled.materialization, options.runtime);
+        }
+        catch (error) {
+            throw nativeInspectionSubmissionError("text_injected", error);
+        }
+        try {
+            // Exactly one Enter attempt. Any error is submission-uncertain and must
+            // never trigger a fallback executable or a blind second Enter.
+            await this.terminalProvider.sendKeys(settled.terminalControl.target, ["C-m"], { socketPath: settled.terminalControl.socketPath });
+        }
+        catch (error) {
+            throw nativeInspectionSubmissionError("enter_uncertain", error);
+        }
+        return {
+            stage: "enter_dispatched",
+            agent: adapter.agent,
+            terminalControl: settled.terminalControl,
+            command: plan.command,
+            behaviorProfile: plan.behaviorProfile,
+            preEnterScreenDigest: settled.screenDigest,
+            preEnterEvidenceInventory: settled.evidenceInventory,
+            materialization: settled.materialization,
+            enterCount: 1
+        };
+    }
+    async observeNativeInspection(agent, terminalControl, request, options = {}) {
+        const adapter = this.registry.require(agent);
+        if (!adapter.observeNativeInspection) {
+            throw new Error(`${adapter.displayName} native inspection observation is not supported`);
+        }
+        const captured = await this.captureInspection(adapter, terminalControl, {
+            runtime: options.runtime,
+            scrollbackLines: options.scrollbackLines
+        });
+        const screenDigest = nativeInspectionScreenFingerprint(captured.screen);
+        const adapterObservation = adapter.observeNativeInspection({
+            operation: request.operation,
+            previousScreenFingerprint: request.previousScreenFingerprint,
+            preEnterEvidenceInventory: request.preEnterEvidenceInventory,
+            expectedNativeThreadId: request.expectedNativeThreadId,
+            expectedAgentVersion: request.expectedAgentVersion,
+            expectedCwd: request.expectedCwd,
+            screen: captured.screen
+        });
+        const observation = adapter.agent === "claude" &&
+            options.runtime?.requireExactClaudeAgentRow === true &&
+            adapterObservation.status === "observed" &&
+            adapterObservation.evidence === "claude_status_panel"
+            ? {
+                ...adapterObservation,
+                evidence: "claude_status_panel+claude_agents_exact_pid"
+            }
+            : adapterObservation;
+        return {
+            terminalControl: captured.terminalControl,
+            status: statusFromInspection(adapter, captured.terminalControl, captured.inspection, { screen: captured.screen, runtime: options.runtime }),
+            screenDigest,
+            observation
+        };
+    }
+    /**
+     * Dismiss one exact adapter-owned modal result after re-observing the same
+     * evidence under the terminal identity fence. There is exactly one key
+     * attempt and no automated retry across an uncertain dismissal boundary.
+     */
+    async dismissNativeInspection(agent, terminalControl, plan, request, expectedEvidenceFingerprint, options = {}) {
+        const adapter = this.registry.require(agent);
+        try {
+            assertClosedStatusInspectionPlan(adapter, terminalControl, plan);
+            assertClosedNativeInspectionDismissal(plan);
+        }
+        catch (error) {
+            throw new NativeInspectionDismissalError(error instanceof Error ? error.message : String(error), { cause: error });
+        }
+        const observeExactPanel = async (control) => {
+            const captured = await this.captureInspection(adapter, control, {
+                runtime: options.runtime,
+                scrollbackLines: options.scrollbackLines
+            });
+            const observation = adapter.observeNativeInspection?.({
+                operation: request.operation,
+                previousScreenFingerprint: request.previousScreenFingerprint,
+                preEnterEvidenceInventory: request.preEnterEvidenceInventory,
+                expectedNativeThreadId: request.expectedNativeThreadId,
+                expectedAgentVersion: request.expectedAgentVersion,
+                expectedCwd: request.expectedCwd,
+                screen: captured.screen
+            });
+            if (!observation ||
+                observation.status !== "observed" ||
+                observation.result?.kind !== "native_status" ||
+                observation.evidenceFingerprint !== expectedEvidenceFingerprint) {
+                throw new Error(observation?.reason ??
+                    "the exact fresh native status panel changed before dismissal");
+            }
+            const verified = await this.verifyTerminalIdentity(adapter.agent, captured.terminalControl, options.runtime);
+            if (!sameTerminalControlIdentity(captured.terminalControl, verified)) {
+                throw new Error("terminal control identity changed before native status dismissal");
+            }
+            return verified;
+        };
+        try {
+            let verified = await observeExactPanel(terminalControl);
+            await options.beforeDismiss?.({
+                agent: adapter.agent,
+                terminalControl: verified,
+                plan,
+                evidenceFingerprint: expectedEvidenceFingerprint
+            });
+            verified = await observeExactPanel(verified);
+            try {
+                await this.terminalProvider.sendKeys(verified.target, plan.expectedResult.dismissal.keys, { socketPath: verified.socketPath });
+            }
+            catch (error) {
+                throw new NativeInspectionDismissalError("native status modal dismissal outcome is uncertain; do not retry automatically", { cause: error });
+            }
+            return {
+                stage: "dismiss_dispatched",
+                agent: adapter.agent,
+                terminalControl: verified,
+                keys: plan.expectedResult.dismissal.keys,
+                dismissCount: 1
+            };
+        }
+        catch (error) {
+            if (error instanceof NativeInspectionDismissalError) {
+                throw error;
+            }
+            throw new NativeInspectionDismissalError(error instanceof Error ? error.message : String(error), { cause: error });
+        }
+    }
+    async settleNativeInspectionComposer(adapter, terminalControl, plan, runtime) {
+        const startedAt = performance.now();
+        let stableDigest;
+        let stableKind;
+        let stableSince;
+        let stableCaptures = 0;
+        while (performance.now() - startedAt <= CODEX_MULTILINE_SETTLE_TIMEOUT_MS) {
+            const captured = await this.captureInspection(adapter, terminalControl, {
+                runtime,
+                scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES
+            });
+            assertNativeInspectionComposerSafe(captured.inspection);
+            const materialized = exactNativeInspectionComposerCapture(adapter.agent, captured.screen, plan);
+            const now = performance.now();
+            if (materialized) {
+                if (materialized.digest === stableDigest &&
+                    materialized.kind === stableKind) {
+                    stableCaptures += 1;
+                }
+                else {
+                    stableDigest = materialized.digest;
+                    stableKind = materialized.kind;
+                    stableSince = now;
+                    stableCaptures = 1;
+                }
+                const stableForMs = stableSince === undefined ? 0 : now - stableSince;
+                if (stableCaptures >= CODEX_MULTILINE_STABLE_CAPTURES &&
+                    stableForMs >= plan.composer.minimumStableMs) {
+                    const evidence = {
+                        kind: materialized.kind,
+                        digest: materialized.digest,
+                        stableForMs,
+                        stableCaptures
+                    };
+                    return this.revalidateNativeInspectionComposer(adapter, captured.terminalControl, plan, evidence, runtime);
+                }
+            }
+            else {
+                stableDigest = undefined;
+                stableKind = undefined;
+                stableSince = undefined;
+                stableCaptures = 0;
+            }
+            const elapsed = performance.now() - startedAt;
+            const remaining = CODEX_MULTILINE_SETTLE_TIMEOUT_MS - elapsed;
+            if (remaining <= 0) {
+                break;
+            }
+            await terminalSettleDelay(Math.min(CODEX_MULTILINE_SETTLE_POLL_MS, remaining));
+        }
+        throw new Error(`${adapter.displayName} /status composer did not become exact, idle, and stable before the bounded submit deadline`);
+    }
+    async revalidateNativeInspectionComposer(adapter, terminalControl, plan, expected, runtime) {
+        const captured = await this.captureInspection(adapter, terminalControl, {
+            runtime,
+            scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES
+        });
+        assertNativeInspectionComposerSafe(captured.inspection);
+        const materialized = exactNativeInspectionComposerCapture(adapter.agent, captured.screen, plan);
+        if (!materialized ||
+            materialized.digest !== expected.digest ||
+            materialized.kind !== expected.kind) {
+            throw new Error(`${adapter.displayName} /status composer changed after its stable pre-submit capture`);
+        }
+        const baseline = adapter.observeNativeInspection?.({
+            operation: plan.operation,
+            screen: captured.screen
+        });
+        if (!baseline ||
+            baseline.status === "ambiguous" ||
+            !Array.isArray(baseline.evidenceInventory)) {
+            throw new Error(baseline?.reason ??
+                `${adapter.displayName} /status pre-Enter evidence inventory was not proven`);
+        }
+        const verifiedImmediatelyBeforeEnter = await this.verifyTerminalIdentity(adapter.agent, captured.terminalControl, runtime);
+        if (!sameTerminalControlIdentity(captured.terminalControl, verifiedImmediatelyBeforeEnter)) {
+            throw new Error(`terminal control identity changed after the final ${adapter.displayName} /status composer capture`);
+        }
+        return {
+            terminalControl: verifiedImmediatelyBeforeEnter,
+            screenDigest: nativeInspectionScreenFingerprint(captured.screen),
+            evidenceInventory: baseline.evidenceInventory,
+            materialization: expected
+        };
+    }
     async settleCodexMultilineComposer(adapter, terminalControl, expectedText, runtime) {
         const startedAt = performance.now();
         let stableDigest;
@@ -739,6 +1040,210 @@ export class TerminalAgentBridge {
         return result?.terminalControl ?? terminalControl;
     }
 }
+function nativeInspectionSubmissionError(stage, error) {
+    if (error instanceof NativeInspectionSubmissionError) {
+        const stageRank = {
+            not_started: 0,
+            text_injected: 1,
+            enter_uncertain: 2
+        };
+        if (stageRank[error.stage] >= stageRank[stage]) {
+            return error;
+        }
+        return new NativeInspectionSubmissionError(stage, error.message, {
+            cause: error
+        });
+    }
+    return new NativeInspectionSubmissionError(stage, error instanceof Error ? error.message : String(error), { cause: error });
+}
+function assertClosedStatusInspectionPlan(adapter, terminalControl, plan) {
+    if (!terminalControl.capabilities.includes("send_keys")) {
+        throw new Error(`${adapter.displayName} terminal input is not supported`);
+    }
+    if (!terminalControl.capabilities.includes("screen_status")) {
+        throw new Error(`${adapter.displayName} terminal screen inspection is not supported`);
+    }
+    const codexProfile = adapter.agent === "codex" && [
+        "codex-tui-0.146.0",
+        "codex-tui-0.146.1"
+    ].includes(plan.behaviorProfile);
+    const claudeProfile = adapter.agent === "claude" &&
+        plan.behaviorProfile === "claude-code-2.1.218-native-status";
+    const exactPresentation = codexProfile
+        ? plan.expectedResult.presentation === "inline" &&
+            plan.expectedResult.dismissal === undefined &&
+            plan.composer.minimumStableMs >= CODEX_PASTE_ENTER_SETTLE_MS
+        : claudeProfile
+            ? plan.expectedResult.presentation === "modal" &&
+                plan.composer.minimumStableMs >= 80 &&
+                plan.expectedResult.dismissal?.expected === "idle_empty_composer" &&
+                JSON.stringify(plan.expectedResult.dismissal.keys) ===
+                    JSON.stringify(["Escape"])
+            : false;
+    if (plan.operation.kind !== "status" ||
+        plan.command !== "/status" ||
+        plan.effect !== "read_only" ||
+        plan.requiresIdle !== true ||
+        plan.composer.kind !== "exact" ||
+        !Number.isFinite(plan.composer.minimumStableMs) ||
+        plan.composer.minimumStableMs < 0 ||
+        plan.expectedResult.kind !== "native_status" ||
+        !exactPresentation) {
+        throw new Error("refusing a non-closed or unverified native inspection plan");
+    }
+}
+function assertClosedNativeInspectionDismissal(plan) {
+    if (plan.expectedResult.presentation !== "modal" ||
+        plan.expectedResult.dismissal?.expected !== "idle_empty_composer" ||
+        JSON.stringify(plan.expectedResult.dismissal.keys) !==
+            JSON.stringify(["Escape"])) {
+        throw new Error("native inspection has no closed verified modal dismissal plan");
+    }
+}
+function assertNativeInspectionComposerSafe(inspection, displayName = "terminal agent") {
+    if (inspection.approval.blocked ||
+        inspection.activity.state === "awaiting_approval" ||
+        inspection.activity.state === "working") {
+        throw new Error(`${displayName} became busy or blocked while its /status composer was settling`);
+    }
+    // Codex's generic activity parser deliberately reports a non-empty slash
+    // composer as unknown. At this stage the caller has already proved an idle,
+    // empty styled composer under the terminal lock; the exact-current composer
+    // capture below is the stronger continuation proof after AKK injected only
+    // the adapter-owned /status command.
+}
+function exactNativeInspectionComposerCapture(agent, screen, plan) {
+    return agent === "codex"
+        ? exactCodexNativeInspectionComposerCapture(screen, plan)
+        : exactClaudeNativeInspectionComposerCapture(screen, plan);
+}
+function exactCodexNativeInspectionComposerCapture(screen, plan) {
+    const lines = screen.replace(/\r\n?/gu, "\n").split("\n");
+    let currentComposerIndex = -1;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (CODEX_COMPOSER_MARKER.test(lines[index])) {
+            currentComposerIndex = index;
+            break;
+        }
+    }
+    if (currentComposerIndex < 0) {
+        return undefined;
+    }
+    const composerText = lines[currentComposerIndex]
+        .replace(/^[›»]\s?/u, "")
+        .trimEnd();
+    if (composerText !== plan.command) {
+        return undefined;
+    }
+    const footerIndex = lines.findIndex((line, candidateIndex) => candidateIndex > currentComposerIndex &&
+        CODEX_COMPOSER_FOOTER.test(line.trim()));
+    const region = lines.slice(currentComposerIndex, footerIndex < 0 ? lines.length : footerIndex);
+    while (region.length > 1 && region.at(-1)?.trim() === "") {
+        region.pop();
+    }
+    const popupRows = region.slice(1).filter((line) => line.trim().length > 0);
+    let kind;
+    if (popupRows.length === 0) {
+        kind = "exact_slash_composer";
+    }
+    else if (popupRows.length === 1 &&
+        popupRows[0].trimEnd() ===
+            CODEX_NATIVE_STATUS_POPUP_BY_PROFILE[plan.behaviorProfile]) {
+        kind = "exact_slash_popup";
+    }
+    else {
+        return undefined;
+    }
+    return {
+        kind,
+        digest: createHash("sha256").update(region.join("\n")).digest("hex")
+    };
+}
+function exactClaudeNativeInspectionComposerCapture(screen, plan) {
+    const frame = exactClaudeNativeInspectionComposerFrame(screen);
+    if (!frame) {
+        return undefined;
+    }
+    const { lines, openIndex, closeIndex, composerRows, trailing } = frame;
+    if (composerRows.length !== 1 ||
+        !/^\s*❯(?:\s|$)/u.test(composerRows[0]) ||
+        composerRows[0].replace(/^\s*❯\s?/u, "").trimEnd() !== plan.command) {
+        return undefined;
+    }
+    let kind;
+    if (trailing.length === 0 || claudeNativeInspectionTrailingIsFooter(trailing)) {
+        kind = "exact_slash_composer";
+    }
+    else {
+        const suggestions = [];
+        for (const line of trailing) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("/")) {
+                suggestions.push(trimmed.replace(/\s+/gu, " "));
+            }
+            else if (suggestions.length > 0) {
+                suggestions[suggestions.length - 1] +=
+                    ` ${trimmed.replace(/\s+/gu, " ")}`;
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (JSON.stringify(suggestions) !== JSON.stringify(CLAUDE_NATIVE_STATUS_POPUP_BY_PROFILE[plan.behaviorProfile])) {
+            return undefined;
+        }
+        kind = "exact_slash_popup";
+    }
+    return {
+        kind,
+        digest: createHash("sha256")
+            .update(lines.slice(openIndex, closeIndex + 1).concat(trailing).join("\n"))
+            .digest("hex")
+    };
+}
+/**
+ * Prove the exact idle input frame from the verified Claude Code 2.1.218
+ * profile. A loose or historical `❯` prompt is not enough to authorize even
+ * the initial literal `/status` injection.
+ */
+export function isExactClaudeNativeInspectionIdleComposer(screen) {
+    const frame = exactClaudeNativeInspectionComposerFrame(screen);
+    if (!frame) {
+        return false;
+    }
+    return (frame.composerRows.length === 1 &&
+        /^\s*❯\s*$/u.test(frame.composerRows[0]) &&
+        (frame.trailing.length === 0 ||
+            claudeNativeInspectionTrailingIsFooter(frame.trailing)));
+}
+function exactClaudeNativeInspectionComposerFrame(screen) {
+    const lines = screen.replace(/\r\n?/gu, "\n").replace(/\u00a0/gu, " ")
+        .split("\n");
+    const dividerIndexes = lines
+        .map((line, index) => /^\s*[─━]{8,}\s*$/u.test(line) ? index : -1)
+        .filter((index) => index >= 0);
+    if (dividerIndexes.length < 2) {
+        return undefined;
+    }
+    const closeIndex = dividerIndexes.at(-1);
+    const openIndex = dividerIndexes.at(-2);
+    return {
+        lines,
+        openIndex,
+        closeIndex,
+        composerRows: lines.slice(openIndex + 1, closeIndex)
+            .filter((line) => line.trim().length > 0),
+        trailing: lines.slice(closeIndex + 1)
+            .filter((line) => line.trim().length > 0)
+    };
+}
+function claudeNativeInspectionTrailingIsFooter(lines) {
+    return lines.length <= 2 && lines.every((line) => /^\s*(?:[⏵⏴]{1,2}|\?)\s*.*(?:shift\+tab|accept edits|bypass permissions|for shortcuts|← for agents)/iu
+        .test(line));
+}
+function nativeInspectionScreenFingerprint(screen) {
+    return `sha256:${createHash("sha256").update(screen).digest("hex")}`;
+}
 function exactCodexComposerCapture(screen, expectedText) {
     const lines = screen.replace(/\r\n?/gu, "\n").split("\n");
     const expectedComparable = composerComparableText(expectedText);