@scotthuang/agent-knock-knock 0.13.15 → 0.13.17

package/dist/src/terminal-watch-cli-adapter.js

@@ -1,33 +1,19 @@
-import { assertAutomaticActivityWatchIdentity, automaticSendWatchReceipt, createAutomaticActivityWatchAnchor, isAutomaticSendWatch, unsafeFallbackWatchPreparation } from "./terminal-watch-send-activity.js";
+import { automaticSendWatchReceipt, createAutomaticActivityWatchAnchor, isAutomaticSendWatch, unsafeFallbackWatchPreparation } from "./terminal-watch-send-activity.js";
 import { isCodexPaginatedReadCandidate } from "./codex-lifecycle-compatibility.js";
-import { respondCodexPaginatedAsyncQuestion } from "./codex-paginated-async-response.js";
-import { publicTerminalWatch, terminalWatchCapturedAgentVersion } from "./terminal-watch-presentation.js";
-import { createHash } from "node:crypto";
-import path from "node:path";
-import { CodexLegacyThreadHistoryError } from "./codex-paginated-observation.js";
-import { capturePaginatedWatchAnchor as capturePaginatedAnchor, paginatedWatchProcessMatches, observePaginatedWatch, refreshPaginatedResponseForeground } from "./codex-paginated-watch.js";
-import { observeCodexPaginatedBlockingQuestion, respondCodexPaginatedBlockingQuestion } from "./codex-paginated-questionnaire-runtime.js";
-import { selectCodexUserExplicitSendWatchSource } from "./terminal-send-watch-policy.js";
+import { publicTerminalWatch } from "./terminal-watch-presentation.js";
 import { callbackRouteFingerprint } from "./callback-route-authority.js";
 import { createTerminalWatchOpenClawCallbackRoute, parseCallbackRoute } from "./callback-transport.js";
-import { captureClaudeTranscriptAnchor, captureClaudeHumanStartedActiveTaskAnchor, observeClaudeUserExplicitFallbackTranscript, observeClaudeHumanStartedActiveTask } from "./claude-local-transcript-provider.js";
-import { codexAsyncQuestionMainComposerVisible } from "./codex-async-question-adapter.js";
 import { hostProfileCallbackRouteMatchesRuntime } from "./host-profile-callback-transport.js";
-import { captureTerminalInteractionRuntimeOffer, TerminalInteractionDispatchReservedError, TerminalInteractionInputNotStartedError } from "./terminal-agent-bridge.js";
-import { executorForConversation, turnIdForConversation } from "./protocol.js";
-import { rolloutFileIdentityMatches } from "./terminal-binding-authority.js";
-import { captureCodexCandidateSetRolloutAcceptanceAnchor, captureCodexRolloutAcceptanceAnchor, detectCodexBoundQuestionnaireAttribution, detectCodexBoundRolloutCompletion, detectCodexCandidateSetRolloutAcceptance, detectCodexRolloutAcceptance, captureCodexHumanStartedActiveTaskAnchor, observeCodexHumanStartedActiveTask } from "./terminal-submission-acceptance.js";
-import { createTerminalInteractionAggregate, hashTerminalInteractionResponse, reduceTerminalInteractionAggregate } from "./terminal-interaction-core.js";
-import { selectTerminalInteractionResponder } from "./terminal-interaction-authority.js";
-import { validateAnyTerminalInteractionProjection, validateTerminalInteractionSubjectResponse } from "./terminal-interaction-protocol.js";
-import { executeTerminalInteractionResponseTransaction } from "./terminal-interaction-response-transaction.js";
-import { terminalInteractionRuntimeForWatch } from "./terminal-watch-interaction-runtime.js";
-import { consumeWatchInteractionResponse, settleWatchInteractionResponseFailure } from "./terminal-watch-interaction-response-store.js";
-import { sameTerminalControlEvidenceIncarnation, terminalControlEvidence } from "./terminal-control-ref.js";
+import { terminalControlEvidence } from "./terminal-control-ref.js";
 import { createTerminalWatchCallbackCliAdapter, resolveTerminalWatchOpenClawCallback, resolveTerminalWatchOpenClawCallbackContext } from "./terminal-watch-callback-cli-adapter.js";
-import { createTerminalWatchService, terminalWatchObservationFence } from "./terminal-watch-service.js";
-import { assertTerminalWatchManualInteractionSummary, createClaudeUserExplicitFallbackWatchAnchor, createCodexUserExplicitFallbackWatchAnchor, createTerminalActivityWatchAnchor, createTerminalWatchStore, isTerminalActivityWatch, isUserExplicitFallbackWatch, terminalWatchNotificationOnlyRoute, terminalWatchRevision, terminalUserExplicitFallbackWatchId } from "./terminal-watch-store.js";
+import { createTerminalWatchService } from "./terminal-watch-service.js";
+import { assertTerminalWatchManualInteractionSummary, createTerminalActivityWatchAnchor, createTerminalWatchStore, isUserExplicitFallbackWatch, terminalWatchNotificationOnlyRoute, terminalUserExplicitFallbackWatchId } from "./terminal-watch-store.js";
 import { isRecord, nonBlankString as stringValue } from "./value-guards.js";
+import { createTerminalWatchInteractionResponder } from "./terminal-watch-response-cli-adapter.js";
+import { watchAnchorVersionWarnings, captureCodexFallbackWatchAnchor, captureClaudeFallbackWatchAnchor, capturePaginatedWatchAnchorWithLock, captureTerminalWatchAnchor } from "./terminal-watch-anchor-capture.js";
+import { assertSameUserExplicitFallbackTerminal, assertPreparedFallbackTerminal, exactTerminalForWatch, bestEffortBindingTokenForWatch, terminalActivityState, sameManualWatchTarget, safeDiagnostic, terminalControlForWatch, terminalWatchIdentity, terminalAgent, terminalWorkspace, requiredWatchId, requiredString, positiveInteger, positiveMinutes } from "./terminal-watch-terminal-identity.js";
+import { observeTerminalWatch } from "./terminal-watch-observation-adapter.js";
+import { approvalFingerprint } from "./terminal-watch-observation-evidence.js";
 const DEFAULT_TERMINAL_WATCH_HARD_TIMEOUT_MINUTES = 720;
 export function createTerminalWatchCliAdapter(dependencies) {
     const callback = dependencies.callback ??
@@ -418,246 +404,6 @@ function createTerminalWatchStatusRunner(dependencies, serviceFor) {
         });
     };
 }
