@scotthuang/agent-knock-knock 0.12.13 → 0.12.15

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

@@ -1,9 +1,10 @@
 // Raw CLI composition for renew, cancel, and close maintenance commands.
 import { AsyncLocalStorage } from "node:async_hooks";
 import path from "node:path";
+import { supersedeCallbackNotificationDelivery, supersedeUnacceptedCallbackDeliveries } from "./callback-outbox-policy.js";
 import { withCanonicalMutationLocks } from "./mutation-transaction.js";
 import { budgetAction, executorForConversation, sessionIdForConversation, isSessionSendBlockingStatus, turnIdForConversation } from "./protocol.js";
-import { appendEvent, loadState, logPathForStatePath, pathsForConversationDir, saveState, withStoreWriterLeaseAsync } from "./store.js";
+import { appendEvent, appendExplicitUserCloseEvent, loadState, logPathForStatePath, pathsForConversationDir, saveExplicitUserCloseState, saveState, withStoreWriterLeaseAsync } from "./store.js";
 import { loadManagedSession, tryLoadManagedSession } from "./session-store.js";
 import { TerminalControlUnavailableError } from "./terminal-control-provider.js";
 import { terminalControlsShareIncarnation } from "./terminal-authority-policy.js";
@@ -13,11 +14,12 @@ import { terminalBridgeSubmission } from "./terminal-dispatch-receipt.js";
 import { terminalDispatchLedgerLooksLifecycle } from "./terminal-dispatch-ledger-codec.js";
 import { loadDeferredForegroundTransfer } from "./deferred-foreground-transfer.js";
 import { isFinalDeferredForegroundTransferStatus } from "./deferred-foreground-transfer-policy.js";
+import { cleanupDeferredForegroundUserClose } from "./deferred-foreground-user-close.js";
 import { isRecoverableTerminalDispatchStatus } from "./terminal-dispatch-policy.js";
 import { decideVerifiedDeadAgentProcess } from "./verified-dead-agent-policy.js";
 import { terminalMonitorDeadlineAt as deadlineAt } from "./terminal-monitor-decision-policy.js";
 import { writeCliJson as printJson } from "./cli-command-runtime.js";
