@scotthuang/agent-knock-knock 0.12.11 → 0.12.13

package/dist/src/native-thread-transition-settlement-service.js

@@ -0,0 +1,134 @@
+import { managedSessionRevision, nativeThreadTransitionRevision } from "./managed-session.js";
+import { decideNativeThreadTransitionFailure, reduceNativeThreadTransitionPhase } from "./native-thread-transition-policy.js";
+export async function settleVerifiedNativeThreadTransition(request, scopes, resources, ports) {
+    const observed = await ports.verification(scopes, resources, request.verification);
+    const verifiedAt = ports.runtime.now();
+    const finalized = ports.effects.finalizeIdentity(observed, request.transition, verifiedAt);
+    let transition = reduceNativeThreadTransitionPhase(request.transition, {
+        type: "target_verified",
+        at: verifiedAt.toISOString(),
+        afterBinding: finalized.binding
+    });
+    transition = ports.persistence.saveTransition(scopes, resources, transition, { expectedRevision: nativeThreadTransitionRevision(transition) });
+    ports.runtime.crashAfterVerified();
+    await ports.effects.assertTargetOwnership(scopes, resources, transition);
+    if (ports.runtime.injectTargetConflict()) {
+        ports.persistence.saveSession(scopes, resources, {
+            schema: "agent-knock-knock/session",
+            version: 1,
+            session_id: transition.target_session_id,
+            agent: transition.agent,
+            workspace: ports.effects.targetConflictWorkspace(),
+            status: "detached",
+            binding: finalized.binding,
+            lineage: { created_by: "attach" },
+            created_at: verifiedAt.toISOString(),
+            updated_at: verifiedAt.toISOString(),
+            last_transition_id: "injected-target-conflict"
+        }, { expectedRevision: null });
+    }
+    const committedTarget = ports.persistence.commitVerified(scopes, resources, transition, verifiedAt.toISOString());
+    const committedAt = ports.runtime.now().toISOString();
+    transition = reduceNativeThreadTransitionPhase(transition, {
+        type: "commit_recorded",
+        at: committedAt
+    });
+    transition = ports.persistence.saveTransition(scopes, resources, transition, { expectedRevision: nativeThreadTransitionRevision(transition) });
+    ports.persistence.saveLedger(scopes, resources, transition, {
+        phase: "command_resolved",
+        at: committedAt,
+        binding: finalized.binding,
+        reason: "native thread transition committed"
+    }, {
+        expectedTransitionId: transition.transition_id,
+        expectedStatus: "submitted"
+    });
+    ports.present({
+        status: "committed",
+        transition,
+        identity: finalized.identity,
+        binding: finalized.binding,
+        committedTarget
+    });
+}
+export async function settleFailedNativeThreadTransition(request, error, scopes, resources, ports) {
+    const failedAt = ports.runtime.now().toISOString();
+    const message = error instanceof Error ? error.message : String(error);
+    const durable = ports.persistence.loadTransition(scopes, resources, request.transitionId);
+    const decision = decideNativeThreadTransitionFailure({
+        durableStatus: durable.status,
+        inputStarted: request.inputStarted,
+        errorProvesInputNotStarted: ports.runtime.errorProvesInputNotStarted(error)
+    });
+    if (decision.action === "report_committed_bookkeeping_failure") {
+        throw new Error(`native thread transition ${request.transitionId} committed, but final ` +
+            `bookkeeping failed: ${message}`);
+    }
+    if (decision.action === "require_verified_recovery") {
+        ports.persistence.saveLedger(scopes, resources, durable, {
+            phase: "uncertain_reason_error",
+            at: failedAt,
+            reason: "verified lifecycle commit was interrupted; recovery must revalidate before roll-forward",
+            error: ports.runtime.summarizeError(message)
+        }, { expectedTransitionId: request.transitionId });
+        ports.present({
+            status: "verified_recovery_required",
+            transitionId: request.transitionId,
+            reason: message
+        });
+        return;
+    }
+    if (decision.action === "abort_before_terminal_input") {
+        let aborted = reduceNativeThreadTransitionPhase(durable, {
+            type: "aborted_before_input",
+            at: failedAt,
+            error: message
+        });
+        aborted = ports.persistence.saveTransition(scopes, resources, aborted, { expectedRevision: nativeThreadTransitionRevision(durable) });
+        if (request.sourceBefore && request.sourceTransitioning) {
+            ports.persistence.saveSession(scopes, resources, {
+                ...request.sourceTransitioning,
+                status: request.sourceBefore.status,
+                last_transition_id: request.sourceBefore.last_transition_id,
+                updated_at: failedAt
+            }, {
+                expectedRevision: managedSessionRevision(request.sourceTransitioning)
+            });
+        }
+        ports.persistence.saveLedger(scopes, resources, aborted, {
+            phase: "resolved",
+            at: failedAt,
+            reason: "native thread transition aborted before terminal input"
+        }, { expectedTransitionId: request.transitionId });
+        throw error;
+    }
+    let uncertain = reduceNativeThreadTransitionPhase(durable, {
+        type: "outcome_uncertain",
+        at: failedAt,
+        error: message
+    });
+    uncertain = ports.persistence.saveTransition(scopes, resources, uncertain, { expectedRevision: nativeThreadTransitionRevision(durable) });
+    if (request.sourceBefore && request.sourceTransitioning) {
+        ports.persistence.saveSession(scopes, resources, {
+            ...request.sourceTransitioning,
+            status: "quarantined",
+            quarantine_reason: "native thread transition outcome is uncertain",
+            last_transition_id: request.transitionId,
+            updated_at: failedAt
+        }, {
+            expectedRevision: managedSessionRevision(request.sourceTransitioning)
+        });
+    }
+    ports.persistence.saveLedger(scopes, resources, uncertain, {
+        phase: "uncertain_error_reason",
+        at: failedAt,
+        error: ports.runtime.summarizeError(message),
+        reason: "native thread transition could not be verified"
+    }, { expectedTransitionId: request.transitionId });
+    ports.present({
+        status: "uncertain",
+        transitionId: request.transitionId,
+        reason: message
+    });
+}
+//# sourceMappingURL=native-thread-transition-settlement-service.js.map