-function createTerminalWatchInteractionResponder(dependencies, serviceFor) {
-    return async function runRespondInteraction(options) {
-        const watchId = requiredWatchId(options.watch);
-        const interactionId = requiredString(options.interaction, "--interaction is required");
-        const expectedFingerprint = requiredSha256(options.expectedInteractionFingerprint, "interaction prompt fingerprint");
-        const expectedExpiresAt = requiredTimestamp(options.expectedInteractionExpiresAt, "--expected-interaction-expires-at");
-        const responseValue = parseWatchInteractionResponse(options.responseJson);
-        const storeDir = dependencies.storeDirFromOptions(options);
-        const repository = createTerminalWatchStore(storeDir, {
-            acquire: dependencies.acquireFileLock
-        });
-        const service = serviceFor(options);
-        const displayed = await service.reconcile(watchId);
-        assertWatchControllerSession(displayed, options.openclawSession);
-        const displayedInteraction = requiredExecutableWatchInteraction(displayed, interactionId, expectedFingerprint);
-        const response = validateTerminalInteractionSubjectResponse(responseValue, displayedInteraction.projection, { now: dependencies.now(), allowExpiredForLiveRecapture: true });
-        if (response.subject.kind !== "terminal_watch" ||
-            response.subject.watch_id !== watchId) {
-            throw new Error("--response-json subject watch_id does not match --watch");
-        }
-        const exact = await exactTerminalForWatch(displayed.terminal.terminal_id, options, dependencies);
-        if (!terminalMatchesWatch(exact.rawTerminal, displayed)) {
-            throw new Error("terminal Watch identity changed before interaction response; refresh status");
-        }
-        const terminalControl = terminalControlForWatch(exact.rawTerminal);
-        const releaseTerminal = dependencies.acquireTerminalLock(storeDir, terminalControl);
-        try {
-            const withWriterLease = dependencies.withStoreWriterLeaseAsync ??
-                (async (_storeDir, operation) => operation());
-            await withWriterLease(storeDir, async () => {
-                let current = repository.load(watchId);
-                assertWatchControllerSession(current, options.openclawSession);
-                const executableInteraction = requiredExecutableWatchInteraction(current, interactionId, expectedFingerprint);
-                const decision = terminalWatchResponseDecision(current, exact.rawTerminal, executableInteraction.projection.surface_id, executableInteraction.projection.prompt_fingerprint, options, dependencies);
-                if (!decision.executable || decision.suppress) {
-                    throw new Error("a higher-priority terminal interaction responder owns this live questionnaire; refresh status");
-                }
-                const version = terminalWatchCapturedAgentVersion(current) ??
-                    requiredString(exact.rawTerminal.agent_version, "running coding-agent version");
-                const runtime = terminalInteractionRuntimeForWatch({
-                    watch: current,
-                    rawTerminal: exact.rawTerminal,
-                    checkpoint: current.observation_checkpoint,
-                    version,
-                    terminalTarget: terminalControl.target,
-                    responseAuthority: "executable"
-                });
-                const bridge = dependencies.createBridge?.(options);
-                if (!bridge) {
-                    throw new Error("terminal interaction bridge is unavailable");
-                }
-                if (runtime.codexPaginatedThread && executableInteraction.projection.kind === "async_question") {
-                    await refreshPaginatedResponseForeground(bridge, terminalControl, runtime, dependencies.now);
-                }
-                const attemptId = dependencies.randomUUID();
-                const responseHash = hashTerminalInteractionResponse(response);
-                const reservation = { attemptId, responseHash };
-                const result = await executeTerminalInteractionResponseTransaction({
-                    reservationFailureFence: "confirmed",
-                    dispatch: (hooks) => "schema" in current.observation_checkpoint &&
-                        current.observation_checkpoint.schema === "agent-knock-knock/codex-paginated-task-checkpoint" &&
-                        executableInteraction.projection.kind === "questionnaire"
-                        ? respondCodexPaginatedBlockingQuestion({
-                            watch: current, checkpoint: current.observation_checkpoint, terminalControl,
-                            response, expectedFingerprint, now: dependencies.now,
-                            authorize: hooks.authorize, beforeDispatch: hooks.beforeDispatch,
-                            persistDraft: (draft) => {
-                                current = repository.withWriterLease((scope) => scope.withWatchLock(watchId, () => {
-                                    const latest = scope.load(watchId);
-                                    const checkpoint = latest.observation_checkpoint;
-                                    if (!("schema" in checkpoint) || checkpoint.schema !== "agent-knock-knock/codex-paginated-task-checkpoint") {
-                                        throw new Error("Codex blocking question checkpoint changed");
-                                    }
-                                    const nextCheckpoint = { ...checkpoint };
-                                    if (draft)
-                                        nextCheckpoint.blocking_question_draft = draft;
-                                    else
-                                        delete nextCheckpoint.blocking_question_draft;
-                                    return scope.save({ ...latest,
-                                        observation_checkpoint: nextCheckpoint,
-                                        updated_at: dependencies.now().toISOString()
-                                    }, { expectedRevision: terminalWatchRevision(latest) });
-                                }));
-                            }
-                        })
-                        : runtime.codexPaginatedThread && executableInteraction.projection.kind === "async_question"
-                            ? respondCodexPaginatedAsyncQuestion({
-                                bridge, terminalControl, terminalEvidence: current.terminal.terminal_endpoint,
-                                runtime, response, now: dependencies.now,
-                                options: { agentVersion: version, expectedFingerprint, expectedExpiresAt,
-                                    scrollbackLines: Number(options.scrollbackLines ?? 120), runtime,
-                                    authorize: hooks.authorize, beforeDispatch: hooks.beforeDispatch }
-                            })
-                            : bridge.respondInteraction(current.agent, terminalControl, response, {
-                                agentVersion: version,
-                                expectedFingerprint,
-                                expectedExpiresAt,
-                                scrollbackLines: Number(options.scrollbackLines ?? 120),
-                                runtime,
-                                authorize: hooks.authorize,
-                                beforeDispatch: hooks.beforeDispatch
-                            }),
-                    authorize: ({ projection, fingerprint }) => {
-                        const latest = repository.load(watchId);
-                        const interaction = requiredExecutableWatchInteraction(latest, interactionId, expectedFingerprint);
-                        const latestDecision = terminalWatchResponseDecision(latest, exact.rawTerminal, interaction.projection.surface_id, interaction.projection.prompt_fingerprint, options, dependencies);
-                        return projection.interaction_id === interactionId &&
-                            fingerprint === expectedFingerprint &&
-                            interaction.projection.subject.kind === "terminal_watch" &&
-                            projection.version === 2 &&
-                            projection.subject.kind === "terminal_watch" &&
-                            projection.subject.watch_id === watchId &&
-                            latestDecision.executable && !latestDecision.suppress
-                            ? { approved: true }
-                            : {
-                                approved: false,
-                                reason: "terminal Watch interaction authority changed before response"
-                            };
-                    },
-                    createReservation: () => reservation,
-                    reserve: ({ projection, fingerprint }, receipt, confirm) => {
-                        current = repository.withWriterLease((scope) => scope.withWatchLock(watchId, () => {
-                            const latest = scope.load(watchId);
-                            const interaction = requiredExecutableWatchInteraction(latest, interactionId, expectedFingerprint);
-                            if (projection.interaction_id !== interactionId ||
-                                fingerprint !== expectedFingerprint ||
-                                interaction.aggregate.state !== "pending") {
-                                throw new Error("terminal Watch interaction authority changed before dispatch");
-                            }
-                            const dispatchDecision = terminalWatchResponseDecision(latest, exact.rawTerminal, interaction.projection.surface_id, interaction.projection.prompt_fingerprint, options, dependencies);
-                            if (!dispatchDecision.executable || dispatchDecision.suppress) {
-                                throw new TerminalInteractionInputNotStartedError("terminal Watch interaction ownership changed before dispatch");
-                            }
-                            const reservedAt = dependencies.now().toISOString();
-                            const aggregate = reduceTerminalInteractionAggregate(interaction.aggregate, {
-                                type: "reserve",
-                                attempt_id: receipt.attemptId,
-                                response_hash: receipt.responseHash,
-                                at: reservedAt
-                            });
-                            const saved = scope.save({
-                                ...latest,
-                                current_interaction: {
-                                    projection: interaction.projection,
-                                    aggregate
-                                },
-                                updated_at: reservedAt
-                            }, { expectedRevision: terminalWatchRevision(latest) });
-                            // Match the predecessor's commit boundary: a later lock
-                            // release failure must still settle this durable receipt.
-                            confirm();
-                            return saved;
-                        }));
-                    },
-                    release: (receipt) => {
-                        current = settleWatchInteractionResponseFailure(repository, {
-                            watchId,
-                            interactionId,
-                            reservation: receipt,
-                            state: "release",
-                            now: dependencies.now
-                        });
-                    },
-                    releaseFailure: (_receipt, _error, releaseError) => releaseError,
-                    markUncertain: (receipt) => {
-                        current = settleWatchInteractionResponseFailure(repository, {
-                            watchId,
-                            interactionId,
-                            reservation: receipt,
-                            state: "response_uncertain",
-                            now: dependencies.now
-                        });
-                    },
-                    consume: (receipt) => {
-                        current = consumeWatchInteractionResponse(repository, {
-                            watchId,
-                            interactionId,
-                            reservation: receipt,
-                            now: dependencies.now,
-                            notificationFingerprint: sha256
-                        });
-                    },
-                    responded: (execution) => execution.responded,
-                    isInputNotStarted: (error) => error instanceof TerminalInteractionInputNotStartedError,
-                    duplicateReservationError: () => new Error("terminal Watch interaction response was already reserved"),
-                    inputNotStartedError: (error) => error,
-                    missingReservationError: () => new TerminalInteractionDispatchReservedError("reservation_uncertain", "terminal Watch response was dispatched without a durable reservation")
-                });
-                const execution = result.execution;
-                if (result.state === "blocked") {
-                    dependencies.printJson({
-                        watch: publicTerminalWatch(current, [], true),
-                        interaction_id: interactionId,
-                        responded: false,
-                        blocked: execution.blocked,
-                        reason: execution.reason
-                    });
-                    return;
-                }
-                dependencies.printJson({
-                    watch: publicTerminalWatch(current, [], true),
-                    interaction_id: interactionId,
-                    responded: true,
-                    blocked: false,
-                    question_id: execution.questionId,
-                    response_kind: execution.responseKind,
-                    outcome: execution.outcome
-                });
-            });
-        }
-        finally {
-            releaseTerminal();
-        }
-    };
-}
-function watchAnchorVersionWarnings(anchor, terminal) {
-    const runningVersion = stringValue(terminal.agent_version);
-    if (!runningVersion) {
-        return [
-            "running_agent_version_unavailable: exact task observation remains enabled"
-        ];
-    }
-    const artifactVersion = anchor.schema ===
-        "agent-knock-knock/codex-human-started-active-task-anchor"
-        ? anchor.codex_version
-        : anchor.schema ===
-            "agent-knock-knock/claude-human-started-active-task-anchor"
-            ? anchor.claude_version
-            : undefined;
-    if (!artifactVersion)
-        return [];
-    if (artifactVersion !== runningVersion) {
-        return [
-            `the active task artifact reports ${artifactVersion}, not the running ` +
-                `coding-agent version ${runningVersion}; Watch remains enabled because ` +
-                "version evidence is advisory"
-        ];
-    }
-    return [];
-}
 /**
  * A shared native-Host lifecycle owns no single controller session. Bind its
  * trusted Profile template to the exact session captured when this Watch was
@@ -694,125 +440,6 @@ function callbackRouteForUserExplicitFallback(options) {
         respond: true
     });
 }
-function assertSameUserExplicitFallbackTerminal(expected, observed) {
-    if (requiredString(observed.id, "terminal id") !== expected.conversationId ||
-        terminalAgent(observed) !== expected.agent ||
-        positiveInteger(observed.pid, "terminal PID") !== expected.pid ||
-        !isRecord(observed.terminal_control) ||
-        !sameTerminalControlEvidenceIncarnation(expected.terminalControl, observed.terminal_control)) {
-        throw new Error("terminal changed before the user-explicit fallback Watch anchor was captured");
-    }
-}
-function assertPreparedFallbackTerminal(prepared, observed) {
-    if (requiredString(observed.id, "terminal id") !== prepared.terminalId ||
-        terminalAgent(observed) !== prepared.agent ||
-        positiveInteger(observed.pid, "terminal PID") !== prepared.pid ||
-        !isRecord(observed.terminal_control) ||
-        !sameTerminalControlEvidenceIncarnation(prepared.terminalEndpoint, observed.terminal_control)) {
-        throw new Error("terminal changed before the user-explicit fallback Watch was attached");
-    }
-    if (isTerminalActivityWatch(prepared)) {
-        assertAutomaticActivityWatchIdentity(prepared.anchor, observed, terminalWorkspace(observed), prepared.terminalIdentity.workspace);
-    }
-}
-async function exactTerminalForWatch(terminalId, options, dependencies) {
-    const observation = await dependencies.observeExactTerminal({
-        options,
-        terminalId
-    });
-    if (observation.state === "unavailable") {
-        throw new Error("authoritative observation of the exact terminal is temporarily " +
-            "unavailable; retry after refreshing AKK list");
-    }
-    if (observation.state === "absent") {
-        throw new Error(`expected exact terminal ${terminalId}; observed none`);
-    }
-    return observation;
-}
-function bindingTokenForWatch(terminal) {
-    return requiredSha256(terminal.lifecycle_binding_token, "current terminal binding token");
-}
-function bestEffortBindingTokenForWatch(terminal) {
-    try {
-        return { token: bindingTokenForWatch(terminal) };
-    }
-    catch {
-        const terminalControl = terminalControlForWatch(terminal);
-        return {
-            token: sha256({
-                schema: "agent-knock-knock/terminal-watch-observation-binding",
-                version: 1,
-                terminal_id: requiredString(terminal.id, "terminal id"),
-                agent: terminalAgent(terminal),
-                pid: positiveInteger(terminal.pid, "terminal PID"),
-                endpoint: terminalControlEvidence(terminalControl),
-                process_uuid: stringValue(terminal.native_agent_process_uuid) ?? null,
-                process_birth: stringValue(terminal.native_agent_process_birth) ?? null
-            }),
-            warning: "lifecycle_binding_token_unavailable: Watch used read-only terminal/process observation identity"
-        };
-    }
-}
-function terminalActivityState(terminal) {
-    const state = stringValue(terminal.activity_state);
-    return state === "awaiting_approval" || state === "working" ||
-        state === "idle"
-        ? state
-        : "unknown";
-}
-function sameManualWatchTarget(watch, agent, terminal, anchor) {
-    return watch.status === "active" &&
-        watch.agent === agent &&
-        watch.terminal.terminal_id === terminal.terminal_id &&
-        watch.terminal.workspace === terminal.workspace &&
-        sameTerminalControlEvidenceIncarnation(watch.terminal.terminal_endpoint, terminal.terminal_endpoint) &&
-        sameManualWatchAnchorTarget(watch.anchor, anchor);
-}
-function sameManualWatchAnchorTarget(left, right) {
-    if (left.schema !== right.schema)
-        return false;
-    if (left.schema === "agent-knock-knock/codex-paginated-task-anchor" && right.schema === left.schema) {
-        return samePaginatedWatchTask(left, right);
-    }
-    if (left.schema ===
-        "agent-knock-knock/codex-human-started-active-task-anchor" &&
-        right.schema === left.schema) {
-        return left.turn_id === right.turn_id &&
-            left.process_uuid === right.process_uuid &&
-            left.process_birth === right.process_birth &&
-            left.rollout.device === right.rollout.device &&
-            left.rollout.inode === right.rollout.inode;
-    }
-    if (left.schema ===
-        "agent-knock-knock/claude-human-started-active-task-anchor" &&
-        right.schema === left.schema) {
-        return sameClaudeWatchTask(left, right);
-    }
-    if (left.schema === "agent-knock-knock/terminal-activity-watch-anchor" &&
-        right.schema === left.schema) {
-        return left.origin === right.origin &&
-            left.request_hash === right.request_hash &&
-            left.pid === right.pid &&
-            optionalIdentityCompatible(left.native_process_uuid, right.native_process_uuid) &&
-            optionalIdentityCompatible(left.native_process_birth, right.native_process_birth);
-    }
-    return left.anchor_fingerprint === right.anchor_fingerprint;
-}
-function sameClaudeWatchTask(left, right) {
-    return left.prompt_uuid === right.prompt_uuid &&
-        left.pid === right.pid &&
-        left.agent_started_at_ms === right.agent_started_at_ms &&
-        left.device === right.device &&
-        left.inode === right.inode;
-}
-function samePaginatedWatchTask(left, right) {
-    return left.native_thread_id === right.native_thread_id && left.turn_id === right.turn_id &&
-        left.process_uuid === right.process_uuid && left.process_birth === right.process_birth &&
-        left.origin === right.origin && left.codex_home === right.codex_home;
-}
-function optionalIdentityCompatible(left, right) {
-    return left === undefined || right === undefined || left === right;
-}
 function sameManualWatchCallbackAuthority(watch, callbackRoute, openclawSession, openclawBin) {
     if (watch.openclaw_session !== openclawSession)
         return false;
@@ -824,1497 +451,6 @@ function sameManualWatchCallbackAuthority(watch, callbackRoute, openclawSession,
         callbackRouteFingerprint(watch.callback_route) ===
             callbackRouteFingerprint(callbackRoute);
 }
-function safeDiagnostic(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return message.replace(/[\r\n\0]+/gu, " ").trim().slice(0, 500) ||
-        "unknown provider observation error";
-}
-function terminalControlForWatch(terminal) {
-    if (!isRecord(terminal.terminal_control)) {
-        throw new Error("the exact terminal has no terminal control authority");
-    }
-    return terminal.terminal_control;
-}
-async function captureCodexFallbackWatchAnchor(input, rawTerminal, agentVersion, dependencies) {
-    let inventory = rawTerminal._codex_open_root_rollout_inventory;
-    let paginated;
-    if (isCodexPaginatedReadCandidate(agentVersion)) {
-        try {
-            paginated = await capturePaginatedWatchAnchor(rawTerminal, input.options, dependencies, input.requestText === undefined ? input.requestHash
-                : createHash("sha256").update(input.requestText.replace(/\r\n?/gu, "\n").trim()).digest("hex"));
-        }
-        catch (error) {
-            if (!(error instanceof CodexLegacyThreadHistoryError) || !isRecord(inventory) || !Array.isArray(inventory.roots))
-                throw error;
-            const roots = inventory.roots.filter((root) => root.sessionId === error.threadId);
-            if (roots.length !== 1)
-                throw error;
-            inventory = { ...inventory, roots };
-        }
-    }
-    const source = selectCodexUserExplicitSendWatchSource({
-        agentVersion,
-        legacyRootCount: isRecord(inventory) && Array.isArray(inventory.roots) ? inventory.roots.length : 0,
-        paginatedAnchorAvailable: paginated !== undefined
-    });
-    if (source.source === "none")
-        throw new Error(source.warning);
-    if (paginated) {
-        return paginated;
-    }
-    else {
-        const acceptanceAnchor = isRecord(inventory)
-            ? captureCodexCandidateSetRolloutAcceptanceAnchor({
-                inventory: inventory,
-                now: dependencies.now()
-            })
-            : captureCodexRolloutAcceptanceAnchor({
-                nativeThreadId: requiredString(rawTerminal.native_agent_session_id, "Codex native thread id"),
-                processUuid: requiredString(rawTerminal.native_agent_process_uuid, "Codex process UUID"),
-                processBirth: requiredString(rawTerminal.native_agent_process_birth, "Codex process birth"),
-                mode: "existing",
-                rollout: codexIdentity(rawTerminal).rollout,
-                now: dependencies.now()
-            });
-        return createCodexUserExplicitFallbackWatchAnchor({
-            acceptanceAnchor,
-            requestHash: input.requestHash,
-            codexVersion: agentVersion
-        });
-    }
-}
-function captureClaudeFallbackWatchAnchor(input, rawTerminal, agentVersion, dependencies) {
-    const transcriptAnchor = captureClaudeTranscriptAnchor({
-        sessionId: requiredString(rawTerminal.native_agent_session_id, "Claude native session id"),
-        cwd: terminalWorkspace(rawTerminal),
-        pid: positiveInteger(rawTerminal.pid, "Claude PID"),
-        claudeHome: stringValue(input.options.claudeHome),
-        agentRows: dependencies.loadClaudeAgentRows(input.options, { required: true }),
-        now: dependencies.now()
-    });
-    if (!transcriptAnchor) {
-        throw new Error("Claude transcript anchor is unavailable before terminal input");
-    }
-    return createClaudeUserExplicitFallbackWatchAnchor({
-        transcriptAnchor,
-        requestHash: input.requestHash,
-        claudeVersion: agentVersion
-    });
-}
-async function capturePaginatedWatchAnchor(terminal, options, dependencies, requestHash) {
-    const bridge = dependencies.createBridge?.(options);
-    if (dependencies.capturePaginatedAnchor) {
-        return dependencies.capturePaginatedAnchor({ terminal, bridge: bridge, requestHash,
-            codexHome: stringValue(options.codexHome), now: dependencies.now });
-    }
-    if (!bridge)
-        throw new Error("Codex paginated terminal inspection is unavailable");
-    return capturePaginatedAnchor({ terminal, bridge, requestHash,
-        codexHome: stringValue(options.codexHome), now: dependencies.now });
-}
-async function capturePaginatedWatchAnchorWithLock(terminal, options, dependencies) {
-    const release = dependencies.acquireTerminalLock(dependencies.storeDirFromOptions(options), terminalControlForWatch(terminal));
-    try {
-        return await capturePaginatedWatchAnchor(terminal, options, dependencies);
-    }
-    finally {
-        release();
-    }
-}
-function captureTerminalWatchAnchor(agent, terminal, options, dependencies) {
-    if (agent === "codex") {
-        return captureCodexHumanStartedActiveTaskAnchor({
-            currentIdentity: codexIdentity(terminal),
-            now: dependencies.now()
-        });
-    }
-    return captureClaudeHumanStartedActiveTaskAnchor({
-        sessionId: requiredString(terminal.native_agent_session_id, "Claude native session id"),
-        cwd: terminalWorkspace(terminal),
-        pid: positiveInteger(terminal.pid, "Claude PID"),
-        claudeHome: stringValue(options.claudeHome),
-        agentRows: dependencies.loadClaudeAgentRows(options, { required: true }),
-        now: dependencies.now()
-    });
-}
-async function observeTerminalWatch(watch, options, dependencies) {
-    const observedAt = dependencies.now().toISOString();
-    const fence = terminalWatchObservationFence(watch);
-    const exactTerminal = await currentTerminalForWatch(watch, options, dependencies);
-    const rawTerminal = exactTerminal.state === "available"
-        ? exactTerminal.rawTerminal
-        : undefined;
-    if (watch.anchor.schema === "agent-knock-knock/codex-paginated-task-anchor") {
-        const terminalMatches = Boolean(rawTerminal && terminalMatchesWatch(rawTerminal, watch) && paginatedWatchProcessMatches(rawTerminal, watch.anchor));
-        return observePaginatedWatch({ watch, observedAt, terminalMatches,
-            terminalAvailable: exactTerminal.state === "available",
-            readSnapshot: dependencies.readPaginatedSnapshot,
-            blockingQuestionnaire: (checkpoint) => observeCodexPaginatedBlockingQuestion({
-                watch, checkpoint, now: new Date(observedAt),
-                responseDecision: (surfaceId, fingerprint) => rawTerminal
-                    ? terminalWatchResponseDecision({ ...watch, observation_checkpoint: checkpoint }, rawTerminal, surfaceId, fingerprint, options, dependencies)
-                    : { executable: false, suppress: false }
-            }),
-            questionnaire: (checkpoint, questions, allowResponses) => exactTerminal.state === "available"
-                ? terminalWatchQuestionnaireObservation({ watch: allowResponses ? watch : { ...watch, interaction_policy: "notify_only" }, observedAt, options, dependencies,
-                    rawTerminal, projectedTerminal: exactTerminal.terminal, terminalMatches,
-                    observationCheckpoint: checkpoint, codexAsyncQuestionEvidence: questions })
-                : undefined });
-    }
-    const projectedTerminal = exactTerminal.state === "available"
-        ? exactTerminal.terminal
-        : undefined;
-    const activityTerminalIdentity = rawTerminal && isTerminalActivityWatch(watch)
-        ? terminalActivityWatchIdentityMatch(rawTerminal, watch)
-        : undefined;
-    const terminalMatches = rawTerminal
-        ? isUserExplicitFallbackWatch(watch)
-            ? terminalMatchesUserExplicitFallbackWatch(rawTerminal, watch)
-            : isTerminalActivityWatch(watch)
-                ? activityTerminalIdentity === "match"
-                : terminalMatchesWatch(rawTerminal, watch)
-        : false;
-    if (isUserExplicitFallbackWatch(watch)) {
-        return observeUserExplicitFallbackTerminalWatch({
-            watch,
-            exactTerminal,
-            rawTerminal,
-            projectedTerminal,
-            terminalMatches,
-            observedAt,
-            options,
-            dependencies
-        });
-    }
-    if (isTerminalActivityWatch(watch)) {
-        return observeTerminalActivityWatch({
-            watch,
-            exactTerminal,
-            rawTerminal,
-            projectedTerminal,
-            terminalIdentityMatch: activityTerminalIdentity ?? "mismatch",
-            observedAt,
-            options,
-            dependencies
-        });
-    }
-    const observation = watch.anchor.schema ===
-        "agent-knock-knock/codex-human-started-active-task-anchor"
-        ? observeCodexHumanStartedActiveTask({
-            anchor: watch.anchor,
-            currentIdentity: rawTerminal
-                ? codexIdentity(rawTerminal)
-                : codexIdentityForWatch(watch),
-            resumeOffsetBytes: watch.observation_checkpoint.safe_resume_offset_bytes
-        })
-        : watch.anchor.schema ===
-            "agent-knock-knock/claude-human-started-active-task-anchor"
-            ? observeClaudeHumanStartedActiveTask({
-                anchor: watch.anchor,
-                claudeHome: stringValue(options.claudeHome),
-                agentRows: dependencies.loadClaudeAgentRows(options, { required: true }),
-                resumeOffsetBytes: watch.observation_checkpoint.safe_resume_offset_bytes,
-                checkpoint: claudeObservationCheckpoint(watch)
-            })
-            : (() => {
-                throw new Error("terminal Watch anchor is unsupported");
-            })();
-    if (observation.status === "invalidated") {
-        return invalidatedObservation(watch, observedAt, "task_anchor_invalidated");
-    }
-    if (observation.status === "completed") {
-        const completion = observation.completion;
-        const kind = completion.outcome === "failure" ? "failed" : "completed";
-        return {
-            ...fence,
-            kind,
-            observed_at: observedAt,
-            evidence_fingerprint: sha256({
-                kind,
-                watch_id: watch.watch_id,
-                completion_id: completion.id ?? null,
-                completion_timestamp: completion.timestamp ?? null,
-                anchor_fingerprint: watch.anchor.anchor_fingerprint
-            }),
-            reason_code: completion.outcome === "failure"
-                ? "anchored_task_failed"
-                : "anchored_task_completed",
-            completion_text: completion.text.slice(0, 4000),
-            completion_id: completion.id,
-            completion_timestamp: completion.timestamp
-        };
-    }
-    if (observation.status === "unavailable") {
-        return {
-            ...fence,
-            kind: "unavailable",
-            observed_at: observedAt,
-            reason_code: "provider_observation_unavailable"
-        };
-    }
-    const safeResumeOffsetBytes = observation.safeResumeOffsetBytes;
-    const observationCheckpoint = "checkpoint" in observation
-        ? observation.checkpoint
-        : undefined;
-    if (exactTerminal.state === "unavailable") {
-        return {
-            ...fence,
-            kind: "unavailable",
-            observed_at: observedAt,
-            safe_resume_offset_bytes: safeResumeOffsetBytes,
-            observation_checkpoint: observationCheckpoint,
-            reason_code: "terminal_observation_unavailable"
-        };
-    }
-    if (rawTerminal && !terminalMatches) {
-        return invalidatedObservation(watch, observedAt, "terminal_identity_changed");
-    }
-    if (exactTerminal.state === "absent") {
-        return invalidatedObservation(watch, observedAt, "terminal_process_unavailable");
-    }
-    if (!projectedTerminal) {
-        throw new Error("exact terminal observation is inconsistent");
-    }
-    const approval = approvalFingerprint(projectedTerminal);
-    if (approval) {
-        return {
-            ...fence,
-            kind: "approval",
-            observed_at: observedAt,
-            last_activity_at: observedAt,
-            safe_resume_offset_bytes: safeResumeOffsetBytes,
-            observation_checkpoint: observationCheckpoint,
-            evidence_fingerprint: approval,
-            reason_code: "terminal_waiting_for_approval"
-        };
-    }
-    const interaction = terminalWatchQuestionnaireObservation({
-        watch,
-        rawTerminal,
-        projectedTerminal,
-        terminalMatches: true,
-        observedAt,
-        observationCheckpoint,
-        options,
-        dependencies
-    });
-    if (interaction)
-        return interaction;
-    return {
-        ...fence,
-        kind: "pending",
-        observed_at: observedAt,
-        safe_resume_offset_bytes: safeResumeOffsetBytes,
-        observation_checkpoint: observationCheckpoint
-    };
-}
-function observeTerminalActivityWatch(input) {
-    const { watch, exactTerminal, projectedTerminal, rawTerminal, terminalIdentityMatch, observedAt } = input;
-    const fence = terminalWatchObservationFence(watch);
-    if (exactTerminal.state === "unavailable") {
-        return {
-            ...fence,
-            kind: "unavailable",
-            observed_at: observedAt,
-            reason_code: "terminal_observation_unavailable"
-        };
-    }
-    if (exactTerminal.state === "absent") {
-        return invalidatedObservation(watch, observedAt, "terminal_process_unavailable");
-    }
-    if (terminalIdentityMatch === "unavailable") {
-        return {
-            ...fence,
-            kind: "unavailable",
-            observed_at: observedAt,
-            reason_code: "terminal_identity_observation_incomplete"
-        };
-    }
-    if (terminalIdentityMatch === "mismatch") {
-        return invalidatedObservation(watch, observedAt, "terminal_identity_changed");
-    }
-    if (!projectedTerminal) {
-        return {
-            ...fence,
-            kind: "unavailable",
-            observed_at: observedAt,
-            reason_code: "terminal_activity_unavailable"
-        };
-    }
-    if (rawTerminal) {
-        const interaction = terminalWatchQuestionnaireObservation({
-            watch,
-            rawTerminal,
-            projectedTerminal,
-            terminalMatches: true,
-            observedAt,
-            observationCheckpoint: terminalActivityObservationCheckpoint(watch),
-            options: input.options,
-            dependencies: input.dependencies
-        });
-        if (interaction)
-            return interaction;
-    }
-    const state = terminalActivityState(projectedTerminal);
-    const current = terminalActivityObservationCheckpoint(watch);
-    const active = state === "working" || state === "awaiting_approval";
-    const hasSeenActivity = current.has_seen_activity || active;
-    const consecutiveIdle = state === "idle" && hasSeenActivity
-        ? current.last_activity_state === "idle"
-            ? current.consecutive_idle_observations + 1
-            : 1
-        : 0;
-    const checkpoint = {
-        ...current,
-        has_seen_activity: hasSeenActivity,
-        consecutive_idle_observations: consecutiveIdle,
-        last_activity_state: state
-    };
-    if (state === "unknown") {
-        return {
-            ...fence,
-            kind: "unavailable",
-            observed_at: observedAt,
-            observation_checkpoint: checkpoint,
-            reason_code: "terminal_activity_unknown"
-        };
-    }
-    if (state === "awaiting_approval") {
-        const approval = approvalFingerprint(projectedTerminal);
-        if (approval) {
-            return {
-                ...fence,
-                kind: "approval",
-                observed_at: observedAt,
-                last_activity_at: observedAt,
-                observation_checkpoint: checkpoint,
-                evidence_fingerprint: approval,
-                reason_code: "terminal_waiting_for_approval"
-            };
-        }
-    }
-    if (state === "idle" && hasSeenActivity && consecutiveIdle >= 2) {
-        return {
-            ...fence,
-            kind: "completed",
-            observed_at: observedAt,
-            observation_checkpoint: checkpoint,
-            evidence_fingerprint: sha256({
-                watch_id: watch.watch_id,
-                reason_code: "terminal_activity_became_stably_idle",
-                anchor_fingerprint: watch.anchor.anchor_fingerprint
-            }),
-            reason_code: "terminal_activity_became_stably_idle"
-        };
-    }
-    return {
-        ...fence,
-        kind: "pending",
-        observed_at: observedAt,
-        ...(active ? { last_activity_at: observedAt } : {}),
-        observation_checkpoint: checkpoint
-    };
-}
-async function observeUserExplicitFallbackTerminalWatch(input) {
-    const { watch, exactTerminal, rawTerminal, projectedTerminal, terminalMatches, observedAt, options, dependencies } = input;
-    const fence = terminalWatchObservationFence(watch);
-    if (watch.anchor.schema ===
-        "agent-knock-knock/codex-user-explicit-fallback-watch-anchor") {
-        const anchor = watch.anchor.acceptance_anchor;
-        const persistedCheckpoint = codexFallbackObservationCheckpoint(watch);
-        let acceptance;
-        let currentIdentity;
-        let acceptedCheckpoint;
-        if (persistedCheckpoint.acceptance_evidence &&
-            persistedCheckpoint.accepted_identity) {
-            acceptance = persistedCheckpoint.acceptance_evidence;
-            currentIdentity = {
-                sessionId: persistedCheckpoint.accepted_identity.native_thread_id,
-                processUuid: persistedCheckpoint.accepted_identity.process_uuid,
-                processBirth: persistedCheckpoint.accepted_identity.process_birth,
-                rollout: persistedCheckpoint.accepted_identity.rollout
-            };
-            acceptedCheckpoint = persistedCheckpoint;
-        }
-        else if (anchor.version === 3) {
-            const inventory = rawTerminal?._codex_open_root_rollout_inventory;
-            if (!isRecord(inventory)) {
-                return fallbackPendingOrTerminalObservation({
-                    watch,
-                    exactTerminal,
-                    rawTerminal,
-                    terminalMatches,
-                    observedAt,
-                    reasonCode: "codex_rollout_inventory_unavailable"
-                });
-            }
-            const result = detectCodexCandidateSetRolloutAcceptance({
-                anchor,
-                currentInventory: inventory,
-                requestHash: watch.anchor.request_hash
-            });
-            if (result.status === "uncertain") {
-                if (result.code === "candidate_scan_invalid") {
-                    return {
-                        ...fence,
-                        kind: "unavailable",
-                        observed_at: observedAt,
-                        reason_code: "native_acceptance_scan_unavailable"
-                    };
-                }
-                return invalidatedObservation(watch, observedAt, `native_acceptance_${result.code}`);
-            }
-            if (result.status === "pending") {
-                return fallbackPendingOrTerminalObservation({
-                    watch,
-                    exactTerminal,
-                    rawTerminal,
-                    terminalMatches,
-                    observedAt
-                });
-            }
-            acceptance = result.evidence;
-            currentIdentity = result.identity;
-            acceptedCheckpoint = codexFallbackAcceptedCheckpoint(watch, acceptance, currentIdentity);
-        }
-        else {
-            try {
-                currentIdentity = anchor.version === 1
-                    ? {
-                        sessionId: anchor.native_thread_id,
-                        processUuid: anchor.process_uuid,
-                        processBirth: anchor.process_birth,
-                        rollout: anchor.rollout
-                    }
-                    : rawTerminal
-                        ? codexIdentity(rawTerminal)
-                        : (() => {
-                            throw new Error("Codex pre-materialization identity is unavailable");
-                        })();
-                acceptance = detectCodexRolloutAcceptance({
-                    anchor,
-                    currentIdentity,
-                    requestHash: watch.anchor.request_hash
-                });
-            }
-            catch (error) {
-                if (retryableProviderError(error)) {
-                    return {
-                        ...fence,
-                        kind: "unavailable",
-                        observed_at: observedAt,
-                        reason_code: "native_acceptance_scan_unavailable"
-                    };
-                }
-                return invalidatedObservation(watch, observedAt, "native_acceptance_identity_changed");
-            }
-            if (!acceptance) {
-                return fallbackPendingOrTerminalObservation({
-                    watch,
-                    exactTerminal,
-                    rawTerminal,
-                    terminalMatches,
-                    observedAt
-                });
-            }
-            acceptedCheckpoint = codexFallbackAcceptedCheckpoint(watch, acceptance, currentIdentity);
-        }
-        if (!acceptance || !acceptedCheckpoint) {
-            throw new Error("Codex fallback Watch acceptance checkpoint is incomplete");
-        }
-        const completion = detectCodexBoundRolloutCompletion({
-            anchor,
-            acceptanceEvidence: acceptance,
-            currentIdentity,
-            requestHash: watch.anchor.request_hash
-        });
-        if (completion.status === "completed") {
-            return fallbackCompletionObservation(watch, observedAt, completion.completion, completion.diagnostics.observed_end_offset_bytes, codexFallbackAcceptedCheckpoint(watch, acceptance, currentIdentity));
-        }
-        if (completion.status === "failure") {
-            if (completion.diagnostics.code === "rollout_unreadable") {
-                return {
-                    ...fence,
-                    kind: "unavailable",
-                    observed_at: observedAt,
-                    safe_resume_offset_bytes: acceptedCheckpoint.safe_resume_offset_bytes,
-                    observation_checkpoint: acceptedCheckpoint,
-                    reason_code: "accepted_rollout_unavailable"
-                };
-            }
-            return invalidatedObservation(watch, observedAt, `native_completion_${completion.diagnostics.code}`);
-        }
-        const interaction = fallbackQuestionnaireObservation({
-            watch,
-            exactTerminal,
-            rawTerminal,
-            projectedTerminal,
-            terminalMatches,
-            observedAt,
-            observationCheckpoint: codexFallbackAcceptedCheckpoint(watch, acceptance, currentIdentity),
-            options,
-            dependencies
-        });
-        if (interaction)
-            return interaction;
-        return fallbackPendingOrTerminalObservation({
-            watch,
-            exactTerminal,
-            rawTerminal,
-            terminalMatches,
-            observedAt,
-            observedEndOffsetBytes: completion.diagnostics.observed_end_offset_bytes,
-            observationCheckpoint: codexFallbackAcceptedCheckpoint(watch, acceptance, currentIdentity)
-        });
-    }
-    if (watch.anchor.schema !==
-        "agent-knock-knock/claude-user-explicit-fallback-watch-anchor") {
-        throw new Error("user-explicit fallback Watch anchor is unsupported");
-    }
-    const request = {
-        sessionId: watch.anchor.transcript_anchor.session_id,
-        cwd: watch.anchor.transcript_anchor.cwd,
-        requestHash: watch.anchor.request_hash,
-        startedAt: watch.anchor.captured_at,
-        context: {
-            claudeTranscriptAnchor: watch.anchor.transcript_anchor,
-            pid: watch.anchor.transcript_anchor.pid
-        }
-    };
-    const persistedCheckpoint = claudeFallbackObservationCheckpoint(watch);
-    const observation = observeClaudeUserExplicitFallbackTranscript(request, {
-        claudeHome: stringValue(options.claudeHome),
-        // This observer is transcript-authoritative by design. Completion must
-        // remain recoverable after the exact pane/process leaves discovery.
-        acceptanceEvidence: persistedCheckpoint.acceptance_evidence
-    });
-    if (observation.status === "unavailable") {
-        return {
-            ...fence,
-            kind: "unavailable",
-            observed_at: observedAt,
-            reason_code: "native_acceptance_scan_unavailable"
-        };
-    }
-    const acceptance = observation.acceptance;
-    if (!acceptance) {
-        return fallbackPendingOrTerminalObservation({
-            watch,
-            exactTerminal,
-            rawTerminal,
-            terminalMatches,
-            observedAt
-        });
-    }
-    const acceptedCheckpoint = claudeFallbackAcceptedCheckpoint(watch, acceptance);
-    if (observation.status === "completed") {
-        return fallbackCompletionObservation(watch, observedAt, observation.completion, observation.observedEndOffsetBytes, acceptedCheckpoint);
-    }
-    const interaction = fallbackQuestionnaireObservation({
-        watch,
-        exactTerminal,
-        rawTerminal,
-        projectedTerminal,
-        terminalMatches,
-        observedAt,
-        observationCheckpoint: acceptedCheckpoint,
-        options,
-        dependencies
-    });
-    if (interaction)
-        return interaction;
-    return fallbackPendingOrTerminalObservation({
-        watch,
-        exactTerminal,
-        rawTerminal,
-        terminalMatches,
-        observedAt,
-        observedEndOffsetBytes: observation.observedEndOffsetBytes,
-        observationCheckpoint: acceptedCheckpoint
-    });
-}
-function fallbackQuestionnaireObservation(input) {
-    if (input.exactTerminal.state !== "available" ||
-        !input.rawTerminal ||
-        !input.projectedTerminal ||
-        !input.terminalMatches) {
-        return undefined;
-    }
-    return terminalWatchQuestionnaireObservation({
-        ...input,
-        rawTerminal: input.rawTerminal,
-        projectedTerminal: input.projectedTerminal
-    }, true);
-}
-function terminalWatchQuestionnaireObservation(input, requireFallbackAttribution = false) {
-    if (!input.rawTerminal || !input.terminalMatches)
-        return undefined;
-    const rawTerminal = input.rawTerminal;
-    const screen = terminalWatchScreenExcerpt(rawTerminal, input.projectedTerminal);
-    const version = terminalWatchCapturedAgentVersion(input.watch) ??
-        stringValue(rawTerminal.agent_version);
-    if (!screen || !version)
-        return undefined;
-    const responseWatch = input.observationCheckpoint
-        ? {
-            ...input.watch,
-            observation_checkpoint: input.observationCheckpoint
-        }
-        : input.watch;
-    const captureOffer = (responseAuthority) => captureTerminalInteractionRuntimeOffer({
-        agent: input.watch.agent,
-        terminalControl: terminalControlForWatch(rawTerminal),
-        screen,
-        runtime: terminalInteractionRuntimeForWatch({
-            watch: responseWatch,
-            rawTerminal,
-            checkpoint: responseWatch.observation_checkpoint,
-            version,
-            terminalTarget: terminalControlForWatch(rawTerminal).target,
-            responseAuthority
-        }),
-        now: new Date(input.observedAt),
-        approvalBlocked: Boolean(approvalFingerprint(input.projectedTerminal)),
-        trustedTerminalEvidence: input.watch.terminal.terminal_endpoint,
-        codexAsyncQuestionEvidence: input.codexAsyncQuestionEvidence
-    });
-    let offer = captureOffer("notify_only");
-    if (!offer)
-        return absentAsyncQuestionObservation(input, screen, version);
-    if (input.watch.current_interaction?.projection.kind === "async_question" &&
-        offer.projection.kind === "questionnaire" &&
-        offer.nativeInspection.status !== "actionable") {
-        return absentAsyncQuestionObservation(input, screen, version);
-    }
-    if (requireFallbackAttribution &&
-        !fallbackQuestionnaireContextMatches(input.watch, rawTerminal, input.observationCheckpoint ?? input.watch.observation_checkpoint, offer.nativeInspection)) {
-        return undefined;
-    }
-    const responseDecision = terminalWatchResponseDecision(responseWatch, rawTerminal, offer.surfaceId, offer.promptFingerprint, input.options, input.dependencies);
-    if (responseDecision.executable && !(responseWatch.anchor.schema === "agent-knock-knock/codex-paginated-task-anchor" && offer.projection.kind === "questionnaire")) {
-        const executableOffer = captureOffer("executable");
-        if (!executableOffer ||
-            executableOffer.surfaceId !== offer.surfaceId ||
-            executableOffer.projection.interaction_id !==
-                offer.projection.interaction_id) {
-            throw new Error("terminal Watch interaction surface changed during responder arbitration");
-        }
-        offer = executableOffer;
-    }
-    const currentInteraction = {
-        projection: offer.projection.version === 2 &&
-            offer.projection.subject.kind === "terminal_watch"
-            ? offer.projection
-            : (() => {
-                throw new Error("Watch interaction projection lost its Watch subject");
-            })(),
-        aggregate: createTerminalInteractionAggregate(offer.projection, input.observedAt)
-    };
-    const manualInteraction = terminalWatchManualInteractionSummary(offer.nativeInspection);
-    const interactionReasonPrefix = offer.projection.kind === "async_question"
-        ? "terminal_async_question"
-        : "terminal_questionnaire";
-    return {
-        ...terminalWatchObservationFence(input.watch),
-        kind: "interaction",
-        observed_at: input.observedAt,
-        last_activity_at: input.observedAt,
-        ...(input.observationCheckpoint
-            ? { observation_checkpoint: input.observationCheckpoint }
-            : {}),
-        evidence_fingerprint: sha256({
-            schema: "agent-knock-knock/terminal-watch-interaction-event",
-            version: 1,
-            watch_id: input.watch.watch_id,
-            interaction_id: offer.projection.interaction_id,
-            surface_id: offer.surfaceId
-        }),
-        reason_code: responseDecision.suppress
-            ? `${interactionReasonPrefix}_managed_responder_precedence`
-            : currentInteraction.projection.capabilities.respond
-                ? `${interactionReasonPrefix}_response_requested`
-                : `${interactionReasonPrefix}_requires_manual_response`,
-        current_interaction: currentInteraction,
-        ...(responseDecision.suppress
-            ? { suppress_notification: true }
-            : {}),
-        ...(!responseDecision.suppress &&
-            !currentInteraction.projection.capabilities.respond
-            ? { manual_interaction: manualInteraction }
-            : {})
-    };
-}
-function absentAsyncQuestionObservation(input, screen, version) {
-    const prior = input.watch.current_interaction;
-    if (prior?.projection.kind !== "async_question" ||
-        prior.aggregate.state !== "pending" ||
-        !input.rawTerminal ||
-        !terminalWatchCandidateMatchesLiveContext(input.watch, input.rawTerminal) ||
-        !codexAsyncQuestionMainComposerVisible({ version, screen })) {
-        return undefined;
-    }
-    return {
-        ...terminalWatchObservationFence(input.watch),
-        kind: "pending",
-        observed_at: input.observedAt,
-        ...(input.observationCheckpoint
-            ? { observation_checkpoint: input.observationCheckpoint }
-            : {}),
-        async_interaction_absent: {
-            interaction_id: prior.projection.interaction_id,
-            prompt_fingerprint: prior.projection.prompt_fingerprint
-        }
-    };
-}
-/**
- * Durable fallback completion remains bound to its accepted provider artifact
- * even after the pane moves elsewhere. A live questionnaire is different: it
- * may be attributed to a Watch only while that exact accepted native context
- * is still the one rendered in the pane.
- */
-function fallbackQuestionnaireContextMatches(watch, terminal, checkpoint, inspection) {
-    if (watch.anchor.schema !==
-        "agent-knock-knock/codex-user-explicit-fallback-watch-anchor") {
-        return true;
-    }
-    if (!("schema" in checkpoint) ||
-        checkpoint.schema !==
-            "agent-knock-knock/codex-user-explicit-fallback-watch-checkpoint" ||
-        !checkpoint.accepted_identity ||
-        !checkpoint.acceptance_evidence) {
-        return false;
-    }
-    const accepted = checkpoint.accepted_identity;
-    const exactLiveContext = stringValue(terminal.native_agent_session_id)?.toLowerCase() ===
-        accepted.native_thread_id &&
-        stringValue(terminal.native_agent_process_uuid) === accepted.process_uuid &&
-        stringValue(terminal.native_agent_process_birth) === accepted.process_birth &&
-        rolloutFileIdentityMatches(terminal.native_agent_rollout, accepted.rollout);
-    if (exactLiveContext)
-        return true;
-    if ("interaction_kind" in inspection) {
-        // Async-question rollout evidence is already exact-file bound, but unlike
-        // blocking request_user_input it has no cross-rollout attribution format
-        // in Codex 0.154/0.155.1. Never follow it to a different live context.
-        return false;
-    }
-    const inventory = terminal._codex_open_root_rollout_inventory;
-    if (!isRecord(inventory))
-        return false;
-    const attribution = detectCodexBoundQuestionnaireAttribution({
-        currentInventory: inventory,
-        acceptedIdentity: {
-            sessionId: accepted.native_thread_id,
-            processUuid: accepted.process_uuid,
-            processBirth: accepted.process_birth,
-            rollout: accepted.rollout
-        },
-        acceptanceId: checkpoint.acceptance_evidence.acceptanceId,
-        screen: {
-            currentStep: inspection.current_step,
-            totalSteps: inspection.total_steps,
-            prompt: inspection.question.prompt,
-            responseKind: inspection.question.response_kind,
-            ...(inspection.question.options
-                ? {
-                    options: inspection.question.options.map((option) => ({
-                        label: option.label,
-                        ...(option.description
-                            ? { description: option.description }
-                            : {})
-                    }))
-                }
-                : {}),
-            exactShape: inspection.status === "actionable" &&
-                inspection.question.response_kind !== "multi_select"
-        }
-    });
-    return attribution.status === "matched";
-}
-function terminalWatchResponseDecision(watch, rawTerminal, surfaceId, promptFingerprint, options, dependencies) {
-    if (watch.status !== "active" ||
-        watch.interaction_policy !== "respond_when_exact" ||
-        isTerminalActivityWatch(watch) ||
-        !terminalWatchCandidateMatchesLiveContext(watch, rawTerminal) ||
-        (watch.callback_route !== undefined &&
-            watch.callback_route.capabilities?.respond !== true)) {
-        return { executable: false, suppress: false };
-    }
-    const terminalControl = terminalControlForWatch(rawTerminal);
-    let blockers;
-    try {
-        blockers = dependencies.terminalIncarnationBlockingTurns(dependencies.storeDirFromOptions(options), terminalControl);
-    }
-    catch {
-        return { executable: false, suppress: false };
-    }
-    let storedWatches;
-    try {
-        storedWatches = createTerminalWatchStore(dependencies.storeDirFromOptions(options), { acquire: dependencies.acquireFileLock }).list();
-    }
-    catch {
-        return { executable: false, suppress: false };
-    }
-    const currentIndex = storedWatches.findIndex((candidate) => candidate.watch_id === watch.watch_id);
-    if (currentIndex < 0) {
-        storedWatches.push(watch);
-    }
-    else {
-        storedWatches[currentIndex] = watch;
-    }
-    const candidates = storedWatches.flatMap((candidate) => {
-        const surfaceCandidate = terminalWatchSurfaceCandidate(candidate, watch, rawTerminal, surfaceId, promptFingerprint);
-        return surfaceCandidate ? [surfaceCandidate] : [];
-    });
-    const fences = [
-        ...blockers.flatMap((turn) => {
-            const fence = managedTerminalInteractionFence(turn, surfaceId, promptFingerprint, watch.agent);
-            return fence ? [fence] : [];
-        }),
-        ...candidates
-            .filter((candidate) => candidate.disposition === "fence")
-            .map((candidate) => ({
-            owner_session: candidate.watch.openclaw_session
-        }))
-    ];
-    if (fences.length > 0) {
-        return {
-            executable: false,
-            suppress: fences.some((fence) => fence.owner_session === watch.openclaw_session)
-        };
-    }
-    const claims = [
-        ...blockers.flatMap((turn) => {
-            const claim = managedTerminalInteractionResponderClaim(turn, surfaceId, promptFingerprint, watch.agent);
-            return claim ? [claim] : [];
-        }),
-        ...candidates
-            .filter((candidate) => candidate.disposition === "responder")
-            .map(({ watch: candidate }) => ({
-            owner_id: candidate.watch_id,
-            owner_session: candidate.openclaw_session,
-            surface_id: surfaceId,
-            responder_class: isUserExplicitFallbackWatch(candidate)
-                ? "exact_request_watch"
-                : "exact_task_watch",
-            response_authority: "executable",
-            created_at: candidate.created_at
-        }))
-    ];
-    const winner = selectTerminalInteractionResponder(claims);
-    const executable = winner?.owner_id === watch.watch_id;
-    return {
-        executable,
-        suppress: Boolean(winner &&
-            !executable &&
-            winner.owner_session === watch.openclaw_session)
-    };
-}
-function terminalWatchSurfaceCandidate(candidate, current, rawTerminal, surfaceId, promptFingerprint) {
-    if (candidate.status !== "active" ||
-        candidate.interaction_policy !== "respond_when_exact" ||
-        isTerminalActivityWatch(candidate) ||
-        candidate.terminal.terminal_id !== current.terminal.terminal_id ||
-        !terminalWatchCandidateMatchesLiveContext(candidate, rawTerminal) ||
-        (candidate.callback_route !== undefined &&
-            candidate.callback_route.capabilities?.respond !== true)) {
-        return undefined;
-    }
-    const persisted = candidate.current_interaction;
-    const samePersistedSurface = Boolean(persisted &&
-        persisted.projection.surface_id === surfaceId &&
-        persisted.projection.prompt_fingerprint === promptFingerprint);
-    if (candidate.watch_id !== current.watch_id) {
-        if (!samePersistedSurface ||
-            !terminalWatchesShareExactTask(candidate, current) ||
-            (persisted.aggregate.state === "pending" &&
-                (persisted.projection.response_authority !== "executable" ||
-                    persisted.projection.capabilities.respond !== true ||
-                    persisted.aggregate.response_authority !== "executable"))) {
-            return undefined;
-        }
-    }
-    return {
-        watch: candidate,
-        disposition: samePersistedSurface && persisted.aggregate.state !== "pending"
-            ? "fence"
-            : "responder"
-    };
-}
-function terminalWatchesShareExactTask(left, right) {
-    const leftKey = terminalWatchExactTaskKey(left);
-    const rightKey = terminalWatchExactTaskKey(right);
-    return leftKey !== undefined && leftKey === rightKey;
-}
-function terminalWatchExactTaskKey(watch) {
-    const anchor = watch.anchor;
-    if (anchor.schema === "agent-knock-knock/codex-paginated-task-anchor") {
-        const checkpoint = watch.observation_checkpoint;
-        const turnId = "schema" in checkpoint && checkpoint.schema === "agent-knock-knock/codex-paginated-task-checkpoint"
-            ? checkpoint.acceptance_evidence?.acceptanceId ?? anchor.turn_id : anchor.turn_id;
-        return turnId ? sha256({ source: "codex_paginated", thread: anchor.native_thread_id,
-            task: turnId, home: anchor.codex_home, process: anchor.process_uuid }) : undefined;
-    }
-    if (anchor.schema ===
-        "agent-knock-knock/codex-human-started-active-task-anchor") {
-        return codexWatchTaskKey({
-            taskId: anchor.turn_id,
-            nativeSessionId: anchor.native_thread_id,
-            processUuid: anchor.process_uuid,
-            processBirth: anchor.process_birth,
-            rollout: anchor.rollout,
-            requestHash: anchor.request_hash
-        });
-    }
-    if (anchor.schema ===
-        "agent-knock-knock/codex-user-explicit-fallback-watch-anchor") {
-        const checkpoint = watch.observation_checkpoint;
-        if (!("schema" in checkpoint) ||
-            checkpoint.schema !==
-                "agent-knock-knock/codex-user-explicit-fallback-watch-checkpoint" ||
-            !checkpoint.accepted_identity ||
-            !checkpoint.acceptance_evidence)
-            return undefined;
-        return codexWatchTaskKey({
-            taskId: checkpoint.acceptance_evidence.acceptanceId,
-            nativeSessionId: checkpoint.accepted_identity.native_thread_id,
-            processUuid: checkpoint.accepted_identity.process_uuid,
-            processBirth: checkpoint.accepted_identity.process_birth,
-            rollout: checkpoint.accepted_identity.rollout,
-            requestHash: anchor.request_hash
-        });
-    }
-    if (anchor.schema ===
-        "agent-knock-knock/claude-human-started-active-task-anchor") {
-        return claudeWatchTaskKey({
-            taskId: anchor.prompt_uuid,
-            nativeSessionId: anchor.session_id,
-            pid: anchor.pid,
-            agentStartedAtMs: anchor.agent_started_at_ms,
-            transcriptFileId: anchor.transcript_file_id,
-            cwd: anchor.cwd,
-            requestHash: anchor.request_hash
-        });
-    }
-    if (anchor.schema ===
-        "agent-knock-knock/claude-user-explicit-fallback-watch-anchor") {
-        const checkpoint = watch.observation_checkpoint;
-        if (!("schema" in checkpoint) ||
-            checkpoint.schema !==
-                "agent-knock-knock/claude-user-explicit-fallback-watch-checkpoint" ||
-            !checkpoint.accepted_prompt_uuid ||
-            !checkpoint.acceptance_evidence)
-            return undefined;
-        const transcriptFileId = stringValue(checkpoint.acceptance_evidence.metadata?.transcript_file_id);
-        if (!transcriptFileId)
-            return undefined;
-        return claudeWatchTaskKey({
-            taskId: checkpoint.accepted_prompt_uuid,
-            nativeSessionId: anchor.transcript_anchor.session_id,
-            pid: anchor.transcript_anchor.pid,
-            agentStartedAtMs: anchor.transcript_anchor.agent_started_at_ms,
-            transcriptFileId,
-            cwd: anchor.transcript_anchor.cwd,
-            requestHash: anchor.request_hash
-        });
-    }
-    return undefined;
-}
-function codexWatchTaskKey(input) {
-    const rollout = isRecord(input.rollout) ? input.rollout : undefined;
-    const device = stringValue(rollout?.device);
-    const inode = stringValue(rollout?.inode);
-    const rolloutPath = stringValue(rollout?.path);
-    if (!device || !inode || !rolloutPath)
-        return undefined;
-    return sha256({
-        agent: "codex",
-        task_id: input.taskId,
-        native_session_id: input.nativeSessionId.toLowerCase(),
-        process_uuid: input.processUuid,
-        process_birth: input.processBirth,
-        rollout: { device, inode, path: rolloutPath },
-        request_hash: input.requestHash
-    });
-}
-function claudeWatchTaskKey(input) {
-    if (!Number.isSafeInteger(input.pid) || input.pid <= 0 ||
-        !Number.isSafeInteger(input.agentStartedAtMs) ||
-        input.agentStartedAtMs <= 0)
-        return undefined;
-    return sha256({
-        agent: "claude",
-        task_id: input.taskId,
-        native_session_id: input.nativeSessionId,
-        pid: input.pid,
-        agent_started_at_ms: input.agentStartedAtMs,
-        transcript_file_id: input.transcriptFileId,
-        cwd: input.cwd,
-        request_hash: input.requestHash
-    });
-}
-function managedTerminalInteractionFence(turn, surfaceId, promptFingerprint, agent) {
-    const ownerSession = stringValue(turn.openclaw_session);
-    const takeover = isRecord(turn.native_session_takeover)
-        ? turn.native_session_takeover
-        : undefined;
-    if (ownerSession &&
-        executorForConversation(turn).kind === agent &&
-        stringValue(takeover?.terminal_bridge_last_interaction_surface_id) ===
-            surfaceId &&
-        stringValue(takeover?.terminal_bridge_last_interaction_fingerprint) ===
-            promptFingerprint &&
-        stringValue(takeover?.terminal_bridge_last_interaction_id) !== undefined &&
-        canonicalTimestamp(takeover?.terminal_bridge_last_interaction_at) !== undefined) {
-        return { owner_session: ownerSession };
-    }
-    const evidence = managedTerminalInteractionEvidence(turn, surfaceId, promptFingerprint, agent);
-    if (!evidence)
-        return undefined;
-    const dispatch = isRecord(evidence.takeover.terminal_bridge_interaction_dispatch)
-        ? evidence.takeover.terminal_bridge_interaction_dispatch
-        : undefined;
-    const dispatchState = stringValue(dispatch?.state);
-    const dispatchMatches = (dispatchState === "reserved" || dispatchState === "uncertain") &&
-        stringValue(dispatch?.interaction_id) ===
-            evidence.projection.interaction_id &&
-        stringValue(dispatch?.interaction_prompt_fingerprint) ===
-            promptFingerprint;
-    return evidence.projection.state === "response_uncertain" || dispatchMatches
-        ? { owner_session: evidence.ownerSession }
-        : undefined;
-}
-function canonicalTimestamp(value) {
-    const timestamp = stringValue(value);
-    return timestamp &&
-        Number.isFinite(Date.parse(timestamp)) &&
-        new Date(timestamp).toISOString() === timestamp
-        ? timestamp
-        : undefined;
-}
-function managedTerminalInteractionResponderClaim(turn, surfaceId, promptFingerprint, agent) {
-    const evidence = managedTerminalInteractionEvidence(turn, surfaceId, promptFingerprint, agent);
-    if (!evidence)
-        return undefined;
-    const createdAt = stringValue(evidence.notification.notified_at);
-    if (!createdAt ||
-        !Number.isFinite(Date.parse(createdAt)) ||
-        new Date(createdAt).toISOString() !== createdAt)
-        return undefined;
-    if (evidence.projection.state !== "pending" ||
-        evidence.projection.capabilities.respond !== true) {
-        return undefined;
-    }
-    return {
-        owner_id: evidence.ownerId,
-        owner_session: evidence.ownerSession,
-        surface_id: surfaceId,
-        responder_class: "managed_turn",
-        response_authority: "executable",
-        created_at: createdAt
-    };
-}
-function managedTerminalInteractionEvidence(turn, surfaceId, promptFingerprint, agent) {
-    const takeover = isRecord(turn.native_session_takeover)
-        ? turn.native_session_takeover
-        : undefined;
-    const notification = isRecord(takeover?.terminal_bridge_interaction_notification)
-        ? takeover.terminal_bridge_interaction_notification
-        : undefined;
-    if (!takeover ||
-        !notification ||
-        stringValue(notification.surface_id) !== surfaceId ||
-        stringValue(notification.prompt_fingerprint) !== promptFingerprint)
-        return undefined;
-    let ownerId;
-    try {
-        ownerId = turnIdForConversation(turn);
-    }
-    catch {
-        return undefined;
-    }
-    const ownerSession = stringValue(turn.openclaw_session);
-    if (!ownerSession)
-        return undefined;
-    const projection = (() => {
-        try {
-            return validateAnyTerminalInteractionProjection(notification.interaction_state);
-        }
-        catch {
-            return undefined;
-        }
-    })();
-    if (!projection ||
-        projection.interaction_id !== stringValue(notification.interaction_id) ||
-        projection.agent !== agent ||
-        projection.questions.length !== 1 ||
-        projection.questions[0]?.question_id !==
-            stringValue(notification.question_id) ||
-        (projection.version === 1
-            ? projection.turn_id !== ownerId
-            : projection.subject.kind !== "managed_turn" ||
-                projection.subject.turn_id !== ownerId))
-        return undefined;
-    return { ownerId, ownerSession, takeover, notification, projection };
-}
-function terminalWatchCandidateMatchesLiveContext(watch, terminal) {
-    if (!terminalMatchesWatch(terminal, watch))
-        return false;
-    if (watch.anchor.schema === "agent-knock-knock/codex-paginated-task-anchor") {
-        return paginatedWatchProcessMatches(terminal, watch.anchor);
-    }
-    const sessionId = stringValue(terminal.native_agent_session_id);
-    if (watch.anchor.schema ===
-        "agent-knock-knock/codex-human-started-active-task-anchor") {
-        return sessionId?.toLowerCase() === watch.anchor.native_thread_id &&
-            rolloutFileIdentityMatches(terminal.native_agent_rollout, watch.anchor.rollout);
-    }
-    if (watch.anchor.schema ===
-        "agent-knock-knock/codex-user-explicit-fallback-watch-anchor") {
-        const checkpoint = watch.observation_checkpoint;
-        return "schema" in checkpoint &&
-            checkpoint.schema ===
-                "agent-knock-knock/codex-user-explicit-fallback-watch-checkpoint" &&
-            checkpoint.accepted_identity !== undefined &&
-            sessionId?.toLowerCase() === checkpoint.accepted_identity.native_thread_id &&
-            rolloutFileIdentityMatches(terminal.native_agent_rollout, checkpoint.accepted_identity.rollout);
-    }
-    if (watch.anchor.schema ===
-        "agent-knock-knock/claude-human-started-active-task-anchor") {
-        return sessionId === watch.anchor.session_id;
-    }
-    if (watch.anchor.schema ===
-        "agent-knock-knock/claude-user-explicit-fallback-watch-anchor") {
-        return sessionId === watch.anchor.transcript_anchor.session_id;
-    }
-    return false;
-}
-function terminalWatchScreenExcerpt(rawTerminal, projectedTerminal) {
-    const direct = stringValue(projectedTerminal.screen_excerpt) ??
-        stringValue(rawTerminal.screen_excerpt);
-    if (direct)
-        return direct;
-    const status = isRecord(rawTerminal._terminal_status_snapshot)
-        ? rawTerminal._terminal_status_snapshot
-        : undefined;
-    const screen = status && isRecord(status.screen) ? status.screen : undefined;
-    return stringValue(screen?.excerpt);
-}
-function terminalWatchManualInteractionSummary(inspection) {
-    const exposeQuestion = inspection.status === "actionable";
-    return {
-        kind: "interaction_kind" in inspection
-            ? inspection.interaction_kind
-            : "questionnaire",
-        response_kind: inspection.question.response_kind,
-        required: inspection.question.required,
-        current_step: inspection.current_step,
-        total_steps: inspection.total_steps,
-        parser_status: inspection.status,
-        ...(exposeQuestion
-            ? {
-                prompt: boundedInteractionText(inspection.question.prompt, 1_000),
-                ...(inspection.question.options &&
-                    inspection.question.options.length > 0
-                    ? {
-                        options: inspection.question.options.slice(0, 8).map((option) => ({
-                            label: boundedInteractionText(option.label, 300),
-                            ...(option.description
-                                ? {
-                                    description: boundedInteractionText(option.description, 600)
-                                }
-                                : {})
-                        }))
-                    }
-                    : {})
-            }
-            : { manual_reason: inspection.reason })
-    };
-}
-function boundedInteractionText(value, maxCharacters) {
-    const normalized = value
-        .replace(/[\u0000-\u001F\u007F-\u009F]+/gu, " ")
-        .replace(/\s+/gu, " ")
-        .trim()
-        .slice(0, maxCharacters);
-    return normalized || "Native questionnaire";
-}
-function fallbackPendingOrTerminalObservation(input) {
-    if (input.exactTerminal.state === "unavailable") {
-        return {
-            ...terminalWatchObservationFence(input.watch),
-            kind: "unavailable",
-            observed_at: input.observedAt,
-            reason_code: input.reasonCode ?? "terminal_observation_unavailable"
-        };
-    }
-    if (input.exactTerminal.state === "absent" || !input.rawTerminal) {
-        return invalidatedObservation(input.watch, input.observedAt, "terminal_process_unavailable");
-    }
-    if (!input.terminalMatches) {
-        return invalidatedObservation(input.watch, input.observedAt, "terminal_identity_changed");
-    }
-    if (input.reasonCode) {
-        return {
-            ...terminalWatchObservationFence(input.watch),
-            kind: "unavailable",
-            observed_at: input.observedAt,
-            reason_code: input.reasonCode
-        };
-    }
-    return fallbackPendingObservation(input.watch, input.observedAt, input.observedEndOffsetBytes, input.observationCheckpoint);
-}
-function fallbackPendingObservation(watch, observedAt, observedEndOffsetBytes, observationCheckpoint) {
-    const effectiveCheckpoint = observationCheckpoint ?? (watch.anchor.schema ===
-        "agent-knock-knock/codex-user-explicit-fallback-watch-anchor"
-        ? watch.observation_checkpoint
-        : undefined);
-    const safeResumeOffsetBytes = effectiveCheckpoint
-        ?.safe_resume_offset_bytes ?? fallbackResumeOffset(watch, observedEndOffsetBytes);
-    return {
-        ...terminalWatchObservationFence(watch),
-        kind: "pending",
-        observed_at: observedAt,
-        safe_resume_offset_bytes: safeResumeOffsetBytes,
-        ...(effectiveCheckpoint
-            ? { observation_checkpoint: effectiveCheckpoint }
-            : {})
-    };
-}
-function codexFallbackObservationCheckpoint(watch) {
-    const checkpoint = watch.observation_checkpoint;
-    if (!("schema" in checkpoint) ||
-        checkpoint.schema !==
-            "agent-knock-knock/codex-user-explicit-fallback-watch-checkpoint") {
-        throw new Error("Codex fallback Watch has no exact acceptance checkpoint");
-    }
-    return checkpoint;
-}
-function claudeFallbackObservationCheckpoint(watch) {
-    const checkpoint = watch.observation_checkpoint;
-    if (!("schema" in checkpoint) ||
-        checkpoint.schema !==
-            "agent-knock-knock/claude-user-explicit-fallback-watch-checkpoint") {
-        throw new Error("Claude fallback Watch has no exact acceptance checkpoint");
-    }
-    return checkpoint;
-}
-function codexFallbackAcceptedCheckpoint(watch, acceptanceEvidence, currentIdentity) {
-    const nativeThreadId = requiredString(currentIdentity.sessionId, "accepted Codex native thread id");
-    const processUuid = requiredString(currentIdentity.processUuid, "accepted Codex process UUID");
-    const processBirth = requiredString(currentIdentity.processBirth, "accepted Codex process birth");
-    const rollout = currentIdentity.rollout;
-    if (!rollout) {
-        throw new Error("accepted Codex rollout identity is unavailable");
-    }
-    const acceptanceOffset = numericMetadata(acceptanceEvidence.metadata, "observed_end_offset_bytes");
-    if (acceptanceOffset === undefined) {
-        throw new Error("accepted Codex rollout boundary is unavailable");
-    }
-    return {
-        schema: "agent-knock-knock/codex-user-explicit-fallback-watch-checkpoint",
-        version: 1,
-        safe_resume_offset_bytes: fallbackResumeOffset(watch, acceptanceOffset),
-        acceptance_evidence: acceptanceEvidence,
-        accepted_identity: {
-            native_thread_id: nativeThreadId,
-            process_uuid: processUuid,
-            process_birth: processBirth,
-            rollout
-        }
-    };
-}
-function claudeFallbackAcceptedCheckpoint(watch, acceptanceEvidence) {
-    const acceptanceOffset = numericMetadata(acceptanceEvidence.metadata, "observed_end_offset_bytes");
-    if (acceptanceOffset === undefined) {
-        throw new Error("accepted Claude transcript boundary is unavailable");
-    }
-    const promptUuid = requiredString(acceptanceEvidence.acceptanceId, "accepted Claude prompt UUID");
-    return {
-        schema: "agent-knock-knock/claude-user-explicit-fallback-watch-checkpoint",
-        version: 1,
-        safe_resume_offset_bytes: fallbackResumeOffset(watch, acceptanceOffset),
-        acceptance_evidence: acceptanceEvidence,
-        accepted_prompt_uuid: promptUuid
-    };
-}
-function fallbackCompletionObservation(watch, observedAt, completion, observedEndOffsetBytes, observationCheckpoint) {
-    const safeResumeOffsetBytes = observationCheckpoint
-        ?.safe_resume_offset_bytes ?? fallbackResumeOffset(watch, observedEndOffsetBytes);
-    const kind = completion.outcome === "failure" ? "failed" : "completed";
-    return {
-        ...terminalWatchObservationFence(watch),
-        kind,
-        observed_at: observedAt,
-        safe_resume_offset_bytes: safeResumeOffsetBytes,
-        ...(observationCheckpoint
-            ? { observation_checkpoint: observationCheckpoint }
-            : {}),
-        evidence_fingerprint: sha256({
-            kind,
-            watch_id: watch.watch_id,
-            completion_id: completion.id ?? null,
-            completion_timestamp: completion.timestamp ?? null,
-            anchor_fingerprint: watch.anchor.anchor_fingerprint
-        }),
-        reason_code: completion.outcome === "failure"
-            ? "anchored_task_failed"
-            : "anchored_task_completed",
-        completion_text: completion.text.slice(0, 4000),
-        completion_id: completion.id,
-        completion_timestamp: completion.timestamp
-    };
-}
-function fallbackResumeOffset(watch, observedEndOffsetBytes) {
-    return Math.max(watch.observation_checkpoint.safe_resume_offset_bytes, Number.isSafeInteger(observedEndOffsetBytes) &&
-        Number(observedEndOffsetBytes) >= 0
-        ? Number(observedEndOffsetBytes)
-        : 0);
-}
-function numericMetadata(metadata, field) {
-    const value = metadata?.[field];
-    return Number.isSafeInteger(value) && Number(value) >= 0
-        ? Number(value)
-        : undefined;
-}
-function retryableProviderError(error) {
-    return isRecord(error) && typeof error.code === "string" && new Set([
-        "EACCES", "EAGAIN", "EBUSY", "EIO", "EMFILE", "ENFILE", "ENOENT",
-        "EPERM", "ESTALE", "ETIMEDOUT"
-    ]).has(error.code);
-}
-function claudeObservationCheckpoint(watch) {
-    const checkpoint = watch.observation_checkpoint;
-    if (!("schema" in checkpoint) ||
-        checkpoint.schema !==
-            "agent-knock-knock/claude-human-started-active-task-checkpoint") {
-        throw new Error("Claude terminal Watch has no continuation checkpoint");
-    }
-    return checkpoint;
-}
-async function currentTerminalForWatch(watch, options, dependencies) {
-    return dependencies.observeExactTerminal({
-        options,
-        terminalId: watch.terminal.terminal_id
-    });
-}
-function terminalMatchesWatch(terminal, watch) {
-    try {
-        return terminalAgent(terminal) === watch.agent &&
-            requiredString(terminal.id, "terminal id") ===
-                watch.terminal.terminal_id &&
-            terminalWorkspace(terminal) === watch.terminal.workspace &&
-            isRecord(terminal.terminal_control) &&
-            sameTerminalControlEvidenceIncarnation(terminal.terminal_control, watch.terminal.terminal_endpoint);
-    }
-    catch {
-        return false;
-    }
-}
-function terminalActivityWatchIdentityMatch(terminal, watch) {
-    try {
-        if (!isTerminalActivityWatch(watch) ||
-            terminalAgent(terminal) !== watch.agent ||
-            requiredString(terminal.id, "terminal id") !==
-                watch.terminal.terminal_id ||
-            terminalWorkspace(terminal) !== watch.terminal.workspace ||
-            positiveInteger(terminal.pid, "terminal PID") !== watch.anchor.pid) {
-            return "mismatch";
-        }
-        if (!isRecord(terminal.terminal_control)) {
-            return "unavailable";
-        }
-        if (!sameTerminalControlEvidenceIncarnation(terminal.terminal_control, watch.terminal.terminal_endpoint)) {
-            return "mismatch";
-        }
-        const processUuid = stringValue(terminal.native_agent_process_uuid);
-        const processBirth = stringValue(terminal.native_agent_process_birth);
-        if ((watch.anchor.native_process_uuid !== undefined && !processUuid) ||
-            (watch.anchor.native_process_birth !== undefined && !processBirth)) {
-            return "unavailable";
-        }
-        return (watch.anchor.native_process_uuid !== undefined &&
-            processUuid !== watch.anchor.native_process_uuid) || (watch.anchor.native_process_birth !== undefined &&
-            processBirth !== watch.anchor.native_process_birth)
-            ? "mismatch"
-            : "match";
-    }
-    catch {
-        return "unavailable";
-    }
-}
-function terminalMatchesUserExplicitFallbackWatch(terminal, watch) {
-    try {
-        if (!isUserExplicitFallbackWatch(watch) ||
-            terminalAgent(terminal) !== watch.agent ||
-            requiredString(terminal.id, "terminal id") !==
-                watch.terminal.terminal_id ||
-            terminalWorkspace(terminal) !== watch.terminal.workspace ||
-            !isRecord(terminal.terminal_control) ||
-            !sameTerminalControlEvidenceIncarnation(terminal.terminal_control, watch.terminal.terminal_endpoint)) {
-            return false;
-        }
-        if (watch.anchor.schema ===
-            "agent-knock-knock/codex-user-explicit-fallback-watch-anchor") {
-            return requiredString(terminal.native_agent_process_uuid, "Codex process UUID") === watch.anchor.acceptance_anchor.process_uuid &&
-                requiredString(terminal.native_agent_process_birth, "Codex process birth") === watch.anchor.acceptance_anchor.process_birth;
-        }
-        return watch.anchor.schema ===
-            "agent-knock-knock/claude-user-explicit-fallback-watch-anchor" &&
-            positiveInteger(terminal.pid, "Claude PID") ===
-                watch.anchor.transcript_anchor.pid;
-    }
-    catch {
-        return false;
-    }
-}
-function terminalActivityObservationCheckpoint(watch) {
-    const checkpoint = watch.observation_checkpoint;
-    if (!("schema" in checkpoint) ||
-        checkpoint.schema !==
-            "agent-knock-knock/terminal-activity-watch-checkpoint") {
-        throw new Error("terminal activity Watch has no activity checkpoint");
-    }
-    return checkpoint;
-}
-function terminalWatchIdentity(terminal, bindingToken) {
-    const terminalControl = terminal.terminal_control;
-    return {
-        terminal_id: requiredString(terminal.id, "terminal id"),
-        terminal_endpoint: terminalControlEvidence(terminalControl),
-        workspace: terminalWorkspace(terminal),
-        binding_token: bindingToken
-    };
-}
-function codexIdentity(terminal) {
-    if (!isRecord(terminal.native_agent_rollout)) {
-        throw new Error("Codex terminal has no exact rollout identity");
-    }
-    return {
-        sessionId: requiredString(terminal.native_agent_session_id, "Codex native thread id"),
-        processUuid: requiredString(terminal.native_agent_process_uuid, "Codex process UUID"),
-        processBirth: requiredString(terminal.native_agent_process_birth, "Codex process birth"),
-        rollout: {
-            fd: requiredString(terminal.native_agent_rollout.fd, "Codex rollout fd"),
-            device: requiredString(terminal.native_agent_rollout.device, "Codex rollout device"),
-            inode: requiredString(terminal.native_agent_rollout.inode, "Codex rollout inode"),
-            path: requiredString(terminal.native_agent_rollout.path, "Codex rollout path")
-        }
-    };
-}
-function codexIdentityForWatch(watch) {
-    if (watch.agent !== "codex" ||
-        watch.anchor.schema !==
-            "agent-knock-knock/codex-human-started-active-task-anchor") {
-        throw new Error("terminal Watch has no Codex identity");
-    }
-    return {
-        sessionId: watch.anchor.native_thread_id,
-        processUuid: watch.anchor.process_uuid,
-        processBirth: watch.anchor.process_birth,
-        rollout: watch.anchor.rollout
-    };
-}
 function watchStatusInteractionAccess(watch, options) {
     if (!Object.hasOwn(options, "openclawSession"))
         return false;
@@ -2324,122 +460,4 @@ function watchStatusInteractionAccess(watch, options) {
     }
     return true;
 }