-import { cliCwd, cliEnv, cliExit, cliNow, cliNowMs, cliRuntimeLog as runtimeLog } from "./cli-runtime-context.js";
+import { cliCwd, cliNow, cliNowMs, cliRuntimeLog as runtimeLog } from "./cli-runtime-context.js";
 import { isRecord, nonBlankString as stringValue } from "./value-guards.js";
 const terminalMaintenanceContext = new AsyncLocalStorage();
 function terminalMaintenanceRuntime() {
@@ -137,94 +139,100 @@ async function runRenew(options) {
     let renewedTerminalControl = terminalControl;
     let inactivityTimeoutMinutes = 0;
     let hardTimeoutMinutes = 0;
-    const releaseStateLock = acquireFileLock(`${statePath}.lock`);
-    try {
-        const current = loadState(statePath);
-        if (current.status !== "stalled") {
-            throw new Error(`cannot renew ${current.conversation_id}; conversation is ${current.status}, not stalled`);
-        }
-        if (isVerifiedDeadTerminalAgentProcess(current)) {
-            throw new Error(`cannot renew ${current.conversation_id}; its bound terminal agent ` +
-                "process is verified dead");
-        }
-        if (terminalBridgeSubmission(current)?.status === "uncertain") {
-            throw new Error(`cannot renew ${current.conversation_id}; its terminal submission is uncertain`);
-        }
-        const currentTakeover = isRecord(current.native_session_takeover)
-            ? current.native_session_takeover
-            : undefined;
-        const currentControl = terminalControlFromTakeover(currentTakeover);
-        if (!currentControl || currentTakeover?.terminal_bridge !== true) {
-            throw new Error(`cannot renew ${current.conversation_id}; conversation is not a terminal bridge task`);
-        }
-        if (current.conversation_id !== conversation.conversation_id ||
-            !terminalControlsShareIncarnation(currentControl, terminalControl) ||
-            stringValue(currentTakeover.terminal_bridge_message_id) !== expectedMessageId ||
-            stringValue(currentTakeover.terminal_bridge_started_at) !== expectedStartedAt) {
-            throw new Error("conversation changed while waiting to renew; refresh status and retry");
+    const writerStoreDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
+    await withStoreWriterLease(writerStoreDir, async () => {
+        const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+        try {
+            const current = loadState(statePath);
+            if (current.status !== "stalled") {
+                throw new Error(`cannot renew ${current.conversation_id}; conversation is ${current.status}, not stalled`);
+            }
+            if (isVerifiedDeadTerminalAgentProcess(current)) {
+                throw new Error(`cannot renew ${current.conversation_id}; its bound terminal agent ` +
+                    "process is verified dead");
+            }
+            if (terminalBridgeSubmission(current)?.status === "uncertain") {
+                throw new Error(`cannot renew ${current.conversation_id}; its terminal submission is uncertain`);
+            }
+            const currentTakeover = isRecord(current.native_session_takeover)
+                ? current.native_session_takeover
+                : undefined;
+            const currentControl = terminalControlFromTakeover(currentTakeover);
+            if (!currentControl || currentTakeover?.terminal_bridge !== true) {
+                throw new Error(`cannot renew ${current.conversation_id}; conversation is not a terminal bridge task`);
+            }
+            if (current.conversation_id !== conversation.conversation_id ||
+                !terminalControlsShareIncarnation(currentControl, terminalControl) ||
+                stringValue(currentTakeover.terminal_bridge_message_id) !== expectedMessageId ||
+                stringValue(currentTakeover.terminal_bridge_started_at) !== expectedStartedAt) {
+                throw new Error("conversation changed while waiting to renew; refresh status and retry");
+            }
+            assertTurnBindingCurrent(current, "renew");
+            renewedTerminalControl = currentControl;
+            inactivityTimeoutMinutes = positiveMinutes(options.minutes ??
+                options.agentTimeoutMinutes ??
+                currentTakeover.terminal_bridge_inactivity_timeout_minutes ??
+                terminalMaintenanceRuntime().dependencies.runtime
+                    .defaultAgentTimeoutMinutes, "--minutes");
+            hardTimeoutMinutes = positiveMinutes(currentTakeover.terminal_bridge_hard_timeout_minutes ??
+                terminalMaintenanceRuntime().dependencies.runtime
+                    .defaultAgentHardTimeoutMinutes, "--agent-hard-timeout-minutes");
+            const startedAt = stringValue(currentTakeover.terminal_bridge_started_at);
+            const startedAtMs = startedAt ? Date.parse(startedAt) : NaN;
+            if (Number.isFinite(startedAtMs) &&
+                cliNowMs() - startedAtMs >= hardTimeoutMinutes * 60 * 1000) {
+                throw new Error(`cannot renew ${current.conversation_id}; terminal bridge hard lifetime of ${hardTimeoutMinutes} minutes has elapsed`);
+            }
+            const now = cliNow().toISOString();
+            const hardDeadline = deadlineAt(startedAt ?? now, hardTimeoutMinutes) ??
+                new Date(cliNowMs() + hardTimeoutMinutes * 60 * 1000).toISOString();
+            const inactivityDeadline = deadlineAt(now, inactivityTimeoutMinutes) ??
+                new Date(cliNowMs() + inactivityTimeoutMinutes * 60 * 1000).toISOString();
+            renewed = {
+                ...supersedeCallbackNotificationDelivery(current, {
+                    at: now,
+                    reason: "superseded_by_terminal_monitor_renewal"
+                }),
+                status: "waiting_for_agent",
+                native_session_takeover: {
+                    ...currentTakeover,
+                    terminal_bridge_monitor_lock_version: terminalMaintenanceRuntime().dependencies.runtime.monitorLockVersion,
+                    terminal_bridge_monitor_started_at: now,
+                    terminal_bridge_last_activity_at: now,
+                    terminal_bridge_inactivity_timeout_minutes: inactivityTimeoutMinutes,
+                    terminal_bridge_hard_timeout_minutes: hardTimeoutMinutes,
+                    terminal_bridge_inactivity_deadline_at: inactivityDeadline,
+                    terminal_bridge_hard_deadline_at: hardDeadline,
+                    terminal_bridge_renewed_at: now
+                },
+                updated_at: now
+            };
+            Reflect.deleteProperty(renewed, "stalled_at");
+            Reflect.deleteProperty(renewed, "stalled_reason");
+            Reflect.deleteProperty(renewed, "stalled_notification_sent_at");
+            Reflect.deleteProperty(renewed, "stalled_notification_message_id");
+            saveState(statePath, renewed);
+            appendEvent(logPath, {
+                ts: now,
+                conversation_id: current.conversation_id,
+                event: "terminal_bridge_renewed",
+                previous_status: current.status,
+                terminal_control: currentControl,
+                agent_timeout_minutes: inactivityTimeoutMinutes,
+                agent_hard_timeout_minutes: hardTimeoutMinutes,
+                last_activity_at: now
+            });
+            runtimeLog("info", "terminal_bridge_renewed", {
+                conversation_id: current.conversation_id,
+                terminal_target: currentControl.target,
+                agent_timeout_minutes: inactivityTimeoutMinutes,
+                agent_hard_timeout_minutes: hardTimeoutMinutes
+            });
         }
-        assertTurnBindingCurrent(current, "renew");
-        renewedTerminalControl = currentControl;
-        inactivityTimeoutMinutes = positiveMinutes(options.minutes ??
-            options.agentTimeoutMinutes ??
-            currentTakeover.terminal_bridge_inactivity_timeout_minutes ??
-            terminalMaintenanceRuntime().dependencies.runtime
-                .defaultAgentTimeoutMinutes, "--minutes");
-        hardTimeoutMinutes = positiveMinutes(currentTakeover.terminal_bridge_hard_timeout_minutes ??
-            terminalMaintenanceRuntime().dependencies.runtime
-                .defaultAgentHardTimeoutMinutes, "--agent-hard-timeout-minutes");
-        const startedAt = stringValue(currentTakeover.terminal_bridge_started_at);
-        const startedAtMs = startedAt ? Date.parse(startedAt) : NaN;
-        if (Number.isFinite(startedAtMs) &&
-            cliNowMs() - startedAtMs >= hardTimeoutMinutes * 60 * 1000) {
-            throw new Error(`cannot renew ${current.conversation_id}; terminal bridge hard lifetime of ${hardTimeoutMinutes} minutes has elapsed`);
+        finally {
+            releaseStateLock();
         }
-        const now = cliNow().toISOString();
-        const hardDeadline = deadlineAt(startedAt ?? now, hardTimeoutMinutes) ??
-            new Date(cliNowMs() + hardTimeoutMinutes * 60 * 1000).toISOString();
-        const inactivityDeadline = deadlineAt(now, inactivityTimeoutMinutes) ??
-            new Date(cliNowMs() + inactivityTimeoutMinutes * 60 * 1000).toISOString();
-        renewed = {
-            ...current,
-            status: "waiting_for_agent",
-            native_session_takeover: {
-                ...currentTakeover,
-                terminal_bridge_monitor_lock_version: terminalMaintenanceRuntime().dependencies.runtime.monitorLockVersion,
-                terminal_bridge_monitor_started_at: now,
-                terminal_bridge_last_activity_at: now,
-                terminal_bridge_inactivity_timeout_minutes: inactivityTimeoutMinutes,
-                terminal_bridge_hard_timeout_minutes: hardTimeoutMinutes,
-                terminal_bridge_inactivity_deadline_at: inactivityDeadline,
-                terminal_bridge_hard_deadline_at: hardDeadline,
-                terminal_bridge_renewed_at: now
-            },
-            updated_at: now
-        };
-        Reflect.deleteProperty(renewed, "stalled_at");
-        Reflect.deleteProperty(renewed, "stalled_reason");
-        Reflect.deleteProperty(renewed, "stalled_notification_sent_at");
-        Reflect.deleteProperty(renewed, "stalled_notification_message_id");
-        saveState(statePath, renewed);
-        appendEvent(logPath, {
-            ts: now,
-            conversation_id: current.conversation_id,
-            event: "terminal_bridge_renewed",
-            previous_status: current.status,
-            terminal_control: currentControl,
-            agent_timeout_minutes: inactivityTimeoutMinutes,
-            agent_hard_timeout_minutes: hardTimeoutMinutes,
-            last_activity_at: now
-        });
-        runtimeLog("info", "terminal_bridge_renewed", {
-            conversation_id: current.conversation_id,
-            terminal_target: currentControl.target,
-            agent_timeout_minutes: inactivityTimeoutMinutes,
-            agent_hard_timeout_minutes: hardTimeoutMinutes
-        });
-    }
-    finally {
-        releaseStateLock();
-    }
+    });
     const monitor = startTerminalBridgeMonitorForConversation({
         conversation: renewed,
         statePath,
@@ -336,90 +344,89 @@ async function runTerminalConversationCancel({ options, conversationId, agent, t
 }
 async function runTerminalControlCancel({ options, statePath, logPath, agent, terminalControl }) {
     const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDirFromOptions(options), terminalControl, { timeoutMs: 30000 });
-    let releaseStateLock;
     try {
-        releaseStateLock = acquireFileLock(`${statePath}.lock`);
         const writerStoreDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
         return await withStoreWriterLease(writerStoreDir, async () => {
-            const currentConversation = loadState(statePath);
-            if (!["waiting_for_agent", "waiting_for_openclaw"].includes(currentConversation.status)) {
-                throw new Error(`cannot cancel ${currentConversation.conversation_id}; conversation is ${currentConversation.status}`);
-            }
-            const currentTakeover = isRecord(currentConversation.native_session_takeover)
-                ? currentConversation.native_session_takeover
-                : undefined;
-            const currentControl = terminalControlFromTakeover(currentTakeover);
-            if (!currentControl ||
-                !terminalControlsShareIncarnation(currentControl, terminalControl)) {
-                throw new Error("terminal control changed while waiting to cancel; refresh status and retry");
-            }
-            assertManagedTerminalDispatchOwner({
-                storeDir: writerStoreDir,
-                conversation: currentConversation,
-                terminalControl: currentControl,
-                action: "cancel"
-            });
-            const cancellation = await createTerminalAgentBridge(options).cancel(agent, currentControl, {
-                runtime: terminalRuntimeIdentityForConversation(currentConversation, currentControl),
-                scrollbackLines: Number(options.scrollbackLines ?? 120)
-            });
-            if (!cancellation.cancelRequested) {
-                printJson({
+            const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+            try {
+                const currentConversation = loadState(statePath);
+                if (!["waiting_for_agent", "waiting_for_openclaw"].includes(currentConversation.status)) {
+                    throw new Error(`cannot cancel ${currentConversation.conversation_id}; conversation is ${currentConversation.status}`);
+                }
+                const currentTakeover = isRecord(currentConversation.native_session_takeover)
+                    ? currentConversation.native_session_takeover
+                    : undefined;
+                const currentControl = terminalControlFromTakeover(currentTakeover);
+                if (!currentControl ||
+                    !terminalControlsShareIncarnation(currentControl, terminalControl)) {
+                    throw new Error("terminal control changed while waiting to cancel; refresh status and retry");
+                }
+                assertManagedTerminalDispatchOwner({
+                    storeDir: writerStoreDir,
                     conversation: currentConversation,
-                    cancel_requested: false,
-                    reason: cancellation.reason,
+                    terminalControl: currentControl,
+                    action: "cancel"
+                });
+                const cancellation = await createTerminalAgentBridge(options).cancel(agent, currentControl, {
+                    runtime: terminalRuntimeIdentityForConversation(currentConversation, currentControl),
+                    scrollbackLines: Number(options.scrollbackLines ?? 120)
+                });
+                if (!cancellation.cancelRequested) {
+                    printJson({
+                        conversation: currentConversation,
+                        cancel_requested: false,
+                        reason: cancellation.reason,
+                        terminal_control: currentControl,
+                        budget: budgetAction(currentConversation)
+                    });
+                    return;
+                }
+                const now = cliNow().toISOString();
+                appendEvent(logPath, {
+                    ts: now,
+                    conversation_id: currentConversation.conversation_id,
+                    event: "terminal_cancel_requested",
                     terminal_control: currentControl,
-                    budget: budgetAction(currentConversation)
+                    key: cancellation.key,
+                    keys: cancellation.keys,
+                    denied_approval: cancellation.deniedApproval,
+                    request_id: cancellation.requestId
+                });
+                runtimeLog("info", "terminal_cancel_requested", {
+                    conversation_id: currentConversation.conversation_id,
+                    agent,
+                    terminal_target: currentControl.target,
+                    key: cancellation.key,
+                    keys: cancellation.keys,
+                    denied_approval: cancellation.deniedApproval,
+                    request_id: cancellation.requestId
+                });
+                const nextConversation = {
+                    ...currentConversation,
+                    status: "cancelled",
+                    cancelled_at: now,
+                    terminal_cancel_requested_at: now,
+                    updated_at: now
+                };
+                saveState(statePath, nextConversation);
+                printJson({
+                    conversation: nextConversation,
+                    cancel_requested: true,
+                    terminal_control: currentControl,
+                    key: cancellation.key,
+                    keys: cancellation.keys,
+                    denied_approval: cancellation.deniedApproval,
+                    request_id: cancellation.requestId,
+                    budget: budgetAction(nextConversation)
                 });
-                return;
             }
-            const now = cliNow().toISOString();
-            appendEvent(logPath, {
-                ts: now,
-                conversation_id: currentConversation.conversation_id,
-                event: "terminal_cancel_requested",
-                terminal_control: currentControl,
-                key: cancellation.key,
-                keys: cancellation.keys,
-                denied_approval: cancellation.deniedApproval,
-                request_id: cancellation.requestId
-            });
-            runtimeLog("info", "terminal_cancel_requested", {
-                conversation_id: currentConversation.conversation_id,
-                agent,
-                terminal_target: currentControl.target,
-                key: cancellation.key,
-                keys: cancellation.keys,
-                denied_approval: cancellation.deniedApproval,
-                request_id: cancellation.requestId
-            });
-            const nextConversation = {
-                ...currentConversation,
-                status: "cancelled",
-                cancelled_at: now,
-                terminal_cancel_requested_at: now,
-                updated_at: now
-            };
-            saveState(statePath, nextConversation);
-            printJson({
-                conversation: nextConversation,
-                cancel_requested: true,
-                terminal_control: currentControl,
-                key: cancellation.key,
-                keys: cancellation.keys,
-                denied_approval: cancellation.deniedApproval,
-                request_id: cancellation.requestId,
-                budget: budgetAction(nextConversation)
-            });
+            finally {
+                releaseStateLock();
+            }
         });
     }
     finally {
-        try {
-            releaseStateLock?.();
-        }
-        finally {
-            releaseTerminalLock();
-        }
+        releaseTerminalLock();
     }
 }
 async function runObservedHandoffClose({ options, statePath, logPath, initialConversation }) {
@@ -538,7 +545,10 @@ async function runObservedHandoffClose({ options, statePath, logPath, initialCon
         }
         const now = cliNow().toISOString();
         const closed = {
-            ...conversation,
+            ...supersedeCallbackNotificationDelivery(conversation, {
+                at: now,
+                reason: "superseded_by_human_context_switch"
+            }),
             status: "closed",
             closed_at: now,
             close_reason: "superseded_by_human_context_switch",
@@ -595,187 +605,99 @@ async function runClose(options) {
         return;
     }
     const loaded = loadConversationFromOptions(options);
-    if (stringValue(options.expectedHandoffToken)) {
-        await runObservedHandoffClose({
-            options,
-            statePath: loaded.statePath,
-            logPath: loaded.logPath,
-            initialConversation: loaded.conversation
-        });
-        return;
-    }
-    if (stringValue(options.reason) === "superseded_by_human_context_switch") {
-        throw new Error("reason superseded_by_human_context_switch requires the fresh " +
-            "expected_handoff_token advertised by AKK list");
-    }
     const { statePath, logPath } = loaded;
     const closeStoreDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
-    const nativeTakeover = isRecord(loaded.conversation.native_session_takeover)
-        ? loaded.conversation.native_session_takeover
-        : undefined;
-    const terminalControl = terminalControlFromTakeover(nativeTakeover);
-    const releaseTerminalLock = terminalControl
-        ? acquireTerminalBridgeSendLock(closeStoreDir, terminalControl, { timeoutMs: 30000 })
-        : () => { };
     const closeWithFreshState = async () => {
         const releaseStateLock = acquireFileLock(`${statePath}.lock`);
         try {
-            const conversation = loadState(statePath);
-            let verifiedDeadProcess;
-            assertConversationHasNoNonterminalDeferredForegroundTransfer({
-                storeDir: closeStoreDir,
-                conversation,
-                action: "close"
-            });
+            const conversation = {
+                ...loadState(statePath),
+                store_dir: path.resolve(closeStoreDir),
+                conversation_dir: path.resolve(path.dirname(statePath)),
+                state_path: path.resolve(statePath),
+                event_log_path: path.resolve(logPath)
+            };
             const currentTakeover = isRecord(conversation.native_session_takeover)
                 ? conversation.native_session_takeover
                 : undefined;
             const currentTerminalControl = terminalControlFromTakeover(currentTakeover);
-            if (terminalControl &&
-                !terminalControlsShareIncarnation(currentTerminalControl, terminalControl)) {
-                throw new Error("terminal control changed after the close action was listed; refresh AKK list");
-            }
-            if (conversation.status === "closed" && currentTerminalControl) {
-                const recoveredAuthority = exactVerifiedDeadTerminalAgentProcessAuthority({
-                    conversation,
-                    storeDir: closeStoreDir,
-                    terminalControl: currentTerminalControl,
-                    logPath
-                });
-                const recoveredDecision = decideVerifiedDeadAgentProcess({
-                    persistedAuthority: recoveredAuthority
-                });
-                if (recoveredDecision.status === "invalid") {
-                    throw new Error(`cannot finish close recovery for ${conversation.conversation_id}; ` +
-                        recoveredDecision.reason);
-                }
-                if (recoveredDecision.status === "verified_dead") {
-                    const audit = ensureVerifiedDeadTerminalAgentProcessEvent({
-                        logPath,
-                        proof: recoveredDecision.proof,
-                        action: "managed_close"
-                    });
-                    const expectedMessageId = required(stringValue(currentTakeover?.terminal_bridge_message_id), "verified-dead close recovery has no terminal message id");
-                    const dispatchLedgerResolved = resolveVerifiedDeadTerminalBridgeDispatchLedger({
-                        terminalControl: currentTerminalControl,
-                        conversation,
-                        storeDir: closeStoreDir,
-                        statePath,
-                        logPath,
-                        expectedMessageId,
-                        reason: "conversation explicitly closed by request"
-                    });
-                    ensureVerifiedDeadConversationClosedEvent({
-                        logPath,
-                        conversation,
-                        evidenceId: audit.evidenceId
-                    });
-                    printJson({
-                        conversation,
-                        closed: true,
-                        recovered: true,
-                        terminal_dispatch_resolved: dispatchLedgerResolved
-                    });
-                    return;
-                }
-            }
-            if (terminalControl && currentTerminalControl) {
-                verifiedDeadProcess =
-                    await assertGenericCloseDoesNotBypassObservedHandoff({
-                        options,
-                        storeDir: closeStoreDir,
-                        conversation,
-                        terminalControl: currentTerminalControl
-                    });
-            }
             const now = cliNow().toISOString();
-            const closeReason = stringValue(options.reason) ?? "closed by request";
-            const verifiedDeadAudit = verifiedDeadProcess
-                ? ensureVerifiedDeadTerminalAgentProcessEvent({
-                    logPath,
-                    proof: verifiedDeadProcess,
-                    action: "managed_close"
-                })
-                : undefined;
-            const verifiedDeadMessageId = verifiedDeadAudit
-                ? required(stringValue(currentTakeover?.terminal_bridge_message_id), "verified-dead close has no terminal message id")
-                : undefined;
-            if (verifiedDeadAudit && currentTerminalControl) {
-                assertVerifiedDeadTerminalBridgeDispatchAuthority({
-                    terminalControl: currentTerminalControl,
-                    conversation,
-                    storeDir: closeStoreDir,
-                    statePath,
-                    logPath,
-                    expectedMessageId: verifiedDeadMessageId
-                });
-            }
+            const closedAt = stringValue(conversation.closed_at) ?? now;
+            const closeReason = stringValue(options.reason) ??
+                stringValue(conversation.close_reason) ?? "closed by request";
             const closed = {
-                ...conversation,
+                ...supersedeUnacceptedCallbackDeliveries(conversation, {
+                    at: now,
+                    reason: "superseded_by_conversation_close"
+                }),
                 status: "closed",
-                closed_at: now,
+                closed_at: closedAt,
                 close_reason: closeReason,
-                ...(verifiedDeadAudit
-                    ? {
-                        terminal_agent_process_disposition: {
-                            status: "verified_dead",
-                            proof: verifiedDeadAudit.proof,
-                            evidence_id: verifiedDeadAudit.evidenceId,
-                            recorded_at: verifiedDeadAudit.recordedAt
-                        }
-                    }
-                    : {}),
+                disposition: "user_abandoned_management",
+                callback_expected: false,
                 updated_at: now
             };
-            saveState(statePath, closed);
-            if (verifiedDeadAudit &&
-                cliEnv().AKK_TEST_EXIT_AFTER_VERIFIED_DEAD_CLOSE_STATE === "1") {
-                cliExit(86);
+            delete closed.idle_since;
+            saveExplicitUserCloseState(statePath, closed);
+            let transferCleanup;
+            try {
+                transferCleanup = cleanupDeferredForegroundUserClose({
+                    storeDir: closeStoreDir,
+                    conversation: closed,
+                    at: now
+                });
+            }
+            catch (error) {
+                transferCleanup = {
+                    transfer_finalized: false,
+                    detached_session_ids: [],
+                    warnings: [
+                        `deferred_transfer_cleanup: ${error instanceof Error ? error.message : String(error)}`
+                    ]
+                };
             }
             let dispatchLedgerResolved = false;
             let dispatchLedgerWarning;
-            if (currentTerminalControl) {
+            const ledgerTerminalControl = currentTerminalControl;
+            if (ledgerTerminalControl) {
                 try {
-                    dispatchLedgerResolved = verifiedDeadAudit
-                        ? resolveVerifiedDeadTerminalBridgeDispatchLedger({
-                            terminalControl: currentTerminalControl,
-                            conversation: closed,
-                            storeDir: closeStoreDir,
-                            statePath,
-                            logPath,
-                            expectedMessageId: verifiedDeadMessageId,
-                            reason: "conversation explicitly closed by request"
-                        })
-                        : resolveTerminalBridgeDispatchLedger(currentTerminalControl, {
-                            conversation: closed,
-                            expectedMessageId: stringValue(currentTakeover?.terminal_bridge_message_id),
-                            reason: "conversation explicitly closed by request"
-                        });
+                    dispatchLedgerResolved = resolveTerminalBridgeDispatchLedger(ledgerTerminalControl, {
+                        conversation: closed,
+                        expectedMessageId: stringValue(currentTakeover?.terminal_bridge_message_id),
+                        reason: "conversation explicitly closed by request"
+                    });
                 }
                 catch (error) {
                     dispatchLedgerWarning =
                         error instanceof Error ? error.message : String(error);
                     runtimeLog("error", "terminal_dispatch_ledger_resolve_failed", {
                         conversation_id: closed.conversation_id,
-                        terminal_target: currentTerminalControl.target,
+                        terminal_target: ledgerTerminalControl.target,
                         error: dispatchLedgerWarning
                     });
                 }
             }
-            if (verifiedDeadAudit) {
-                ensureVerifiedDeadConversationClosedEvent({
-                    logPath,
-                    conversation: closed,
-                    evidenceId: verifiedDeadAudit.evidenceId
-                });
-            }
-            else {
-                appendEvent(logPath, {
-                    ts: now,
+            let closeEventWarning;
+            try {
+                appendExplicitUserCloseEvent(logPath, {
+                    ts: closedAt,
                     conversation_id: conversation.conversation_id,
                     event: "conversation_closed",
                     status: "closed",
-                    reason: closed.close_reason
+                    reason: closed.close_reason,
+                    disposition: "user_abandoned_management",
+                    terminal_input_sent: false,
+                    coding_agent_stopped: false,
+                    tmux_pane_closed: false
+                });
+            }
+            catch (error) {
+                closeEventWarning = error instanceof Error
+                    ? error.message
+                    : String(error);
+                runtimeLog("warn", "conversation_close_event_append_failed", {
+                    conversation_id: closed.conversation_id,
+                    error: closeEventWarning
                 });
             }
             runtimeLog("info", "conversation_closed", {
@@ -788,11 +710,26 @@ async function runClose(options) {
             printJson({
                 conversation: closed,
                 closed: true,
+                management_released: true,
+                terminal_input_sent: false,
+                coding_agent_stopped: false,
+                tmux_pane_closed: false,
+                next_action: "refresh list; if the coding agent is still working, use the fresh Watch action",
+                deferred_transfer: transferCleanup,
                 terminal_dispatch_resolved: dispatchLedgerResolved,
-                ...(dispatchLedgerWarning
+                ...(dispatchLedgerWarning ||
+                    closeEventWarning ||
+                    transferCleanup.warnings.length > 0
                     ? {
-                        terminal_dispatch_warning: textSummary(dispatchLedgerWarning),
-                        do_not_retry: true
+                        warnings: [
+                            ...transferCleanup.warnings,
+                            ...(dispatchLedgerWarning
+                                ? [`terminal_dispatch: ${dispatchLedgerWarning}`]
+                                : []),
+                            ...(closeEventWarning
+                                ? [`close_event: ${closeEventWarning}`]
+                                : [])
+                        ].map((warning) => textSummary(warning))
                     }
                     : {})
             });
@@ -801,17 +738,7 @@ async function runClose(options) {
             releaseStateLock();
         }
     };
-    try {
-        if (terminalControl) {
-            await withStoreWriterLeaseAsync(closeStoreDir, closeWithFreshState);
-        }
-        else {
-            await closeWithFreshState();
-        }
-    }
-    finally {
-        releaseTerminalLock();
-    }
+    await withStoreWriterLeaseAsync(closeStoreDir, closeWithFreshState);
 }
 async function assertGenericCloseDoesNotBypassObservedHandoff({ options, storeDir, conversation, terminalControl }) {
     if (!isSessionSendBlockingStatus(conversation.status)) {