package/dist/src/native-thread-transition-settlement-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-thread-transition-settlement-service.js","sourceRoot":"","sources":["../../src/native-thread-transition-settlement-service.ts"],"names":[],"mappings":"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"}

package/dist/src/native-thread-transition-verification-adapter.d.ts

@@ -0,0 +1,62 @@
+import type { TerminalNativeIdentityFence, TerminalRuntimeIdentity, TerminalThreadLifecycleAgentRow, TerminalThreadLifecycleCapabilities, TerminalThreadLifecycleCandidateToken, TerminalThreadLifecycleOperation, TerminalThreadLifecyclePlan } from "./terminal-agent-adapter.js";
+import { TerminalAgentBridge, type ResolvedTerminalConversation, type TerminalBridgeStatus } from "./terminal-agent-bridge.js";
+import { terminalNativeIdentityFence as nativeThreadIdentityFence, terminalNativeIdentityMatchesFence as nativeThreadIdentityMatchesFence, type TerminalNativeIdentity } from "./terminal-binding-authority.js";
+import { type ManagedSessionState, type NativeThreadTransition } from "./managed-session.js";
+import type { NativeThreadVerificationRequest } from "./native-thread-transition-settlement-service.js";
+export { nativeThreadIdentityFence, nativeThreadIdentityMatchesFence };
+export type NativeThreadVerificationAdapterPorts = Readonly<{
+    createBridge: () => TerminalAgentBridge;
+    loadClaudeAgentRows: () => readonly TerminalThreadLifecycleAgentRow[];
+    runningVersion: () => string | undefined;
+    runtimeForIdentity: (identity: TerminalNativeIdentity) => TerminalRuntimeIdentity;
+    emptyRuntime: () => TerminalRuntimeIdentity;
+    physicalRuntime: () => TerminalRuntimeIdentity;
+    resolveIdentity: (preferredSessionId: string, allowedCompanionIdentity: TerminalNativeIdentityFence | undefined, allowedAdditionalIdentities: readonly TerminalNativeIdentityFence[]) => Promise<TerminalNativeIdentity | undefined>;
+    sleep: (milliseconds: number) => Promise<void>;
+}>;
+export type NativeThreadVerificationPreparationRequest = Readonly<{
+    operation: TerminalThreadLifecycleOperation;
+    expectedBindingToken: string;
+    bindingTokens: readonly string[];
+    capabilities: TerminalThreadLifecycleCapabilities;
+    beforeIdentity?: TerminalNativeIdentity;
+    physicalBeforeIdentity?: TerminalNativeIdentity;
+    allowedCompanionIdentity?: TerminalNativeIdentityFence;
+    allowedAdditionalIdentities?: readonly TerminalNativeIdentityFence[];
+}>;
+export type NativeThreadVerificationPreparationPorts = NativeThreadVerificationAdapterPorts & Readonly<{
+    plan: () => TerminalThreadLifecyclePlan | undefined;
+    assertReady: (status: TerminalBridgeStatus) => void;
+    revalidateSelectionSnapshot?: () => Promise<void>;
+    finalizeIdentity: (identity: TerminalNativeIdentity) => TerminalNativeIdentity;
+}>;
+export type PreparedNativeThreadVerification = Readonly<{
+    bridge: TerminalAgentBridge;
+    plan: TerminalThreadLifecyclePlan;
+    beforeIdentity: TerminalNativeIdentity;
+    beforeRuntime: TerminalRuntimeIdentity;
+    initialScreenDigest?: string;
+}>;
+export type NativeThreadCompanionSet = Readonly<{
+    primary?: TerminalNativeIdentityFence;
+    additional: TerminalNativeIdentityFence[];
+}>;
+export declare function nativeThreadRuntimeWithCompanionFences(runtime: TerminalRuntimeIdentity, companions: NativeThreadCompanionSet): TerminalRuntimeIdentity;
+export declare function probeCodexCurrentThread(request: Readonly<{
+    terminal: ResolvedTerminalConversation;
+    currentIdentity?: TerminalNativeIdentity;
+    runtimeIdentity?: TerminalNativeIdentity;
+    runtimeOverride?: TerminalRuntimeIdentity;
+}>, ports: NativeThreadVerificationAdapterPorts): Promise<TerminalNativeIdentity>;
+export declare function prepareNativeThreadVerification(request: NativeThreadVerificationPreparationRequest, terminal: ResolvedTerminalConversation, ports: NativeThreadVerificationPreparationPorts): Promise<PreparedNativeThreadVerification>;
+export declare function nativeThreadCandidateFileIdentity(token: TerminalThreadLifecycleCandidateToken | undefined): NativeThreadTransition["target_candidate_file_identity"];
+export declare function assertResumedNativeThreadMatchesCandidate(identity: TerminalNativeIdentity, expected: NativeThreadTransition["target_candidate_file_identity"]): void;
+export declare function knownNativeThreadCompanionSet(input: Readonly<{
+    terminal: Pick<ResolvedTerminalConversation, "conversationId" | "pid" | "terminalControl">;
+    transition: NativeThreadTransition;
+    managedSessions: readonly ManagedSessionState[];
+}>, ports: Readonly<{
+    terminalAliasMatches: (storedTerminalId: unknown, storedControl: unknown, currentTerminalId: unknown, currentControl: unknown) => boolean;
+    workspaceMatches: (left: unknown, right: unknown) => boolean;
+}>): NativeThreadCompanionSet;
+export declare function verifyNativeThreadTransition(request: NativeThreadVerificationRequest, terminal: ResolvedTerminalConversation, ports: NativeThreadVerificationAdapterPorts): Promise<TerminalNativeIdentity>;