-function approvalFingerprint(terminal) {
-    if (terminal.activity_state !== "awaiting_approval")
-        return undefined;
-    const approval = isRecord(terminal.approval_state)
-        ? terminal.approval_state
-        : undefined;
-    const fingerprint = stringValue(approval?.fingerprint);
-    return fingerprint && /^[a-f0-9]{64}$/u.test(fingerprint)
-        ? fingerprint
-        : undefined;
-}
-function invalidatedObservation(watch, observedAt, reasonCode) {
-    return {
-        ...terminalWatchObservationFence(watch),
-        kind: "invalidated",
-        observed_at: observedAt,
-        evidence_fingerprint: sha256({
-            watch_id: watch.watch_id,
-            reason_code: reasonCode,
-            anchor_fingerprint: watch.anchor.anchor_fingerprint
-        }),
-        reason_code: reasonCode
-    };
-}
-function terminalAgent(terminal) {
-    const agent = stringValue(terminal.agent);
-    if (agent !== "codex" && agent !== "claude") {
-        throw new Error("terminal Watch supports only Codex or Claude Code");
-    }
-    return agent;
-}
-function terminalWorkspace(terminal) {
-    const workspace = requiredString(terminal.workspace ?? terminal.cwd, "terminal workspace");
-    if (!path.isAbsolute(workspace)) {
-        throw new Error("terminal workspace must be absolute");
-    }
-    return path.resolve(workspace);
-}
-function requiredWatchId(value) {
-    const watchId = requiredString(value, "--watch");
-    if (!/^terminal-watch-[A-Za-z0-9._:-]+$/u.test(watchId)) {
-        throw new Error("--watch must be an exact Terminal Watch id");
-    }
-    return watchId;
-}
-function requiredString(value, label) {
-    const result = stringValue(value);
-    if (!result || result.includes("\0")) {
-        throw new Error(`${label} is required`);
-    }
-    return result;
-}
-function requiredSha256(value, label) {
-    const result = requiredString(value, label);
-    if (!/^[a-f0-9]{64}$/u.test(result)) {
-        throw new Error(`${label} must be exactly 64 lowercase ASCII hexadecimal characters`);
-    }
-    return result;
-}
-function requiredTimestamp(value, label) {
-    const result = requiredString(value, label);
-    if (!Number.isFinite(Date.parse(result))) {
-        throw new Error(`${label} must be a valid timestamp`);
-    }
-    return result;
-}
-function parseWatchInteractionResponse(value) {
-    const serialized = requiredString(value, "--response-json");
-    try {
-        const parsed = JSON.parse(serialized);
-        if (!isRecord(parsed)) {
-            throw new Error("response must be an object");
-        }
-        return parsed;
-    }
-    catch (error) {
-        throw new Error(`--response-json is invalid: ${safeDiagnostic(error)}`);
-    }
-}
-function assertWatchControllerSession(watch, requestedValue) {
-    const requested = stringValue(requestedValue);
-    if (!requested || requested !== watch.openclaw_session) {
-        throw new Error(`terminal Watch ${watch.watch_id} belongs to a different controller session; no terminal input was sent`);
-    }
-}
-function requiredExecutableWatchInteraction(watch, interactionId, expectedFingerprint) {
-    if (watch.status !== "active") {
-        throw new Error(`terminal Watch ${watch.watch_id} is ${watch.status}`);
-    }
-    const interaction = watch.current_interaction;
-    if (watch.interaction_policy !== "respond_when_exact" ||
-        !interaction ||
-        interaction.aggregate.state !== "pending" ||
-        interaction.projection.interaction_id !== interactionId ||
-        interaction.projection.prompt_fingerprint !== expectedFingerprint ||
-        interaction.projection.response_authority !== "executable" ||
-        !interaction.projection.capabilities.respond) {
-        throw new Error("terminal Watch has no matching executable interaction offer; refresh status");
-    }
-    return interaction;
-}
-function positiveInteger(value, label) {
-    const result = Number(value);
-    if (!Number.isSafeInteger(result) || result <= 0) {
-        throw new Error(`${label} must be a positive integer`);
-    }
-    return result;
-}
-function positiveMinutes(value, fallback) {
-    const result = value === undefined ? fallback : Number(value);
-    if (!Number.isFinite(result) || result <= 0) {
-        throw new Error("--hard-timeout-minutes must be a positive number");
-    }
-    return result;
-}
-function sha256(value) {
-    return createHash("sha256").update(JSON.stringify(value)).digest("hex");
-}
 //# sourceMappingURL=terminal-watch-cli-adapter.js.map