@scotthuang/agent-knock-knock 0.13.2 → 0.13.4

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

@@ -1,27 +1,26 @@
 // Infrastructure composition for terminal list discovery and selector projection.
 import { AsyncLocalStorage } from "node:async_hooks";
-import fs from "node:fs";
 import path from "node:path";
 import { listDeferredForegroundTransfers } from "./deferred-foreground-transfer.js";
-import { isFinalDeferredForegroundTransferStatus } from "./deferred-foreground-transfer-policy.js";
-import { humanObservedHandoffBindingToken, isExactNativeThreadId, managedSessionBindingToken, managedSessionRevision, unmanagedTerminalBindingToken } from "./managed-session.js";
-import { executorForConversation, isSessionSendBlockingStatus, isTerminalDispatchOwnerReleasedStatus, resolveExecutor, sessionIdForConversation, turnIdForConversation } from "./protocol.js";
+import { isExactNativeThreadId, unmanagedTerminalBindingToken } from "./managed-session.js";
+import { executorForConversation, resolveExecutor, sessionIdForConversation } from "./protocol.js";
 import { resolveSessionSelector, sessionShortRef } from "./session-selector.js";
 import { projectSessionSelectorCandidate } from "./terminal-selector-projection-service.js";
-import { listManagedSessions, loadNativeThreadTransition, nativeThreadTransitionsDir, tryLoadManagedSession } from "./session-store.js";
+import { listManagedSessions, tryLoadManagedSession } from "./session-store.js";
 import { defaultStoreDir, ensureStoreWritable, inspectStoreCompatibility, listConversations, storeManifestPath, STORE_SESSION_AUTHORITY_PROTOCOL } from "./store.js";
-import { parseTerminalConversationId } from "./terminal-agent-adapter.js";
 import { exactCodexReadyStyledComposerCapture } from "./terminal-agent-bridge.js";
 import { captureCodexHumanStartedActiveTaskAnchor } from "./terminal-submission-acceptance.js";
-import { applySessionAuthorityToDispatch, authoritativeTerminalIdentity, compareManagedConversationRecency, decideManagedTerminalAssociation, decideLocalTerminalDispatchOwnership, decideTerminalSendAuthority, decideTerminalSessionAuthorityConflict, decideTerminalUserExplicitSendAuthority, managedTurnNeedsAttention as terminalManagedTurnNeedsAttention, nonOwnerTerminalActions, projectBlockingTurn, projectHandoffDecision, projectHandoffPresentation, projectPublicManagementConflict, projectReconcileBindingAction, projectTerminalDispatchConflict, projectTerminalManagement, selectManagedTerminalHistory, selectTerminalAvailableActions } from "./terminal-action-projection.js";
-import { childProcessIdsForRoot, decideManagedBindingConflict, deferredCodexForegroundBindingToken, exactBoundCodexSendSource, isCompleteNativeRollout, nativeAgentIdentityMatchesTurn, processIncarnationRelationship, selectRootTerminalProcesses, terminalControlAliasMatches, terminalControlsShareIncarnation, verifiedEmptyCodexHandoffToken } from "./terminal-authority-policy.js";
-import { decideTerminalBindingMatch, terminalObservationFromListEntry } from "./terminal-binding-authority.js";
-import { decideTerminalScopedCodexApprovalAuthority, terminalScopedCodexApprovalPromptSnapshot } from "./terminal-scoped-approval-authority.js";
-import { sameCanonicalStatePath } from "./terminal-dispatch-ledger-codec.js";
-import * as dispatch from "./terminal-dispatch-policy.js";
-import { actionsForManagedSessionBinding, currentTerminalActions, listActionContracts, readOnlyListActions, readOnlyManagedTurn, userReleaseListActions, userReleasableManagedTurn, renderAvailableListActions, renderCurrentManagedTurn, renderHistoricalManagedTurn, renderManagedTurnListEntry, safeUnavailableManagedTurnActions, sendActionForManagedSession, withoutGenericHandoffSourceClose } from "./terminal-list-renderer.js";
-import { hasCanonicalTerminalEndpoint, terminalControlEvidenceMatches } from "./terminal-control-ref.js";
-import { validTerminalMonitorTimestampMs as validTimestampMs } from "./terminal-monitor-decision-policy.js";
+import { decideTerminalUserExplicitSendAuthority } from "./terminal-action-projection.js";
+import { materializeModelControlAvailability } from "./terminal-model-control-availability.js";
+import { terminalModelControlPlanConforms } from "./terminal-model-control.js";
+import { childProcessIdsForRoot, terminalControlsShareIncarnation } from "./terminal-authority-policy.js";
+import { terminalScopedCodexApprovalPromptSnapshot } from "./terminal-scoped-approval-authority.js";
+import { listActionContracts, renderAvailableListActions, renderTerminalModelControlActions } from "./terminal-list-renderer.js";
+import { collectTerminalListInventory } from "./terminal-list-inventory.js";
+import { collectTerminalListTerminalFacts } from "./terminal-list-facts.js";
+import { decideTerminalListActions, modelControlPolicyFacts } from "./terminal-list-action-policy.js";
+import { createTerminalListOwnershipService } from "./terminal-list-ownership-service.js";
+import { createTerminalListProjectionService } from "./terminal-list-projection-service.js";
 import { isRecord, nonBlankString as stringValue } from "./value-guards.js";
 import { expandHome, writeCliJson as printJson } from "./cli-command-runtime.js";
 import { cliCwd, cliNowMs, cliRuntimeLog as runtimeLog } from "./cli-runtime-context.js";
@@ -33,16 +32,43 @@ function terminalListRuntime() {
     }
     return runtime;
 }
