@scotthuang/agent-knock-knock 0.11.3 → 0.11.5

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.11.5 - 2026-08-09
+
+### Added
+
+- Extend the closed `native_inspect(status)` action to exact Claude Code 2.1.218 with an adapter-owned `/status` plan, a separately measured 80 ms composer-stability boundary, bounded and redacted Status-panel parsing, and safe return to the original idle composer.
+
+### Security
+
+- Fence Claude inspection with a fresh snapshot token, the shared terminal lock, exact pane, PID, process birth, cwd, binding, unique `claude agents --json --all` Session identity, and exclusive active ownership before and across terminal input.
+- Keep ordinary `send` and `respond` slash-command rejection intact, issue at most one Enter and one Escape without blind retries, create no AKK lifecycle state, and leave `/usage`, `/cost`, `/stats`, and `/usage-credits` unavailable.
+
+## 0.11.4 - 2026-08-09
+
+### Added
+
+- Add an adapter-owned, version-scoped native status inspection for Codex 0.146.0 and 0.146.1, exposed through a closed `native_inspect(status)` action that returns a bounded and redacted fresh `/status` result without creating a Session, Turn, receipt, monitor, callback, or Store state.
+
+### Security
+
+- Keep ordinary `send` and `respond` slash-command rejection intact while serializing native inspection with terminal mutations, revalidating the exact terminal, process, binding, version, idle composer, and ownership state, and dispatching at most one Enter only after the versioned 121 ms materialization boundary.
+- Fail closed after identity drift, ambiguous or stale status evidence, and uncertain submission outcomes without blind retries or a second Enter.
+
 ## 0.11.3 - 2026-08-08
 
 ### Fixed

package/README.md

@@ -87,6 +87,8 @@ Human-friendly selectors such as `only`, `codex`, `claude`, a terminal ID, or `@
 
 Native clear/new/resume operations are explicit lifecycle actions, separate from ordinary Turn creation. A successful new/clear creates a new native thread and AKK Session; resume activates the exact historical native thread and its corresponding Session. Each successful lifecycle transition creates no Turn. The next ordinary send creates the first Turn in the selected context. AKK serializes the transition, verifies the resulting native identity, and advances the terminal binding generation so work and callbacks from the previous context cannot cross the boundary.
 
+AKK status and native status inspection are different operations. `agent_knock_knock_status` (and `/akk status`) reads AKK Turn state plus a bounded current terminal screen; it does not execute the coding agent's `/status`. When an idle terminal row advertises `native_inspect`, `agent_knock_knock_native_inspect` can execute only its prefilled, version-scoped inspection with the exact `terminal_id`, `inspection="status"`, and fresh `expected_binding_token`. Supported profiles are Codex 0.146.0/0.146.1 and Claude Code 2.1.218. Claude's adapter parses a newly opened Status panel, dismisses that exact panel once, and proves the same pane returned to an idle empty composer. The action creates no Session, Turn, receipt, monitor, or callback. `/usage`, `/cost`, `/stats`, `/usage-credits`, `/model`, `/compact`, arbitrary slash strings, and unsupported versions remain unavailable. In particular, bare Codex `/usage` opens an interactive menu whose later Enter can select an account-side usage-limit reset; do not automate it as a read-only inspection.
+
 ## Optional: Natural-Language Delegation
 
 The quick start uses direct `/akk ...` commands, which bypass the model and work without plugin tool access. To let OpenClaw decide to use AKK from a natural-language request, grant the optional `agent-knock-knock` tools in the applicable tool policy.
@@ -132,7 +134,7 @@ If you also want standalone shell commands such as `agent-knock-knock doctor`, i
 npm install -g @scotthuang/agent-knock-knock
 ```
 
-Standalone `agent-knock-knock list` and `status` are read-only with respect to managed-turn state by default. Passing `--reconcile` explicitly enables controlled reconciliation; OpenClaw does this for `/akk list`, `/akk status`, and the corresponding plugin tools.
+Standalone `agent-knock-knock list` and AKK `status` are read-only with respect to managed-turn state by default. Passing `--reconcile` explicitly enables controlled reconciliation; OpenClaw does this for `/akk list`, `/akk status`, and the corresponding plugin tools. This AKK status path does not run the coding agent's native `/status`; the separately advertised `native_inspect` action owns that bounded terminal input.
 
 ### Alternative: Install from npm
 
