@scotthuang/agent-knock-knock 0.12.13 → 0.12.15

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

@@ -9,16 +9,16 @@ import { executorForConversation, isSessionSendBlockingStatus, isTerminalDispatc
 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 { defaultStoreDir, ensureStoreWritable, inspectStoreCompatibility, listConversations, STORE_SESSION_AUTHORITY_PROTOCOL } from "./store.js";
+import { defaultStoreDir, ensureStoreWritable, inspectStoreCompatibility, listConversations, storeManifestPath, STORE_SESSION_AUTHORITY_PROTOCOL } from "./store.js";
 import { exactCodexReadyStyledComposerCapture } from "./terminal-agent-bridge.js";
 import { captureCodexHumanStartedActiveTaskAnchor } from "./terminal-submission-acceptance.js";
-import { applySessionAuthorityToDispatch, authoritativeTerminalIdentity, compareManagedConversationRecency, decideManagedTerminalAssociation, decideLocalTerminalDispatchOwnership, decideTerminalSendAuthority, decideTerminalSessionAuthorityConflict, managedTurnNeedsAttention as terminalManagedTurnNeedsAttention, nonOwnerTerminalActions, projectBlockingTurn, projectHandoffDecision, projectHandoffPresentation, projectPublicManagementConflict, projectReconcileBindingAction, projectTerminalDispatchConflict, projectTerminalManagement, selectManagedTerminalHistory, selectTerminalAvailableActions } from "./terminal-action-projection.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, renderAvailableListActions, renderCurrentManagedTurn, renderHistoricalManagedTurn, renderManagedTurnListEntry, safeUnavailableManagedTurnActions, sendActionForManagedSession, withoutGenericHandoffSourceClose } from "./terminal-list-renderer.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 { isRecord, nonBlankString as stringValue } from "./value-guards.js";
@@ -65,13 +65,29 @@ function projectSelectorCandidate(entry, commandName, observedAtMs, options) {
 }
 async function runList(options) {
     const storeDir = expandHome(options.storeDir ?? options.logDir ?? defaultStoreDir(cliCwd()));
-    const store = inspectStoreCompatibility(storeDir);
-    const reconciliation = options.reconcile === true
-        ? await reconcileStoreForList(storeDir, options)
-        : {
+    const store = inspectStoreCompatibilityForTerminalList(storeDir);
+    let reconciliation;
+    if (options.reconcile === true) {
+        try {
+            reconciliation = await reconcileStoreForList(storeDir, options);
+        }
+        catch (error) {
+            reconciliation = {
+                status: "failed",
+                reason: error instanceof Error ? error.message : String(error)
+            };
+            runtimeLog("warn", "terminal_list_reconciliation_failed", {
+                store_dir: storeDir,
+                error: reconciliation.reason
+            });
+        }
+    }
+    else {
+        reconciliation = {
             status: "disabled",
             reason: "standalone list is read-only unless --reconcile is supplied"
         };
+    }
     const agentFilter = options.agent ? resolveExecutor({ kind: options.agent }).kind : undefined;
     const statusFilter = options.status;
     const terminalScan = await buildTerminalListGroup({ options, agentFilter, statusFilter });
@@ -107,14 +123,75 @@ async function runList(options) {
         reconciliation
     });
 }
+function inspectStoreCompatibilityForTerminalList(storeDir) {
+    try {
+        return inspectStoreCompatibility(storeDir);
+    }
+    catch (error) {
+        return {
+            status: "incompatible",
+            store_dir: storeDir,
+            manifest_path: storeManifestPath(storeDir),
+            readable: false,
+            writable: false,
+            reason: `AKK Store metadata is unavailable: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
+function physicalOnlyTerminalProjection(terminals, reason) {
+    return {
+        terminals: terminals.map((terminal) => {
+            const { _automated_input_composer_ready: _composer, _codex_open_root_rollout_inventory: _inventory, _codex_latent_clear_resume: _resume, _terminal_user_explicit_send_action: terminalUserExplicitSendAction, _terminal_status_snapshot: _status, ...publicTerminal } = terminal;
+            const actions = isRecord(publicTerminal.available_actions)
+                ? publicTerminal.available_actions
+                : {};
+            const send = isRecord(terminalUserExplicitSendAction)
+                ? terminalUserExplicitSendAction
+                : undefined;
+            const status = isRecord(actions.status) ? actions.status : undefined;
+            return {
+                ...publicTerminal,
+                management_state: "unavailable",
+                management_unavailable: { reason },
+                managed: {
+                    session_id: null,
+                    session_short_ref: null,
+                    current_turn: null,
+                    recent_turn: null,
+                    turn_count: 0,
+                    hidden_turn_count: 0,
+                    session_count: 0
+                },
+                available_actions: {
+                    ...(status ? { status } : {}),
+                    ...(send ? { send } : {})
+                }
+            };
+        }),
+        unavailableManagedTurns: []
+    };
+}
 function projectTerminalListScan(input) {
     const { options, storeDir, store, terminalScan, agentFilter, statusFilter, tolerateInvalidWatchRecords } = input;
     const includeAll = Boolean(options.all);
-    const allManagedConversations = listConversations(storeDir)
-        .filter(terminalListRuntime().isDiscoverableTmuxConversation);
-    const managedSessions = store.readable
-        ? listManagedSessions(storeDir)
-        : [];
+    const managementErrors = [];
+    let allManagedConversations = [];
+    try {
+        allManagedConversations = listConversations(storeDir)
+            .filter(terminalListRuntime().isDiscoverableTmuxConversation);
+    }
+    catch (error) {
+        managementErrors.push(`managed Turn inventory is unavailable: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let managedSessions = [];
+    if (store.readable) {
+        try {
+            managedSessions = listManagedSessions(storeDir);
+        }
+        catch (error) {
+            managementErrors.push(`managed Session inventory is unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     const displayedConversations = allManagedConversations
         .filter((conversation) => includeAll || terminalListRuntime().isActiveStatus(conversation.status))
         .filter((conversation) => terminalListRuntime().matchesConfiguredWorkspace(options.workspace, conversation.workspace))
@@ -122,26 +199,48 @@ function projectTerminalListScan(input) {
         .filter((conversation) => !statusFilter || conversation.status === statusFilter);
     const workspaceConversations = allManagedConversations.filter((conversation) => terminalListRuntime().matchesConfiguredWorkspace(options.workspace, conversation.workspace));
     const physicalTerminals = terminalScan.terminalControlled.filter((entry) => terminalListRuntime().matchesConfiguredWorkspace(options.workspace, entry.workspace ?? entry.cwd));
-    const projection = terminalFirstListProjection({
-        storeDir,
-        terminals: physicalTerminals,
-        managedSessions,
-        sessionAuthorityRequired: Number(store.writer_protocol) >= STORE_SESSION_AUTHORITY_PROTOCOL,
-        allConversations: workspaceConversations,
-        displayedConversations,
-        includeAll,
-        managedOnly: options.managedOnly === true,
-        statusFilter,
-        mutationsAllowed: store.writable === true
-    });
+    let projection;
+    if (managementErrors.length === 0) {
+        try {
+            projection = terminalFirstListProjection({
+                storeDir,
+                terminals: physicalTerminals,
+                managedSessions,
+                sessionAuthorityRequired: Number(store.writer_protocol) >= STORE_SESSION_AUTHORITY_PROTOCOL,
+                allConversations: workspaceConversations,
+                displayedConversations,
+                includeAll,
+                managedOnly: options.managedOnly === true,
+                statusFilter,
+                mutationsAllowed: store.writable === true
+            });
+        }
+        catch (error) {
+            managementErrors.push(`managed terminal projection is unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            projection = physicalOnlyTerminalProjection(physicalTerminals, managementErrors.join("; "));
+        }
+    }
+    else {
+        projection = physicalOnlyTerminalProjection(physicalTerminals, managementErrors.join("; "));
+    }
     const exactWatchScan = terminalListRuntime()
         .scanTerminalWatchesForExactObservation;
-    const watchObservation = tolerateInvalidWatchRecords && exactWatchScan
-        ? exactWatchScan(storeDir, { includeAll })
-        : {
-            watches: terminalListRuntime().listTerminalWatches?.(storeDir, { includeAll }) ?? [],
-            activeOverlayTrusted: true
-        };
+    let watchObservation;
+    try {
+        watchObservation = tolerateInvalidWatchRecords && exactWatchScan
+            ? exactWatchScan(storeDir, { includeAll })
+            : {
+                watches: terminalListRuntime().listTerminalWatches?.(storeDir, { includeAll }) ?? [],
+                activeOverlayTrusted: true
+            };
+    }
+    catch (error) {
+        runtimeLog("warn", "terminal_watch_inventory_unavailable", {
+            store_dir: storeDir,
+            error: error instanceof Error ? error.message : String(error)
+        });
+        watchObservation = { watches: [], activeOverlayTrusted: false };
+    }
     const observedTerminalWatches = watchObservation.watches;
     const terminalWatches = options.managedOnly
         ? []
@@ -167,7 +266,7 @@ function projectTerminalListScan(input) {
 async function observeExactTerminal(request) {
     const { options, terminalId } = request;
     const storeDir = expandHome(options.storeDir ?? options.logDir ?? defaultStoreDir(cliCwd()));
-    const store = inspectStoreCompatibility(storeDir);
+    const store = inspectStoreCompatibilityForTerminalList(storeDir);
     const scan = await buildTerminalListGroup({ options, terminalId });
     const matches = scan.terminalControlled.filter((terminal) => stringValue(terminal.id) === terminalId);
     if (matches.length !== 1) {
@@ -340,9 +439,10 @@ function managedTurnListActionFacts(task, conversation) {
     const terminalBridgeReady = Boolean(conversation &&
         terminalListRuntime().terminalBridgeEnabled(conversation) &&
         terminalListRuntime().terminalControlFromTakeover(nativeTakeover) !== undefined);
+    const submission = terminalListRuntime().terminalBridgeSubmission(conversation);
     const renewEligible = Boolean(terminalBridgeReady &&
         task.status === "stalled" &&
-        terminalListRuntime().terminalBridgeSubmission(conversation)?.status !== "uncertain" &&
+        submission?.status !== "uncertain" &&
         !terminalListRuntime().isVerifiedDeadTerminalAgentProcess(conversation ?? {}));
     const callbackDelivery = isRecord(conversation?.callback_delivery)
         ? conversation.callback_delivery
@@ -351,11 +451,18 @@ function managedTurnListActionFacts(task, 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
+        retryCallbackEligible,
+        retrySubmissionCandidate
     };
 }
 async function terminalControlledListEntry(session, activeSessions, options, bridge = terminalListRuntime().createTerminalAgentBridge(options)) {
@@ -436,15 +543,35 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
     });
     const codexLifecycleIncarnationAvailable = session.agent !== "codex" ||
         Boolean(nativeProcessUuid && nativeProcessBirth);
-    const terminalHasBlockingTurn = terminalIncarnationBlockingTurns(terminalListRuntime().storeDirFromOptions(options), terminalControl).length > 0;
+    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 automatedInputComposerReady = await observeAutomatedInputComposerReady({
         session,
         terminalControl,
         terminalState: effectiveTerminalState,
-        nativeIdentityObservation,
-        codexOpenRootRolloutInventory,
         options
     });
+    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 entry = {
         id: bridge.terminalConversationId(session),
         short_ref: sessionShortRef(bridge.terminalConversationId(session)),
@@ -534,11 +661,38 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             terminalHasBlockingTurn
         })
     };
-    const availableActions = renderAvailableListActions(entry);
+    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,
+        exactEmptyComposer: automatedInputComposerReady
+    });
+    const terminalUserExplicitSendAction = terminalUserExplicitSendAuthority.eligible
+        ? {
+            tool: "agent_knock_knock_send",
+            arguments: {
+                selector: terminalUserExplicitSendAuthority.terminalId,
+                expected_terminal_token: terminalUserExplicitSendAuthority.expectedTerminalToken
+            },
+            missing_required: ["request"],
+            scope: "terminal_user_explicit"
+        }
+        : undefined;
     const { commands: _commands, ...publicEntry } = entry;
     return {
         ...publicEntry,
-        available_actions: availableActions
+        ...(terminalUserExplicitSendAction
+            ? { _terminal_user_explicit_send_action: terminalUserExplicitSendAction }
+            : {}),
+        available_actions: renderedActions
     };
 }
 function terminalListCommands(input) {
@@ -651,7 +805,17 @@ function terminalBridgeStatusWithActivity(status, activityState, activityReason)
     return Object.create(Object.getPrototypeOf(status), descriptors);
 }
 async function observeTerminalNativeListIdentity(session, terminalControl, options, bridge) {
-    const orphanedDispatch = terminalListRuntime().orphanedTerminalDispatchForRecovery(terminalControl);
+    let orphanedDispatch;
+    try {
+        orphanedDispatch =
+            terminalListRuntime().orphanedTerminalDispatchForRecovery(terminalControl);
+    }
+    catch (error) {
+        runtimeLog("warn", "terminal_orphaned_dispatch_observation_unavailable", {
+            terminal_target: terminalControl.target,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
     let codexIdentityContext;
     if (session.agent === "codex") {
         try {
@@ -677,15 +841,25 @@ async function observeTerminalNativeListIdentity(session, terminalControl, optio
             });
         }
     }
-    const nativeIdentityObservation = await terminalListRuntime().observeCurrentNativeAgentSessionIdentity({
-        options,
-        agent: session.agent,
-        pid: session.pid,
-        cwd: session.cwd ?? terminalControl.currentPath,
-        preferredSessionId: codexIdentityContext?.preferredSessionId,
-        allowedCompanionIdentity: codexIdentityContext?.companions.primary,
-        allowedAdditionalIdentities: codexIdentityContext?.companions.additional
-    });
+    let nativeIdentityObservation;
+    try {
+        nativeIdentityObservation =
+            await terminalListRuntime().observeCurrentNativeAgentSessionIdentity({
+                options,
+                agent: session.agent,
+                pid: session.pid,
+                cwd: session.cwd ?? terminalControl.currentPath,
+                preferredSessionId: codexIdentityContext?.preferredSessionId,
+                allowedCompanionIdentity: codexIdentityContext?.companions.primary,
+                allowedAdditionalIdentities: codexIdentityContext?.companions.additional
+            });
+    }
+    catch (error) {
+        nativeIdentityObservation = {
+            status: "unavailable",
+            reason: error instanceof Error ? error.message : String(error)
+        };
+    }
     const nativeAgentIdentity = nativeIdentityObservation.status === "resolved"
         ? nativeIdentityObservation.identity
         : undefined;
@@ -752,13 +926,9 @@ async function observeTerminalNativeListIdentity(session, terminalControl, optio
         nativeProcessEvidence
     };
 }
-async function observeAutomatedInputComposerReady({ session, terminalControl, terminalState, nativeIdentityObservation, codexOpenRootRolloutInventory, options }) {
+async function observeAutomatedInputComposerReady({ session, terminalControl, terminalState, options }) {
     let ready = terminalListRuntime().nativeInspectionComposerEmpty(session.agent, terminalState.screen_excerpt);
     if (session.agent !== "codex" ||
-        (terminalState.activity_state !== "idle" &&
-            (terminalState.activity_state !== "unknown" ||
-                (nativeIdentityObservation.status !== "verified_absent" &&
-                    codexOpenRootRolloutInventory === undefined))) ||
         terminalState.approval_state.blocked === true ||
         !terminalControl.capabilities.includes("send_keys") ||
         !terminalControl.capabilities.includes("screen_status")) {
@@ -779,7 +949,7 @@ async function observeAutomatedInputComposerReady({ session, terminalControl, te
 }
 function observeTerminalListBindingAuthority(terminal, context) {
     const { storeDir, managedSessions, allConversations, displayedConversations, mutationsAllowed, nonterminalDeferredTransfers } = context;
-    const { _automated_input_composer_ready: automatedInputComposerReady, _codex_open_root_rollout_inventory: codexOpenRootRolloutInventoryValue, _codex_latent_clear_resume: codexLatentClearResumeValue, _terminal_status_snapshot: _terminalStatusSnapshot, ...publicTerminal } = terminal;
+    const { _automated_input_composer_ready: automatedInputComposerReady, _codex_open_root_rollout_inventory: codexOpenRootRolloutInventoryValue, _codex_latent_clear_resume: codexLatentClearResumeValue, _terminal_user_explicit_send_action: terminalUserExplicitSendAction, _terminal_status_snapshot: _terminalStatusSnapshot, ...publicTerminal } = terminal;
     const codexOpenRootRolloutInventory = isRecord(codexOpenRootRolloutInventoryValue)
         ? codexOpenRootRolloutInventoryValue
         : undefined;
@@ -938,6 +1108,7 @@ function observeTerminalListBindingAuthority(terminal, context) {
         automatedInputComposerReady,
         codexOpenRootRolloutInventory,
         codexLatentClearResumeValue,
+        terminalUserExplicitSendAction,
         publicTerminal,
         terminalControl,
         terminalHasNonterminalDeferredTransfer,
@@ -1235,14 +1406,9 @@ function observeTerminalHandoffAuthority(terminal, context, observation) {
         })
         : undefined;
     const blockingHandoffTurnIds = new Set(handoffSourceBlockingTurns.map((turn) => turn.conversation_id));
-    // An active source Turn may be superseded only through the snapshot-bound
-    // handoff decision above. Never expose the generic Store-only close action
-    // for that Turn, because doing so would bypass expected_handoff_token after
-    // the live native thread or Turn generation changed. `blocking_turns` is
-    // reserved for other same-incarnation blockers such as legacy collateral
-    // stalls; clear those first, refresh, and only then decide the handoff.
-    const terminalRecoveryBlockingTurns = terminalBlockingTurns.filter((turn) => !blockingHandoffTurnIds.has(turn.conversation_id) &&
-        !conversationHasNonterminalDeferredTransfer(turn));
+    // 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,
@@ -1329,7 +1495,7 @@ function observeTerminalListActionAuthority(terminal, context, binding) {
 }
 function renderTerminalFirstListEntry(terminal, context, observation) {
     const { sessionAuthorityRequired, includeAll, mutationsAllowed, conversationHasNonterminalDeferredTransfer } = context;
-    const { automatedInputComposerReady, publicTerminal, allRelated, displayedRelated, relatedSessions, authoritativeSession, ownership, rawSendAction, sessionAwareRawActions, externalHandoffDetected, externalHandoffSnapshotToken, handoffSourceBlockingTurns, verifiedEmptyRawSendAction, verifiedEmptyCodexSnapshotToken, deferredCodexSourceRolloutAuthority, deferredCodexForegroundToken, reconcileBindingAction, externalHandoffAdoptable, handoffDecision, blockingHandoffTurnIds, terminalRecoveryBlockingTurns, terminalScopedCodexApprovalAction, rolloutBackedCodexSession } = observation;
+    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,
@@ -1351,11 +1517,14 @@ function renderTerminalFirstListEntry(terminal, context, observation) {
     const currentTurnValue = ownership.state === "current"
         ? currentManagedTurnForTerminal(ownership.conversation, terminal, sessionAwareRawActions)
         : undefined;
-    const currentTurnProjection = currentTurnValue && (!mutationsAllowed ||
-        (ownership.state === "current" &&
-            conversationHasNonterminalDeferredTransfer(ownership.conversation)))
-        ? readOnlyManagedTurn(currentTurnValue)
-        : currentTurnValue;
+    const currentTurnProjection = currentTurnValue
+        ? !mutationsAllowed
+            ? readOnlyManagedTurn(currentTurnValue)
+            : ownership.state === "current" &&
+                conversationHasNonterminalDeferredTransfer(ownership.conversation)
+                ? userReleasableManagedTurn(currentTurnValue)
+                : currentTurnValue
+        : undefined;
     const currentTurn = currentTurnProjection
         ? withoutGenericHandoffSourceClose(currentTurnProjection, blockingHandoffTurnIds)
         : undefined;
@@ -1372,20 +1541,24 @@ function renderTerminalFirstListEntry(terminal, context, observation) {
     const recentTurnValue = recentConversation
         ? historicalManagedTurnForTerminal(recentConversation)
         : undefined;
-    const recentTurnProjection = recentTurnValue && (!mutationsAllowed ||
-        Boolean(recentConversation &&
-            conversationHasNonterminalDeferredTransfer(recentConversation)))
-        ? readOnlyManagedTurn(recentTurnValue)
-        : recentTurnValue;
+    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 &&
-            !conversationHasNonterminalDeferredTransfer(conversation)
-            ? turn
-            : readOnlyManagedTurn(turn), blockingHandoffTurnIds);
+        return withoutGenericHandoffSourceClose(!mutationsAllowed
+            ? readOnlyManagedTurn(turn)
+            : conversationHasNonterminalDeferredTransfer(conversation)
+                ? userReleasableManagedTurn(turn)
+                : turn, blockingHandoffTurnIds);
     });
     const visibleTurnIds = new Set([currentTurn, recentTurn, ...history]
         .map((turn) => stringValue(turn?.conversation_id))
@@ -1446,6 +1619,20 @@ function renderTerminalFirstListEntry(terminal, context, observation) {
                 }
             }
             : 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"
@@ -1454,6 +1641,7 @@ function renderTerminalFirstListEntry(terminal, context, observation) {
         sessionAwareRawActions: sessionAwareRawActions,
         nonOwnerRawActions,
         authoritativeSendAction,
+        terminalUserExplicitSendAction: prioritizedTerminalUserExplicitSendAction,
         reconcileBindingAction,
         terminalScopedApprovalAction: terminalScopedCodexApprovalAction,
         isAction: isRecord
@@ -1562,14 +1750,17 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         });
         return {
             ...managedTurn,
-            available_actions: mutationsAllowed &&
-                !conversationHasNonterminalDeferredTransfer(conversation)
-                ? safeUnavailableManagedTurnActions(isRecord(managedTurn.available_actions)
+            available_actions: !mutationsAllowed
+                ? readOnlyListActions(isRecord(managedTurn.available_actions)
                     ? managedTurn.available_actions
                     : {})
-                : 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
@@ -2266,6 +2457,12 @@ function managedListApprovalState(conversation) {
 }
 async function resolveConversationSelectorOption(commandName, options) {
     const sendOperation = commandName === "send";
+    // Submission retry is already bound to one authoritative managed Turn.
+    // Keep it out of ordinary-send selector discovery so an omitted Session
+    // target cannot be inferred and mixed into the exact `send --turn` form.
+    if (sendOperation && stringValue(options.turn)) {
+        return;
+    }
     if (stringValue(options.expectedTerminalToken)) {
         // Selector resolution may replace an alias (or an omitted selector) with a
         // discovered full terminal id. Preserve the caller's actual authority so
@@ -2282,11 +2479,54 @@ async function resolveConversationSelectorOption(commandName, options) {
     const supplied = stringValue(sendOperation
         ? options.session ?? options.conversation ?? options.conversationId
         : options.turn ?? options.conversation ?? options.conversationId)?.trim();
-    if (supplied && !isSessionSelectorSyntax(supplied)) {
+    if (sendOperation &&
+        options.managedOnly === true &&
+        supplied?.startsWith("terminal:v") &&
+        !stringValue(options.expectedTerminalToken)) {
+        // `--managed-only` is an explicit diagnostic/test request for the legacy
+        // managed state machine. Keep an exact physical id on that path without
+        // upgrading it to the default user-priority Send authority. Ordinary user
+        // Send never sets this option and continues to discover and bind fresh
+        // physical authority below.
+        options.session = supplied;
+        return;
+    }
+    if (supplied &&
+        !isSessionSelectorSyntax(supplied) &&
+        !(sendOperation &&
+            supplied.startsWith("terminal:v") &&
+            !stringValue(options.expectedTerminalToken))) {
         // Full authoritative IDs keep their existing command-specific validation
         // path. This avoids a discovery scan before option validation and preserves
         // precise downstream errors for closed or currently non-actionable state.
         if (sendOperation) {
+            if (supplied.startsWith("terminal:v") &&
+                stringValue(options.expectedTerminalToken)) {
+                try {
+                    const observed = await observeExactTerminal({
+                        options,
+                        terminalId: supplied
+                    });
+                    const actions = observed.state === "available" &&
+                        isRecord(observed.terminal.available_actions)
+                        ? observed.terminal.available_actions
+                        : {};
+                    const send = isRecord(actions.send) ? actions.send : {};
+                    const argumentsValue = isRecord(send.arguments)
+                        ? send.arguments
+                        : {};
+                    options.expectedManagedTerminalToken =
+                        stringValue(argumentsValue.expected_terminal_token) ===
+                            stringValue(options.expectedTerminalToken)
+                            ? stringValue(argumentsValue.expected_managed_terminal_token)
+                            : undefined;
+                }
+                catch {
+                    // Managed fast-path discovery is optional. The physical Send token
+                    // is still revalidated by execution and may fall back without Store.
+                    options.expectedManagedTerminalToken = undefined;
+                }
+            }
             options.session = supplied;
         }
         else {
@@ -2299,12 +2539,24 @@ async function resolveConversationSelectorOption(commandName, options) {
         operation: commandName
     });
     if (sendOperation) {
-        options.session = resolution.id;
+        const physical = resolution.candidate.userExplicitTerminalSend;
+        if (!physical) {
+            throw new Error("the selected terminal no longer advertises user-priority Send");
+        }
+        // Preserve a token-bearing caller's original selector for the exact fence.
+        if (!stringValue(options.expectedTerminalToken)) {
+            terminalListRuntime().rememberOriginalExpectedTerminalSelector(options, physical.terminalId);
+        }
+        options.expectedTerminalToken = physical.expectedTerminalToken;
+        options.expectedManagedTerminalToken =
+            physical.expectedManagedTerminalToken;
+        options.session = physical.terminalId;
+        options.conversation = physical.terminalId;
     }
     else {
         options.turn = resolution.id;
+        options.conversation = resolution.id;
     }
-    options.conversation = resolution.id;
     delete options.conversationId;
 }
 function isSessionSelectorSyntax(value) {
@@ -2312,6 +2564,59 @@ function isSessionSelectorSyntax(value) {
         /^@[0-9a-f]+$/iu.test(value));
 }
 async function sessionSelectorCandidates(commandName, options) {
+    const terminalScan = await buildTerminalListGroup({
+        options: {
+            ...options,
+            noApprovalScan: commandName === "send"
+                ? false
+                : ["approve", "cancel"].includes(commandName)
+                    ? options.noApprovalScan
+                    : true
+        },
+        agentFilter: undefined,
+        statusFilter: undefined
+    });
+    const observedAtMs = cliNowMs();
+    if (commandName === "send") {
+        return terminalScan.terminalControlled
+            .filter((entry) => terminalListRuntime().matchesConfiguredWorkspace(options.workspace, entry.workspace ?? entry.cwd))
+            .flatMap((entry) => {
+            const action = isRecord(entry._terminal_user_explicit_send_action)
+                ? entry._terminal_user_explicit_send_action
+                : undefined;
+            const argumentsValue = isRecord(action?.arguments)
+                ? action.arguments
+                : undefined;
+            const terminalId = stringValue(entry.id);
+            const expectedTerminalToken = stringValue(argumentsValue?.expected_terminal_token);
+            if (action?.scope !== "terminal_user_explicit" ||
+                !terminalId ||
+                stringValue(argumentsValue?.selector ?? argumentsValue?.terminal_id) !== terminalId ||
+                !expectedTerminalToken) {
+                return [];
+            }
+            const candidate = projectSelectorCandidate({
+                ...entry,
+                available_actions: { send: action }
+            }, commandName, observedAtMs, {
+                defaultActionable: true,
+                // Physical Send authority is independent of Store writability.
+                mutationsAllowed: true
+            });
+            return [{
+                    ...candidate,
+                    userExplicitTerminalSend: {
+                        terminalId,
+                        expectedTerminalToken,
+                        ...(stringValue(argumentsValue?.expected_managed_terminal_token) === undefined
+                            ? {}
+                            : {
+                                expectedManagedTerminalToken: stringValue(argumentsValue?.expected_managed_terminal_token)
+                            })
+                    }
+                }];
+        });
+    }
     const storeDir = terminalListRuntime().storeDirFromOptions(options);
     const mutationsAllowed = inspectStoreCompatibility(storeDir).writable === true;
     const selectorStore = inspectStoreCompatibility(storeDir);
@@ -2325,16 +2630,6 @@ async function sessionSelectorCandidates(commandName, options) {
         approvalState: managedListApprovalState(conversation),
         conversation
     }));
-    const terminalScan = await buildTerminalListGroup({
-        options: {
-            ...options,
-            noApprovalScan: ["send", "approve", "cancel"].includes(commandName)
-                ? options.noApprovalScan
-                : true
-        },
-        agentFilter: undefined,
-        statusFilter: undefined
-    });
     const terminalProjection = terminalFirstListProjection({
         storeDir,
         terminals: terminalScan.terminalControlled.filter((entry) => terminalListRuntime().matchesConfiguredWorkspace(options.workspace, entry.workspace ?? entry.cwd)),
@@ -2349,87 +2644,6 @@ async function sessionSelectorCandidates(commandName, options) {
         statusFilter: undefined,
         mutationsAllowed
     });
-    const observedAtMs = cliNowMs();
-    if (commandName === "send") {
-        const sessionEntries = terminalProjection.terminals.flatMap((entry) => {
-            const managedState = isRecord(entry.managed) ? entry.managed : undefined;
-            const recentTurn = isRecord(managedState?.recent_turn)
-                ? managedState.recent_turn
-                : undefined;
-            const currentTurn = isRecord(managedState?.current_turn)
-                ? managedState.current_turn
-                : undefined;
-            const sessionId = stringValue(managedState?.session_id);
-            const actions = isRecord(entry.available_actions)
-                ? entry.available_actions
-                : undefined;
-            const sendAction = isRecord(actions?.send)
-                ? actions.send
-                : undefined;
-            const sendArguments = isRecord(sendAction?.arguments)
-                ? sendAction.arguments
-                : undefined;
-            if (!sessionId ||
-                !sendAction ||
-                stringValue(sendArguments?.session_id) !== sessionId) {
-                return [];
-            }
-            const commonEntry = {
-                agent: entry.agent,
-                status: "idle",
-                workspace: entry.workspace ?? entry.cwd,
-                updated_at: recentTurn?.updated_at ??
-                    currentTurn?.updated_at,
-                available_actions: {
-                    send: sendAction
-                }
-            };
-            return [
-                {
-                    ...commonEntry,
-                    id: sessionId,
-                    short_ref: sessionShortRef(sessionId),
-                    source: "managed_session"
-                },
-                {
-                    ...commonEntry,
-                    id: String(entry.id),
-                    short_ref: stringValue(entry.short_ref) ??
-                        sessionShortRef(String(entry.id)),
-                    source: "managed_session_terminal_alias"
-                }
-            ];
-        });
-        const rawTerminalEntries = terminalProjection.terminals.filter((entry) => {
-            const managedState = isRecord(entry.managed) ? entry.managed : undefined;
-            const actions = isRecord(entry.available_actions)
-                ? entry.available_actions
-                : undefined;
-            const sendAction = isRecord(actions?.send) ? actions.send : undefined;
-            const sendArguments = isRecord(sendAction?.arguments)
-                ? sendAction.arguments
-                : undefined;
-            return (!stringValue(managedState?.session_id) ||
-                !stringValue(sendArguments?.session_id));
-        });
-        return [
-            ...managed.map((entry) => projectSelectorCandidate(entry, commandName, observedAtMs, {
-                defaultActionable: false,
-                mutationsAllowed
-            })),
-            ...sessionEntries.map((entry) => projectSelectorCandidate(entry, commandName, observedAtMs, {
-                // A managed terminal's full id/@short-ref is an explicit alias for
-                // its Session send target. It must not duplicate the Session in
-                // omitted, only, latest, or agent-name selection.
-                defaultActionable: entry.source !== "managed_session_terminal_alias",
-                mutationsAllowed
-            })),
-            ...rawTerminalEntries.map((entry) => projectSelectorCandidate(entry, commandName, observedAtMs, {
-                defaultActionable: true,
-                mutationsAllowed
-            }))
-        ];
-    }
     return [
         ...managed.map((entry) => projectSelectorCandidate(entry, commandName, observedAtMs, {
             defaultActionable: options.managedOnly === true,