package/dist/src/native-thread-transition-verification-adapter.js

@@ -0,0 +1,451 @@
+import path from "node:path";
+import { isCompleteNativeRollout, terminalNativeIdentityFence as nativeThreadIdentityFence, terminalNativeIdentityMatchesFence as nativeThreadIdentityMatchesFence } from "./terminal-binding-authority.js";
+import { isExactNativeThreadId } from "./managed-session.js";
+import { classifyCodexLifecyclePostcondition, isFreshCodexPostProbeScreen } from "./native-thread-lifecycle-policy.js";
+import { decideNativeThreadTransitionEligibility } from "./native-thread-transition-policy.js";
+import { nonBlankString } from "./value-guards.js";
+export { nativeThreadIdentityFence, nativeThreadIdentityMatchesFence };
+export function nativeThreadRuntimeWithCompanionFences(runtime, companions) {
+    return {
+        ...runtime,
+        allowedPreMaterializationNativeIdentity: companions.primary,
+        allowedAdditionalNativeIdentities: [...companions.additional]
+    };
+}
+function codexBeforeRuntime(request, identity, ports) {
+    const exactPhysicalIdentity = request.physicalBeforeIdentity?.sessionId === identity?.sessionId
+        ? request.physicalBeforeIdentity
+        : undefined;
+    const runtime = exactPhysicalIdentity
+        ? ports.runtimeForIdentity(exactPhysicalIdentity)
+        : {
+            ...ports.emptyRuntime(),
+            ...(identity?.processUuid
+                ? { nativeProcessUuid: identity.processUuid }
+                : {}),
+            ...(identity?.processBirth
+                ? { nativeProcessBirth: identity.processBirth }
+                : {}),
+            expectedNativeSessionId: identity?.sessionId
+        };
+    return nativeThreadRuntimeWithCompanionFences(runtime, {
+        primary: request.allowedCompanionIdentity,
+        additional: [...(request.allowedAdditionalIdentities ?? [])]
+    });
+}
+function assertVerifiedClaudeBeforeObservation(request, terminal, ports) {
+    if (terminal.agent !== "claude")
+        return;
+    if (!terminal.terminalControl.currentPath) {
+        throw new Error("Claude lifecycle control requires an exact terminal working directory");
+    }
+    const observed = terminal.adapter.observeThreadLifecycle?.({
+        operation: request.operation,
+        phase: "before",
+        pid: terminal.pid,
+        processStartedAt: request.beforeIdentity?.processStartedAt,
+        cwd: terminal.terminalControl.currentPath,
+        agentRows: ports.loadClaudeAgentRows()
+    });
+    if (observed?.status !== "observed" ||
+        !isExactNativeThreadId(request.beforeIdentity?.sessionId) ||
+        observed.nativeThreadId !== request.beforeIdentity.sessionId.toLowerCase() ||
+        observed.idle !== true) {
+        throw new Error("Claude lifecycle control requires one exact idle interactive agents row " +
+            `for the current process incarnation${observed?.reason ? `: ${observed.reason}` : ""}`);
+    }
+}
+export async function probeCodexCurrentThread(request, ports) {
+    const { terminal } = request;
+    if (terminal.agent !== "codex") {
+        throw new Error("the current native thread identity is unavailable");
+    }
+    const bridge = ports.createBridge();
+    const probeRuntime = request.runtimeOverride ??
+        (request.runtimeIdentity
+            ? ports.runtimeForIdentity(request.runtimeIdentity)
+            : ports.emptyRuntime());
+    const agentVersion = ports.runningVersion();
+    if (!agentVersion) {
+        throw new Error("Codex /status requires the exact running version before terminal input");
+    }
+    const submission = await bridge.submitCodexStatusProbe(terminal.terminalControl, agentVersion, { runtime: probeRuntime });
+    let lastObservationReason = "no fresh idle Codex /status card was captured after the one Enter dispatch";
+    let sawIncompleteSessionUuid = false;
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+        const status = await bridge.status(terminal.agent, terminal.terminalControl, {
+            runtime: probeRuntime,
+            scrollbackLines: submission.observationScrollbackLines
+        });
+        if (status.reachable &&
+            status.screen.digest !== submission.observationBaselineDigest) {
+            const observed = terminal.adapter.observeThreadLifecycle?.({
+                operation: { kind: "new_thread" },
+                phase: "before",
+                screen: status.screen.excerpt ?? ""
+            });
+            lastObservationReason = observed?.reason ?? lastObservationReason;
+            sawIncompleteSessionUuid ||= observed?.status === "missing" &&
+                /complete Session UUID/iu.test(observed.reason ?? "");
+            if (observed?.status === "observed" &&
+                observed.nativeThreadId &&
+                status.activity_state === "idle") {
+                return {
+                    sessionId: observed.nativeThreadId,
+                    processUuid: request.currentIdentity?.processUuid ??
+                        request.runtimeIdentity?.processUuid,
+                    processBirth: request.currentIdentity?.processBirth ??
+                        request.runtimeIdentity?.processBirth,
+                    rollout: request.currentIdentity?.sessionId === observed.nativeThreadId
+                        ? request.currentIdentity.rollout
+                        : undefined,
+                    evidence: observed.evidence ?? "codex_status_card"
+                };
+            }
+        }
+        await ports.sleep(100);
+    }
+    throw new Error(sawIncompleteSessionUuid
+        ? "Codex /status Enter was dispatched exactly once, but the status card " +
+            "was truncated before the complete current Session UUID; widen or zoom " +
+            "the pane, refresh AKK list, and do not retry the probe automatically"
+        : "Codex /status Enter was dispatched exactly once, but no fresh exact " +
+            `current Session UUID was proven; do not retry automatically: ${lastObservationReason}`);
+}
+export async function prepareNativeThreadVerification(request, terminal, ports) {
+    const eligibility = decideNativeThreadTransitionEligibility({
+        operation: request.operation.kind,
+        bindingTokenMatches: request.bindingTokens.includes(request.expectedBindingToken),
+        capabilityStatus: request.capabilities.status,
+        newThreadSupported: request.capabilities.newThread,
+        resumeExactSupported: request.capabilities.resumeExact
+    });
+    if (eligibility.action === "reject") {
+        throw new Error(eligibility.reason === "binding_token_changed"
+            ? "terminal binding changed after it was listed; refresh AKK list and retry"
+            : request.capabilities.reason);
+    }
+    if (ports.revalidateSelectionSnapshot) {
+        await ports.revalidateSelectionSnapshot();
+    }
+    const plan = ports.plan();
+    if (!plan) {
+        throw new Error("the agent adapter did not produce a lifecycle plan");
+    }
+    const bridge = ports.createBridge();
+    let beforeIdentity = request.beforeIdentity;
+    let beforeRuntime = terminal.agent === "codex"
+        ? codexBeforeRuntime(request, beforeIdentity, ports)
+        : request.physicalBeforeIdentity
+            ? ports.runtimeForIdentity(request.physicalBeforeIdentity)
+            : ports.emptyRuntime();
+    const terminalStatus = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: beforeRuntime });
+    ports.assertReady(terminalStatus);
+    assertVerifiedClaudeBeforeObservation(request, terminal, ports);
+    if (terminal.agent === "codex") {
+        const statusIdentity = await probeCodexCurrentThread({
+            terminal,
+            currentIdentity: beforeIdentity,
+            runtimeIdentity: request.physicalBeforeIdentity,
+            runtimeOverride: beforeRuntime
+        }, ports);
+        if (beforeIdentity &&
+            beforeIdentity.sessionId !== statusIdentity.sessionId) {
+            throw new Error("Codex /status disagrees with the open rollout identity before /clear");
+        }
+        beforeIdentity = {
+            ...beforeIdentity,
+            ...statusIdentity,
+            evidence: beforeIdentity
+                ? `${beforeIdentity.evidence}+codex_status_card`
+                : statusIdentity.evidence
+        };
+        beforeRuntime = codexBeforeRuntime(request, beforeIdentity, ports);
+    }
+    if (!isExactNativeThreadId(beforeIdentity?.sessionId)) {
+        throw new Error("native thread lifecycle requires an exact before-thread UUID");
+    }
+    return {
+        bridge,
+        plan,
+        beforeIdentity: ports.finalizeIdentity(beforeIdentity),
+        beforeRuntime,
+        initialScreenDigest: terminalStatus.screen.digest
+    };
+}
+function sameFilesystemDevice(left, right) {
+    try {
+        return BigInt(left) === BigInt(right);
+    }
+    catch {
+        return left === right;
+    }
+}
+export function nativeThreadCandidateFileIdentity(token) {
+    if (!token || token.agent !== "codex" || token.source !== "codex_rollout") {
+        return undefined;
+    }
+    return {
+        path: path.resolve(token.fileToken.path),
+        device: token.fileToken.device,
+        inode: token.fileToken.inode
+    };
+}
+export function assertResumedNativeThreadMatchesCandidate(identity, expected) {
+    if (!expected) {
+        throw new Error("Codex resume is missing its revalidated rollout token");
+    }
+    const rollout = identity.rollout;
+    if (!isCompleteNativeRollout(rollout) ||
+        !nonBlankString(expected.path) ||
+        !nonBlankString(expected.device) ||
+        !nonBlankString(expected.inode) ||
+        path.resolve(rollout.path) !== path.resolve(expected.path) ||
+        !sameFilesystemDevice(rollout.device, expected.device) ||
+        rollout.inode !== expected.inode) {
+        throw new Error("the resumed Codex rollout does not match the revalidated candidate file identity");
+    }
+}
+export function knownNativeThreadCompanionSet(input, ports) {
+    const { terminal, transition } = input;
+    const candidates = [];
+    if (transition.before_process_uuid &&
+        transition.before_process_birth &&
+        isCompleteNativeRollout(transition.before_process_rollout)) {
+        candidates.push({
+            sessionId: transition.before_native_thread_id,
+            processUuid: transition.before_process_uuid,
+            processBirth: transition.before_process_birth,
+            rollout: transition.before_process_rollout
+        });
+    }
+    const after = transition.after_binding;
+    if (after?.native_thread_id &&
+        after.native_process.process_uuid &&
+        after.native_process.process_birth &&
+        after.native_process.pid === terminal.pid &&
+        ports.terminalAliasMatches(after.terminal_id, after.terminal_control, terminal.conversationId, terminal.terminalControl) &&
+        after.native_process.process_uuid === transition.before_process_uuid &&
+        after.native_process.process_birth === transition.before_process_birth &&
+        isCompleteNativeRollout(after.native_process.rollout)) {
+        candidates.push({
+            sessionId: after.native_thread_id,
+            processUuid: after.native_process.process_uuid,
+            processBirth: after.native_process.process_birth,
+            rollout: after.native_process.rollout
+        });
+    }
+    for (const session of input.managedSessions) {
+        const binding = session.binding;
+        if (session.agent !== "codex" ||
+            session.status !== "detached" ||
+            !binding?.native_thread_id ||
+            !binding.native_process.process_uuid ||
+            !binding.native_process.process_birth ||
+            binding.native_process.pid !== terminal.pid ||
+            binding.native_process.process_uuid !== transition.before_process_uuid ||
+            binding.native_process.process_birth !== transition.before_process_birth ||
+            !ports.terminalAliasMatches(binding.terminal_id, binding.terminal_control, terminal.conversationId, terminal.terminalControl) ||
+            !ports.workspaceMatches(transition.workspace, session.workspace) ||
+            !isCompleteNativeRollout(binding.native_process.rollout)) {
+            continue;
+        }
+        candidates.push({
+            sessionId: binding.native_thread_id,
+            processUuid: binding.native_process.process_uuid,
+            processBirth: binding.native_process.process_birth,
+            rollout: binding.native_process.rollout
+        });
+    }
+    const seen = new Set();
+    const exact = candidates.filter((candidate) => {
+        const key = JSON.stringify(candidate);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    return { primary: exact[0], additional: exact.slice(1) };
+}
+function beforeFences(request) {
+    const candidates = [
+        nativeThreadIdentityFence(request.physicalBeforeIdentity),
+        nativeThreadIdentityFence(request.beforeIdentity),
+        request.allowedCompanionIdentity,
+        ...(request.allowedAdditionalIdentities ?? [])
+    ];
+    const unique = [];
+    for (const candidate of candidates) {
+        if (candidate &&
+            !unique.some((value) => nativeThreadIdentityMatchesFence(value, candidate))) {
+            unique.push(candidate);
+        }
+    }
+    return unique;
+}
+function sameStableIdentity(left, right) {
+    return left?.sessionId === right.sessionId &&
+        left.processUuid === right.processUuid &&
+        left.processBirth === right.processBirth &&
+        left.rollout?.fd === right.rollout?.fd &&
+        left.rollout?.device === right.rollout?.device &&
+        left.rollout?.inode === right.rollout?.inode &&
+        left.rollout?.path === right.rollout?.path;
+}
+export async function verifyNativeThreadTransition(request, terminal, ports) {
+    const bridge = ports.createBridge();
+    const exactBeforeRoots = beforeFences(request);
+    let probeSent = false;
+    let postProbeBaselineDigest;
+    let observationScrollbackLines;
+    let stableIdentity;
+    let stableCount = 0;
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        let verifiedIdentity;
+        if (terminal.agent === "claude") {
+            try {
+                const parsed = terminal.adapter.observeThreadLifecycle?.({
+                    operation: request.operation,
+                    phase: "after",
+                    pid: terminal.pid,
+                    processStartedAt: request.beforeIdentity?.processStartedAt,
+                    cwd: terminal.terminalControl.currentPath,
+                    agentRows: ports.loadClaudeAgentRows(),
+                    beforeNativeThreadId: request.beforeIdentity?.sessionId,
+                    expectedNativeThreadId: request.operation.kind === "resume_thread"
+                        ? request.operation.nativeThreadId
+                        : undefined
+                });
+                if (parsed?.status === "verified" &&
+                    parsed.nativeThreadId &&
+                    parsed.idle === true &&
+                    request.beforeIdentity?.processStartedAt !== undefined) {
+                    const observed = {
+                        sessionId: parsed.nativeThreadId,
+                        processStartedAt: request.beforeIdentity.processStartedAt,
+                        processUuid: `claude-pid:${terminal.pid}:started:` +
+                            String(request.beforeIdentity.processStartedAt),
+                        evidence: parsed.evidence ?? "claude_agents_exact_pid"
+                    };
+                    const status = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: ports.runtimeForIdentity(observed) });
+                    if (status.reachable && status.activity_state === "idle") {
+                        verifiedIdentity = observed;
+                    }
+                }
+            }
+            catch {
+                // Polling observations fail closed within the already-dispatched
+                // transition; observation errors never prove a matching identity.
+            }
+        }
+        else {
+            const afterProbe = request.plan.steps.find((step) => step.kind === "identity_probe_after");
+            if (!afterProbe ||
+                afterProbe.effect !== "read_only" ||
+                afterProbe.command !== "/status") {
+                throw new Error("the Codex lifecycle plan has no exact post-transition identity probe");
+            }
+            const agentVersion = ports.runningVersion();
+            if (!agentVersion) {
+                throw new Error("Codex lifecycle postcondition /status requires the exact running version before terminal input");
+            }
+            const physicalRuntime = ports.physicalRuntime();
+            const status = await bridge.status(terminal.agent, terminal.terminalControl, {
+                runtime: physicalRuntime,
+                ...(observationScrollbackLines === undefined
+                    ? {}
+                    : { scrollbackLines: observationScrollbackLines })
+            });
+            const screenDigest = status.screen.digest;
+            if (!probeSent &&
+                status.reachable &&
+                status.activity_state === "idle" &&
+                screenDigest !== undefined &&
+                screenDigest !== request.initialScreenDigest) {
+                const receipt = await bridge.submitCodexStatusProbe(terminal.terminalControl, agentVersion, { runtime: physicalRuntime });
+                postProbeBaselineDigest = receipt.observationBaselineDigest;
+                observationScrollbackLines = receipt.observationScrollbackLines;
+                probeSent = true;
+            }
+            else if (status.reachable &&
+                isFreshCodexPostProbeScreen({
+                    probeSent,
+                    screenDigest,
+                    postProbeBaselineDigest
+                })) {
+                const parsed = terminal.adapter.observeThreadLifecycle?.({
+                    operation: request.operation,
+                    phase: "after",
+                    screen: status.screen.excerpt ?? "",
+                    beforeNativeThreadId: request.beforeIdentity?.sessionId,
+                    expectedNativeThreadId: request.operation.kind === "resume_thread"
+                        ? request.operation.nativeThreadId
+                        : undefined
+                });
+                if (request.operation.kind === "new_thread" &&
+                    parsed?.nativeThreadId &&
+                    exactBeforeRoots.some((identity) => identity.sessionId === parsed.nativeThreadId)) {
+                    throw new Error(`Codex /clear reported previously known native thread ` +
+                        `${parsed.nativeThreadId} instead of a distinct new thread`);
+                }
+                const allowedBeforeRoots = parsed?.nativeThreadId
+                    ? exactBeforeRoots.filter((identity) => identity.sessionId !== parsed.nativeThreadId)
+                    : exactBeforeRoots;
+                let observed;
+                let observationSucceeded = false;
+                if (parsed?.nativeThreadId) {
+                    observed = await ports.resolveIdentity(parsed.nativeThreadId, allowedBeforeRoots[0], allowedBeforeRoots.slice(1));
+                    observationSucceeded = true;
+                }
+                const evidenceBefore = exactBeforeRoots.find((candidate) => nativeThreadIdentityMatchesFence(observed, candidate)) ?? request.beforeIdentity;
+                const evidence = parsed?.nativeThreadId
+                    ? classifyCodexLifecyclePostcondition({
+                        operation: request.operation.kind,
+                        parsedNativeThreadId: parsed.nativeThreadId,
+                        observationSucceeded,
+                        observedIdentity: observed,
+                        beforeIdentity: evidenceBefore
+                    })
+                    : "invalid";
+                if (parsed?.status === "verified" &&
+                    parsed.nativeThreadId &&
+                    evidence !== "invalid" &&
+                    status.activity_state === "idle") {
+                    verifiedIdentity = {
+                        sessionId: parsed.nativeThreadId,
+                        processUuid: evidence === "matching_after"
+                            ? observed?.processUuid
+                            : request.beforeIdentity?.processUuid,
+                        processBirth: evidence === "matching_after"
+                            ? observed?.processBirth
+                            : request.beforeIdentity?.processBirth,
+                        rollout: evidence === "matching_after"
+                            ? observed?.rollout
+                            : undefined,
+                        evidence: parsed.evidence ?? "codex_status_card"
+                    };
+                }
+            }
+        }
+        if (verifiedIdentity) {
+            if (sameStableIdentity(stableIdentity, verifiedIdentity)) {
+                stableCount += 1;
+            }
+            else {
+                stableIdentity = verifiedIdentity;
+                stableCount = 1;
+            }
+            if (stableCount >= 2)
+                return verifiedIdentity;
+        }
+        else {
+            stableIdentity = undefined;
+            stableCount = 0;
+        }
+        await ports.sleep(100);
+    }
+    throw new Error(request.operation.kind === "resume_thread"
+        ? `the terminal did not verify native thread ${request.operation.nativeThreadId}`
+        : "the terminal did not verify a distinct new native thread");
+}
+//# sourceMappingURL=native-thread-transition-verification-adapter.js.map