@@ -226,11 +228,15 @@ Selectors fail closed: `only` works only with one actionable target, `latest` re
 
 To change native context, first copy the full `terminal_id` from `/akk list`; lifecycle commands do not accept an ordinary-send `@short-ref` or loose agent selector. `/akk threads <exact-terminal-id>` lists exact, same-workspace candidates with a deterministic number, a collision-safe display-only `@short-id`, an opaque snapshot handle, and the complete UUID. `/akk resume-thread <exact-terminal-id>` without a selection shows that list. A complete UUID remains compatible. A number or short ID resolves only against the latest list displayed in the same OpenClaw session, while an opaque handle names its exact snapshot; all expire after five minutes and fail after terminal, process, workspace, binding, candidate-set, or relevant action changes. None is ever passed to Codex or Claude Code as native identity: AKK resolves the saved tuple back to its full UUID and fresh evidence tokens first. `previous` (or `刚才那个`) is advertised only when the current Session's latest committed lifecycle transition identifies exactly one currently verified resumable source; it never guesses from title, recency, or static lineage. `/akk new-thread` and its human alias `/akk clear-thread` start a clean context. AKK does not poll bindings in the background: if a recorded owner process exits, the next lifecycle listing can classify that sole historical binding as resumable, and the resume mutation compare-and-swap detaches it before touching the terminal. Live, stale, expired, unsupported, busy, ambiguous, active-elsewhere, or unverifiable transitions fail closed. Do not send `/clear`, `/new`, `/resume`, `/status`, Codex `/fork`, `/side`, or `/btw`, Claude `/branch`, or any other first-line native slash command as an ordinary task or answer; use an advertised AKK action, express the request in natural language, or enter an unsupported native command manually in tmux.
 
+To request a native Codex status card or Claude Status panel, first run `agent_knock_knock_list` and use only that terminal row's advertised `native_inspect` action. The structured tool schema is closed to `inspection="status"`; callers cannot provide `/status` or another slash command as text. AKK serializes the inspection with terminal mutations, revalidates the fresh token and exact terminal identity, and returns only after it proves one fresh bounded status result and an idle postcondition. For Claude, that includes safely dismissing the exact modal once. It never turns ordinary `send` or `respond` into a slash-command escape hatch.
+
+The top-level v7 `action_contracts` documents this closed inspection alongside the existing lifecycle and Turn actions; `available_actions` remains the only current-action authority.
+
 For natural-language tool use, `agent_knock_knock_list` is terminal-first. Each live pane appears exactly once in `terminals[]`; `process_state` reports whether its coding-agent process is alive and `activity_state` reports the parsed screen state. `managed.session_id` identifies the continuing AKK session, `managed.current_turn` is its optional active Turn, and `managed.recent_turn` is retained history; retained Turns do not occupy the terminal. Pass `all=true` to include older entries in `managed.history`. By default, `unavailable_managed_turns[]` contains attention-needed records whose pane cannot be presented as a live terminal; `all=true` also includes retained unavailable history.
 
-Use only an `available_actions` entry returned in that snapshot, begin with its prefilled authoritative arguments, and supply every `missing_required` field. A managed Session's `send` uses its prefilled `session_id` and creates a new Turn. For first attach only, use a discovery selector explicitly named by the user or the unmanaged raw-terminal row's prefilled `selector`; do not infer or reuse one. `respond` is available only while a Turn is `waiting_for_openclaw`; it uses `turn_id` and keeps the answer inside that Turn. Managed status, approval, cancellation, renewal, callback retry, and close also use the exact `turn_id`. A raw terminal may be controlled only through the exact status, approval, cancellation, or orphan-close action that its own row advertises with a prefilled `conversation_id`; never construct or guess one. For an ordinary send, add only `request`—`timeoutSeconds` is unsupported, and monitoring limits should be omitted unless the user explicitly asks to change them. AKK revalidates availability before every side effect.
+Use only an `available_actions` entry returned in that snapshot, begin with its prefilled authoritative arguments, and supply every `missing_required` field. A managed Session's `send` uses its prefilled `session_id` and creates a new Turn. For first attach only, use a discovery selector explicitly named by the user or the unmanaged raw-terminal row's prefilled `selector`; do not infer or reuse one. `respond` is available only while a Turn is `waiting_for_openclaw`; it uses `turn_id` and keeps the answer inside that Turn. Managed status, approval, cancellation, renewal, callback retry, and close also use the exact `turn_id`. Native inspection instead uses the exact terminal row's `terminal_id`, closed `inspection`, and snapshot-bound `expected_binding_token`; do not substitute AKK status or ordinary send. A raw terminal may be controlled only through the exact status, approval, cancellation, or orphan-close action that its own row advertises with a prefilled `conversation_id`; never construct or guess one. For an ordinary send, add only `request`—`timeoutSeconds` is unsupported, and monitoring limits should be omitted unless the user explicitly asks to change them. AKK revalidates availability before every side effect.
 