+function terminalListOwnershipService() {
+    return terminalListRuntime().ownershipService;
+}
+function terminalListProjectionService() {
+    return terminalListRuntime().projectionService;
+}
 function withTerminalListRuntime(runtime, operation) {
     return terminalListRuntimeContext.run(runtime, operation);
 }
 export function createTerminalListCliFacade(dependencies) {
+    const ownershipService = createTerminalListOwnershipService({
+        ...dependencies.store,
+        ...dependencies.authority,
+        codexProcessIncarnationForPid: dependencies.discovery.codexProcessIncarnationForPid,
+        currentWorkingDirectory: cliCwd,
+        runtimeLog
+    });
+    const projectionService = createTerminalListProjectionService({
+        approvalTtlMs: dependencies.policy.approvalTtlMs,
+        callbackRetryDisposition: dependencies.store.callbackRetryDisposition,
+        isVerifiedDeadTerminalAgentProcess: dependencies.store.isVerifiedDeadTerminalAgentProcess,
+        listDeferredForegroundTransfers,
+        nowMs: cliNowMs,
+        ownershipService,
+        summarizeConversation: dependencies.store.summarizeConversation,
+        terminalBridgeEnabled: dependencies.store.terminalBridgeEnabled,
+        terminalBridgeSubmission: dependencies.store.terminalBridgeSubmission,
+        terminalControlFromTakeover: dependencies.store.terminalControlFromTakeover
+    });
     const runtime = {
         ...dependencies.reconciliation,
         ...dependencies.discovery,
         ...dependencies.store,
         ...dependencies.authority,
-        ...dependencies.policy
+        ...dependencies.policy,
+        ownershipService,
+        projectionService
     };
     const call = (operation) => withTerminalListRuntime(runtime, operation);
     return {
@@ -203,7 +229,7 @@ function projectTerminalListScan(input) {
     let projection;
     if (managementErrors.length === 0) {
         try {
-            projection = terminalFirstListProjection({
+            projection = terminalListProjectionService().projectTerminalFirstList({
                 storeDir,
                 terminals: physicalTerminals,
                 managedSessions,
@@ -350,290 +376,36 @@ async function reconcileStoreForList(storeDir, options) {
         idle_timeout_minutes: idle.idle_timeout_minutes
     };
 }
-async function buildTerminalListGroup({ options, agentFilter, statusFilter, terminalId }) {
-    const empty = {
-        terminalControlled: [],
-        summary: {
-            enabled: false,
-            agents: [],
-            error: undefined
-        }
-    };
-    if (options.managedOnly) {
-        return empty;
-    }
-    const registry = terminalListRuntime().createRuntimeTerminalAgentRegistry(options);
-    const adapters = agentFilter
-        ? [registry.get(agentFilter)].filter((adapter) => adapter !== undefined)
-        : registry.list();
-    if (agentFilter && adapters.length === 0) {
-        return {
-            ...empty,
-            summary: {
-                enabled: true,
-                agents: [],
-                skipped: `terminal agent adapter is not registered for ${agentFilter}`
-            }
-        };
-    }
-    const terminalProvider = terminalListRuntime().createTerminalControlProvider(options);
-    const bridge = terminalListRuntime().createTerminalAgentBridge(options, terminalProvider, registry);
-    const terminalDiagnostics = options.terminalDebug
-        ? await terminalControlDiagnostics(terminalProvider)
-        : undefined;
-    const exactTarget = terminalId
-        ? exactTerminalTargetDiagnostic(terminalId)
-        : undefined;
-    if (terminalId) {
-        runtimeLog("info", "terminal_exact_scan", {
-            stage: "started",
-            terminal_id: terminalId,
-            target: exactTarget
-        });
-    }
-    const terminalControlled = [];
-    let activeCount = 0;
-    const errors = [];
-    try {
-        const processSource = terminalListRuntime().createTerminalProcessSource(options);
-        const snapshots = await processSource.listProcessSnapshots((snapshot) => adapters.some((adapter) => adapter.capabilities.processDiscovery && adapter.classifyProcess(snapshot) !== undefined), { includeAncestors: true });
-        if (terminalId) {
-            const targetPid = exactTarget?.pid;
-            runtimeLog("info", "terminal_exact_scan", {
-                stage: "process_inventory",
-                terminal_id: terminalId,
-                target_pid: targetPid,
-                snapshot_count: snapshots.length,
-                target_process_found: targetPid === undefined
-                    ? undefined
-                    : snapshots.some((snapshot) => snapshot.pid === targetPid),
-                target_process_snapshots: targetPid === undefined
-                    ? []
-                    : snapshots
-                        .filter((snapshot) => snapshot.pid === targetPid)
-                        .map((snapshot) => ({ pid: snapshot.pid, ppid: snapshot.ppid }))
-            });
-        }
-        const activeSessions = await bridge.listProcesses(snapshots, adapters.map((adapter) => adapter.agent));
-        const rootSessions = selectRootTerminalProcesses(activeSessions, snapshots);
-        const controlledSessions = rootSessions.filter((session) => session.terminalControl !== undefined);
-        if (terminalId) {
-            const targetPid = exactTarget?.pid;
-            const targetSessions = targetPid === undefined
-                ? []
-                : activeSessions.filter((session) => session.pid === targetPid);
-            runtimeLog("info", "terminal_exact_scan", {
-                stage: "process_classification_and_association",
-                terminal_id: terminalId,
-                target_pid: targetPid,
-                classified_process_count: activeSessions.length,
-                root_process_count: rootSessions.length,
-                controlled_process_count: controlledSessions.length,
-                target_classified_count: targetSessions.length,
-                target_controlled_count: targetSessions.filter((session) => session.terminalControl !== undefined).length,
-                target_sessions: targetSessions.map((session) => ({
-                    agent: session.agent,
-                    pid: session.pid,
-                    ppid: session.ppid,
-                    kind: session.kind,
-                    confidence: session.confidence,
-                    selected_as_root: rootSessions.includes(session),
-                    terminal_conversation_id: session.terminalControl
-                        ? bridge.terminalConversationId(session)
-                        : undefined,
-                    terminal_control: terminalControlScanDiagnostic(session.terminalControl)
-                }))
-            });
-        }
-        activeCount = controlledSessions.length;
-        const selectedSessions = terminalId
-            ? activeSessions.filter((session) => session.terminalControl !== undefined &&
-                bridge.terminalConversationId(session) === terminalId)
-            : controlledSessions;
-        for (const session of selectedSessions) {
-            try {
-                terminalControlled.push(await terminalControlledListEntry(session, activeSessions, options, bridge));
-            }
-            catch (error) {
-                errors.push(`terminal process ${session.pid}: ` +
-                    (error instanceof Error ? error.message : String(error)));
-            }
-        }
-    }
-    catch (error) {
-        errors.push(error instanceof Error ? error.message : String(error));
-    }
-    if (terminalId) {
-        runtimeLog("info", "terminal_exact_scan", {
-            stage: "complete",
-            terminal_id: terminalId,
-            controlled_process_count: activeCount,
-            terminal_row_count: terminalControlled.length,
-            terminal_row_ids: terminalControlled.map((terminal) => terminal.id),
-            errors
-        });
-    }
-    return {
-        terminalControlled,
-        summary: {
-            enabled: true,
-            agents: adapters.map((adapter) => adapter.agent),
-            active_count: activeCount,
-            terminal_count: terminalControlled.length,
-            approval_scan: options.noApprovalScan ? "disabled" : "enabled",
-            diagnostics: terminalDiagnostics,
-            error: errors.length > 0 ? errors.join("; ") : undefined
+async function buildTerminalListGroup({ options, agentFilter, statusFilter: _statusFilter, terminalId }) {
+    const runtime = terminalListRuntime();
+    return collectTerminalListInventory({
+        options,
+        agentFilter,
+        terminalId,
+        ports: {
+            createRegistry: (currentOptions) => runtime.createRuntimeTerminalAgentRegistry(currentOptions),
+            createBridge: (currentOptions, provider, registry) => runtime.createTerminalAgentBridge(currentOptions, provider, registry),
+            createProvider: (currentOptions) => runtime.createTerminalControlProvider(currentOptions),
+            createProcessSource: (currentOptions) => runtime.createTerminalProcessSource(currentOptions),
+            projectTerminal: ({ session, activeSessions, options: currentOptions, bridge }) => terminalControlledListEntry(session, activeSessions, currentOptions, bridge),
+            log: runtimeLog
         }
-    };
-}
-function exactTerminalTargetDiagnostic(terminalId) {
-    try {
-        const parsed = parseTerminalConversationId(terminalId);
-        return parsed ? {
-            provider: parsed.kind,
-            agent: parsed.agent,
-            route: parsed.target,
-            pid: parsed.pid
-        } : undefined;
-    }
-    catch (error) {
-        return {
-            parse_error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-function terminalControlScanDiagnostic(terminalControl) {
-    if (!terminalControl) {
-        return undefined;
-    }
-    const control = terminalControl;
-    return {
-        kind: terminalControl.kind,
-        target: terminalControl.target,
-        pane_pid: control.panePid,
-        process_anchor_pid: control.processAnchorPid,
-        endpoint_key: control.endpointKey,
-        resource_key: control.resourceKey,
-        terminal_id: control.terminalId
-    };
-}
-async function terminalControlDiagnostics(provider) {
-    return provider.diagnostics();
-}
-function managedTurnListEntry(task, { terminalBridge = false, approvalState, conversation } = {}) {
-    return renderManagedTurnListEntry(task, {
-        terminalBridge,
-        approvalState,
-        actionFacts: managedTurnListActionFacts(task, conversation)
     });
 }
-function managedTurnListActionFacts(task, conversation) {
-    const nativeTakeover = isRecord(conversation?.native_session_takeover)
-        ? conversation.native_session_takeover
-        : undefined;
-    const managedApprovalPending = isRecord(nativeTakeover?.terminal_bridge_approval);
-    const terminalBridgeReady = Boolean(conversation &&
-        terminalListRuntime().terminalBridgeEnabled(conversation) &&
-        terminalListRuntime().terminalControlFromTakeover(nativeTakeover) !== undefined);
-    const submission = terminalListRuntime().terminalBridgeSubmission(conversation);
-    const renewEligible = Boolean(terminalBridgeReady &&
-        task.status === "stalled" &&
-        submission?.status !== "uncertain" &&
-        !terminalListRuntime().isVerifiedDeadTerminalAgentProcess(conversation ?? {}));
-    const callbackDelivery = isRecord(conversation?.callback_delivery)
-        ? conversation.callback_delivery
-        : undefined;
-    const retryCallbackEligible = Boolean(conversation &&
-        conversation.legacy_callback_status_error === undefined &&
-        terminalListRuntime().callbackRetryDisposition(callbackDelivery).state ===
-            "retryable");
-    const retrySubmissionCandidate = Boolean(conversation &&
-        executorForConversation(conversation).kind === "codex" &&
-        terminalBridgeReady &&
-        task.status === "stalled" &&
-        submission?.status === "uncertain" &&
-        stringValue(submission.last_proven_stage) === "text_injected");
-    return {
-        terminalBridgeReady,
-        managedApprovalPending,
-        renewEligible,
-        retryCallbackEligible,
-        retrySubmissionCandidate
-    };
-}
 async function terminalControlledListEntry(session, activeSessions, options, bridge = terminalListRuntime().createTerminalAgentBridge(options)) {
     const terminalControl = session.terminalControl;
     if (!terminalControl) {
         throw new Error(`process ${session.pid} is not terminal-controlled`);
     }
-    const terminalState = await listStateForTerminal(session.agent, terminalControl, options, bridge, {
-        pid: session.pid,
-        cwd: session.cwd,
-        // Raw Codex status and approval use the exact full terminal selector as
-        // their runtime conversation identity. Use the same identity while
-        // projecting list actions so a prompt-bound terminal token can be
-        // revalidated by the later status/approve calls.
-        ...(session.agent === "codex"
-            ? { conversationId: bridge.terminalConversationId(session) }
-            : { sessionId: session.sessionId }),
-        terminalTarget: terminalControl.target
-    });
-    const { orphanedDispatch, nativeIdentityObservation, nativeAgentIdentity, authorityNativeIdentityObservation, authorityNativeAgentIdentity, codexOpenRootRolloutInventory, nativeProcessUuid, nativeProcessBirth, nativeProcessEvidence } = await observeTerminalNativeListIdentity(session, terminalControl, options, bridge);
-    const effectiveTerminalState = effectiveTerminalListState({
-        session,
-        terminalState,
-        nativeIdentityObservation,
-        nativeAgentIdentity,
-        nativeIdentityAuthorityObservation: authorityNativeIdentityObservation,
-        codexOpenRootRolloutInventory,
-        nativeProcessUuid,
-        nativeProcessBirth
-    });
-    const terminalStatusSnapshot = effectiveTerminalState._terminal_status_snapshot
-        ? terminalBridgeStatusWithProjection(effectiveTerminalState._terminal_status_snapshot, effectiveTerminalState)
-        : undefined;
-    const statusCardObservation = session.agent === "codex" &&
-        typeof effectiveTerminalState.screen_excerpt === "string"
-        ? bridge.registry.require("codex").observeThreadLifecycle?.({
-            operation: { kind: "new_thread" },
-            phase: "before",
-            screen: effectiveTerminalState.screen_excerpt
-        })
-        : undefined;
-    const statusCardNativeThreadId = statusCardObservation?.status === "observed" &&
-        effectiveTerminalState.activity_state === "idle" &&
-        effectiveTerminalState.approval_state.blocked !== true &&
-        isExactNativeThreadId(statusCardObservation.nativeThreadId)
-        ? statusCardObservation.nativeThreadId
-        : undefined;
-    const agentVersion = terminalListRuntime().agentVersionForRunningProcess(session.agent, session.pid, options);
-    const lifecycleCapability = bridge.registry.require(session.agent)
-        .probeThreadLifecycle?.(agentVersion) ?? {
-        status: "unsupported",
-        agentVersion,
-        newThread: false,
-        resumeExact: false,
-        reason: "native thread lifecycle is unavailable"
-    };
-    const nativeInspectionCapability = bridge.registry.require(session.agent)
-        .probeNativeInspection?.(agentVersion) ?? {
-        status: "unsupported",
-        agentVersion,
-        statusInspection: false,
-        reason: "native inspection is unavailable"
-    };
-    const compatibilityWarnings = [...new Set([
-            lifecycleCapability.compatibilityWarning,
-            nativeInspectionCapability.compatibilityWarning
-        ].filter((warning) => typeof warning === "string" && warning.trim().length > 0))];
-    const codexLatentClearResumeObservationValue = session.agent === "codex"
-        ? terminalListRuntime().codexLatentClearResumeObservation({
-            screen: effectiveTerminalState.screen_excerpt,
-            agentVersion
-        })
-        : undefined;
+    const facts = await collectTerminalFactsForList(session, activeSessions, options, bridge, terminalControl);
+    const { orphanedDispatch, nativeIdentityObservation, nativeAgentIdentity, authorityNativeIdentityObservation, authorityNativeAgentIdentity, codexOpenRootRolloutInventory, nativeProcessUuid, nativeProcessBirth, nativeProcessEvidence } = facts.native;
+    const { observed: _observedTerminalState, effective: effectiveTerminalState, projected: projectedTerminalState, snapshot: terminalStatusSnapshot, statusCardNativeThreadId } = facts.status;
+    const { agentVersion, lifecycleCapability, nativeInspectionCapability, modelControlCapability, compatibilityWarnings } = facts.runtime;
+    const { automatedInputComposerReady, userExplicitComposerReady } = facts.composer;
+    const { terminalId, childPids, processIncarnation: physicalProcessIncarnation } = facts.physical;
+    const { latentClearResume: codexLatentClearResumeObservationValue } = facts.codex;
     const lifecycleBindingToken = unmanagedTerminalBindingToken({
-        terminalId: bridge.terminalConversationId(session),
+        terminalId,
         terminalControl,
         agent: session.agent,
         pid: session.pid,
@@ -644,7 +416,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         rollout: nativeAgentIdentity?.rollout
     });
     const authorityLifecycleBindingToken = unmanagedTerminalBindingToken({
-        terminalId: bridge.terminalConversationId(session),
+        terminalId,
         terminalControl,
         agent: session.agent,
         pid: session.pid,
@@ -654,62 +426,26 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         processBirth: nativeProcessBirth,
         rollout: authorityNativeAgentIdentity?.rollout
     });
-    const codexLifecycleIncarnationAvailable = session.agent !== "codex" ||
-        Boolean(nativeProcessUuid && nativeProcessBirth);
-    let terminalHasBlockingTurn = true;
-    try {
-        terminalHasBlockingTurn = terminalIncarnationBlockingTurns(terminalListRuntime().storeDirFromOptions(options), terminalControl).length > 0;
-    }
-    catch (error) {
-        runtimeLog("warn", "terminal_managed_turn_inventory_unavailable", {
-            terminal_target: terminalControl.target,
-            error: error instanceof Error ? error.message : String(error)
-        });
-    }
-    const composerAuthority = await observeAutomatedInputComposerReady({
-        session,
-        terminalControl,
-        terminalState: effectiveTerminalState,
-        options
-    });
-    const automatedInputComposerReady = composerAuthority.automatedInputComposerReady;
-    const userExplicitComposerReady = composerAuthority.userExplicitComposerReady;
-    let physicalProcessIncarnation;
-    try {
-        physicalProcessIncarnation =
-            terminalListRuntime().processIncarnationForPid(session.pid);
-    }
-    catch (error) {
-        runtimeLog("warn", "terminal_physical_process_incarnation_unavailable", {
-            agent: session.agent,
-            terminal_target: terminalControl.target,
-            pid: session.pid,
-            error: error instanceof Error ? error.message : String(error)
-        });
-    }
-    const commands = terminalListCommands({
+    const actionSubject = {
+        exactTerminalRow: true,
+        processState: "active",
         agent: session.agent,
         terminalControl,
-        terminalState: effectiveTerminalState,
-        lifecycleCapability,
-        nativeInspectionCapability,
-        nativeAgentIdentity: authorityNativeAgentIdentity,
-        nativeProcessUuid,
-        nativeProcessBirth,
-        codexLifecycleIncarnationAvailable,
-        automatedInputComposerReady,
-        hasOrphanedDispatch: orphanedDispatch !== undefined,
-        terminalHasBlockingTurn,
-        terminalHasInteraction: terminalStatusSnapshot?.interaction_state !== undefined
+        pid: session.pid
+    };
+    const actionDecisions = decideTerminalListActions({
+        subject: actionSubject,
+        facts
     });
+    const commands = actionDecisions.commands;
     const entry = {
-        id: bridge.terminalConversationId(session),
-        short_ref: sessionShortRef(bridge.terminalConversationId(session)),
+        id: terminalId,
+        short_ref: sessionShortRef(terminalId),
         source: "terminal",
         agent: session.agent,
         process_state: "active",
         pid: session.pid,
-        child_pids: childProcessIdsForRoot(session, activeSessions),
+        child_pids: childPids,
         command: session.command,
         cwd: session.cwd,
         workspace: session.cwd,
@@ -731,6 +467,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         agent_version: agentVersion,
         native_thread_lifecycle: lifecycleCapability,
         native_inspection: nativeInspectionCapability,
+        model_control: modelControlCapability,
         ...(compatibilityWarnings.length > 0
             ? { compatibility_warnings: compatibilityWarnings }
             : {}),
@@ -738,23 +475,23 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         confidence: session.confidence,
         reason: session.reason,
         terminal_control: terminalControl,
-        approval_state: effectiveTerminalState.approval_state,
-        activity_state: effectiveTerminalState.activity_state,
-        activity_reason: effectiveTerminalState.activity_reason,
-        screen_state: effectiveTerminalState.screen_state,
-        screen_reason: effectiveTerminalState.screen_reason,
-        native_identity_state: effectiveTerminalState.native_identity_state,
-        durable_activity_state: effectiveTerminalState.durable_activity_state,
-        durable_activity_reason: effectiveTerminalState.durable_activity_reason,
+        approval_state: projectedTerminalState.approval_state,
+        activity_state: projectedTerminalState.activity_state,
+        activity_reason: projectedTerminalState.activity_reason,
+        screen_state: projectedTerminalState.screen_state,
+        screen_reason: projectedTerminalState.screen_reason,
+        native_identity_state: projectedTerminalState.native_identity_state,
+        durable_activity_state: projectedTerminalState.durable_activity_state,
+        durable_activity_reason: projectedTerminalState.durable_activity_reason,
         // Internal exact-observation evidence. The public projection strips this
         // object; raw terminal status reuses it so screen, approval, and activity
         // all describe the same capture.
         ...(terminalStatusSnapshot
             ? { _terminal_status_snapshot: terminalStatusSnapshot }
             : {}),
-        // Internal action-projection evidence. terminalFirstListProjection strips
-        // this field after gating every automated-input action that can follow a
-        // human native-thread switch.
+        // Internal action-projection evidence. The terminal-first projection
+        // service strips this field after gating every automated-input action that
+        // can follow a human native-thread switch.
         _automated_input_composer_ready: automatedInputComposerReady,
         _user_explicit_composer_ready: userExplicitComposerReady,
         _native_identity_authority: {
@@ -783,7 +520,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
                     owner_conversation_id: stringValue(orphanedDispatch.conversation_id),
                     message_id: stringValue(orphanedDispatch.message_id),
                     transition_id: stringValue(orphanedDispatch.transition_id),
-                    recovery: `/akk close ${bridge.terminalConversationId(session)} ` +
+                    recovery: `/akk close ${terminalId} ` +
                         (orphanedDispatch.kind === "lifecycle"
                             ? `--expected-transition-id ${String(orphanedDispatch.transition_id)}`
                             : `--expected-message-id ${String(orphanedDispatch.message_id)}`)
@@ -793,23 +530,25 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         commands
     };
     const renderedActions = renderAvailableListActions(entry);
-    const terminalUserExplicitSendAuthority = decideTerminalUserExplicitSendAuthority({
-        exactTerminalRow: true,
-        terminalId: entry.id,
-        processState: entry.process_state,
-        terminalControl,
-        agent: session.agent,
-        pid: session.pid,
-        processUuid: physicalProcessIncarnation?.processUuid,
-        processBirth: physicalProcessIncarnation?.processBirth,
-        approvalScanned: effectiveTerminalState.approval_state.scanned === true,
-        approvalBlocked: effectiveTerminalState.approval_state.blocked === true,
-        // Codex user-explicit Send treats this observation as advisory: an
-        // off-screen or truncated composer must not hide the physical action.
-        // Claude Code still consumes the exact-composer result in the shared
-        // authority decision below.
-        userExplicitComposerReady
-    });
+    const terminalUserExplicitSendAuthority = actionDecisions.terminalUserExplicitSend.eligible
+        ? decideTerminalUserExplicitSendAuthority({
+            exactTerminalRow: true,
+            terminalId: entry.id,
+            processState: entry.process_state,
+            terminalControl,
+            agent: session.agent,
+            pid: session.pid,
+            processUuid: physicalProcessIncarnation?.processUuid,
+            processBirth: physicalProcessIncarnation?.processBirth,
+            approvalScanned: projectedTerminalState.approval_state.scanned === true,
+            approvalBlocked: projectedTerminalState.approval_state.blocked === true,
+            // Codex user-explicit Send treats this observation as advisory: an
+            // off-screen or truncated composer must not hide the physical action.
+            // Claude Code still consumes the exact-composer result in the shared
+            // authority decision below.
+            userExplicitComposerReady
+        })
+        : { eligible: false };
     const terminalUserExplicitSendAction = terminalUserExplicitSendAuthority.eligible
         ? {
             tool: "agent_knock_knock_send",
@@ -826,6 +565,27 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
                 : {})
         }
         : undefined;
+    const modelControlFacts = modelControlPolicyFacts({
+        subject: actionSubject,
+        facts
+    });
+    const modelControlAvailability = materializeModelControlAvailability({
+        ...modelControlFacts,
+        nativeAuthority: modelControlFacts.nativeAuthority.kind ===
+            "exact_session" && lifecycleBindingToken
+            ? {
+                kind: "exact_session",
+                ordinaryBindingToken: lifecycleBindingToken
+            }
+            : modelControlFacts.nativeAuthority.kind === "verified_zero_rollout"
+                ? { kind: "verified_zero_rollout" }
+                : { kind: "unavailable" }
+    }, actionDecisions.modelControl);
+    const modelControlActions = renderTerminalModelControlActions({
+        renderedActions,
+        availability: modelControlAvailability,
+        mutationScope: modelControlCapability.scope
+    });
     const foregroundIdentificationActions = terminalUserExplicitSendAuthority.eligible &&
         commands.identify_foreground === true
         ? {
@@ -858,59 +618,176 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             ? { _terminal_user_explicit_send_action: terminalUserExplicitSendAction }
             : {}),
         available_actions: {
-            ...renderedActions,
+            ...modelControlActions,
             ...foregroundIdentificationActions
         }
     };
 }
-function terminalListCommands(input) {
-    const { agent, terminalControl, terminalState, lifecycleCapability, nativeInspectionCapability, nativeAgentIdentity, nativeProcessUuid, nativeProcessBirth, codexLifecycleIncarnationAvailable, automatedInputComposerReady, hasOrphanedDispatch, terminalHasBlockingTurn, terminalHasInteraction } = input;
-    const foregroundIdentificationEligible = agent === "codex" &&
-        nativeInspectionCapability.status === "supported" &&
-        nativeInspectionCapability.statusInspection === true &&
-        terminalState.screen_state === "idle" &&
-        terminalState.native_identity_state !== "resolved" &&
-        terminalState.approval_state.scanned === true &&
-        terminalState.approval_state.blocked !== true &&
-        automatedInputComposerReady &&
-        codexLifecycleIncarnationAvailable &&
-        terminalControl.capabilities.includes("send_keys") &&
-        terminalControl.capabilities.includes("screen_status") &&
-        !terminalHasInteraction &&
-        !hasOrphanedDispatch &&
-        !terminalHasBlockingTurn;
+async function collectTerminalFactsForList(session, activeSessions, options, bridge, terminalControl) {
+    const terminalId = bridge.terminalConversationId(session);
+    const adapter = bridge.registry.require(session.agent);
+    return collectTerminalListTerminalFacts({
+        session,
+        terminalControl,
+        terminalId,
+        childPids: childProcessIdsForRoot(session, activeSessions),
+        adapter,
+        ports: terminalListFactPortsFor({
+            session,
+            terminalControl,
+            terminalId,
+            options,
+            bridge
+        })
+    });
+}
+function terminalListFactPortsFor(input) {
+    const { session, terminalControl, terminalId, options, bridge } = input;
     return {
-        send: !terminalHasBlockingTurn,
-        approve: terminalControl.capabilities.includes("terminal_approval") &&
-            terminalState.approval_state.approvable === true,
-        status: true,
-        cancel: terminalControl.capabilities.includes("terminal_cancel"),
-        close: hasOrphanedDispatch,
-        new_thread: lifecycleCapability.status === "supported" &&
-            lifecycleCapability.newThread === true &&
-            codexLifecycleIncarnationAvailable &&
-            !terminalHasBlockingTurn,
-        list_resumable_threads: lifecycleCapability.status === "supported" &&
-            lifecycleCapability.resumeExact === true &&
-            codexLifecycleIncarnationAvailable,
-        native_inspect: nativeInspectionCapability.status === "supported" &&
-            nativeInspectionCapability.statusInspection === true &&
-            terminalState.activity_state === "idle" &&
-            automatedInputComposerReady &&
-            terminalControl.capabilities.includes("send_keys") &&
-            terminalControl.capabilities.includes("screen_status") &&
-            (agent === "codex"
-                ? codexLifecycleIncarnationAvailable
-                : Boolean(nativeAgentIdentity?.sessionId &&
-                    nativeAgentIdentity.processUuid)) &&
-            !hasOrphanedDispatch &&
-            !terminalHasBlockingTurn,
-        identify_foreground: foregroundIdentificationEligible,
-        identify_and_send: foregroundIdentificationEligible,
-        watch: terminalControl.capabilities.includes("screen_status") ||
-            Boolean(nativeAgentIdentity?.sessionId &&
-                (agent !== "codex" || nativeAgentIdentity.rollout))
+        observeStatus: () => listStateForTerminal(session.agent, terminalControl, options, bridge, {
+            pid: session.pid,
+            cwd: session.cwd,
+            // Status and approval share this exact full terminal identity.
+            ...(session.agent === "codex"
+                ? { conversationId: terminalId }
+                : { sessionId: session.sessionId }),
+            terminalTarget: terminalControl.target
+        }),
+        observeNativeIdentity: (observedTerminalId) => observeTerminalNativeListIdentity(session, terminalControl, options, bridge, observedTerminalId),
+        projectEffectiveState: ({ terminalState, native }) => effectiveTerminalListState({
+            session,
+            terminalState,
+            nativeIdentityObservation: native.nativeIdentityObservation,
+            nativeAgentIdentity: native.nativeAgentIdentity,
+            nativeIdentityAuthorityObservation: native.authorityNativeIdentityObservation,
+            codexOpenRootRolloutInventory: native.codexOpenRootRolloutInventory,
+            nativeProcessUuid: native.nativeProcessUuid,
+            nativeProcessBirth: native.nativeProcessBirth
+        }),
+        observeAgentVersion: () => terminalListRuntime().agentVersionForRunningProcess(session.agent, session.pid, options),
+        observeTerminalHasBlockingTurn: () => observeTerminalHasBlockingTurnForList(options, terminalControl),
+        observeComposer: (terminalState) => observeAutomatedInputComposerReady({
+            session,
+            terminalControl,
+            terminalState,
+            options
+        }),
+        observePhysicalProcessIncarnation: () => observePhysicalProcessIncarnationForList(session, terminalControl),
+        observeLatentClearResume: (request) => terminalListRuntime().codexLatentClearResumeObservation(request),
+        observeModelControlResidual: ({ agentVersion, modelControlCapability, modelControlProfile, native, zeroRolloutVerified, effectiveTerminalState, terminalHasInteraction, terminalHasBlockingTurn, hasOrphanedDispatch }) => observeModelControlResidualForList({
+            bridge,
+            session,
+            terminalControl,
+            agentVersion,
+            modelControlCapability,
+            modelControlProfile,
+            nativeAgentIdentity: native.nativeAgentIdentity,
+            zeroRolloutVerified,
+            nativeIdentityEligible: (session.agent === "codex" &&
+                isExactNativeThreadId(native.nativeAgentIdentity?.sessionId)) ||
+                zeroRolloutVerified,
+            effectiveTerminalState,
+            terminalHasInteraction,
+            terminalHasBlockingTurn,
+            hasOrphanedDispatch
+        }),
+        projectStatusSnapshot: terminalBridgeStatusWithProjection
+    };
+}
+function observeTerminalHasBlockingTurnForList(options, terminalControl) {
+    try {
+        return terminalIncarnationBlockingTurns(terminalListRuntime().storeDirFromOptions(options), terminalControl).length > 0;
+    }
+    catch (error) {
+        runtimeLog("warn", "terminal_managed_turn_inventory_unavailable", {
+            terminal_target: terminalControl.target,
+            error: error instanceof Error ? error.message : String(error)
+        });
+        return true;
+    }
+}
+function observePhysicalProcessIncarnationForList(session, terminalControl) {
+    try {
+        return terminalListRuntime().processIncarnationForPid(session.pid);
+    }
+    catch (error) {
+        runtimeLog("warn", "terminal_physical_process_incarnation_unavailable", {
+            agent: session.agent,
+            terminal_target: terminalControl.target,
+            pid: session.pid,
+            error: error instanceof Error ? error.message : String(error)
+        });
+        return undefined;
+    }
+}
+async function observeModelControlResidualForList(input) {
+    const inspect = input.bridge.inspectModelControlResidual;
+    const profile = input.modelControlProfile;
+    if (typeof inspect !== "function" ||
+        input.session.agent !== "codex" ||
+        !profile?.supportsResidualRepair ||
+        input.modelControlCapability.status !== "supported" ||
+        input.modelControlCapability.behaviorProfile !==
+            profile.behaviorProfile ||
+        !input.nativeIdentityEligible ||
+        input.effectiveTerminalState.activity_state === "working" ||
+        input.effectiveTerminalState.activity_state === "awaiting_approval" ||
+        input.effectiveTerminalState.approval_state.scanned !== true ||
+        input.effectiveTerminalState.approval_state.blocked === true ||
+        input.terminalHasInteraction ||
+        input.terminalHasBlockingTurn ||
+        input.hasOrphanedDispatch) {
+        return undefined;
+    }
+    const adapter = input.bridge.registry.require("codex");
+    const plan = input.modelControlCapability.status === "supported"
+        ? adapter.planModelControl?.(input.modelControlCapability)
+        : undefined;
+    if (!plan || !terminalModelControlPlanConforms({
+        agent: input.session.agent,
+        agentVersion: input.agentVersion,
+        plan
+    })) {
+        return undefined;
+    }
+    const identity = input.nativeAgentIdentity;
+    const runtime = {
+        pid: input.session.pid,
+        agentVersion: input.agentVersion,
+        cwd: input.terminalControl.currentPath,
+        terminalTarget: input.terminalControl.target,
+        ...(input.zeroRolloutVerified
+            ? { expectedEmptyNativeSession: true }
+            : {}),
+        ...(identity?.sessionId
+            ? {
+                nativeSessionId: identity.sessionId,
+                expectedNativeSessionId: identity.sessionId
+            }
+            : {}),
+        ...(identity?.processUuid
+            ? { nativeProcessUuid: identity.processUuid }
+            : {}),
+        ...(identity?.processBirth
+            ? { nativeProcessBirth: identity.processBirth }
+            : {}),
+        ...(identity?.rollout
+            ? {
+                requireNativeRolloutIdentity: true,
+                nativeRollout: identity.rollout
+            }
+            : {})
     };
+    try {
+        return await inspect.call(input.bridge, "codex", input.terminalControl, profile.agentVersion, plan, { runtime, beforeInput: () => undefined });
+    }
+    catch (error) {
+        runtimeLog("warn", "terminal_model_control_residual_probe_unavailable", {
+            terminal_target: input.terminalControl.target,
+            error: error instanceof Error ? error.message : String(error)
+        });
+        return undefined;
+    }
 }
 function effectiveTerminalListState(input) {
     const { session, terminalState, nativeIdentityObservation, nativeAgentIdentity, nativeIdentityAuthorityObservation, codexOpenRootRolloutInventory, nativeProcessUuid, nativeProcessBirth } = input;
@@ -1073,7 +950,7 @@ function terminalBridgeStatusWithProjection(status, projection) {
     }
     return Object.create(Object.getPrototypeOf(status), descriptors);
 }
-async function observeTerminalNativeListIdentity(session, terminalControl, options, bridge) {
+async function observeTerminalNativeListIdentity(session, terminalControl, options, bridge, terminalId) {
     let orphanedDispatch;
     try {
         orphanedDispatch =
@@ -1091,7 +968,7 @@ async function observeTerminalNativeListIdentity(session, terminalControl, optio
             codexIdentityContext = terminalListRuntime().codexManagedIdentityResolutionContext({
                 storeDir: terminalListRuntime().storeDirFromOptions(options),
                 terminal: {
-                    conversationId: bridge.terminalConversationId(session),
+                    conversationId: terminalId,
                     agent: session.agent,
                     pid: session.pid,
                     terminalControl
@@ -1262,1197 +1139,41 @@ async function observeAutomatedInputComposerReady({ session, terminalControl, te
         userExplicitComposerReady: userExplicitReady
     };
 }
-function observeTerminalListBindingAuthority(listedTerminal, context) {
-    const { storeDir, managedSessions, allConversations, displayedConversations, mutationsAllowed, nonterminalDeferredTransfers } = context;
-    const { _automated_input_composer_ready: automatedInputComposerReady, _user_explicit_composer_ready: _userExplicitComposerReady, _codex_open_root_rollout_inventory: codexOpenRootRolloutInventoryValue, _codex_latent_clear_resume: codexLatentClearResumeValue, _terminal_user_explicit_send_action: terminalUserExplicitSendAction, _terminal_status_snapshot: _terminalStatusSnapshot, _native_identity_authority: nativeIdentityAuthorityValue, ...publicTerminal } = listedTerminal;
-    const terminal = terminalIdentityAuthorityView(listedTerminal, nativeIdentityAuthorityValue);
-    const codexOpenRootRolloutInventory = isRecord(codexOpenRootRolloutInventoryValue)
-        ? codexOpenRootRolloutInventoryValue
-        : undefined;
-    const terminalControl = isRecord(terminal.terminal_control)
-        ? terminal.terminal_control
-        : undefined;
-    const terminalHasNonterminalDeferredTransfer = Boolean(terminalControl && nonterminalDeferredTransfers.some((transfer) => transfer.terminal_id === String(terminal.id) &&
-        transfer.process_pid === Number(terminal.pid) &&
-        terminalControlEvidenceMatches(transfer.terminal_endpoint, terminalControl)));
-    const allRelated = terminalControl
-        ? allConversations.filter((conversation) => terminalControlsShareIncarnation(terminalControlForManagedConversation(conversation), terminalControl))
-        : [];
-    const displayedRelated = terminalControl
-        ? displayedConversations.filter((conversation) => terminalControlsShareIncarnation(terminalControlForManagedConversation(conversation), terminalControl))
-        : [];
-    const relatedSessions = terminalControl
-        ? managedSessions.filter((session) => terminalControlsShareIncarnation(session.binding?.terminal_control, terminalControl))
-        : [];
-    const matchingSessions = relatedSessions.filter((session) => managedSessionMatchesLiveTerminalEntry(session, terminal, storeDir));
-    const conflictingBoundSessionClaims = relatedSessions.flatMap((session) => {
-        const kind = managedBindingConflictKindForLiveTerminalEntry({
-            storeDir,
-            session,
-            terminal
-        });
-        return kind && kind !== "stale_process_incarnation"
-            ? [{ session, kind }]
-            : [];
-    });
-    const unresolvedSessionClaims = relatedSessions.filter((session) => ["transitioning", "quarantined"].includes(session.status) &&
-        managedSessionClaimsLiveTerminalEntry(session, terminal));
-    const sessionAuthorityConflict = decideTerminalSessionAuthorityConflict({
-        unresolvedSessionClaims,
-        conflictingBoundSessionClaims,
-        matchingSessions
-    });
-    const authoritativeSession = matchingSessions[0];
-    const discoveredOwnership = terminalControl
-        ? terminalDispatchOwnership(terminalControl)
-        : { state: "none" };
-    const localOwnership = discoveredOwnership.state === "current"
-        ? localTerminalDispatchOwnership(discoveredOwnership.conversation, allRelated, terminal)
-        : discoveredOwnership;
-    const dispatchOwnerMismatch = !sessionAuthorityConflict &&
-        localOwnership.state === "current" &&
-        authoritativeSession &&
-        sessionIdForConversation(localOwnership.conversation) !==
-            authoritativeSession.session_id
-        ? {
-            ownerSessionId: sessionIdForConversation(discoveredOwnership.state === "current"
-                ? discoveredOwnership.conversation
-                : localOwnership.conversation)
-        }
-        : undefined;
-    const ownership = applySessionAuthorityToDispatch({
-        localOwnership,
-        sessionAuthorityConflict,
-        authoritativeSession,
-        dispatchOwnerMismatch
-    });
-    const discoveredRawActions = isRecord(terminal.available_actions)
-        ? terminal.available_actions
-        : {};
-    const rawActions = mutationsAllowed
-        ? discoveredRawActions
-        : readOnlyListActions(discoveredRawActions);
-    const rawSendAction = isRecord(rawActions.send)
-        ? rawActions.send
-        : {};
-    const bindingAwareRawActions = authoritativeSession
-        ? actionsForManagedSessionBinding(rawActions, authoritativeSession)
-        : rawActions;
-    const sessionAwareRawActionsBase = authoritativeSession &&
-        managedSessionHasUnresolvedNativeTransition(storeDir, authoritativeSession)
-        ? Object.fromEntries(Object.entries(bindingAwareRawActions).filter(([actionName]) => actionName !== "native_inspect"))
-        : bindingAwareRawActions;
-    const sessionAwareRawActions = terminalHasNonterminalDeferredTransfer
-        ? readOnlyListActions(sessionAwareRawActionsBase)
-        : sessionAwareRawActionsBase;
-    const soleBindingConflict = conflictingBoundSessionClaims.length === 1
-        ? conflictingBoundSessionClaims[0]
-        : undefined;
-    const externalHandoffDetected = conflictingBoundSessionClaims.some(({ kind }) => kind === "live_external_thread_change");
-    const conflictingSessionRevision = Number(soleBindingConflict?.session.revision);
-    const conflictingSessionTurns = soleBindingConflict
-        ? terminalListRuntime().managedTurnsForSession(storeDir, soleBindingConflict.session.session_id)
-        : [];
-    const expectedTerminalToken = stringValue(terminal.lifecycle_binding_token);
-    const externalHandoffNativeThreadId = stringValue(terminal.native_agent_status_card_session_id) ?? stringValue(terminal.native_agent_session_id);
-    const resolvedNativeThreadId = stringValue(terminal.native_agent_session_id);
-    const externalHandoffTerminalToken = terminalControl &&
-        externalHandoffNativeThreadId &&
-        isExactNativeThreadId(externalHandoffNativeThreadId)
-        ? unmanagedTerminalBindingToken({
-            terminalId: stringValue(terminal.id),
-            terminalControl,
-            agent: terminal.agent,
-            pid: Number(terminal.pid),
-            workspace: terminal.workspace ?? terminal.cwd ?? cliCwd(),
-            nativeThreadId: externalHandoffNativeThreadId,
-            processUuid: stringValue(terminal.native_agent_process_uuid),
-            processBirth: stringValue(terminal.native_agent_process_birth),
-            rollout: resolvedNativeThreadId === externalHandoffNativeThreadId &&
-                isRecord(terminal.native_agent_rollout)
-                ? terminal.native_agent_rollout
-                : undefined
-        })
-        : undefined;
-    const externalHandoffTarget = soleBindingConflict?.kind === "live_external_thread_change" &&
-        externalHandoffNativeThreadId &&
-        isExactNativeThreadId(externalHandoffNativeThreadId)
-        ? terminalListRuntime().observedHandoffTargetResolution({
-            storeDir,
-            agent: terminal.agent,
-            workspace: terminal.workspace ?? terminal.cwd ?? cliCwd(),
-            nativeThreadId: externalHandoffNativeThreadId.toLowerCase(),
-            sourceSessionId: soleBindingConflict.session.session_id
-        })
-        : undefined;
-    const externalHandoffSnapshotToken = externalHandoffTerminalToken &&
-        soleBindingConflict?.kind === "live_external_thread_change" &&
-        externalHandoffTarget?.status === "eligible"
-        ? humanObservedHandoffBindingToken({
-            terminal_token: externalHandoffTerminalToken,
-            source_session_id: soleBindingConflict.session.session_id,
-            source_revision: managedSessionRevision(soleBindingConflict.session),
-            source_binding_token: managedSessionBindingToken(soleBindingConflict.session),
-            target: externalHandoffTarget.snapshot
-        })
-        : undefined;
-    const blockingHandoffTurns = conflictingSessionTurns.filter((turn) => isSessionSendBlockingStatus(turn.status));
-    const terminalBlockingTurns = terminalControl
-        ? terminalIncarnationBlockingTurns(storeDir, terminalControl, allRelated)
-        : [];
-    const externalHandoffSourceSessionIds = new Set(conflictingBoundSessionClaims
-        .filter(({ kind }) => kind === "live_external_thread_change")
-        .map(({ session }) => session.session_id));
-    const handoffSourceBlockingTurns = terminalBlockingTurns.filter((turn) => externalHandoffSourceSessionIds.has(sessionIdForConversation(turn)));
-    const nativeIdentityObservation = isRecord(terminal.native_agent_identity_observation)
-        ? terminal.native_agent_identity_observation
-        : undefined;
-    const codexProcessUuid = stringValue(terminal.native_agent_process_uuid);
-    const codexProcessBirth = stringValue(terminal.native_agent_process_birth);
-    const codexWorkspace = stringValue(terminal.workspace ?? terminal.cwd);
-    const codexSendAuthorityContext = terminalControl
-        ? {
-            terminalId: String(terminal.id),
-            terminalControl,
-            pid: Number(terminal.pid),
-            workspace: codexWorkspace,
-            liveProcessUuid: codexProcessUuid,
-            liveProcessBirth: codexProcessBirth
-        }
-        : undefined;
-    return {
-        authorityTerminal: terminal,
-        automatedInputComposerReady,
-        codexOpenRootRolloutInventory,
-        codexLatentClearResumeValue,
-        terminalUserExplicitSendAction,
-        publicTerminal,
-        terminalControl,
-        terminalHasNonterminalDeferredTransfer,
-        allRelated,
-        displayedRelated,
-        relatedSessions,
-        matchingSessions,
-        conflictingBoundSessionClaims,
-        unresolvedSessionClaims,
-        sessionAuthorityConflict,
-        authoritativeSession,
-        discoveredOwnership,
-        ownership,
-        rawActions,
-        rawSendAction,
-        sessionAwareRawActions,
-        soleBindingConflict,
-        externalHandoffDetected,
-        conflictingSessionRevision,
-        conflictingSessionTurns,
-        expectedTerminalToken,
-        externalHandoffNativeThreadId,
-        externalHandoffTarget,
-        externalHandoffSnapshotToken,
-        blockingHandoffTurns,
-        terminalBlockingTurns,
-        handoffSourceBlockingTurns,
-        nativeIdentityObservation,
-        codexProcessUuid,
-        codexProcessBirth,
-        codexWorkspace,
-        codexSendAuthorityContext
-    };
-}
-function terminalIdentityAuthorityView(terminal, authorityValue) {
-    if (!isRecord(authorityValue)) {
-        return terminal;
-    }
-    const observation = isRecord(authorityValue.observation)
-        ? authorityValue.observation
-        : { status: "not_observed" };
-    const identity = isRecord(authorityValue.identity)
-        ? authorityValue.identity
-        : undefined;
-    return {
-        ...terminal,
-        native_agent_session_id: stringValue(identity?.sessionId),
-        native_agent_rollout: isRecord(identity?.rollout)
-            ? identity.rollout
-            : undefined,
-        native_agent_identity_observation: observation,
-        lifecycle_binding_token: stringValue(authorityValue.lifecycle_binding_token) ??
-            terminal.lifecycle_binding_token
-    };
-}
-function observeVerifiedEmptyTerminalAuthority(terminal, context, binding) {
-    const { storeDir, terminals, mutationsAllowed } = context;
-    const { automatedInputComposerReady, terminalControl, matchingSessions, unresolvedSessionClaims, discoveredOwnership, rawActions, soleBindingConflict, blockingHandoffTurns, terminalBlockingTurns, nativeIdentityObservation, codexProcessUuid, codexProcessBirth, codexWorkspace, codexSendAuthorityContext } = binding;
-    const verifiedEmptySourceNativeThreadId = stringValue(soleBindingConflict?.session.binding?.native_thread_id)?.toLowerCase();
-    const verifiedEmptySourceActiveElsewhere = Boolean(verifiedEmptySourceNativeThreadId &&
-        terminals.some((candidate) => stringValue(candidate.id) !== stringValue(terminal.id) &&
-            candidate.agent === "codex" &&
-            stringValue(candidate.native_agent_session_id)?.toLowerCase() ===
-                verifiedEmptySourceNativeThreadId));
-    const verifiedEmptyRawSendAction = isRecord(rawActions.send)
-        ? rawActions.send
-        : {
-            tool: "agent_knock_knock_send",
-            arguments: { selector: stringValue(terminal.id) },
-            missing_required: ["request"]
-        };
-    const verifiedEmptyCodexHandoffEligible = Boolean(mutationsAllowed &&
-        terminal.agent === "codex" &&
-        terminalControl &&
-        discoveredOwnership.state === "none" &&
-        unresolvedSessionClaims.length === 0 &&
-        matchingSessions.length === 0 &&
-        soleBindingConflict?.kind === "unverifiable" &&
-        nativeIdentityObservation?.status === "verified_absent" &&
-        codexSendAuthorityContext &&
-        codexProcessUuid &&
-        codexProcessBirth &&
-        codexWorkspace &&
-        exactBoundCodexSendSource({
-            kind: "verified_empty",
-            sourceSession: soleBindingConflict.session,
-            context: codexSendAuthorityContext
-        }) &&
-        ["idle", "unknown"].includes(String(terminal.activity_state)) &&
-        automatedInputComposerReady === true &&
-        !(isRecord(terminal.approval_state) &&
-            terminal.approval_state.blocked === true) &&
-        blockingHandoffTurns.length === 0 &&
-        terminalBlockingTurns.length === 0 &&
-        !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session) &&
-        !verifiedEmptySourceActiveElsewhere &&
-        terminal.orphaned_terminal_dispatch === undefined &&
-        terminalControl?.capabilities.includes("send_keys") &&
-        terminalControl.capabilities.includes("screen_status"));
-    const verifiedEmptyCodexSnapshotToken = verifiedEmptyCodexHandoffEligible &&
-        codexSendAuthorityContext &&
-        soleBindingConflict &&
-        codexProcessUuid &&
-        codexProcessBirth &&
-        codexWorkspace
-        ? verifiedEmptyCodexHandoffToken({
-            terminalId: String(terminal.id),
-            terminalControl: codexSendAuthorityContext.terminalControl,
-            pid: Number(terminal.pid),
-            workspace: codexWorkspace,
-            processUuid: codexProcessUuid,
-            processBirth: codexProcessBirth,
-            sourceSession: soleBindingConflict.session
-        })
-        : undefined;
-    return {
-        ...binding,
-        verifiedEmptyRawSendAction,
-        verifiedEmptyCodexSnapshotToken
-    };
-}
-function observeDeferredSourceAuthority(terminal, context, observation) {
-    const { terminals } = context;
-    const { codexLatentClearResumeValue, codexOpenRootRolloutInventory, authoritativeSession, matchingSessions, conflictingBoundSessionClaims, unresolvedSessionClaims, soleBindingConflict, nativeIdentityObservation } = observation;
-    const deferredCodexCandidateInventory = codexOpenRootRolloutInventory &&
-        codexOpenRootRolloutInventory.roots.length > 0
-        ? codexOpenRootRolloutInventory
-        : undefined;
-    const abandonedConflictSource = !authoritativeSession &&
-        soleBindingConflict?.kind === "unverifiable" &&
-        matchingSessions.length === 0 &&
-        conflictingBoundSessionClaims.length === 1 &&
-        unresolvedSessionClaims.length === 0 &&
-        terminal.agent === "codex"
-        ? soleBindingConflict.session
-        : undefined;
-    const deferredCodexSource = (authoritativeSession ??
-        abandonedConflictSource) &&
-        terminal.agent === "codex" &&
-        (nativeIdentityObservation?.status === "verified_absent" ||
-            deferredCodexCandidateInventory !== undefined)
-        ? authoritativeSession ?? abandonedConflictSource
-        : undefined;
-    const deferredCodexSourceNativeThreadId = stringValue(deferredCodexSource?.binding?.native_thread_id)?.toLowerCase();
-    const deferredCodexLatentClearResumeFingerprint = isRecord(codexLatentClearResumeValue) &&
-        stringValue(codexLatentClearResumeValue.source_native_thread_id)?.toLowerCase() === deferredCodexSourceNativeThreadId
-        ? stringValue(codexLatentClearResumeValue.fingerprint)
-        : undefined;
-    if (deferredCodexLatentClearResumeFingerprint) {
-        // The resume hint is useful operational context, but it is not durable
-        // foreground authority: it can scroll away while the latent thread is
-        // still current. Candidate routing and its token rely on the complete
-        // rollout inventory and Store authority below instead.
-        runtimeLog("info", "terminal_codex_latent_clear_hint_observed", {
-            terminal_id: String(terminal.id),
-            source_session_id: deferredCodexSource?.session_id,
-            source_native_thread_id: deferredCodexSourceNativeThreadId
-        });
-    }
-    const deferredCodexSourceActiveElsewhere = Boolean(deferredCodexSourceNativeThreadId &&
-        terminals.some((candidate) => stringValue(candidate.id) !== stringValue(terminal.id) &&
-            candidate.agent === "codex" &&
-            stringValue(candidate.native_agent_session_id)?.toLowerCase() ===
-                deferredCodexSourceNativeThreadId));
-    return {
-        ...observation,
-        deferredCodexCandidateInventory,
-        abandonedConflictSource,
-        deferredCodexSource,
-        deferredCodexSourceActiveElsewhere
-    };
-}
-function observeDeferredTerminalAuthority(terminal, context, observation) {
-    const { storeDir, mutationsAllowed } = context;
-    const { automatedInputComposerReady, terminalControl, terminalHasNonterminalDeferredTransfer, matchingSessions, conflictingBoundSessionClaims, unresolvedSessionClaims, discoveredOwnership, terminalBlockingTurns, codexProcessUuid, codexProcessBirth, codexWorkspace, codexSendAuthorityContext, deferredCodexCandidateInventory, abandonedConflictSource, deferredCodexSource, deferredCodexSourceActiveElsewhere } = observation;
-    const deferredCodexAuthority = codexSendAuthorityContext
-        ? terminalListRuntime().observeDeferredCodexAuthority({
-            mode: "list",
-            storeDir,
-            context: codexSendAuthorityContext,
-            sourceSession: deferredCodexSource,
-            candidateInventory: deferredCodexCandidateInventory,
-            abandonment: abandonedConflictSource
-                ? "missing_rollout"
-                : "never",
-            requireUnclaimedCandidate: true
-        })
-        : undefined;
-    const deferredCodexSourceRolloutAuthority = deferredCodexAuthority?.sourceRolloutAuthority ?? "present";
-    const deferredCodexDispatchSnapshot = deferredCodexAuthority?.dispatchSnapshot;
-    const deferredCodexForegroundEligible = Boolean(mutationsAllowed &&
-        !terminalHasNonterminalDeferredTransfer &&
-        deferredCodexSource &&
-        terminalControl &&
-        hasCanonicalTerminalEndpoint(terminalControl) &&
-        discoveredOwnership.state === "none" &&
-        unresolvedSessionClaims.length === 0 &&
-        ((matchingSessions.length === 1 &&
-            conflictingBoundSessionClaims.length === 0) ||
-            (deferredCodexSourceRolloutAuthority ===
-                "explicitly_abandoned_predecessor" &&
-                matchingSessions.length === 0 &&
-                conflictingBoundSessionClaims.length === 1)) &&
-        codexProcessUuid &&
-        codexProcessBirth &&
-        codexWorkspace &&
-        deferredCodexAuthority?.exactSource &&
-        terminalBlockingTurns.length === 0 &&
-        terminal.orphaned_terminal_dispatch === undefined &&
-        deferredCodexDispatchSnapshot &&
-        ["idle", "unknown"].includes(String(terminal.activity_state)) &&
-        automatedInputComposerReady === true &&
-        !(isRecord(terminal.approval_state) &&
-            terminal.approval_state.blocked === true) &&
-        !deferredCodexSourceActiveElsewhere &&
-        terminalControl.capabilities.includes("send_keys") &&
-        terminalControl.capabilities.includes("screen_status"));
-    const deferredCodexForegroundToken = deferredCodexForegroundEligible &&
-        deferredCodexSource &&
-        terminalControl &&
-        codexProcessUuid &&
-        codexProcessBirth &&
-        codexWorkspace &&
-        deferredCodexDispatchSnapshot
-        ? deferredCodexForegroundBindingToken({
-            terminalId: String(terminal.id),
-            terminalControl,
-            pid: Number(terminal.pid),
-            workspace: codexWorkspace,
-            processUuid: codexProcessUuid,
-            processBirth: codexProcessBirth,
-            sourceSession: deferredCodexSource,
-            dispatchSnapshot: deferredCodexDispatchSnapshot,
-            sourceTurnHistory: deferredCodexAuthority?.sourceTurnHistory,
-            sourceRolloutAuthority: deferredCodexSourceRolloutAuthority,
-            sourceAbandonmentFingerprint: deferredCodexAuthority?.sourceAbandonmentFingerprint,
-            ...(deferredCodexCandidateInventory
-                ? { candidateInventory: deferredCodexCandidateInventory }
-                : {})
-        })
-        : undefined;
-    return {
-        ...observation,
-        deferredCodexSourceRolloutAuthority,
-        deferredCodexForegroundToken
-    };
-}
-function observeTerminalHandoffAuthority(terminal, context, observation) {
-    const { storeDir, mutationsAllowed, conversationHasNonterminalDeferredTransfer } = context;
-    const { automatedInputComposerReady, terminalControl, matchingSessions, unresolvedSessionClaims, discoveredOwnership, rawActions, soleBindingConflict, conflictingSessionRevision, conflictingSessionTurns, expectedTerminalToken, externalHandoffNativeThreadId, externalHandoffTarget, externalHandoffSnapshotToken, blockingHandoffTurns, terminalBlockingTurns, handoffSourceBlockingTurns } = observation;
-    const reconcileBindingAction = mutationsAllowed &&
-        discoveredOwnership.state === "none" &&
-        unresolvedSessionClaims.length === 0 &&
-        matchingSessions.length === 0 &&
-        soleBindingConflict &&
-        soleBindingConflict.kind !== "unverifiable" &&
-        Number.isSafeInteger(conflictingSessionRevision) &&
-        conflictingSessionRevision > 0 &&
-        expectedTerminalToken &&
-        terminal.activity_state === "idle" &&
-        !(isRecord(terminal.approval_state) &&
-            terminal.approval_state.blocked === true) &&
-        !conflictingSessionTurns.some((turn) => isSessionSendBlockingStatus(turn.status)) &&
-        terminalBlockingTurns.length === 0 &&
-        !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session)
-        ? projectReconcileBindingAction({
-            terminalId: stringValue(terminal.id),
-            conflictingSession: soleBindingConflict.session,
-            conflictingSessionRevision,
-            expectedTerminalToken
-        })
-        : undefined;
-    const externalHandoffAdoptable = Boolean(mutationsAllowed &&
-        discoveredOwnership.state === "none" &&
-        unresolvedSessionClaims.length === 0 &&
-        soleBindingConflict?.kind === "live_external_thread_change" &&
-        terminal.activity_state === "idle" &&
-        automatedInputComposerReady === true &&
-        !(isRecord(terminal.approval_state) &&
-            terminal.approval_state.blocked === true) &&
-        !conflictingSessionTurns.some((turn) => isSessionSendBlockingStatus(turn.status)) &&
-        terminalBlockingTurns.length === 0 &&
-        !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session) &&
-        externalHandoffTarget?.status === "eligible" &&
-        isRecord(rawActions.send) &&
-        Boolean(externalHandoffSnapshotToken));
-    const handoffDecisionTurn = mutationsAllowed &&
-        soleBindingConflict?.kind === "live_external_thread_change" &&
-        externalHandoffTarget?.status === "eligible" &&
-        terminal.activity_state === "idle" &&
-        !(isRecord(terminal.approval_state) &&
-            terminal.approval_state.blocked === true) &&
-        !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session) &&
-        blockingHandoffTurns.length === 1 &&
-        terminalBlockingTurns.every((turn) => turn.conversation_id === blockingHandoffTurns[0].conversation_id)
-        ? blockingHandoffTurns[0]
-        : undefined;
-    const handoffDecisionToken = handoffDecisionTurn &&
-        externalHandoffSnapshotToken &&
-        terminalControl
-        ? terminalListRuntime().activeTurnHandoffDecisionToken({
-            handoffToken: externalHandoffSnapshotToken,
-            turn: handoffDecisionTurn,
-            ledger: terminalListRuntime().loadTerminalBridgeDispatchLedger(terminalControl)
-        })
-        : undefined;
-    const handoffDecision = handoffDecisionTurn &&
-        handoffDecisionToken &&
-        externalHandoffNativeThreadId
-        ? projectHandoffDecision({
-            sourceSessionId: soleBindingConflict?.session.session_id,
-            sourceTurnId: turnIdForConversation(handoffDecisionTurn),
-            liveNativeThreadId: externalHandoffNativeThreadId,
-            handoffDecisionToken,
-            actionTurnId: turnIdForConversation(handoffDecisionTurn)
-        })
-        : undefined;
-    const blockingHandoffTurnIds = new Set(handoffSourceBlockingTurns.map((turn) => turn.conversation_id));
-    // A blocking managed Turn always remains explicitly closable. Close releases
-    // AKK management only; it does not send input or stop the coding agent.
-    const terminalRecoveryBlockingTurns = terminalBlockingTurns;
-    return {
-        ...observation,
-        reconcileBindingAction,
-        externalHandoffAdoptable,
-        handoffDecision,
-        blockingHandoffTurnIds,
-        terminalRecoveryBlockingTurns
-    };
-}
-function observeTerminalScopedApprovalAuthority(terminal, context, observation) {
-    const { storeDir, mutationsAllowed } = context;
-    const { terminalControl, terminalHasNonterminalDeferredTransfer, conflictingBoundSessionClaims, unresolvedSessionClaims, sessionAuthorityConflict, authoritativeSession, discoveredOwnership, ownership, rawActions } = observation;
-    let terminalScopedCodexApprovalAction;
-    const terminalScopedCodexApprovalPrompt = terminalScopedCodexApprovalPromptSnapshot(terminal.approval_state);
-    if (mutationsAllowed &&
-        terminal.agent === "codex" &&
-        terminalControl &&
-        hasCanonicalTerminalEndpoint(terminalControl) &&
-        authoritativeSession &&
-        !sessionAuthorityConflict &&
-        !terminalHasNonterminalDeferredTransfer &&
-        unresolvedSessionClaims.length === 0 &&
-        conflictingBoundSessionClaims.length === 0 &&
-        terminalScopedCodexApprovalPrompt &&
-        isRecord(rawActions.approve)) {
-        try {
-            const ledger = terminalListRuntime().loadTerminalBridgeDispatchLedger(terminalControl);
-            const boundary = ownership.state === "conflict" &&
-                discoveredOwnership.state === "current" &&
-                ledger
-                ? terminalScopedCodexApprovalBoundary({
-                    storeDir,
-                    terminal,
-                    owner: discoveredOwnership.conversation,
-                    session: authoritativeSession,
-                    ledger,
-                    approval: terminalScopedCodexApprovalPrompt
-                })
-                : ownership.state === "none" &&
-                    discoveredOwnership.state === "none"
-                    ? terminalScopedCodexApprovalBoundary({
-                        storeDir,
-                        terminal,
-                        session: authoritativeSession,
-                        ledger,
-                        approval: terminalScopedCodexApprovalPrompt
-                    })
-                    : undefined;
-            if (!boundary) {
-                throw new Error("terminal-scoped Codex approval has no eligible managed authority");
-            }
-            terminalScopedCodexApprovalAction = {
-                ...rawActions.approve,
-                arguments: {
-                    conversation_id: String(terminal.id),
-                    expected_terminal_token: boundary.token
-                },
-                scope: "terminal_current_prompt",
-                authority: boundary.authority.kind,
-                managed_state_unchanged: true,
-                automatic_approval_eligible: false,
-                durable_dispatch_receipt: false,
-                uncertain_outcome_recovery: "refresh status and inspect the live prompt; do not retry blindly"
-            };
-        }
-        catch (error) {
-            runtimeLog("info", "terminal_scoped_codex_approval_not_advertised", {
-                terminal_id: String(terminal.id),
-                terminal_target: terminalControl.target,
-                reason: error instanceof Error ? error.message : String(error)
-            });
-        }
-    }
-    const rolloutBackedCodexSession = Boolean(authoritativeSession?.agent === "codex" &&
-        isCompleteNativeRollout(authoritativeSession.binding?.native_process.rollout));
-    return {
-        ...observation,
-        terminalScopedCodexApprovalAction,
-        rolloutBackedCodexSession
-    };
-}
-function observeTerminalListActionAuthority(terminal, context, binding) {
-    return observeTerminalScopedApprovalAuthority(terminal, context, observeTerminalHandoffAuthority(terminal, context, observeDeferredTerminalAuthority(terminal, context, observeDeferredSourceAuthority(terminal, context, observeVerifiedEmptyTerminalAuthority(terminal, context, binding)))));
-}
-function renderTerminalFirstListEntry(terminal, context, observation) {
-    const { sessionAuthorityRequired, includeAll, mutationsAllowed, conversationHasNonterminalDeferredTransfer } = context;
-    const { automatedInputComposerReady, terminalUserExplicitSendAction, publicTerminal, terminalControl, allRelated, displayedRelated, relatedSessions, authoritativeSession, ownership, rawSendAction, sessionAwareRawActions, externalHandoffDetected, externalHandoffSnapshotToken, handoffSourceBlockingTurns, verifiedEmptyRawSendAction, verifiedEmptyCodexSnapshotToken, deferredCodexSourceRolloutAuthority, deferredCodexForegroundToken, reconcileBindingAction, externalHandoffAdoptable, handoffDecision, blockingHandoffTurnIds, terminalRecoveryBlockingTurns, terminalScopedCodexApprovalAction, rolloutBackedCodexSession } = observation;
-    const association = decideManagedTerminalAssociation({
-        allRelated,
-        displayedRelated,
-        authoritativeSession,
-        sessionAuthorityRequired,
-        currentOwner: ownership.state === "current"
-            ? ownership.conversation
-            : undefined
-    });
-    const { managedSessionId, sessionIds, sessionAllRelated, sessionDisplayedRelated } = association;
-    // History remains useful when a pane has restarted and therefore no
-    // first-class Session is authoritative for the new process incarnation.
-    // Keep that display-only association separate from the send target: under
-    // protocol 3, only authoritativeSession may populate managedSessionId.
-    const sessionBindingMatchesLiveTerminal = authoritativeSession
-        ? true
-        : Boolean(!sessionAuthorityRequired &&
-            sessionAllRelated.some((turn) => managedTurnMatchesLiveTerminal(turn, terminal)));
-    const currentTurnValue = ownership.state === "current"
-        ? currentManagedTurnForTerminal(ownership.conversation, terminal, sessionAwareRawActions)
-        : undefined;
-    const currentTurnProjection = currentTurnValue
-        ? !mutationsAllowed
-            ? readOnlyManagedTurn(currentTurnValue)
-            : ownership.state === "current" &&
-                conversationHasNonterminalDeferredTransfer(ownership.conversation)
-                ? userReleasableManagedTurn(currentTurnValue)
-                : currentTurnValue
-        : undefined;
-    const currentTurn = currentTurnProjection
-        ? withoutGenericHandoffSourceClose(currentTurnProjection, blockingHandoffTurnIds)
-        : undefined;
-    const nonOwnerRawActions = nonOwnerTerminalActions(sessionAwareRawActions, {
-        hasAuthoritativeSession: Boolean(authoritativeSession),
-        rolloutBackedCodexSession
-    });
-    const { recentConversation, historyConversations } = selectManagedTerminalHistory({
-        displayedRelated: sessionDisplayedRelated,
-        currentConversationId: stringValue(currentTurn?.conversation_id),
-        hasCurrentTurn: Boolean(currentTurn),
-        includeAll
-    });
-    const recentTurnValue = recentConversation
-        ? historicalManagedTurnForTerminal(recentConversation)
-        : undefined;
-    const recentTurnProjection = recentTurnValue
-        ? !mutationsAllowed
-            ? readOnlyManagedTurn(recentTurnValue)
-            : recentConversation &&
-                conversationHasNonterminalDeferredTransfer(recentConversation)
-                ? userReleasableManagedTurn(recentTurnValue)
-                : recentTurnValue
-        : undefined;
-    const recentTurn = recentTurnProjection
-        ? withoutGenericHandoffSourceClose(recentTurnProjection, blockingHandoffTurnIds)
-        : undefined;
-    const history = historyConversations.map((conversation) => {
-        const turn = historicalManagedTurnForTerminal(conversation);
-        return withoutGenericHandoffSourceClose(!mutationsAllowed
-            ? readOnlyManagedTurn(turn)
-            : conversationHasNonterminalDeferredTransfer(conversation)
-                ? userReleasableManagedTurn(turn)
-                : turn, blockingHandoffTurnIds);
-    });
-    const visibleTurnIds = new Set([currentTurn, recentTurn, ...history]
-        .map((turn) => stringValue(turn?.conversation_id))
-        .filter((id) => id !== undefined));
-    const managedSessionShortReference = managedSessionId
-        ? sessionShortRef(managedSessionId)
-        : null;
-    const management = projectTerminalManagement({
-        managedSessionId,
-        managedSessionShortRef: managedSessionShortReference,
-        currentTurn,
-        recentTurn,
-        sessionAllRelatedCount: sessionAllRelated.length,
-        hiddenTurnCount: sessionAllRelated.filter((conversation) => !visibleTurnIds.has(conversation.conversation_id)).length,
-        sessionCount: new Set([
-            ...sessionIds,
-            ...relatedSessions.map((session) => session.session_id)
-        ]).size,
-        authoritativeSession,
-        history: includeAll ? history : undefined
-    });
-    const sendAuthority = decideTerminalSendAuthority({
-        ownership: ownership.state,
-        verifiedEmptyToken: verifiedEmptyCodexSnapshotToken,
-        externalToken: externalHandoffAdoptable
-            ? externalHandoffSnapshotToken
-            : undefined,
-        deferredToken: ownership.state !== "conflict" ||
-            deferredCodexSourceRolloutAuthority ===
-                "explicitly_abandoned_predecessor"
-            ? deferredCodexForegroundToken
-            : undefined,
-        managedSendSessionId: managedSessionId &&
-            !rolloutBackedCodexSession &&
-            sessionBindingMatchesLiveTerminal &&
-            isRecord(sessionAwareRawActions.send)
-            ? managedSessionId
-            : undefined
-    });
-    const tokenSendAction = sendAuthority.mode === "external_handoff"
-        ? rawSendAction
-        : sendAuthority.mode === "verified_empty" ||
-            sendAuthority.mode === "deferred"
-            ? verifiedEmptyRawSendAction
-            : undefined;
-    const authoritativeSendAction = sendAuthority.mode === "managed" && isRecord(sessionAwareRawActions.send)
-        ? sendActionForManagedSession(sessionAwareRawActions.send, sendAuthority.sessionId)
-        : tokenSendAction &&
-            "token" in sendAuthority &&
-            sendAuthority.token
-            ? {
-                ...tokenSendAction,
-                arguments: {
-                    ...(isRecord(tokenSendAction.arguments)
-                        ? tokenSendAction.arguments
-                        : {}),
-                    expected_terminal_token: sendAuthority.token
-                }
-            }
-            : undefined;
-    const managedFastPathToken = "token" in sendAuthority
-        ? sendAuthority.token
-        : undefined;
-    const prioritizedTerminalUserExplicitSendAction = terminalUserExplicitSendAction && managedFastPathToken
-        ? {
-            ...terminalUserExplicitSendAction,
-            arguments: {
-                ...(isRecord(terminalUserExplicitSendAction.arguments)
-                    ? terminalUserExplicitSendAction.arguments
-                    : {}),
-                expected_managed_terminal_token: managedFastPathToken
-            }
-        }
-        : terminalUserExplicitSendAction;
-    const availableActions = selectTerminalAvailableActions({
-        ownership: ownership.state,
-        currentActions: ownership.state === "current"
-            ? currentTerminalActions(currentTurn)
-            : {},
-        sessionAwareRawActions: sessionAwareRawActions,
-        nonOwnerRawActions,
-        authoritativeSendAction,
-        terminalUserExplicitSendAction: prioritizedTerminalUserExplicitSendAction,
-        reconcileBindingAction,
-        terminalScopedApprovalAction: terminalScopedCodexApprovalAction,
-        isAction: isRecord
-    });
-    // An explicit undefined rollout prevents a lingering resolver rollout from
-    // being presented as the authoritative status-card thread.
-    const authoritativeIdentity = authoritativeTerminalIdentity(authoritativeSession);
-    const publicManagementConflict = ownership.state === "conflict"
-        ? projectPublicManagementConflict({
-            conflict: ownership.conflict,
-            verifiedEmptyToken: verifiedEmptyCodexSnapshotToken,
-            deferredToken: deferredCodexForegroundToken,
-            explicitlyAbandonedPredecessor: deferredCodexSourceRolloutAuthority ===
-                "explicitly_abandoned_predecessor"
-        })
-        : undefined;
-    const handoffPresentation = projectHandoffPresentation({
-        externalHandoffDetected,
-        externalHandoffAdoptable,
-        recoveryBlockingTurnCount: terminalRecoveryBlockingTurns.length,
-        hasHandoffDecision: Boolean(handoffDecision),
-        sourceBlockingTurnCount: handoffSourceBlockingTurns.length,
-        automatedInputComposerReady: automatedInputComposerReady === true,
-        verifiedEmptyToken: verifiedEmptyCodexSnapshotToken
-    });
-    return {
-        ...publicTerminal,
-        ...authoritativeIdentity,
-        management_state: ownership.state === "conflict"
-            ? "conflict"
-            : ownership.state === "current" || Boolean(authoritativeSession)
-                ? "managed"
-                : "unmanaged",
-        ...(ownership.state === "conflict"
-            ? { management_conflict: publicManagementConflict }
-            : {}),
-        ...handoffPresentation,
-        ...(handoffDecision ? { handoff_decision: handoffDecision } : {}),
-        ...(terminalRecoveryBlockingTurns.length > 0
-            ? {
-                blocking_turns: terminalRecoveryBlockingTurns.map((turn) => projectBlockingTurn({
-                    sessionId: sessionIdForConversation(turn),
-                    turnId: turnIdForConversation(turn),
-                    status: turn.status,
-                    recoveryTurnId: turnIdForConversation(turn)
-                }))
-            }
-            : {}),
-        managed: management,
-        available_actions: availableActions
-    };
-}
-function terminalFirstListProjection({ storeDir, terminals, managedSessions, sessionAuthorityRequired, allConversations, displayedConversations, includeAll, managedOnly, statusFilter, mutationsAllowed }) {
-    const nonterminalDeferredTransfers = listDeferredForegroundTransfers(storeDir).filter((transfer) => !isFinalDeferredForegroundTransferStatus(transfer.status));
-    const nonterminalDeferredTransferIds = new Set(nonterminalDeferredTransfers.map((transfer) => transfer.transfer_id));
-    const nonterminalDeferredSourceTurnIds = new Set(nonterminalDeferredTransfers.flatMap((transfer) => transfer.version === 2 &&
-        transfer.source_kind === "candidate_rollout_quiescent"
-        ? (transfer.source_turn_history ?? []).map((turn) => turn.turn_id)
-        : []));
-    const conversationHasNonterminalDeferredTransfer = (conversation) => {
-        if (nonterminalDeferredSourceTurnIds.has(turnIdForConversation(conversation))) {
-            return true;
-        }
-        const takeover = isRecord(conversation.native_session_takeover)
-            ? conversation.native_session_takeover
-            : undefined;
-        const transferId = stringValue(takeover?.deferred_foreground_transfer_id);
-        return Boolean(transferId && nonterminalDeferredTransferIds.has(transferId));
-    };
-    const discoveredTerminalControls = terminals.flatMap((terminal) => {
-        const control = isRecord(terminal.terminal_control)
-            ? terminal.terminal_control
-            : undefined;
-        return control ? [control] : [];
-    });
-    const projectionContext = {
-        storeDir,
-        terminals,
-        managedSessions,
-        sessionAuthorityRequired,
-        allConversations,
-        displayedConversations,
-        includeAll,
-        mutationsAllowed,
-        nonterminalDeferredTransfers,
-        conversationHasNonterminalDeferredTransfer
-    };
-    const projectedTerminals = terminals.map((terminal) => {
-        const binding = observeTerminalListBindingAuthority(terminal, projectionContext);
-        return renderTerminalFirstListEntry(binding.authorityTerminal, projectionContext, observeTerminalListActionAuthority(binding.authorityTerminal, projectionContext, binding));
-    });
-    const unavailableManagedTurns = displayedConversations
-        .filter((conversation) => {
-        const managedControl = terminalControlForManagedConversation(conversation);
-        if (discoveredTerminalControls.some((control) => terminalControlsShareIncarnation(managedControl, control))) {
-            return false;
-        }
-        return (includeAll ||
-            managedOnly ||
-            statusFilter !== undefined ||
-            managedTurnNeedsAttention(conversation));
-    })
-        .sort(compareManagedConversationRecency)
-        .map((conversation) => {
-        const managedTurn = managedTurnListEntry(terminalListRuntime().summarizeConversation(conversation), {
-            terminalBridge: terminalListRuntime().terminalBridgeEnabled(conversation),
-            approvalState: managedListApprovalState(conversation),
-            conversation
-        });
-        return {
-            ...managedTurn,
-            available_actions: !mutationsAllowed
-                ? readOnlyListActions(isRecord(managedTurn.available_actions)
-                    ? managedTurn.available_actions
-                    : {})
-                : conversationHasNonterminalDeferredTransfer(conversation)
-                    ? userReleaseListActions(isRecord(managedTurn.available_actions)
-                        ? managedTurn.available_actions
-                        : {}, turnIdForConversation(conversation))
-                    : safeUnavailableManagedTurnActions(isRecord(managedTurn.available_actions)
-                        ? managedTurn.available_actions
-                        : {}),
-            terminal_availability: {
-                available: false,
-                reason: managedOnly
-                    ? "terminal discovery was disabled by --managed-only"
-                    : "the referenced terminal pane is not currently available"
-            }
-        };
-    });
-    return {
-        terminals: projectedTerminals,
-        unavailableManagedTurns
-    };
-}
 function managedSessionMatchesLiveTerminalEntry(session, terminal, storeDir) {
-    const binding = session.binding;
-    const liveControl = isRecord(terminal.terminal_control)
-        ? terminal.terminal_control
-        : undefined;
-    if (session.status !== "bound" ||
-        !binding ||
-        session.agent !== terminal.agent ||
-        binding.native_process.pid !== Number(terminal.pid)) {
-        return false;
-    }
-    const terminalAliasMatches = terminalControlAliasMatches(binding.terminal_id, binding.terminal_control, terminal.id, liveControl);
-    if (!terminalAliasMatches) {
-        return false;
-    }
-    const workspaceMatches = terminalListRuntime().matchesConfiguredWorkspace(session.workspace, terminal.workspace ?? terminal.cwd);
-    if (!workspaceMatches) {
-        return false;
-    }
-    const observation = terminalObservationFromListEntry(terminal, session.agent);
-    const evidence = {
-        terminalAliasMatches,
-        workspaceMatches
-    };
-    let decision = decideTerminalBindingMatch(session, observation, evidence);
-    if (decision.state === "not_exact" &&
-        decision.reason === "native_identity_mismatch" &&
-        session.agent === "codex" &&
-        observation.nativeIdentity.status === "resolved") {
-        decision = decideTerminalBindingMatch(session, observation, {
-            ...evidence,
-            codexLingeringBeforeMatches: terminalListRuntime().codexLingeringBeforeIdentityMatchesSession({
-                storeDir,
-                session,
-                identity: observation.nativeIdentity.identity
-            })
-        });
-    }
-    return decision.state === "exact";
-}
-function managedSessionClaimsLiveTerminalEntry(session, terminal) {
-    const binding = session.binding;
-    const liveControl = isRecord(terminal.terminal_control)
-        ? terminal.terminal_control
-        : undefined;
-    return Boolean(binding &&
-        session.agent === terminal.agent &&
-        binding.native_process.pid === Number(terminal.pid) &&
-        terminalControlsShareIncarnation(binding.terminal_control, liveControl));
-}
-function listedTerminalProcessIncarnation(terminal) {
-    const processUuid = stringValue(terminal.native_agent_process_uuid);
-    const processBirth = stringValue(terminal.native_agent_process_birth);
-    if (terminal.agent !== "codex" ||
-        (processUuid && processBirth)) {
-        return { processUuid, processBirth };
-    }
-    const pid = Number(terminal.pid);
-    if (!Number.isSafeInteger(pid) || pid <= 1) {
-        return { processUuid, processBirth };
-    }
-    try {
-        const incarnation = terminalListRuntime().codexProcessIncarnationForPid(pid);
-        return {
-            processUuid: processUuid ?? incarnation.processUuid,
-            processBirth: processBirth ?? incarnation.processBirth
-        };
-    }
-    catch {
-        return { processUuid, processBirth };
-    }
-}
-function managedBindingConflictKindForLiveTerminalEntry({ storeDir, session, terminal }) {
-    const binding = session.binding;
-    if (session.status !== "bound" ||
-        !binding ||
-        !managedSessionClaimsLiveTerminalEntry(session, terminal) ||
-        managedSessionMatchesLiveTerminalEntry(session, terminal, storeDir)) {
-        return undefined;
-    }
-    const livePid = Number(terminal.pid);
-    const incarnation = listedTerminalProcessIncarnation(terminal);
-    const relationship = processIncarnationRelationship({
-        binding,
-        livePid,
-        liveProcessUuid: incarnation.processUuid,
-        liveProcessBirth: incarnation.processBirth
-    });
-    if (relationship === "different") {
-        return "stale_process_incarnation";
-    }
-    if (!terminalControlAliasMatches(binding.terminal_id, binding.terminal_control, terminal.id, isRecord(terminal.terminal_control)
-        ? terminal.terminal_control
-        : undefined) ||
-        !terminalListRuntime().matchesConfiguredWorkspace(session.workspace, terminal.workspace ?? terminal.cwd)) {
-        return "unverifiable";
-    }
-    return decideManagedBindingConflict({
-        session,
-        claimsTerminal: true,
-        exactBinding: false,
-        ownerConclusivelyInactive: false,
-        processRelationship: relationship,
-        liveNativeThreadId: stringValue(terminal.native_agent_session_id),
-        statusCardNativeThreadId: stringValue(terminal.native_agent_status_card_session_id),
-        managedTurnCount: provisionalManagedBindingTurnCount(storeDir, session)
-    });
+    return terminalListOwnershipService().managedSessionMatchesLiveTerminalEntry(session, terminal, storeDir);
 }
 function provisionalManagedBindingTurnCount(storeDir, session) {
-    const binding = session.binding;
-    return binding && session.lineage.created_by === "attach" &&
-        !session.last_transition_id &&
-        !binding.native_thread_id &&
-        !binding.native_process.rollout
-        ? terminalListRuntime().managedTurnsForSession(storeDir, session.session_id).length
-        : undefined;
+    return terminalListOwnershipService().provisionalManagedBindingTurnCount(storeDir, session);
 }
 function managedSessionHasUnresolvedNativeTransition(storeDir, session) {
-    const root = nativeThreadTransitionsDir(storeDir);
-    if (!fs.existsSync(root)) {
-        return false;
-    }
-    let entries;
-    try {
-        entries = fs.readdirSync(root, { withFileTypes: true });
-    }
-    catch {
-        return true;
-    }
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        let transition;
-        try {
-            transition = loadNativeThreadTransition(storeDir, entry.name);
-        }
-        catch {
-            return true;
-        }
-        if (transition.source_session_id !== session.session_id &&
-            transition.target_session_id !== session.session_id) {
-            continue;
-        }
-        if (!["committed", "aborted"].includes(transition.status)) {
-            return true;
-        }
-    }
-    return false;
+    return terminalListOwnershipService().managedSessionHasUnresolvedNativeTransition(storeDir, session);
 }
 function managedSessionHasAnyNativeTransition(storeDir, session) {
-    const root = nativeThreadTransitionsDir(storeDir);
-    if (!fs.existsSync(root)) {
-        return false;
-    }
-    let entries;
-    try {
-        entries = fs.readdirSync(root, { withFileTypes: true });
-    }
-    catch {
-        return true;
-    }
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        let transition;
-        try {
-            transition = loadNativeThreadTransition(storeDir, entry.name);
-        }
-        catch {
-            return true;
-        }
-        if (transition.source_session_id === session.session_id ||
-            transition.target_session_id === session.session_id) {
-            return true;
-        }
-    }
-    return false;
+    return terminalListOwnershipService().managedSessionHasAnyNativeTransition(storeDir, session);
 }
 function terminalControlForManagedConversation(conversation) {
-    return terminalListRuntime().terminalControlFromTakeover(isRecord(conversation.native_session_takeover)
-        ? conversation.native_session_takeover
-        : undefined);
+    return terminalListOwnershipService().terminalControlForManagedConversation(conversation);
 }
 function terminalIncarnationBlockingTurns(storeDir, terminalControl, conversations = listConversations(storeDir)) {
-    return conversations
-        .filter(terminalListRuntime().isDiscoverableTmuxConversation)
-        .filter((turn) => terminalControlsShareIncarnation(terminalControlForManagedConversation(turn), terminalControl) &&
-        isSessionSendBlockingStatus(turn.status))
-        .sort(compareManagedConversationRecency);
+    return terminalListOwnershipService().terminalIncarnationBlockingTurns(storeDir, terminalControl, conversations);
 }
 function managedTurnNeedsAttention(conversation) {
-    return terminalManagedTurnNeedsAttention({
-        status: conversation.status,
-        get callbackDeliveryStatus() {
-            const delivery = isRecord(conversation.callback_delivery)
-                ? conversation.callback_delivery
-                : undefined;
-            return String(delivery?.status ?? "");
-        }
-    });
+    return terminalListOwnershipService().managedTurnNeedsAttention(conversation);
 }
 function assertTerminalIncarnationCanStartTurn(storeDir, terminalControl) {
-    const blocker = terminalIncarnationBlockingTurns(storeDir, terminalControl)[0];
-    if (!blocker) {
-        return;
-    }
-    throw new Error(`terminal ${terminalControl.target} still has unresolved Turn ` +
-        `${turnIdForConversation(blocker)} (${blocker.status})`);
+    return terminalListOwnershipService().assertTerminalIncarnationCanStartTurn(storeDir, terminalControl);
 }
 function terminalDispatchOwnership(terminalControl) {
-    let ledger;
-    try {
-        ledger = terminalListRuntime().loadTerminalBridgeDispatchLedger(terminalControl);
-    }
-    catch (error) {
-        const decision = dispatch.decideTerminalDispatchOwnership("unreadable");
-        return {
-            state: "conflict",
-            conflict: {
-                reason: decision.code === "ledger_unreadable"
-                    ? error instanceof Error ? error.message : String(error)
-                    : "terminal dispatch ledger is unreadable",
-                recovery: "inspect the shared terminal pane before performing a side effect"
-            }
-        };
-    }
-    const ledgerAuthority = !ledger
-        ? "absent"
-        : ledger.status === "resolved"
-            ? "resolved"
-            : terminalListRuntime().terminalDispatchRecordMatchesControl(ledger, terminalControl, {
-                requireProcessAnchor: false
-            }) && !terminalListRuntime().terminalDispatchRecordMatchesControl(ledger, terminalControl)
-                ? "stale_process_incarnation"
-                : dispatch.isActiveTerminalDispatchStatus(String(ledger.status))
-                    ? "active"
-                    : "inactive_status";
-    let decision = dispatch.decideTerminalDispatchOwnership(ledgerAuthority);
-    if (decision.state === "none" || !ledger)
-        return { state: "none" };
-    const owner = terminalListRuntime().loadTerminalDispatchLedgerOwner(ledger);
-    const ledgerMessageId = stringValue(ledger.message_id);
-    const ownerAuthority = !owner
-        ? "unavailable"
-        : isTerminalDispatchOwnerReleasedStatus(owner.status)
-            ? "released"
-            : !terminalControlsShareIncarnation(terminalControlForManagedConversation(owner), terminalControl)
-                ? "terminal_mismatch"
-                : ledgerMessageId && stringValue(isRecord(owner.native_session_takeover)
-                    ? owner.native_session_takeover.terminal_bridge_message_id
-                    : undefined) !== ledgerMessageId
-                    ? "generation_mismatch"
-                    : "current";
-    decision = dispatch.decideTerminalDispatchOwnership(ledgerAuthority, ownerAuthority);
-    if (decision.state === "none")
-        return { state: "none" };
-    if (decision.state === "current" && owner) {
-        return { state: "current", conversation: owner };
-    }
-    const reason = decision.state === "conflict" &&
-        decision.code === "owner_terminal_mismatch"
-        ? "dispatch owner does not reference this terminal pane incarnation"
-        : decision.state === "conflict" &&
-            decision.code === "owner_generation_mismatch"
-            ? "dispatch generation does not match the owner state"
-            : "dispatch owner state is unavailable";
-    return {
-        state: "conflict",
-        conflict: projectTerminalDispatchConflict({
-            reason,
-            dispatchStatus: stringValue(ledger.status),
-            ownerConversationId: stringValue(ledger.conversation_id),
-            messageId: stringValue(ledger.message_id)
-        })
-    };
-}
-function localTerminalDispatchOwnership(ledgerOwner, localConversations, terminal) {
-    const localOwner = localConversations.find((conversation) => conversation.conversation_id === ledgerOwner.conversation_id &&
-        sameCanonicalStatePath(conversation.state_path, ledgerOwner.state_path));
-    return decideLocalTerminalDispatchOwnership({
-        ledgerOwnerId: ledgerOwner.conversation_id,
-        localOwner,
-        localOwnerMatchesLiveTerminal: localOwner
-            ? managedTurnMatchesLiveTerminal(localOwner, terminal)
-            : false
-    });
+    return terminalListOwnershipService().terminalDispatchOwnership(terminalControl);
 }
 function terminalScopedCodexApprovalBoundary({ storeDir, terminal, session, ledger, approval, owner }) {
-    const terminalRecord = isRecord(terminal) ? terminal : {};
-    const terminalControl = isRecord(terminalRecord.terminal_control)
-        ? terminalRecord.terminal_control
-        : undefined;
-    const control = terminalControl;
-    const terminalId = String(terminalRecord.id);
-    const relatedBoundSessionIds = () => listManagedSessions(storeDir)
-        .filter((candidate) => candidate.status === "bound" &&
-        candidate.agent === "codex" &&
-        candidate.binding?.native_process.pid === Number(terminalRecord.pid) &&
-        terminalControlsShareIncarnation(candidate.binding?.terminal_control, terminalControl))
-        .map((candidate) => candidate.session_id);
-    const blockingTurnIds = () => terminalIncarnationBlockingTurns(storeDir, control)
-        .map((turn) => turnIdForConversation(turn));
-    const hasDeferredRecovery = () => listDeferredForegroundTransfers(storeDir).some((transfer) => !isFinalDeferredForegroundTransferStatus(transfer.status) &&
-        (transfer.source_session_id === session.session_id ||
-            transfer.target_session_id === session.session_id ||
-            (transfer.terminal_id === terminalId &&
-                terminalControlEvidenceMatches(transfer.terminal_endpoint, control))));
-    const commonChecks = {
-        relatedBoundSessionIds, blockingTurnIds,
-        hasNativeTransition: () => managedSessionHasAnyNativeTransition(storeDir, session),
-        hasDeferredRecovery,
-        ledgerMatchesTerminal: () => terminalListRuntime().terminalDispatchRecordMatchesControl(ledger, control)
-    };
-    if (owner && ledger) {
-        return decideTerminalScopedCodexApprovalAuthority({
-            kind: "current_dispatch_owner", storeDir, terminal, owner, session,
-            ledger, approval,
-            checks: {
-                ...commonChecks,
-                assertDispatchOwner: () => terminalListRuntime().assertManagedTerminalDispatchOwner({
-                    storeDir, conversation: owner, terminalControl: control, action: "approve"
-                }),
-                ownerMatchesNativeIdentity: (identity) => nativeAgentIdentityMatchesTurn(owner, identity
-                    ? { ...identity, evidence: "terminal_scoped_approval" }
-                    : undefined)
-            }
-        });
-    }
-    return decideTerminalScopedCodexApprovalAuthority({
-        kind: "managed_session_no_dispatch_owner", storeDir, terminal, session,
-        ledger, approval,
-        checks: {
-            ...commonChecks,
-            dispatchOwnershipIsNone: () => terminalDispatchOwnership(control).state === "none",
-            hasOrphanedDispatch: () => Boolean(terminalListRuntime().orphanedTerminalDispatchForRecovery(control))
-        }
+    return terminalListOwnershipService().terminalScopedCodexApprovalBoundary({
+        storeDir,
+        terminal,
+        session,
+        ledger,
+        approval,
+        owner
     });
 }
 async function resolveTerminalScopedCodexApproval({ options, terminal, approvalSnapshot }) {
@@ -2634,90 +1355,6 @@ async function resolveTerminalScopedCodexApproval({ options, terminal, approvalS
         };
     }
 }
-function historicalManagedTurnForTerminal(conversation) {
-    return renderHistoricalManagedTurn(managedTurnListEntry(terminalListRuntime().summarizeConversation(conversation), {
-        terminalBridge: terminalListRuntime().terminalBridgeEnabled(conversation),
-        approvalState: managedListApprovalState(conversation),
-        conversation
-    }));
-}
-function managedTurnMatchesLiveTerminal(conversation, terminal) {
-    const takeover = isRecord(conversation.native_session_takeover)
-        ? conversation.native_session_takeover
-        : undefined;
-    const liveControl = isRecord(terminal.terminal_control)
-        ? terminal.terminal_control
-        : undefined;
-    const storedControl = terminalListRuntime().terminalControlFromTakeover(takeover);
-    const livePid = Number(terminal.pid);
-    const storedPid = Number(takeover?.terminal_agent_pid);
-    if (executorForConversation(conversation).kind !== terminal.agent ||
-        !Number.isSafeInteger(livePid) ||
-        livePid <= 1 ||
-        storedPid !== livePid ||
-        !terminalControlAliasMatches(stringValue(takeover?.native_session_id), storedControl, stringValue(terminal.id), liveControl) ||
-        !terminalControlsShareIncarnation(storedControl, liveControl)) {
-        return false;
-    }
-    const liveSessionId = stringValue(terminal.native_agent_session_id);
-    const liveProcessUuid = stringValue(terminal.native_agent_process_uuid);
-    const liveProcessBirth = stringValue(terminal.native_agent_process_birth);
-    const liveRollout = isRecord(terminal.native_agent_rollout)
-        ? terminal.native_agent_rollout
-        : undefined;
-    const liveNativeIdentity = liveSessionId
-        ? {
-            sessionId: liveSessionId,
-            ...(liveProcessUuid ? { processUuid: liveProcessUuid } : {}),
-            ...(liveProcessBirth ? { processBirth: liveProcessBirth } : {}),
-            ...(liveRollout
-                ? {
-                    rollout: {
-                        fd: String(liveRollout.fd ?? ""),
-                        device: String(liveRollout.device ?? ""),
-                        inode: String(liveRollout.inode ?? ""),
-                        path: String(liveRollout.path ?? "")
-                    }
-                }
-                : {}),
-            evidence: "live_terminal"
-        }
-        : undefined;
-    if (!nativeAgentIdentityMatchesTurn(conversation, liveNativeIdentity)) {
-        return false;
-    }
-    const liveWorkspace = terminal.workspace ?? terminal.cwd;
-    if (!terminalListRuntime().matchesConfiguredWorkspace(conversation.workspace, liveWorkspace)) {
-        return false;
-    }
-    const livePanePath = liveControl?.currentPath;
-    if (livePanePath !== undefined &&
-        !terminalListRuntime().matchesConfiguredWorkspace(conversation.workspace, livePanePath)) {
-        return false;
-    }
-    return true;
-}
-function currentManagedTurnForTerminal(conversation, terminal, rawTerminalActions) {
-    const managedTurn = managedTurnListEntry(terminalListRuntime().summarizeConversation(conversation), {
-        terminalBridge: terminalListRuntime().terminalBridgeEnabled(conversation),
-        approvalState: managedListApprovalState(conversation),
-        conversation
-    });
-    const rawApproval = isRecord(rawTerminalActions.approve)
-        ? rawTerminalActions.approve
-        : undefined;
-    if (!rawApproval || executorForConversation(conversation).kind !== "codex") {
-        return managedTurn;
-    }
-    return renderCurrentManagedTurn(managedTurn, {
-        isCodex: true,
-        ownerId: conversation.conversation_id,
-        rawApproval,
-        terminalApprovalState: () => isRecord(terminal.approval_state)
-            ? terminal.approval_state
-            : undefined
-    });
-}
 async function listStateForTerminal(agent, terminalControl, options, bridge = terminalListRuntime().createTerminalAgentBridge(options), runtime) {
     if (options.noApprovalScan) {
         return {
@@ -2769,39 +1406,6 @@ async function listStateForTerminal(agent, terminalControl, options, bridge = te
         };
     }
 }
-function managedListApprovalState(conversation) {
-    if (!terminalListRuntime().terminalBridgeEnabled(conversation) ||
-        !["waiting_for_agent", "waiting_for_openclaw"].includes(String(conversation.status))) {
-        return undefined;
-    }
-    const nativeTakeover = isRecord(conversation.native_session_takeover)
-        ? conversation.native_session_takeover
-        : undefined;
-    if (!terminalListRuntime().terminalControlFromTakeover(nativeTakeover) ||
-        !stringValue(nativeTakeover?.terminal_bridge_message_id)) {
-        return undefined;
-    }
-    const approval = isRecord(nativeTakeover?.terminal_bridge_approval)
-        ? nativeTakeover.terminal_bridge_approval
-        : undefined;
-    const approvalState = isRecord(approval?.approval_state)
-        ? approval.approval_state
-        : undefined;
-    const fingerprint = stringValue(approval?.fingerprint);
-    const notifiedAt = stringValue(approval?.notified_at);
-    const notifiedAtMs = validTimestampMs(notifiedAt);
-    if (!approvalState ||
-        !fingerprint ||
-        notifiedAtMs === undefined ||
-        cliNowMs() - notifiedAtMs > terminalListRuntime().approvalTtlMs) {
-        return undefined;
-    }
-    return {
-        ...approvalState,
-        fingerprint,
-        notified_at: notifiedAt
-    };
-}
 async function resolveConversationSelectorOption(commandName, options) {
     const sendOperation = commandName === "send";
     // Submission retry is already bound to one authoritative managed Turn.
@@ -2972,12 +1576,11 @@ async function sessionSelectorCandidates(commandName, options) {
         .filter((conversation) => terminalListRuntime().matchesConfiguredWorkspace(options.workspace, conversation.workspace));
     const discoverableWorkspaceConversations = workspaceConversations
         .filter(terminalListRuntime().isDiscoverableTmuxConversation);
-    const managed = discoverableWorkspaceConversations.map((conversation) => managedTurnListEntry(terminalListRuntime().summarizeConversation(conversation), {
+    const managed = discoverableWorkspaceConversations.map((conversation) => terminalListProjectionService().managedTurnListEntry(terminalListRuntime().summarizeConversation(conversation), {
         terminalBridge: terminalListRuntime().terminalBridgeEnabled(conversation),
-        approvalState: managedListApprovalState(conversation),
         conversation
     }));
-    const terminalProjection = terminalFirstListProjection({
+    const terminalProjection = terminalListProjectionService().projectTerminalFirstList({
         storeDir,
         terminals: terminalScan.terminalControlled.filter((entry) => terminalListRuntime().matchesConfiguredWorkspace(options.workspace, entry.workspace ?? entry.cwd)),
         managedSessions: selectorStore.readable