@scotthuang/agent-knock-knock 0.11.4 → 0.11.6

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 each verified Claude TUI profile, 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 boundary; 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

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
+import { claudeLifecycleBehaviorProfile, claudeLifecycleCompatibilityProfile, claudeNativeInspectionBehaviorProfile, profiledClaudeNativeStatusPanelFields } from "./claude-lifecycle-compatibility.js";
 import { redactString } from "./runtime-log.js";
 import { isExactNativeThreadId } from "./managed-session.js";
 const CLAUDE_SUBCOMMANDS = new Set([
@@ -73,8 +74,31 @@ const CLAUDE_EXCERPT_LINES = 80;
 const CLAUDE_PERMISSION_DETAIL_LENGTH = 600;
 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";
+/**
+ * On each verified Claude TUI profile, 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 boundary; 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 PROFILED_CLAUDE_STATUS_PANEL_FIELDS = new Set(profiledClaudeNativeStatusPanelFields());
+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 +130,9 @@ export function createClaudeTerminalAgentAdapter(options = {}) {
         probeThreadLifecycle: probeClaudeThreadLifecycle,
         planThreadLifecycle: planClaudeThreadLifecycle,
         observeThreadLifecycle: lifecycleObserver,
+        probeNativeInspection: probeClaudeNativeInspection,
+        planNativeInspection: planClaudeNativeInspection,
+        observeNativeInspection: observeClaudeNativeInspection,
         ...(durableCompletion
             ? {
                 async detectDurableCompletion(request) {
@@ -115,6 +142,192 @@ 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 behaviorProfile = claudeNativeInspectionBehaviorProfile(agentVersion);
+    const supported = behaviorProfile !== undefined;
+    return {
+        status: supported ? "supported" : "unsupported",
+        agentVersion,
+        behaviorProfile,
+        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) {
+    const profile = claudeLifecycleCompatibilityProfile(capabilities.agentVersion);
+    if (operation.kind !== "status" ||
+        capabilities.status !== "supported" ||
+        capabilities.statusInspection !== true ||
+        !profile ||
+        capabilities.behaviorProfile !== profile.nativeInspectionBehaviorProfile) {
+        throw new Error(capabilities.reason);
+    }
+    return {
+        operation,
+        behaviorProfile: profile.nativeInspectionBehaviorProfile,
+        command: "/status",
+        effect: "read_only",
+        requiresIdle: true,
+        composer: {
+            kind: "exact",
+            minimumStableMs: profile.nativeInspectionComposerStableMs,
+            maximumSettleMs: profile.nativeInspectionComposerSettleTimeoutMs
+        },
+        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 (!claudeNativeInspectionBehaviorProfile(parsed.agentVersion)) {
+        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 {
@@ -124,11 +337,12 @@ export function probeClaudeThreadLifecycle(agentVersion) {
             reason: "the running Claude Code version could not be verified"
         };
     }
-    const supported = agentVersion === CLAUDE_LIFECYCLE_VERSION;
+    const behaviorProfile = claudeLifecycleBehaviorProfile(agentVersion);
+    const supported = behaviorProfile !== undefined;
     return {
         status: supported ? "supported" : "unsupported",
         agentVersion,
-        behaviorProfile: supported ? CLAUDE_LIFECYCLE_PROFILE : undefined,
+        behaviorProfile,
         newThread: supported,
         resumeExact: supported,
         candidateDiscovery: supported,
@@ -138,9 +352,10 @@ export function probeClaudeThreadLifecycle(agentVersion) {
     };
 }
 export function planClaudeThreadLifecycle(operation, capabilities) {
+    const behaviorProfile = claudeLifecycleBehaviorProfile(capabilities.agentVersion);
     if (capabilities.status !== "supported" ||
-        capabilities.agentVersion !== CLAUDE_LIFECYCLE_VERSION ||
-        capabilities.behaviorProfile !== CLAUDE_LIFECYCLE_PROFILE) {
+        !behaviorProfile ||
+        capabilities.behaviorProfile !== behaviorProfile) {
         throw new Error(capabilities.reason);
     }
     if (operation.kind === "new_thread") {
@@ -149,7 +364,7 @@ export function planClaudeThreadLifecycle(operation, capabilities) {
         }
         return {
             operation,
-            behaviorProfile: CLAUDE_LIFECYCLE_PROFILE,
+            behaviorProfile,
             steps: [{
                     kind: "transition",
                     command: "/clear",
@@ -168,7 +383,7 @@ export function planClaudeThreadLifecycle(operation, capabilities) {
     }
     return {
         operation,
-        behaviorProfile: CLAUDE_LIFECYCLE_PROFILE,
+        behaviorProfile,
         steps: [{
                 kind: "transition",
                 command: `/resume ${operation.nativeThreadId}`,
@@ -280,6 +495,222 @@ 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 (!PROFILED_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 exactProfileFields = new Set(claudeLifecycleCompatibilityProfile(agentVersion)
+        ?.nativeStatusPanelFields ?? []);
+    const exactRequiredValues = claudeLifecycleCompatibilityProfile(agentVersion)
+        ?.nativeStatusPanelRequiredValues ?? {};
+    if (exactProfileFields.size > 0 &&
+        [...rawFields.keys()].some((name) => !exactProfileFields.has(name))) {
+        return {
+            status: "ambiguous",
+            reason: "the Claude Status panel fields do not match its exact version profile"
+        };
+    }
+    if (Object.entries(exactRequiredValues).some(([name, value]) => rawFields.get(name) !== value)) {
+        return {
+            status: "ambiguous",
+            reason: "the Claude Status panel lacks an exact field value required by its version profile"
+        };
+    }
+    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);