-The top-level v6 `action_contracts` adds `list_resumable_threads`, `new_thread`, `resume_thread`, and the conflict-only `reconcile_binding` recovery action. The terminal row advertises `list_resumable_threads` and, when currently safe, `new_thread`. Listing is read-only with respect to Session/Turn state, takes only the full `terminal_id`, and returns a fresh `expected_binding_token` plus candidate rows; each `resumable=true` row retains its complete UUID and exact prefilled `resume_thread` action. If `previous` is present, use only its exact prefilled action for a natural-language “刚才那个” request. Numbers, short IDs, and handles are human display/navigation aids, never tool arguments or authoritative native identity. The `new_thread` and `resume_thread` mutations require the fresh token, and resume additionally requires the candidate's complete `native_thread_id` and opaque `candidate_token`. A binding conflict may advertise `reconcile_binding` only when one exact Session claim can be safely CAS-detached using its listed revision, binding token, and live terminal token; this never adopts the replacement thread, sends terminal input, or creates a Turn. Never construct, guess, truncate, combine across snapshots, or reuse those values after another terminal action. A lifecycle result contains Session and native-thread identities but no `turn_id` because no work was sent.
+The top-level action contracts include `native_inspect`, `list_resumable_threads`, `new_thread`, `resume_thread`, and the conflict-only `reconcile_binding` recovery action. A supported idle Codex or Claude Code terminal may advertise `native_inspect` with its exact terminal ID, the closed `status` inspection kind, and a fresh binding token. The terminal row also advertises `list_resumable_threads` and, when currently safe, `new_thread`. Thread listing is read-only with respect to Session/Turn state, takes only the full `terminal_id`, and returns a fresh `expected_binding_token` plus candidate rows; each `resumable=true` row retains its complete UUID and exact prefilled `resume_thread` action. If `previous` is present, use only its exact prefilled action for a natural-language “刚才那个” request. Numbers, short IDs, and handles are human display/navigation aids, never tool arguments or authoritative native identity. The `new_thread` and `resume_thread` mutations require the fresh token, and resume additionally requires the candidate's complete `native_thread_id` and opaque `candidate_token`. A binding conflict may advertise `reconcile_binding` only when one exact Session claim can be safely CAS-detached using its listed revision, binding token, and live terminal token; this never adopts the replacement thread, sends terminal input, or creates a Turn. Never construct, guess, truncate, combine across snapshots, or reuse those values after another terminal action. Native inspection and lifecycle results contain no `turn_id` because no work was sent.
 
 Workspace is not a routing boundary. AKK can list, inspect, and control verified panes across projects; when more than one target matches, use a selector to choose one explicitly.
 
@@ -339,10 +345,14 @@ is not currently required for publishing.
 ```bash
 npm run build
 npm run typecheck
-npm test
+npm run test:fast
 ```
 
-See [CONTRIBUTING.md](https://github.com/scotthuang/agent-knock-knock/blob/main/CONTRIBUTING.md) for the development and pull request workflow. For local OpenClaw testing, rebuild, run `node dist/src/cli.js install-openclaw`, and restart the Gateway.
+Use the fast tier for the inner loop, add the integration files mapped to the
+subsystem you changed, and run `npm test` once before opening a pull request.
+`npm test` remains the complete suite. See [Testing](docs/testing.md) for the
+tier manifest, targeted integration map, profiling command, and release gates,
+and [CONTRIBUTING.md](https://github.com/scotthuang/agent-knock-knock/blob/main/CONTRIBUTING.md) for the development and pull request workflow. For local OpenClaw testing, rebuild, run `node dist/src/cli.js install-openclaw`, and restart the Gateway.
 
 ### Maintainer Release
 

package/dist/src/claude-terminal-agent-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { ActiveTerminalProcess, TerminalAgentAdapter, TerminalApprovalInspection, TerminalDurableCompletionRequest, TerminalProcessSnapshot, TerminalScreenInspection, TerminalScreenInspectionOptions, TerminalThreadLifecycleCapabilities, TerminalThreadLifecycleObservation, TerminalThreadLifecycleObservationRequest, TerminalThreadLifecycleOperation, TerminalThreadLifecyclePlan } from "./terminal-agent-adapter.js";
+import type { ActiveTerminalProcess, TerminalAgentAdapter, TerminalApprovalInspection, TerminalDurableCompletionRequest, TerminalNativeInspectionCapabilities, TerminalNativeInspectionObservation, TerminalNativeInspectionObservationRequest, TerminalNativeInspectionOperation, TerminalNativeInspectionPlan, TerminalProcessSnapshot, TerminalScreenInspection, TerminalScreenInspectionOptions, TerminalThreadLifecycleCapabilities, TerminalThreadLifecycleObservation, TerminalThreadLifecycleObservationRequest, TerminalThreadLifecycleOperation, TerminalThreadLifecyclePlan } from "./terminal-agent-adapter.js";
 export type ClaudeProcessKind = "claude_cli";
 /** A row returned by `claude agents --json --all`. Unknown fields are intentionally ignored. */
 export interface ClaudeAgentRow {
@@ -8,6 +8,7 @@ export interface ClaudeAgentRow {
     sessionId?: string;
     startedAt?: number;
     status?: string;
+    waitingFor?: string;
 }
 export interface CreateClaudeTerminalAgentAdapterOptions {
     /**
@@ -39,7 +40,18 @@ export interface ClaudePendingApprovalEvidence {
     evidenceFingerprint: string;
     observedEndOffsetBytes: number;
 }
+/**
+ * On the verified 2.1.218 TUI, the exact `/status` composer and its closed
+ * completion list remained byte-stable across an 80 ms capture interval and
+ * one subsequent Enter opened the Status panel. This is a Claude-local
+ * single-line profile; it deliberately does not reuse Codex's 121 ms burst
+ * paste boundary.
+ */
+export declare const CLAUDE_NATIVE_INSPECTION_COMPOSER_STABLE_MS = 80;
 export declare function createClaudeTerminalAgentAdapter(options?: CreateClaudeTerminalAgentAdapterOptions): TerminalAgentAdapter<ClaudeProcessKind>;
+export declare function probeClaudeNativeInspection(agentVersion: string | undefined): TerminalNativeInspectionCapabilities;
+export declare function planClaudeNativeInspection(operation: TerminalNativeInspectionOperation, capabilities: TerminalNativeInspectionCapabilities): TerminalNativeInspectionPlan;
+export declare function observeClaudeNativeInspection(request: TerminalNativeInspectionObservationRequest): TerminalNativeInspectionObservation;
 export declare function probeClaudeThreadLifecycle(agentVersion: string | undefined): TerminalThreadLifecycleCapabilities;
 export declare function planClaudeThreadLifecycle(operation: TerminalThreadLifecycleOperation, capabilities: TerminalThreadLifecycleCapabilities): TerminalThreadLifecyclePlan;
 export declare function observeClaudeThreadLifecycle(request: TerminalThreadLifecycleObservationRequest, legacyOperation?: undefined, fallbackAgentRows?: readonly ClaudeAgentRow[]): TerminalThreadLifecycleObservation;

package/dist/src/claude-terminal-agent-adapter.js

@@ -75,6 +75,43 @@ const CLAUDE_AUTO_APPROVAL_COMMAND_LENGTH = 2000;
 const CLAUDE_NATIVE_VERSION_PATTERN = /^\d+\.\d+\.\d+$/u;
 const CLAUDE_LIFECYCLE_VERSION = "2.1.218";
 const CLAUDE_LIFECYCLE_PROFILE = "claude-code-2.1.218";
+const CLAUDE_NATIVE_INSPECTION_VERSION = "2.1.218";
+const CLAUDE_NATIVE_INSPECTION_PROFILE = "claude-code-2.1.218-native-status";
+/**
+ * On the verified 2.1.218 TUI, the exact `/status` composer and its closed
+ * completion list remained byte-stable across an 80 ms capture interval and
+ * one subsequent Enter opened the Status panel. This is a Claude-local
+ * single-line profile; it deliberately does not reuse Codex's 121 ms burst
+ * paste boundary.
+ */
+export const CLAUDE_NATIVE_INSPECTION_COMPOSER_STABLE_MS = 80;
+const CLAUDE_STATUS_PANEL_HEADER = /^\s*Settings\s+Status\s+Config\s+Usage\s+Stats\s*$/u;
+const CLAUDE_STATUS_PANEL_FOOTER = /^\s*Esc to cancel\s*$/u;
+const CLAUDE_STATUS_PANEL_DIVIDER = /^\s*[─━]{8,}\s*$/u;
+const CLAUDE_STATUS_PANEL_FIELD = /^\s{0,4}([^:]{1,64}):\s+(.{1,1024})\s*$/u;
+const CLAUDE_STATUS_PANEL_MAX_SCAN_LINES = 512;
+const CLAUDE_STATUS_PANEL_MAX_LINES = 48;
+const CLAUDE_STATUS_PANEL_MAX_REGION_LENGTH = 8_192;
+const CLAUDE_STATUS_PANEL_MAX_FIELDS = 24;
+const CLAUDE_STATUS_PANEL_MAX_FIELD_VALUE_LENGTH = 512;
+const CLAUDE_STATUS_PANEL_MAX_EXCERPT_LENGTH = 4_000;
+const CLAUDE_STATUS_PANEL_MAX_EVIDENCE_ENTRIES = 24;
+const CLAUDE_STATUS_PANEL_FIELDS = new Set([
+    "Version",
+    "Session name",
+    "Session ID",
+    "cwd",
+    "Auth token",
+    "Anthropic base URL",
+    "Model",
+    "MCP servers",
+    "Setting sources"
+]);
+const CLAUDE_STATUS_PANEL_SENSITIVE_FIELDS = new Set([
+    "Session name",
+    "Auth token"
+]);
+const NATIVE_INSPECTION_FINGERPRINT = /^sha256:[0-9a-f]{64}$/u;
 const ANSI_ESCAPE_PATTERN = /\x1B(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/gu;
 export function createClaudeTerminalAgentAdapter(options = {}) {
     const agentRows = options.agentRows ?? [];
@@ -106,6 +143,9 @@ export function createClaudeTerminalAgentAdapter(options = {}) {
         probeThreadLifecycle: probeClaudeThreadLifecycle,
         planThreadLifecycle: planClaudeThreadLifecycle,
         observeThreadLifecycle: lifecycleObserver,
+        probeNativeInspection: probeClaudeNativeInspection,
+        planNativeInspection: planClaudeNativeInspection,
+        observeNativeInspection: observeClaudeNativeInspection,
         ...(durableCompletion
             ? {
                 async detectDurableCompletion(request) {
@@ -115,6 +155,191 @@ export function createClaudeTerminalAgentAdapter(options = {}) {
             : {})
     };
 }
+export function probeClaudeNativeInspection(agentVersion) {
+    if (!agentVersion) {
+        return {
+            status: "unknown",
+            statusInspection: false,
+            reason: "the running Claude Code version could not be verified"
+        };
+    }
+    const supported = agentVersion === CLAUDE_NATIVE_INSPECTION_VERSION;
+    return {
+        status: supported ? "supported" : "unsupported",
+        agentVersion,
+        behaviorProfile: supported
+            ? CLAUDE_NATIVE_INSPECTION_PROFILE
+            : undefined,
+        statusInspection: supported,
+        reason: supported
+            ? "Claude Code /status native inspection is supported by the verified version"
+            : "this exact Claude Code version has no AKK native inspection behavior profile"
+    };
+}
+export function planClaudeNativeInspection(operation, capabilities) {
+    if (operation.kind !== "status" ||
+        capabilities.status !== "supported" ||
+        capabilities.statusInspection !== true ||
+        capabilities.agentVersion !== CLAUDE_NATIVE_INSPECTION_VERSION ||
+        capabilities.behaviorProfile !== CLAUDE_NATIVE_INSPECTION_PROFILE) {
+        throw new Error(capabilities.reason);
+    }
+    return {
+        operation,
+        behaviorProfile: CLAUDE_NATIVE_INSPECTION_PROFILE,
+        command: "/status",
+        effect: "read_only",
+        requiresIdle: true,
+        composer: {
+            kind: "exact",
+            minimumStableMs: CLAUDE_NATIVE_INSPECTION_COMPOSER_STABLE_MS
+        },
+        expectedResult: {
+            kind: "native_status",
+            presentation: "modal",
+            dismissal: {
+                keys: ["Escape"],
+                expected: "idle_empty_composer"
+            }
+        }
+    };
+}
+export function observeClaudeNativeInspection(request) {
+    const rawScreen = request.screen ?? "";
+    const rawScreenFingerprint = fingerprintClaudeNativeInspection(rawScreen);
+    const screen = normalizeClaudeNativeInspectionScreen(rawScreen);
+    const screenFingerprint = fingerprintClaudeNativeInspection(screen);
+    const inventory = claudeStatusPanelEvidenceInventory(screen);
+    if (inventory.status === "ambiguous") {
+        return {
+            status: "ambiguous",
+            screenFingerprint,
+            evidenceInventory: inventory.entries,
+            reason: inventory.reason
+        };
+    }
+    const baselineError = validateClaudeStatusEvidenceInventory(request.preEnterEvidenceInventory);
+    if (baselineError) {
+        return {
+            status: "ambiguous",
+            screenFingerprint,
+            evidenceInventory: inventory.entries,
+            reason: baselineError
+        };
+    }
+    if (request.previousScreenFingerprint !== undefined &&
+        (request.previousScreenFingerprint === rawScreenFingerprint ||
+            request.previousScreenFingerprint === screenFingerprint)) {
+        return {
+            status: "stale",
+            screenFingerprint,
+            evidenceInventory: inventory.entries,
+            reason: "the Claude screen did not change after the native inspection command"
+        };
+    }
+    const parsed = parseCurrentClaudeStatusPanel(screen);
+    if (parsed.status !== "observed") {
+        return {
+            status: parsed.status,
+            screenFingerprint,
+            evidenceInventory: inventory.entries,
+            reason: parsed.reason
+        };
+    }
+    const evidenceFingerprint = fingerprintClaudeNativeInspection(parsed.region);
+    if (request.preEnterEvidenceInventory !== undefined) {
+        const priorOccurrences = request.preEnterEvidenceInventory.find((entry) => entry.evidenceFingerprint === evidenceFingerprint)?.occurrenceCount ?? 0;
+        const currentOccurrences = inventory.entries.find((entry) => entry.evidenceFingerprint === evidenceFingerprint)?.occurrenceCount ?? 0;
+        if (currentOccurrences <= priorOccurrences) {
+            return {
+                status: "stale",
+                nativeThreadId: parsed.nativeThreadId,
+                observedAgentVersion: parsed.agentVersion,
+                evidence: "claude_status_panel",
+                evidenceFingerprint,
+                screenFingerprint,
+                evidenceInventory: inventory.entries,
+                reason: "the Claude Status panel did not add fresh exact evidence after Enter"
+            };
+        }
+    }
+    if (parsed.agentVersion !== CLAUDE_NATIVE_INSPECTION_VERSION) {
+        return {
+            status: "mismatch",
+            nativeThreadId: parsed.nativeThreadId,
+            observedAgentVersion: parsed.agentVersion,
+            evidenceFingerprint,
+            screenFingerprint,
+            evidenceInventory: inventory.entries,
+            reason: `Claude /status reported unsupported version ${parsed.agentVersion}`
+        };
+    }
+    if (request.expectedAgentVersion !== undefined &&
+        parsed.agentVersion !== request.expectedAgentVersion) {
+        return {
+            status: "mismatch",
+            nativeThreadId: parsed.nativeThreadId,
+            observedAgentVersion: parsed.agentVersion,
+            evidenceFingerprint,
+            screenFingerprint,
+            evidenceInventory: inventory.entries,
+            reason: `Claude /status reported version ${parsed.agentVersion}, not the ` +
+                `verified running version ${request.expectedAgentVersion}`
+        };
+    }
+    if (!isExactNativeThreadId(request.expectedNativeThreadId)) {
+        return {
+            status: "mismatch",
+            nativeThreadId: parsed.nativeThreadId,
+            observedAgentVersion: parsed.agentVersion,
+            evidenceFingerprint,
+            screenFingerprint,
+            evidenceInventory: inventory.entries,
+            reason: "Claude native status inspection requires an exact claude agents Session identity"
+        };
+    }
+    if (parsed.nativeThreadId !== request.expectedNativeThreadId.toLowerCase()) {
+        return {
+            status: "mismatch",
+            nativeThreadId: parsed.nativeThreadId,
+            observedAgentVersion: parsed.agentVersion,
+            evidenceFingerprint,
+            screenFingerprint,
+            evidenceInventory: inventory.entries,
+            reason: `Claude /status reported ${parsed.nativeThreadId}, not the exact ` +
+                `claude agents Session ${request.expectedNativeThreadId.toLowerCase()}`
+        };
+    }
+    if (request.expectedCwd !== undefined &&
+        normalizeLifecyclePath(parsed.cwd) !==
+            normalizeLifecyclePath(request.expectedCwd)) {
+        return {
+            status: "mismatch",
+            nativeThreadId: parsed.nativeThreadId,
+            observedAgentVersion: parsed.agentVersion,
+            evidenceFingerprint,
+            screenFingerprint,
+            evidenceInventory: inventory.entries,
+            reason: `Claude /status cwd ${parsed.cwd} does not match the verified pane cwd`
+        };
+    }
+    return {
+        status: "observed",
+        nativeThreadId: parsed.nativeThreadId,
+        observedAgentVersion: parsed.agentVersion,
+        evidence: "claude_status_panel",
+        evidenceFingerprint,
+        screenFingerprint,
+        evidenceInventory: inventory.entries,
+        result: {
+            kind: "native_status",
+            nativeThreadId: parsed.nativeThreadId,
+            agentVersion: parsed.agentVersion,
+            fields: parsed.fields,
+            excerpt: claudeNativeStatusExcerpt(parsed.fields)
+        }
+    };
+}
 export function probeClaudeThreadLifecycle(agentVersion) {
     if (!agentVersion) {
         return {
@@ -280,6 +505,205 @@ export function observeClaudeThreadLifecycle(requestOrScreen, legacyOperation, f
             reason: `Claude resumed ${nativeThreadId}, not the requested native thread ${expected}`
         };
 }
+function parseCurrentClaudeStatusPanel(screen) {
+    const lines = screen.split("\n").slice(-CLAUDE_STATUS_PANEL_MAX_SCAN_LINES);
+    const headers = lines
+        .map((line, index) => CLAUDE_STATUS_PANEL_HEADER.test(line) ? index : -1)
+        .filter((index) => index >= 0);
+    if (headers.length === 0) {
+        return {
+            status: "missing",
+            reason: "no current Claude Settings Status panel is visible"
+        };
+    }
+    const headerIndex = headers.at(-1);
+    if (headerIndex === 0 ||
+        !CLAUDE_STATUS_PANEL_DIVIDER.test(lines[headerIndex - 1])) {
+        return {
+            status: "ambiguous",
+            reason: "the Claude Status header is not anchored to its exact panel divider"
+        };
+    }
+    const footerIndexes = lines
+        .map((line, index) => index > headerIndex &&
+        index - headerIndex <= CLAUDE_STATUS_PANEL_MAX_LINES &&
+        CLAUDE_STATUS_PANEL_FOOTER.test(line)
+        ? index
+        : -1)
+        .filter((index) => index >= 0);
+    if (footerIndexes.length !== 1) {
+        return {
+            status: "ambiguous",
+            reason: "the Claude Status panel is incomplete or has ambiguous dismissal markers"
+        };
+    }
+    const footerIndex = footerIndexes[0];
+    if (lines.slice(footerIndex + 1).some((line) => line.trim().length > 0)) {
+        return {
+            status: "missing",
+            reason: "the newest Claude Status panel is historical rather than current"
+        };
+    }
+    const regionLines = lines.slice(headerIndex, footerIndex + 1);
+    const region = regionLines.join("\n");
+    if (regionLines.length > CLAUDE_STATUS_PANEL_MAX_LINES ||
+        region.length > CLAUDE_STATUS_PANEL_MAX_REGION_LENGTH) {
+        return {
+            status: "ambiguous",
+            reason: "the Claude Status panel exceeds the bounded inspection region"
+        };
+    }
+    const rawFields = new Map();
+    for (const line of regionLines.slice(1, -1)) {
+        if (line.trim().length === 0) {
+            continue;
+        }
+        const match = CLAUDE_STATUS_PANEL_FIELD.exec(line);
+        if (!match) {
+            return {
+                status: "ambiguous",
+                reason: "the Claude Status panel contains an unprofiled non-field row"
+            };
+        }
+        const name = match[1].trim();
+        const value = match[2].trim();
+        if (!CLAUDE_STATUS_PANEL_FIELDS.has(name)) {
+            return {
+                status: "ambiguous",
+                reason: "the Claude Status panel contains an unprofiled field"
+            };
+        }
+        if (rawFields.has(name)) {
+            return {
+                status: "ambiguous",
+                reason: `the Claude Status panel repeats field ${name}`
+            };
+        }
+        rawFields.set(name, value);
+    }
+    if (rawFields.size === 0 || rawFields.size > CLAUDE_STATUS_PANEL_MAX_FIELDS) {
+        return {
+            status: "ambiguous",
+            reason: "the Claude Status panel has an invalid number of fields"
+        };
+    }
+    const agentVersion = rawFields.get("Version");
+    const nativeThreadId = rawFields.get("Session ID")?.toLowerCase();
+    const cwd = rawFields.get("cwd");
+    const model = rawFields.get("Model");
+    if (!agentVersion ||
+        !isExactNativeThreadId(nativeThreadId) ||
+        !cwd ||
+        !path.isAbsolute(cwd) ||
+        !model) {
+        return {
+            status: "ambiguous",
+            reason: "the Claude Status panel lacks exact Version, Session ID, cwd, or Model fields"
+        };
+    }
+    const fields = [...rawFields.entries()].map(([name, rawValue]) => ({
+        name,
+        value: redactClaudeNativeStatusField(name, rawValue)
+            .slice(0, CLAUDE_STATUS_PANEL_MAX_FIELD_VALUE_LENGTH)
+    }));
+    return {
+        status: "observed",
+        region,
+        agentVersion,
+        nativeThreadId,
+        cwd,
+        fields
+    };
+}
+function claudeStatusPanelEvidenceInventory(screen) {
+    const lines = screen.split("\n").slice(-CLAUDE_STATUS_PANEL_MAX_SCAN_LINES);
+    const counts = new Map();
+    for (let index = 0; index < lines.length; index += 1) {
+        if (!CLAUDE_STATUS_PANEL_HEADER.test(lines[index])) {
+            continue;
+        }
+        if (index === 0 ||
+            !CLAUDE_STATUS_PANEL_DIVIDER.test(lines[index - 1])) {
+            return {
+                status: "ambiguous",
+                entries: [],
+                reason: "a Claude Status marker is not anchored to its exact panel divider"
+            };
+        }
+        const footerIndex = lines.findIndex((line, candidateIndex) => candidateIndex > index &&
+            candidateIndex - index <= CLAUDE_STATUS_PANEL_MAX_LINES &&
+            CLAUDE_STATUS_PANEL_FOOTER.test(line));
+        if (footerIndex < 0) {
+            return {
+                status: "ambiguous",
+                entries: [],
+                reason: "a Claude Status panel marker has no bounded exact footer"
+            };
+        }
+        const region = lines.slice(index, footerIndex + 1).join("\n");
+        if (region.length > CLAUDE_STATUS_PANEL_MAX_REGION_LENGTH) {
+            return {
+                status: "ambiguous",
+                entries: [],
+                reason: "a Claude Status panel exceeds the bounded evidence region"
+            };
+        }
+        const fingerprint = fingerprintClaudeNativeInspection(region);
+        counts.set(fingerprint, (counts.get(fingerprint) ?? 0) + 1);
+        index = footerIndex;
+    }
+    const entries = [...counts.entries()].map(([evidenceFingerprint, occurrenceCount]) => ({ evidenceFingerprint, occurrenceCount }));
+    if (entries.length > CLAUDE_STATUS_PANEL_MAX_EVIDENCE_ENTRIES) {
+        return {
+            status: "ambiguous",
+            entries,
+            reason: "the Claude Status evidence inventory exceeds its bounded entry count"
+        };
+    }
+    return { status: "observed", entries };
+}
+function validateClaudeStatusEvidenceInventory(inventory) {
+    if (inventory === undefined) {
+        return undefined;
+    }
+    if (inventory.length > CLAUDE_STATUS_PANEL_MAX_EVIDENCE_ENTRIES) {
+        return "the pre-Enter Claude Status evidence inventory is over-bounded";
+    }
+    const seen = new Set();
+    for (const entry of inventory) {
+        if (!NATIVE_INSPECTION_FINGERPRINT.test(entry.evidenceFingerprint) ||
+            !Number.isSafeInteger(entry.occurrenceCount) ||
+            entry.occurrenceCount < 1 ||
+            seen.has(entry.evidenceFingerprint)) {
+            return "the pre-Enter Claude Status evidence inventory is malformed";
+        }
+        seen.add(entry.evidenceFingerprint);
+    }
+    return undefined;
+}
+function redactClaudeNativeStatusField(name, value) {
+    if (CLAUDE_STATUS_PANEL_SENSITIVE_FIELDS.has(name) ||
+        /(?:auth|account|email|api\s*key|token|credential|login|organization|user)/iu
+            .test(name)) {
+        return "[REDACTED]";
+    }
+    return redactString(value).replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/giu, "[REDACTED EMAIL]");
+}
+function claudeNativeStatusExcerpt(fields) {
+    return [
+        "Claude Code native status",
+        ...fields.map((field) => `${field.name}: ${field.value}`)
+    ].join("\n").slice(0, CLAUDE_STATUS_PANEL_MAX_EXCERPT_LENGTH);
+}
+function normalizeClaudeNativeInspectionScreen(screen) {
+    return screen
+        .replace(ANSI_ESCAPE_PATTERN, "")
+        .replace(/\r\n?/gu, "\n")
+        .replace(/\u00a0/gu, " ");
+}
+function fingerprintClaudeNativeInspection(value) {
+    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
 function normalizeLifecyclePath(value) {
     const candidate = nonEmptyString(value);
     return candidate === undefined ? undefined : path.resolve(candidate);