@scotthuang/agent-knock-knock 0.6.2 → 0.8.0

package/dist/src/cli.js

@@ -14,7 +14,7 @@ import { applyMessageToConversation, budgetAction, createConversation, createMes
 import { EXECUTOR_KINDS, executorDefinitionForKind, isExecutorKind } from "./executors.js";
 import { redactString, writeRuntimeLog } from "./runtime-log.js";
 import { formatTranscript, readNdjsonLog } from "./transcript.js";
-import { appendEvent, defaultStoreDir, ensureDir, listConversations, logPathForStatePath, loadConversationById, loadState, messageEvent, pathsForConversation, pathsForConversationDir, saveState, statePathForConversationId } from "./store.js";
+import { appendEvent, assertStoreWriterCompatible, defaultStoreDir, ensureDir, ensureStoreWritable, inspectStoreCompatibility, listConversations, logPathForStatePath, loadConversationById, loadState, messageEvent, pathsForConversation, pathsForConversationDir, saveState, statePathForConversationId, withStoreWriterLeaseAsync } from "./store.js";
 import { StaticTerminalControlProvider, TmuxTerminalControlProvider, terminalPaneContainsProcess } from "./terminal-control-provider.js";
 import { parseTerminalConversationId } from "./terminal-agent-adapter.js";
 import { createProductionTerminalAgentRegistry } from "./terminal-agent-registry.js";
@@ -77,6 +77,18 @@ const SESSION_SELECTOR_COMMANDS = new Set([
     "retry-callback",
     "close"
 ]);
+const STORE_MUTATION_COMMANDS = new Set([
+    "delegate",
+    "send",
+    "approve",
+    "cancel",
+    "renew",
+    "reconcile-monitors",
+    "close",
+    "callback",
+    "retry-callback",
+    "monitor"
+]);
 class InlineCodexSessionAdapter {
     threads;
     processes;
@@ -132,6 +144,7 @@ catch (error) {
 }
 async function runCommand(commandName, options) {
     await resolveConversationSelectorOption(commandName, options);
+    preflightStoreWriter(commandName, options);
     if (commandName === "help" || commandName === "--help" || commandName === "-h") {
         usage();
     }
@@ -188,6 +201,16 @@ async function runCommand(commandName, options) {
         process.exitCode = commandName ? 1 : 0;
     }
 }
+function preflightStoreWriter(commandName, options) {
+    if (!STORE_MUTATION_COMMANDS.has(String(commandName ?? ""))) {
+        return;
+    }
+    const statePath = stringValue(options.state);
+    const storeDir = statePath
+        ? pathsForConversationDir(path.dirname(expandHome(statePath))).storeDir
+        : storeDirFromOptions(options);
+    assertStoreWriterCompatible(storeDir);
+}
 function runInstallOpenClaw(options) {
     const root = packageRootDir();
     const skillOnly = options.skillOnly === true;
@@ -907,7 +930,15 @@ async function runDelegate(options) {
                 return false;
             }
         });
-    const eligible = scopedCandidates.filter((candidate) => candidate.activity_state === "idle");
+    const eligible = scopedCandidates.filter((candidate) => {
+        if (candidate.activity_state !== "idle") {
+            return false;
+        }
+        const terminalControl = isRecord(candidate.terminal_control)
+            ? candidate.terminal_control
+            : undefined;
+        return !terminalControl || terminalDispatchOwnership(terminalControl).state === "none";
+    });
     if (eligible.length === 0) {
         const observed = scopedCandidates.length > 0
             ? ` Found ${scopedCandidates.length} matching pane(s), but none is idle.`
@@ -1327,61 +1358,90 @@ function environmentWithoutGatewayTokens() {
 }
 async function runList(options) {
     const storeDir = expandHome(options.storeDir ?? options.logDir ?? defaultStoreDir(process.cwd()));
-    const cleanup = cleanupIdleConversations(storeDir, options);
+    const store = inspectStoreCompatibility(storeDir);
+    const reconciliation = options.reconcile === true
+        ? await reconcileStoreForList(storeDir, options)
+        : {
+            status: "disabled",
+            reason: "standalone list is read-only unless --reconcile is supplied"
+        };
     const includeAll = Boolean(options.all);
     const agentFilter = options.agent ? resolveExecutor({ kind: options.agent }).kind : undefined;
     const statusFilter = options.status;
     const allStoredConversations = listConversations(storeDir);
-    const storedConversations = allStoredConversations
-        .filter(isDiscoverableTmuxConversation)
+    const allManagedConversations = allStoredConversations
+        .filter(isDiscoverableTmuxConversation);
+    const storedConversations = allManagedConversations
         .filter((conversation) => includeAll || isActiveStatus(conversation.status))
         .filter((conversation) => matchesConfiguredWorkspace(options.workspace, conversation.workspace))
         .filter((conversation) => !agentFilter || executorForConversation(conversation).kind === agentFilter)
         .filter((conversation) => !statusFilter || conversation.status === statusFilter);
-    const conversations = storedConversations.map((conversation) => summarizeConversation(conversation));
-    const delegated = storedConversations.map((conversation) => delegatedListEntry(summarizeConversation(conversation), {
-        terminalBridge: terminalBridgeEnabled(conversation),
-        approvalState: managedListApprovalState(conversation),
-        conversation
-    }));
     const terminalScan = await buildTerminalListGroup({ options, agentFilter, statusFilter });
-    const managedTerminalKeys = new Set(allStoredConversations
-        .filter((conversation) => isActiveStatus(conversation.status))
-        .filter((conversation) => matchesConfiguredWorkspace(options.workspace, conversation.workspace))
-        .map((conversation) => terminalControlSelectorKey(terminalControlFromTakeover(isRecord(conversation.native_session_takeover)
-        ? conversation.native_session_takeover
-        : undefined)))
-        .filter((key) => key !== undefined));
-    const terminalControlled = terminalScan.terminalControlled.filter((entry) => {
-        if (!matchesConfiguredWorkspace(options.workspace, entry.workspace ?? entry.cwd)) {
-            return false;
-        }
-        const key = terminalControlSelectorKey(entry.terminal_control);
-        return key === undefined || !managedTerminalKeys.has(key);
+    const physicalTerminals = terminalScan.terminalControlled.filter((entry) => matchesConfiguredWorkspace(options.workspace, entry.workspace ?? entry.cwd));
+    const projection = terminalFirstListProjection({
+        terminals: physicalTerminals,
+        allConversations: allManagedConversations.filter((conversation) => matchesConfiguredWorkspace(options.workspace, conversation.workspace)),
+        displayedConversations: storedConversations,
+        includeAll,
+        managedOnly: options.managedOnly === true,
+        statusFilter,
+        mutationsAllowed: store.writable === true
     });
     printJson({
         store_dir: storeDir,
-        cleanup,
+        store,
+        reconciliation,
         action_contracts: listActionContracts(),
-        delegated,
-        terminal_controlled: terminalControlled,
+        terminals: projection.terminals,
+        unavailable_managed_turns: projection.unavailableManagedTurns,
         terminal_scan: {
             ...terminalScan.summary,
-            terminal_controlled_count: terminalControlled.length
-        },
-        tasks: conversations
+            terminal_count: projection.terminals.length
+        }
     });
-    runtimeLog("info", "tasks_listed", {
+    runtimeLog("info", "terminals_listed", {
         store_dir: storeDir,
-        returned_count: conversations.length,
-        terminal_controlled_count: terminalControlled.length,
+        terminal_count: projection.terminals.length,
+        unavailable_managed_turn_count: projection.unavailableManagedTurns.length,
         terminal_scan_error: terminalScan.summary.error,
         include_all: includeAll,
         agent_filter: agentFilter,
         status_filter: statusFilter,
-        cleanup
+        reconciliation
     });
 }
+async function reconcileStoreForList(storeDir, options) {
+    try {
+        ensureStoreWritable(storeDir);
+    }
+    catch (error) {
+        if (isRecord(error) && error.code === "AKK_STORE_INCOMPATIBLE") {
+            return {
+                status: "skipped",
+                reason: error instanceof Error ? error.message : String(error),
+                store: inspectStoreCompatibility(storeDir)
+            };
+        }
+        throw error;
+    }
+    const idle = reconcileIdleConversations(storeDir, options);
+    const monitors = await reconcileMonitors(options, {
+        includeCallbackRecovery: false,
+        reason: "list_reconciliation",
+        conversationId: undefined
+    });
+    return {
+        status: "completed",
+        checked: Math.max(idle.checked, monitors.checked),
+        changed: idle.closed + monitors.launched,
+        closed: idle.closed,
+        monitors_launched: monitors.launched,
+        monitors_already_running: monitors.already_running,
+        skipped: idle.skipped + monitors.skipped,
+        errors: monitors.errors,
+        idle_timeout_minutes: idle.idle_timeout_minutes
+    };
+}
 async function buildTerminalListGroup({ options, agentFilter, statusFilter }) {
     const empty = {
         terminalControlled: [],
@@ -1394,16 +1454,6 @@ async function buildTerminalListGroup({ options, agentFilter, statusFilter }) {
     if (options.managedOnly) {
         return empty;
     }
-    if (statusFilter && statusFilter !== "active") {
-        return {
-            ...empty,
-            summary: {
-                enabled: false,
-                agents: [],
-                skipped: `terminal discovery skipped for status filter ${statusFilter}`
-            }
-        };
-    }
     const registry = createRuntimeTerminalAgentRegistry(options);
     const adapters = agentFilter
         ? [registry.get(agentFilter)].filter((adapter) => adapter !== undefined)
@@ -1446,7 +1496,7 @@ async function buildTerminalListGroup({ options, agentFilter, statusFilter }) {
             enabled: true,
             agents: adapters.map((adapter) => adapter.agent),
             active_count: activeCount,
-            terminal_controlled_count: terminalControlled.length,
+            terminal_count: terminalControlled.length,
             approval_scan: options.noApprovalScan ? "disabled" : "enabled",
             diagnostics: terminalDiagnostics,
             error: errors.length > 0 ? errors.join("; ") : undefined
@@ -1462,24 +1512,26 @@ async function terminalControlDiagnostics(provider) {
         paneCount: (await provider.listPanes()).length
     };
 }
-function delegatedListEntry(task, { terminalBridge = false, approvalState, conversation } = {}) {
+function managedTurnListEntry(task, { terminalBridge = false, approvalState, conversation } = {}) {
     const entry = {
         ...task,
         id: task.conversation_id,
         short_ref: sessionShortRef(task.conversation_id),
-        source: "akk_delegate",
+        source: "managed_turn",
         ...(approvalState ? { approval_state: approvalState } : {}),
         commands: {
-            send: canSendDelegated(task.status),
+            send: canFollowUpManagedTurn(task.status),
             cancel: isWaitingForAgent(task.status),
             close: task.status !== "closed",
             status: true,
             approve: terminalBridge && isActiveStatus(task.status)
         }
     };
+    const availableActions = availableListActions(entry, { conversation });
+    const { commands: _commands, ...publicEntry } = entry;
     return {
-        ...entry,
-        available_actions: availableListActions(entry, { conversation })
+        ...publicEntry,
+        available_actions: availableActions
     };
 }
 async function terminalControlledListEntry(session, activeSessions, options, bridge = createTerminalAgentBridge(options)) {
@@ -1497,9 +1549,9 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
     const entry = {
         id: bridge.terminalConversationId(session),
         short_ref: sessionShortRef(bridge.terminalConversationId(session)),
-        source: "terminal_control",
+        source: "terminal",
         agent: session.agent,
-        status: "active",
+        process_state: "active",
         pid: session.pid,
         child_pids: childPidsForRoot(session, activeSessions),
         command: session.command,
@@ -1533,9 +1585,438 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             close: orphanedDispatch !== undefined
         }
     };
+    const availableActions = availableListActions(entry);
+    const { commands: _commands, ...publicEntry } = entry;
+    return {
+        ...publicEntry,
+        available_actions: availableActions
+    };
+}
+function terminalFirstListProjection({ terminals, allConversations, displayedConversations, includeAll, managedOnly, statusFilter, mutationsAllowed }) {
+    const allByTerminal = managedConversationsByTerminal(allConversations);
+    const displayedByTerminal = managedConversationsByTerminal(displayedConversations);
+    const discoveredTerminalKeys = new Set();
+    const projectedTerminals = terminals.map((terminal) => {
+        const terminalControl = isRecord(terminal.terminal_control)
+            ? terminal.terminal_control
+            : undefined;
+        const terminalKey = terminalControlSelectorKey(terminalControl);
+        if (terminalKey) {
+            discoveredTerminalKeys.add(terminalKey);
+        }
+        const allRelated = terminalKey
+            ? [...(allByTerminal.get(terminalKey) ?? [])]
+            : [];
+        const displayedRelated = terminalKey
+            ? [...(displayedByTerminal.get(terminalKey) ?? [])]
+            : [];
+        const discoveredOwnership = terminalControl
+            ? terminalDispatchOwnership(terminalControl)
+            : { state: "none" };
+        const ownership = discoveredOwnership.state === "current"
+            ? localTerminalDispatchOwnership(discoveredOwnership.conversation, allRelated, terminal)
+            : discoveredOwnership;
+        const discoveredRawActions = isRecord(terminal.available_actions)
+            ? terminal.available_actions
+            : {};
+        const rawActions = mutationsAllowed
+            ? discoveredRawActions
+            : readOnlyListActions(discoveredRawActions);
+        const terminalCanAcceptSend = ownership.state === "none" && isRecord(rawActions.send);
+        if (ownership.state === "current" &&
+            !allRelated.some((conversation) => conversation.conversation_id === ownership.conversation.conversation_id)) {
+            allRelated.push(ownership.conversation);
+        }
+        const currentTurnValue = ownership.state === "current"
+            ? currentManagedTurnForTerminal(ownership.conversation, terminal, rawActions)
+            : undefined;
+        const currentTurn = currentTurnValue && !mutationsAllowed
+            ? readOnlyManagedTurn(currentTurnValue)
+            : currentTurnValue;
+        const sortedDisplayed = [...displayedRelated]
+            .filter((conversation) => conversation.conversation_id !== currentTurn?.conversation_id)
+            .sort(compareManagedConversationRecency);
+        const recentConversation = currentTurn ? undefined : sortedDisplayed[0];
+        const recentTurnValue = recentConversation
+            ? historicalManagedTurnForTerminal(recentConversation, terminalCanAcceptSend, terminal)
+            : undefined;
+        const recentTurn = recentTurnValue && !mutationsAllowed
+            ? readOnlyManagedTurn(recentTurnValue)
+            : recentTurnValue;
+        const historyConversations = includeAll
+            ? sortedDisplayed.filter((conversation) => conversation.conversation_id !== recentConversation?.conversation_id)
+            : [];
+        const history = historyConversations.map((conversation) => {
+            const turn = historicalManagedTurnForTerminal(conversation, terminalCanAcceptSend, terminal);
+            return mutationsAllowed ? turn : readOnlyManagedTurn(turn);
+        });
+        const visibleTurnIds = new Set([currentTurn, recentTurn, ...history]
+            .map((turn) => stringValue(turn?.conversation_id))
+            .filter((id) => id !== undefined));
+        const management = {
+            current_turn: currentTurn ?? null,
+            recent_turn: recentTurn ?? null,
+            turn_count: allRelated.length,
+            hidden_turn_count: allRelated.filter((conversation) => !visibleTurnIds.has(conversation.conversation_id)).length,
+            ...(includeAll ? { history } : {})
+        };
+        const availableActions = ownership.state === "current"
+            ? currentTerminalActions(currentTurn)
+            : ownership.state === "conflict"
+                ? safeTerminalActionsDuringConflict(rawActions)
+                : rawActions;
+        return {
+            ...terminal,
+            management_state: ownership.state === "current"
+                ? "managed"
+                : ownership.state === "conflict"
+                    ? "conflict"
+                    : "unmanaged",
+            ...(ownership.state === "conflict"
+                ? { management_conflict: ownership.conflict }
+                : {}),
+            managed: management,
+            available_actions: availableActions
+        };
+    });
+    const unavailableManagedTurns = displayedConversations
+        .filter((conversation) => {
+        const terminalKey = terminalKeyForManagedConversation(conversation);
+        if (terminalKey && discoveredTerminalKeys.has(terminalKey)) {
+            return false;
+        }
+        return (includeAll ||
+            managedOnly ||
+            statusFilter !== undefined ||
+            managedTurnNeedsAttention(conversation.status));
+    })
+        .sort(compareManagedConversationRecency)
+        .map((conversation) => {
+        const managedTurn = managedTurnListEntry(summarizeConversation(conversation), {
+            terminalBridge: terminalBridgeEnabled(conversation),
+            approvalState: managedListApprovalState(conversation),
+            conversation
+        });
+        return {
+            ...managedTurn,
+            available_actions: mutationsAllowed
+                ? safeUnavailableManagedTurnActions(isRecord(managedTurn.available_actions)
+                    ? managedTurn.available_actions
+                    : {})
+                : readOnlyListActions(isRecord(managedTurn.available_actions)
+                    ? managedTurn.available_actions
+                    : {}),
+            terminal_availability: {
+                available: false,
+                reason: managedOnly
+                    ? "terminal discovery was disabled by --managed-only"
+                    : "the referenced tmux pane is not currently available"
+            }
+        };
+    });
+    return {
+        terminals: projectedTerminals,
+        unavailableManagedTurns
+    };
+}
+function managedConversationsByTerminal(conversations) {
+    const groups = new Map();
+    for (const conversation of conversations) {
+        const key = terminalKeyForManagedConversation(conversation);
+        if (!key) {
+            continue;
+        }
+        const group = groups.get(key) ?? [];
+        group.push(conversation);
+        groups.set(key, group);
+    }
+    return groups;
+}
+function terminalKeyForManagedConversation(conversation) {
+    return terminalControlSelectorKey(terminalControlFromTakeover(isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined));
+}
+function compareManagedConversationRecency(left, right) {
+    const leftTime = Date.parse(String(left.updated_at ?? left.created_at ?? ""));
+    const rightTime = Date.parse(String(right.updated_at ?? right.created_at ?? ""));
+    if (Number.isFinite(leftTime) && Number.isFinite(rightTime) && leftTime !== rightTime) {
+        return rightTime - leftTime;
+    }
+    if (Number.isFinite(leftTime) !== Number.isFinite(rightTime)) {
+        return Number.isFinite(leftTime) ? -1 : 1;
+    }
+    return left.conversation_id.localeCompare(right.conversation_id);
+}
+function managedTurnNeedsAttention(status) {
+    return [
+        "created",
+        "running",
+        "waiting_for_agent",
+        "waiting_for_openclaw",
+        "stalled",
+        "callback_pending",
+        "callback_failed",
+        "cancelling"
+    ].includes(status);
+}
+function terminalDispatchOwnership(terminalControl) {
+    let ledger;
+    try {
+        ledger = loadTerminalBridgeDispatchLedger(terminalControl);
+    }
+    catch (error) {
+        return {
+            state: "conflict",
+            conflict: {
+                reason: error instanceof Error ? error.message : String(error),
+                recovery: "inspect the shared tmux pane before performing a side effect"
+            }
+        };
+    }
+    if (!ledger || ledger.status === "resolved") {
+        return { state: "none" };
+    }
+    const ledgerControl = isRecord(ledger.terminal_control)
+        ? ledger.terminal_control
+        : undefined;
+    const ledgerPanePid = Number(ledgerControl?.pane_pid);
+    const currentPanePid = Number(terminalControl.panePid);
+    if (Number.isSafeInteger(ledgerPanePid) &&
+        ledgerPanePid > 0 &&
+        Number.isSafeInteger(currentPanePid) &&
+        currentPanePid > 0 &&
+        ledgerPanePid !== currentPanePid) {
+        return { state: "none" };
+    }
+    if (!["prepared", "submitted", "uncertain"].includes(String(ledger.status))) {
+        return { state: "none" };
+    }
+    const owner = loadTerminalDispatchLedgerOwner(ledger);
+    if (!owner) {
+        return {
+            state: "conflict",
+            conflict: terminalDispatchConflict(ledger, "dispatch owner state is unavailable")
+        };
+    }
+    if (TERMINAL_DISPATCH_RELEASE_STATUSES.has(owner.status)) {
+        return { state: "none" };
+    }
+    const ownerTerminalKey = terminalKeyForManagedConversation(owner);
+    const currentTerminalKey = terminalControlSelectorKey(terminalControl);
+    if (!ownerTerminalKey || ownerTerminalKey !== currentTerminalKey) {
+        return {
+            state: "conflict",
+            conflict: terminalDispatchConflict(ledger, "dispatch owner does not reference this tmux pane incarnation")
+        };
+    }
+    const ownerTakeover = isRecord(owner.native_session_takeover)
+        ? owner.native_session_takeover
+        : undefined;
+    const ledgerMessageId = stringValue(ledger.message_id);
+    const ownerMessageId = stringValue(ownerTakeover?.terminal_bridge_message_id);
+    if (["prepared", "submitted", "uncertain"].includes(String(ledger.status)) &&
+        ledgerMessageId &&
+        ownerMessageId !== ledgerMessageId) {
+        return {
+            state: "conflict",
+            conflict: terminalDispatchConflict(ledger, "dispatch generation does not match the owner state")
+        };
+    }
+    return { state: "current", conversation: owner };
+}
+function terminalDispatchConflict(ledger, reason) {
+    return {
+        reason,
+        dispatch_status: stringValue(ledger.status),
+        owner_conversation_id: stringValue(ledger.conversation_id),
+        message_id: stringValue(ledger.message_id),
+        recovery: "inspect the shared tmux pane and explicitly resolve the current dispatch before performing a side effect"
+    };
+}
+function localTerminalDispatchOwnership(ledgerOwner, localConversations, terminal) {
+    const localOwner = localConversations.find((conversation) => conversation.conversation_id === ledgerOwner.conversation_id &&
+        sameCanonicalStatePath(conversation.state_path, ledgerOwner.state_path));
+    if (localOwner) {
+        if (!managedTurnMatchesLiveTerminal(localOwner, terminal)) {
+            return {
+                state: "conflict",
+                conflict: {
+                    reason: "the terminal dispatch owner no longer matches the live coding-agent process identity or workspace",
+                    owner_conversation_id: ledgerOwner.conversation_id,
+                    recovery: "inspect the shared tmux pane and explicitly resolve the stale dispatch before performing a side effect"
+                }
+            };
+        }
+        return { state: "current", conversation: localOwner };
+    }
     return {
-        ...entry,
-        available_actions: availableListActions(entry)
+        state: "conflict",
+        conflict: {
+            reason: "the terminal dispatch owner belongs to another AKK store or is not supported by this list view",
+            owner_conversation_id: ledgerOwner.conversation_id,
+            recovery: "inspect the shared tmux pane and use the AKK store that owns the current dispatch"
+        }
+    };
+}
+function sameCanonicalStatePath(left, right) {
+    const leftPath = stringValue(left);
+    const rightPath = stringValue(right);
+    return Boolean(leftPath &&
+        rightPath &&
+        path.resolve(leftPath) === path.resolve(rightPath));
+}
+function currentTerminalActions(currentTurn) {
+    if (!currentTurn || !isRecord(currentTurn.available_actions)) {
+        return {};
+    }
+    const actions = {};
+    for (const action of ["status", "approve", "cancel", "renew", "retry_callback"]) {
+        if (isRecord(currentTurn.available_actions[action])) {
+            actions[action] = currentTurn.available_actions[action];
+        }
+    }
+    return actions;
+}
+function safeTerminalActionsDuringConflict(rawActions) {
+    const actions = {};
+    for (const action of ["status", "close"]) {
+        if (isRecord(rawActions[action])) {
+            actions[action] = rawActions[action];
+        }
+    }
+    return actions;
+}
+function safeUnavailableManagedTurnActions(actionsValue) {
+    const actions = {};
+    for (const action of ["status", "retry_callback", "close"]) {
+        if (isRecord(actionsValue[action])) {
+            actions[action] = actionsValue[action];
+        }
+    }
+    return actions;
+}
+function readOnlyListActions(actionsValue) {
+    return isRecord(actionsValue.status)
+        ? { status: actionsValue.status }
+        : {};
+}
+function readOnlyManagedTurn(managedTurn) {
+    return {
+        ...managedTurn,
+        available_actions: readOnlyListActions(isRecord(managedTurn.available_actions)
+            ? managedTurn.available_actions
+            : {})
+    };
+}
+function historicalManagedTurnForTerminal(conversation, terminalCanAcceptSend, terminal) {
+    const managedTurn = managedTurnListEntry(summarizeConversation(conversation), {
+        terminalBridge: terminalBridgeEnabled(conversation),
+        approvalState: managedListApprovalState(conversation),
+        conversation
+    });
+    const availableActions = isRecord(managedTurn.available_actions)
+        ? managedTurn.available_actions
+        : {};
+    const safeActions = safeUnavailableManagedTurnActions(availableActions);
+    if (terminalCanAcceptSend &&
+        managedTurnMatchesLiveTerminal(conversation, terminal) &&
+        isRecord(availableActions.follow_up)) {
+        safeActions.follow_up = availableActions.follow_up;
+    }
+    return {
+        ...managedTurn,
+        available_actions: safeActions
+    };
+}
+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 = 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 ||
+        stringValue(takeover?.native_session_id) !== stringValue(terminal.id) ||
+        terminalControlSelectorKey(storedControl) !==
+            terminalControlSelectorKey(liveControl)) {
+        return false;
+    }
+    const storedSessionId = stringValue(takeover?.terminal_agent_session_id);
+    const liveSessionId = stringValue(terminal.session_id);
+    if (storedSessionId && storedSessionId !== liveSessionId) {
+        return false;
+    }
+    const liveWorkspace = terminal.workspace ?? terminal.cwd;
+    if (!matchesConfiguredWorkspace(conversation.workspace, liveWorkspace)) {
+        return false;
+    }
+    const livePanePath = liveControl?.currentPath;
+    if (livePanePath !== undefined &&
+        !matchesConfiguredWorkspace(conversation.workspace, livePanePath)) {
+        return false;
+    }
+    return true;
+}
+function currentManagedTurnForTerminal(conversation, terminal, rawTerminalActions) {
+    const managedTurn = managedTurnListEntry(summarizeConversation(conversation), {
+        terminalBridge: terminalBridgeEnabled(conversation),
+        approvalState: managedListApprovalState(conversation),
+        conversation
+    });
+    const rawApproval = isRecord(rawTerminalActions.approve)
+        ? rawTerminalActions.approve
+        : undefined;
+    if (!rawApproval || executorForConversation(conversation).kind !== "codex") {
+        return managedTurn;
+    }
+    const ownerId = conversation.conversation_id;
+    const approval = retargetConversationAction(rawApproval, ownerId);
+    const terminalApprovalState = isRecord(terminal.approval_state)
+        ? terminal.approval_state
+        : undefined;
+    return {
+        ...managedTurn,
+        ...(terminalApprovalState
+            ? { approval_state: terminalApprovalState }
+            : {}),
+        available_actions: {
+            ...(isRecord(managedTurn.available_actions)
+                ? managedTurn.available_actions
+                : {}),
+            approve: approval
+        }
+    };
+}
+function retargetConversationAction(action, conversationId) {
+    const beforeCall = isRecord(action.before_call)
+        ? action.before_call
+        : undefined;
+    return {
+        ...action,
+        arguments: {
+            ...(isRecord(action.arguments) ? action.arguments : {}),
+            conversation_id: conversationId
+        },
+        ...(beforeCall
+            ? {
+                before_call: {
+                    ...beforeCall,
+                    arguments: {
+                        ...(isRecord(beforeCall.arguments)
+                            ? beforeCall.arguments
+                            : {}),
+                        conversation_id: conversationId
+                    }
+                }
+            }
+            : {})
     };
 }
 async function listStateForTerminal(agent, terminalControl, options, bridge = createTerminalAgentBridge(options), runtime) {
@@ -1602,7 +2083,7 @@ function childPidsForRoot(root, processes) {
         .filter((process) => process.agent === root.agent && process.ppid === root.pid)
         .map((process) => process.pid);
 }
-function canSendDelegated(status) {
+function canFollowUpManagedTurn(status) {
     return !["done", "failed", "closed", "cancelled"].includes(status);
 }
 function managedListApprovalState(conversation) {
@@ -1640,28 +2121,31 @@ function managedListApprovalState(conversation) {
 }
 function listActionContracts() {
     return {
-        version: 2,
+        version: 3,
         instructions: [
-            "Use only actions present in delegated[].available_actions or terminal_controlled[].available_actions.",
-            "Never use commands for routing or tool calls. It is a deprecated, non-authoritative compatibility field with mixed legacy semantics.",
+            "Treat terminals[] as the primary resource and use only actions present in available_actions.",
+            "Use a terminal send action to start a new managed turn. Use a managed turn follow_up action only when continuing that specific managed turn.",
             "Start with the action's prefilled arguments, supply every missing_required field, and consult the top-level action's optional fields only when needed.",
             "Authoritative full IDs are prefilled; short_ref is for display and human input.",
             "Availability is a snapshot. AKK revalidates process, tmux pane, workspace, activity, approval, and recovery state before side effects."
         ],
         field_semantics: {
+            process_state: {
+                terminals: "physical_terminal_process_liveness",
+                authoritative_for_tool_calls: false
+            },
             status: {
-                delegated: "task_lifecycle",
-                terminal_controlled: "process_liveness",
+                managed_turns: "managed_turn_lifecycle",
                 authoritative_for_tool_calls: false
             },
             activity_state: {
-                terminal_controlled: "screen_activity_classification",
+                terminals: "terminal_screen_activity_classification",
                 authoritative_for_tool_calls: false
             },
-            commands: {
-                meaning: "legacy_compatibility_flags_with_mixed_semantics",
-                deprecated: true,
-                authoritative_for_tool_calls: false
+            managed: {
+                current_turn: "the authoritative dispatch-ledger owner, never inferred from history",
+                recent_turn: "the latest visible non-owning turn for intentional follow-up",
+                history: "older turns, present only with --all"
             },
             available_actions: {
                 meaning: "currently_safe_actions",
@@ -1681,7 +2165,19 @@ function listActionContracts() {
                     "agentHardTimeoutMinutes"
                 ],
                 unsupported: ["timeoutSeconds"],
-                ordinary_use: "Add request only. Omit timeout fields unless the user explicitly asks to change monitoring limits."
+                ordinary_use: "Start a new managed turn on the selected physical terminal. Add request only and omit timeout fields unless the user explicitly asks to change monitoring limits."
+            },
+            follow_up: {
+                tool: "agent_knock_knock_send",
+                target_argument: "selector",
+                required: ["request"],
+                optional: [
+                    "selector",
+                    "idleTimeoutMinutes",
+                    "agentTimeoutMinutes",
+                    "agentHardTimeoutMinutes"
+                ],
+                ordinary_use: "Continue the explicitly selected managed turn. Start from its prefilled selector and add request."
             },
             status: {
                 tool: "agent_knock_knock_status",
@@ -1736,8 +2232,8 @@ function availableListActions(entry, { conversation } = {}) {
             arguments: { conversation_id: id }
         }
     };
-    const terminalControlled = entry.source === "terminal_control";
-    const managed = entry.source === "akk_delegate";
+    const terminalControlled = entry.source === "terminal";
+    const managed = entry.source === "managed_turn";
     const approvalState = isRecord(entry.approval_state)
         ? entry.approval_state
         : {};
@@ -1756,7 +2252,7 @@ function availableListActions(entry, { conversation } = {}) {
             (terminalControlled &&
                 entry.activity_state === "idle" &&
                 approvalState.blocked !== true))) {
-        actions.send = {
+        actions[managed ? "follow_up" : "send"] = {
             tool: "agent_knock_knock_send",
             arguments: { selector: id },
             missing_required: ["request"]
@@ -1862,53 +2358,112 @@ function isSessionSelectorSyntax(value) {
 }
 async function sessionSelectorCandidates(commandName, options) {
     const storeDir = storeDirFromOptions(options);
-    cleanupIdleConversations(storeDir, options);
+    const mutationsAllowed = inspectStoreCompatibility(storeDir).writable === true;
     const storedConversations = listConversations(storeDir);
     const workspaceConversations = storedConversations
         .filter((conversation) => matchesConfiguredWorkspace(options.workspace, conversation.workspace));
     const discoverableWorkspaceConversations = workspaceConversations
         .filter(isDiscoverableTmuxConversation);
-    const managed = discoverableWorkspaceConversations.map((conversation) => delegatedListEntry(summarizeConversation(conversation), {
+    const managed = discoverableWorkspaceConversations.map((conversation) => managedTurnListEntry(summarizeConversation(conversation), {
         terminalBridge: terminalBridgeEnabled(conversation),
         approvalState: managedListApprovalState(conversation),
         conversation
     }));
-    const managedTerminalKeys = new Set(workspaceConversations
-        .filter((conversation) => isActiveStatus(conversation.status))
-        .map((conversation) => terminalControlSelectorKey(terminalControlFromTakeover(isRecord(conversation.native_session_takeover)
-        ? conversation.native_session_takeover
-        : undefined)))
-        .filter((key) => key !== undefined));
     const terminalScan = await buildTerminalListGroup({
         options: {
             ...options,
-            noApprovalScan: commandName === "approve"
+            noApprovalScan: ["send", "approve", "cancel"].includes(commandName)
                 ? options.noApprovalScan
                 : true
         },
         agentFilter: undefined,
         statusFilter: undefined
     });
+    const terminalProjection = terminalFirstListProjection({
+        terminals: terminalScan.terminalControlled.filter((entry) => matchesConfiguredWorkspace(options.workspace, entry.workspace ?? entry.cwd)),
+        allConversations: discoverableWorkspaceConversations,
+        displayedConversations: discoverableWorkspaceConversations,
+        includeAll: false,
+        managedOnly: options.managedOnly === true,
+        statusFilter: undefined,
+        mutationsAllowed
+    });
     const observedAtMs = Date.now();
     return [
-        ...managed,
-        ...terminalScan.terminalControlled.filter((entry) => {
-            if (!matchesConfiguredWorkspace(options.workspace, entry.workspace ?? entry.cwd)) {
-                return false;
-            }
-            const key = terminalControlSelectorKey(entry.terminal_control);
-            return key === undefined || !managedTerminalKeys.has(key);
-        })
-    ].map((entry) => ({
+        ...managed.map((entry) => sessionSelectorCandidateForEntry(entry, commandName, observedAtMs, {
+            defaultActionable: options.managedOnly === true,
+            mutationsAllowed
+        })),
+        ...terminalProjection.terminals.map((entry) => sessionSelectorCandidateForEntry(entry, commandName, observedAtMs, {
+            defaultActionable: true,
+            mutationsAllowed
+        }))
+    ];
+}
+function sessionSelectorCandidateForEntry(entry, commandName, observedAtMs, { defaultActionable, mutationsAllowed }) {
+    const action = mutationsAllowed || commandName === "status"
+        ? listActionForCommand(entry, commandName)
+        : undefined;
+    const targetId = listActionTargetId(action);
+    return {
         id: String(entry.id),
+        ...(targetId && targetId !== entry.id ? { targetId } : {}),
         agent: resolveExecutor({ kind: entry.agent }).kind,
-        actionable: sessionEntrySupportsCommand(entry, commandName),
+        actionable: action !== undefined,
+        defaultActionable,
         ...sessionEntryRecency(entry, observedAtMs),
         source: stringValue(entry.source),
-        status: stringValue(entry.status),
+        status: stringValue(entry.status ?? entry.process_state),
         workspace: stringValue(entry.workspace ?? entry.cwd),
         label: stringValue(entry.request ?? entry.command)
-    }));
+    };
+}
+function listActionForCommand(entry, commandName) {
+    const actions = isRecord(entry.available_actions)
+        ? entry.available_actions
+        : {};
+    const actionName = commandName === "retry-callback"
+        ? "retry_callback"
+        : commandName === "send" && entry.source === "managed_turn"
+            ? "follow_up"
+            : commandName;
+    if (isRecord(actions[actionName])) {
+        return actions[actionName];
+    }
+    if (commandName !== "approve") {
+        return undefined;
+    }
+    if (managedTurnCanEnterApprovalPath(entry)) {
+        return {
+            tool: "agent_knock_knock_approve",
+            arguments: { conversation_id: String(entry.id) }
+        };
+    }
+    const managed = isRecord(entry.managed) ? entry.managed : undefined;
+    const currentTurn = isRecord(managed?.current_turn)
+        ? managed.current_turn
+        : undefined;
+    if (currentTurn && managedTurnCanEnterApprovalPath(currentTurn)) {
+        return {
+            tool: "agent_knock_knock_approve",
+            arguments: {
+                conversation_id: String(currentTurn.conversation_id ?? currentTurn.id)
+            }
+        };
+    }
+    return undefined;
+}
+function managedTurnCanEnterApprovalPath(entry) {
+    const executor = isRecord(entry.executor) ? entry.executor : undefined;
+    return (entry.source === "managed_turn" &&
+        executor?.transport === "tmux" &&
+        isActiveStatus(String(entry.status)));
+}
+function listActionTargetId(action) {
+    const actionArguments = isRecord(action?.arguments)
+        ? action.arguments
+        : undefined;
+    return stringValue(actionArguments?.selector ?? actionArguments?.conversation_id);
 }
 function terminalControlSelectorKey(value) {
     if (!isRecord(value)) {
@@ -1925,22 +2480,6 @@ function terminalControlSelectorKey(value) {
         socket_path: stringValue(value.socketPath) ?? null
     });
 }
-function sessionEntrySupportsCommand(entry, commandName) {
-    const commands = isRecord(entry.commands) ? entry.commands : {};
-    if (typeof commands[commandName] === "boolean") {
-        return commands[commandName] === true;
-    }
-    if (entry.source !== "akk_delegate") {
-        return false;
-    }
-    if (commandName === "renew") {
-        return entry.status === "stalled";
-    }
-    if (commandName === "retry-callback") {
-        return ["callback_pending", "callback_failed"].includes(entry.status);
-    }
-    return false;
-}
 function sessionEntryRecency(entry, observedAtMs) {
     const timestamp = Date.parse(String(entry.updated_at ?? entry.created_at ?? ""));
     if (Number.isFinite(timestamp)) {
@@ -1956,7 +2495,23 @@ async function resolveTerminalConversationFromOptions(options) {
     return createTerminalAgentBridge(options).resolveConversationId(stringValue(options.conversation ?? options.conversationId));
 }
 async function runStatus(options) {
-    cleanupIdleConversations(storeDirFromOptions(options), options);
+    const explicitStatePath = options.state
+        ? expandHome(String(options.state))
+        : undefined;
+    const storeDir = explicitStatePath
+        ? pathsForConversationDir(path.dirname(explicitStatePath)).storeDir
+        : storeDirFromOptions(options);
+    const reconciliationConversationId = stringValue(options.conversation ?? options.conversationId) ??
+        (explicitStatePath
+            ? path.basename(pathsForConversationDir(path.dirname(explicitStatePath))
+                .conversationDir)
+            : undefined);
+    const reconciliation = options.reconcile === true
+        ? await reconcileStoreForStatus(storeDir, options, reconciliationConversationId)
+        : {
+            status: "disabled",
+            reason: "standalone status is read-only unless --reconcile is supplied"
+        };
     const terminalConversation = await resolveTerminalConversationFromOptions(options);
     if (terminalConversation) {
         const terminalStatus = await terminalStatusForControl(terminalConversation.agent, terminalConversation.terminalControl, options, {
@@ -1970,6 +2525,8 @@ async function runStatus(options) {
             conversation_id: terminalConversation.conversationId,
             source: "terminal_control",
             agent: terminalConversation.agent,
+            store: inspectStoreCompatibility(storeDir),
+            reconciliation,
             ...context,
             terminal_control: terminalConversation.terminalControl,
             terminal_status: terminalStatus,
@@ -1984,13 +2541,12 @@ async function runStatus(options) {
     }
     const loaded = loadConversationFromOptions(options);
     const { statePath, logPath } = loaded;
-    const conversation = await migrateLegacyTerminalAgentIdentity({
-        ...loaded,
-        options
-    });
+    const conversation = loaded.conversation;
     const events = readExistingEvents(logPath);
     const result = {
         conversation,
+        store: inspectStoreCompatibility(storeDir),
+        reconciliation,
         summary: summarizeConversation(conversation),
         confidence: "high",
         about: managedConversationAbout(conversation, events),
@@ -2027,6 +2583,38 @@ async function runStatus(options) {
         trace: Boolean(options.trace)
     });
 }
+async function reconcileStoreForStatus(storeDir, options, conversationId) {
+    try {
+        ensureStoreWritable(storeDir);
+    }
+    catch (error) {
+        if (isRecord(error) && error.code === "AKK_STORE_INCOMPATIBLE") {
+            return {
+                status: "skipped",
+                reason: error instanceof Error ? error.message : String(error),
+                store: inspectStoreCompatibility(storeDir)
+            };
+        }
+        throw error;
+    }
+    const idle = reconcileIdleConversations(storeDir, options, new Date(), conversationId);
+    const monitors = await reconcileMonitors(options, {
+        includeCallbackRecovery: false,
+        reason: "status_reconciliation",
+        conversationId
+    });
+    return {
+        status: "completed",
+        checked: Math.max(idle.checked, monitors.checked),
+        changed: idle.closed + monitors.launched,
+        closed: idle.closed,
+        monitors_launched: monitors.launched,
+        monitors_already_running: monitors.already_running,
+        skipped: idle.skipped + monitors.skipped,
+        errors: monitors.errors,
+        idle_timeout_minutes: idle.idle_timeout_minutes
+    };
+}
 async function terminalStatusContext(terminalConversation, terminalStatus, options) {
     if (terminalConversation.agent === "codex") {
         try {
@@ -2497,7 +3085,6 @@ async function runSend(options) {
     if (options.agentHardTimeoutMinutes !== undefined) {
         positiveMinutes(options.agentHardTimeoutMinutes, "--agent-hard-timeout-minutes");
     }
-    cleanupIdleConversations(storeDirFromOptions(options), options);
     const terminalConversation = await resolveTerminalConversationFromOptions(options);
     if (terminalConversation) {
         if (!options.background) {
@@ -2514,6 +3101,7 @@ async function runSend(options) {
                 messageBody,
                 terminalControl: terminalConversation.terminalControl
             });
+            ensureStoreWritable(managed.conversation.store_dir);
             ensureDir(path.dirname(managed.statePath));
             releaseStateLock = acquireFileLock(`${managed.statePath}.lock`);
             await runTerminalControlSend({
@@ -2599,7 +3187,6 @@ async function runSend(options) {
     throw new Error(`conversation ${migratedConversation.conversation_id} is not attached to a live tmux terminal`);
 }
 async function runApprove(options) {
-    cleanupIdleConversations(storeDirFromOptions(options), options);
     const terminalConversation = await resolveTerminalConversationFromOptions(options);
     if (terminalConversation) {
         await runTerminalConversationApprove({
@@ -2773,6 +3360,7 @@ async function runApprove(options) {
         }
     };
     let releaseStateLock;
+    let approvalDispatchReserved = false;
     const releaseApprovalStateLock = () => {
         if (releaseStateLock) {
             const release = releaseStateLock;
@@ -2780,323 +3368,330 @@ async function runApprove(options) {
             release();
         }
     };
+    releaseStateLock = acquireFileLock(`${statePath}.lock`);
+    const writerStoreDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
     try {
-        let approval;
-        let lockedConversation = conversation;
-        const currentConversation = loadState(statePath);
-        const currentTakeover = isRecord(currentConversation.native_session_takeover)
-            ? currentConversation.native_session_takeover
-            : undefined;
-        const currentControl = terminalControlFromTakeover(currentTakeover);
-        const currentApproval = isRecord(currentTakeover?.terminal_bridge_approval)
-            ? currentTakeover.terminal_bridge_approval
-            : undefined;
-        if (currentConversation.status !== conversation.status ||
-            currentTakeover?.terminal_bridge_message_id !== nativeTakeover?.terminal_bridge_message_id ||
-            currentControl?.target !== terminalControl.target ||
-            currentControl?.socketPath !== terminalControl.socketPath ||
-            (claudeScreenApproval &&
-                currentApproval?.fingerprint !== monitoredApproval?.fingerprint)) {
-            throw new Error("approval state changed while waiting for terminal control; refresh status and retry");
-        }
-        assertManagedTerminalDispatchOwner({
-            conversation: currentConversation,
-            terminalControl: currentControl,
-            action: "approve"
-        });
-        lockedConversation = currentConversation;
-        approval = await createTerminalAgentBridge(options).approve(executor.kind, terminalControl, {
-            expectedFingerprint,
-            scrollbackLines: Number(options.scrollbackLines ?? 120),
-            runtime: runtimeIdentity,
-            managedRequest: terminalDurableRequestForConversation(currentConversation, terminalControl),
-            requiredDecisionMode: autoApproved && executor.kind === "claude" ? "keys" : undefined,
-            authorize: autoApproved
-                ? ({ agent, terminalControl: currentTerminalControl, inspection, fingerprint }) => {
-                    if (!autoApprovalPolicy) {
-                        return {
-                            approved: false,
-                            reason: "automatic approval requires an executor-side policy"
-                        };
-                    }
-                    const candidate = policyCandidateForInspection({
-                        agent,
-                        currentTerminalControl,
-                        inspection,
-                        fingerprint
-                    });
-                    executorPolicyDecision = evaluateApprovalPolicy({
-                        policy: autoApprovalPolicy,
-                        candidate
-                    });
-                    if (executorPolicyDecision.action !== "approve") {
-                        return {
-                            approved: false,
-                            reason: `executor-side auto-approval policy rejected the current request: ${executorPolicyDecision.reason}`
-                        };
-                    }
-                    if (policyRuleId && executorPolicyDecision.ruleId !== policyRuleId) {
-                        return {
-                            approved: false,
-                            reason: "executor-side auto-approval rule changed before execution"
-                        };
-                    }
-                    if (policyFingerprint &&
-                        executorPolicyDecision.policyFingerprint !== policyFingerprint) {
-                        return {
-                            approved: false,
-                            reason: "executor-side auto-approval policy changed before execution"
-                        };
-                    }
-                    return { approved: true };
-                }
-                : undefined,
-            beforeKeyDispatch: claudeScreenApproval
-                ? ({ fingerprint, terminalControl: dispatchControl, inspection, keys }) => {
-                    if (autoApproved) {
+        return await withStoreWriterLeaseAsync(writerStoreDir, async () => {
+            let approval;
+            let lockedConversation = conversation;
+            const currentConversation = loadState(statePath);
+            const currentTakeover = isRecord(currentConversation.native_session_takeover)
+                ? currentConversation.native_session_takeover
+                : undefined;
+            const currentControl = terminalControlFromTakeover(currentTakeover);
+            const currentApproval = isRecord(currentTakeover?.terminal_bridge_approval)
+                ? currentTakeover.terminal_bridge_approval
+                : undefined;
+            if (currentConversation.status !== conversation.status ||
+                currentTakeover?.terminal_bridge_message_id !== nativeTakeover?.terminal_bridge_message_id ||
+                currentControl?.target !== terminalControl.target ||
+                currentControl?.socketPath !== terminalControl.socketPath ||
+                (claudeScreenApproval &&
+                    currentApproval?.fingerprint !== monitoredApproval?.fingerprint)) {
+                throw new Error("approval state changed while waiting for terminal control; refresh status and retry");
+            }
+            assertManagedTerminalDispatchOwner({
+                conversation: currentConversation,
+                terminalControl: currentControl,
+                action: "approve"
+            });
+            lockedConversation = currentConversation;
+            approval = await createTerminalAgentBridge(options).approve(executor.kind, terminalControl, {
+                expectedFingerprint,
+                scrollbackLines: Number(options.scrollbackLines ?? 120),
+                runtime: runtimeIdentity,
+                managedRequest: terminalDurableRequestForConversation(currentConversation, terminalControl),
+                requiredDecisionMode: autoApproved && executor.kind === "claude" ? "keys" : undefined,
+                authorize: autoApproved
+                    ? ({ agent, terminalControl: currentTerminalControl, inspection, fingerprint }) => {
                         if (!autoApprovalPolicy) {
-                            throw new Error("automatic approval requires an executor-side policy before dispatch");
+                            return {
+                                approved: false,
+                                reason: "automatic approval requires an executor-side policy"
+                            };
                         }
-                        const freshPolicyDecision = evaluateApprovalPolicy({
+                        const candidate = policyCandidateForInspection({
+                            agent,
+                            currentTerminalControl,
+                            inspection,
+                            fingerprint
+                        });
+                        executorPolicyDecision = evaluateApprovalPolicy({
                             policy: autoApprovalPolicy,
-                            candidate: policyCandidateForInspection({
-                                agent: executor.kind,
-                                currentTerminalControl: dispatchControl,
-                                inspection,
-                                fingerprint
-                            })
+                            candidate
                         });
-                        if (freshPolicyDecision.action !== "approve") {
-                            throw new Error(`executor-side auto-approval policy rejected the recaptured request: ${freshPolicyDecision.reason}`);
-                        }
-                        if (executorPolicyDecision?.ruleId &&
-                            freshPolicyDecision.ruleId !== executorPolicyDecision.ruleId) {
-                            throw new Error("executor-side auto-approval rule changed after recapture");
+                        if (executorPolicyDecision.action !== "approve") {
+                            return {
+                                approved: false,
+                                reason: `executor-side auto-approval policy rejected the current request: ${executorPolicyDecision.reason}`
+                            };
                         }
-                        if (policyRuleId && freshPolicyDecision.ruleId !== policyRuleId) {
-                            throw new Error("executor-side auto-approval rule changed before dispatch");
+                        if (policyRuleId && executorPolicyDecision.ruleId !== policyRuleId) {
+                            return {
+                                approved: false,
+                                reason: "executor-side auto-approval rule changed before execution"
+                            };
                         }
                         if (policyFingerprint &&
-                            freshPolicyDecision.policyFingerprint !== policyFingerprint) {
-                            throw new Error("executor-side auto-approval policy changed before dispatch");
+                            executorPolicyDecision.policyFingerprint !== policyFingerprint) {
+                            return {
+                                approved: false,
+                                reason: "executor-side auto-approval policy changed before execution"
+                            };
                         }
-                        executorPolicyDecision = freshPolicyDecision;
-                    }
-                    if (releaseStateLock) {
-                        throw new Error("Claude approval dispatch was already reserved");
-                    }
-                    releaseStateLock = acquireFileLock(`${statePath}.lock`);
-                    const latestConversation = loadState(statePath);
-                    const latestTakeover = isRecord(latestConversation.native_session_takeover)
-                        ? latestConversation.native_session_takeover
-                        : undefined;
-                    const latestControl = terminalControlFromTakeover(latestTakeover);
-                    const latestApproval = isRecord(latestTakeover?.terminal_bridge_approval)
-                        ? latestTakeover.terminal_bridge_approval
-                        : undefined;
-                    const latestNotifiedAt = validTimestampMs(latestApproval?.notified_at);
-                    const latestApprovalState = isRecord(latestApproval?.approval_state)
-                        ? latestApproval.approval_state
-                        : undefined;
-                    const latestPolicyEvidence = isRecord(latestApprovalState?.policy_evidence)
-                        ? latestApprovalState.policy_evidence
-                        : undefined;
-                    const recapturedPolicyEvidence = inspection.approval.approvable
-                        ? inspection.approval.policyEvidence
-                        : undefined;
-                    const latestDispatch = isRecord(latestTakeover?.terminal_bridge_approval_dispatch)
-                        ? latestTakeover.terminal_bridge_approval_dispatch
-                        : undefined;
-                    if (!latestTakeover ||
-                        latestConversation.status !== "waiting_for_openclaw" ||
-                        latestTakeover.terminal_bridge_message_id !==
-                            nativeTakeover?.terminal_bridge_message_id ||
-                        latestApproval?.fingerprint !== fingerprint ||
-                        latestNotifiedAt === undefined ||
-                        Date.now() - latestNotifiedAt > CLAUDE_SCREEN_APPROVAL_TTL_MS ||
-                        expectedFingerprint !== fingerprint ||
-                        latestControl?.target !== dispatchControl.target ||
-                        latestControl?.socketPath !== dispatchControl.socketPath ||
-                        (autoApproved &&
-                            (latestPolicyEvidence?.source !== "claude_transcript" ||
-                                latestPolicyEvidence.evidence_fingerprint !==
-                                    recapturedPolicyEvidence?.evidenceFingerprint))) {
-                        throw new Error("approval state changed before terminal dispatch; refresh status and retry");
+                        return { approved: true };
                     }
-                    if (latestDispatch?.state === "reserved" &&
-                        latestDispatch.terminal_bridge_message_id ===
-                            latestTakeover.terminal_bridge_message_id) {
-                        throw new Error("a previous Claude approval dispatch has an uncertain outcome; inspect and resolve the terminal manually");
-                    }
-                    const reservedAt = new Date().toISOString();
-                    const reservedConversation = {
-                        ...latestConversation,
-                        native_session_takeover: {
-                            ...latestTakeover,
-                            terminal_bridge_approval_dispatch: {
-                                state: "reserved",
-                                attempt_id: randomUUID(),
-                                fingerprint,
-                                keys,
-                                terminal_target: dispatchControl.target,
-                                terminal_bridge_message_id: latestTakeover.terminal_bridge_message_id,
-                                reserved_at: reservedAt
+                    : undefined,
+                beforeKeyDispatch: claudeScreenApproval
+                    ? ({ fingerprint, terminalControl: dispatchControl, inspection, keys }) => {
+                        if (autoApproved) {
+                            if (!autoApprovalPolicy) {
+                                throw new Error("automatic approval requires an executor-side policy before dispatch");
                             }
-                        },
-                        updated_at: reservedAt
-                    };
-                    saveState(statePath, reservedConversation);
-                    lockedConversation = reservedConversation;
+                            const freshPolicyDecision = evaluateApprovalPolicy({
+                                policy: autoApprovalPolicy,
+                                candidate: policyCandidateForInspection({
+                                    agent: executor.kind,
+                                    currentTerminalControl: dispatchControl,
+                                    inspection,
+                                    fingerprint
+                                })
+                            });
+                            if (freshPolicyDecision.action !== "approve") {
+                                throw new Error(`executor-side auto-approval policy rejected the recaptured request: ${freshPolicyDecision.reason}`);
+                            }
+                            if (executorPolicyDecision?.ruleId &&
+                                freshPolicyDecision.ruleId !== executorPolicyDecision.ruleId) {
+                                throw new Error("executor-side auto-approval rule changed after recapture");
+                            }
+                            if (policyRuleId && freshPolicyDecision.ruleId !== policyRuleId) {
+                                throw new Error("executor-side auto-approval rule changed before dispatch");
+                            }
+                            if (policyFingerprint &&
+                                freshPolicyDecision.policyFingerprint !== policyFingerprint) {
+                                throw new Error("executor-side auto-approval policy changed before dispatch");
+                            }
+                            executorPolicyDecision = freshPolicyDecision;
+                        }
+                        if (approvalDispatchReserved) {
+                            throw new Error("Claude approval dispatch was already reserved");
+                        }
+                        approvalDispatchReserved = true;
+                        if (!releaseStateLock) {
+                            throw new Error("approval state lock was released before terminal dispatch");
+                        }
+                        const latestConversation = loadState(statePath);
+                        const latestTakeover = isRecord(latestConversation.native_session_takeover)
+                            ? latestConversation.native_session_takeover
+                            : undefined;
+                        const latestControl = terminalControlFromTakeover(latestTakeover);
+                        const latestApproval = isRecord(latestTakeover?.terminal_bridge_approval)
+                            ? latestTakeover.terminal_bridge_approval
+                            : undefined;
+                        const latestNotifiedAt = validTimestampMs(latestApproval?.notified_at);
+                        const latestApprovalState = isRecord(latestApproval?.approval_state)
+                            ? latestApproval.approval_state
+                            : undefined;
+                        const latestPolicyEvidence = isRecord(latestApprovalState?.policy_evidence)
+                            ? latestApprovalState.policy_evidence
+                            : undefined;
+                        const recapturedPolicyEvidence = inspection.approval.approvable
+                            ? inspection.approval.policyEvidence
+                            : undefined;
+                        const latestDispatch = isRecord(latestTakeover?.terminal_bridge_approval_dispatch)
+                            ? latestTakeover.terminal_bridge_approval_dispatch
+                            : undefined;
+                        if (!latestTakeover ||
+                            latestConversation.status !== "waiting_for_openclaw" ||
+                            latestTakeover.terminal_bridge_message_id !==
+                                nativeTakeover?.terminal_bridge_message_id ||
+                            latestApproval?.fingerprint !== fingerprint ||
+                            latestNotifiedAt === undefined ||
+                            Date.now() - latestNotifiedAt > CLAUDE_SCREEN_APPROVAL_TTL_MS ||
+                            expectedFingerprint !== fingerprint ||
+                            latestControl?.target !== dispatchControl.target ||
+                            latestControl?.socketPath !== dispatchControl.socketPath ||
+                            (autoApproved &&
+                                (latestPolicyEvidence?.source !== "claude_transcript" ||
+                                    latestPolicyEvidence.evidence_fingerprint !==
+                                        recapturedPolicyEvidence?.evidenceFingerprint))) {
+                            throw new Error("approval state changed before terminal dispatch; refresh status and retry");
+                        }
+                        if (latestDispatch?.state === "reserved" &&
+                            latestDispatch.terminal_bridge_message_id ===
+                                latestTakeover.terminal_bridge_message_id) {
+                            throw new Error("a previous Claude approval dispatch has an uncertain outcome; inspect and resolve the terminal manually");
+                        }
+                        const reservedAt = new Date().toISOString();
+                        const reservedConversation = {
+                            ...latestConversation,
+                            native_session_takeover: {
+                                ...latestTakeover,
+                                terminal_bridge_approval_dispatch: {
+                                    state: "reserved",
+                                    attempt_id: randomUUID(),
+                                    fingerprint,
+                                    keys,
+                                    terminal_target: dispatchControl.target,
+                                    terminal_bridge_message_id: latestTakeover.terminal_bridge_message_id,
+                                    reserved_at: reservedAt
+                                }
+                            },
+                            updated_at: reservedAt
+                        };
+                        saveState(statePath, reservedConversation);
+                        lockedConversation = reservedConversation;
+                    }
+                    : undefined
+            });
+            const actualFingerprint = approval.fingerprint;
+            const effectivePolicyRuleId = executorPolicyDecision?.ruleId ?? policyRuleId;
+            const effectivePolicyFingerprint = executorPolicyDecision?.policyFingerprint ?? policyFingerprint;
+            if (!approval.approved) {
+                releaseApprovalStateLock();
+                releaseApprovalTerminalLock();
+                if (autoApproved) {
+                    appendEvent(logPath, {
+                        ts: new Date().toISOString(),
+                        conversation_id: conversation.conversation_id,
+                        event: "terminal_auto_approval_decision",
+                        action: "rejected",
+                        reason: approval.reason,
+                        terminal_control: terminalControl,
+                        expected_fingerprint: expectedFingerprint,
+                        actual_fingerprint: actualFingerprint,
+                        policy_rule_id: effectivePolicyRuleId,
+                        policy_fingerprint: effectivePolicyFingerprint
+                    });
                 }
-                : undefined
-        });
-        const actualFingerprint = approval.fingerprint;
-        const effectivePolicyRuleId = executorPolicyDecision?.ruleId ?? policyRuleId;
-        const effectivePolicyFingerprint = executorPolicyDecision?.policyFingerprint ?? policyFingerprint;
-        if (!approval.approved) {
-            releaseApprovalStateLock();
-            releaseApprovalTerminalLock();
+                printJson({
+                    conversation,
+                    approved: false,
+                    blocked: approval.blocked,
+                    reason: approval.reason,
+                    terminal_control: terminalControl,
+                    expected_approval_fingerprint: expectedFingerprint,
+                    actual_approval_fingerprint: actualFingerprint,
+                    screen_excerpt: approval.screenExcerpt
+                });
+                return;
+            }
+            appendEvent(logPath, {
+                ts: new Date().toISOString(),
+                conversation_id: conversation.conversation_id,
+                event: "terminal_approval_send",
+                terminal_control: terminalControl,
+                key: approval.key,
+                keys: approval.keys,
+                label: approval.label,
+                decision_mode: approval.decisionMode,
+                request_id: approval.requestId,
+                approval_fingerprint: actualFingerprint,
+                auto_approved: autoApproved,
+                policy_rule_id: effectivePolicyRuleId,
+                policy_fingerprint: effectivePolicyFingerprint
+            });
             if (autoApproved) {
                 appendEvent(logPath, {
                     ts: new Date().toISOString(),
                     conversation_id: conversation.conversation_id,
                     event: "terminal_auto_approval_decision",
-                    action: "rejected",
-                    reason: approval.reason,
+                    action: "approved",
                     terminal_control: terminalControl,
-                    expected_fingerprint: expectedFingerprint,
-                    actual_fingerprint: actualFingerprint,
+                    approval_fingerprint: actualFingerprint,
                     policy_rule_id: effectivePolicyRuleId,
                     policy_fingerprint: effectivePolicyFingerprint
                 });
             }
-            printJson({
-                conversation,
-                approved: false,
-                blocked: approval.blocked,
-                reason: approval.reason,
-                terminal_control: terminalControl,
-                expected_approval_fingerprint: expectedFingerprint,
-                actual_approval_fingerprint: actualFingerprint,
-                screen_excerpt: approval.screenExcerpt
-            });
-            return;
-        }
-        appendEvent(logPath, {
-            ts: new Date().toISOString(),
-            conversation_id: conversation.conversation_id,
-            event: "terminal_approval_send",
-            terminal_control: terminalControl,
-            key: approval.key,
-            keys: approval.keys,
-            label: approval.label,
-            decision_mode: approval.decisionMode,
-            request_id: approval.requestId,
-            approval_fingerprint: actualFingerprint,
-            auto_approved: autoApproved,
-            policy_rule_id: effectivePolicyRuleId,
-            policy_fingerprint: effectivePolicyFingerprint
-        });
-        if (autoApproved) {
-            appendEvent(logPath, {
-                ts: new Date().toISOString(),
+            runtimeLog("info", "terminal_approval_send", {
                 conversation_id: conversation.conversation_id,
-                event: "terminal_auto_approval_decision",
-                action: "approved",
-                terminal_control: terminalControl,
+                terminal_target: terminalControl.target,
+                key: approval.key,
+                keys: approval.keys,
+                label: approval.label,
+                decision_mode: approval.decisionMode,
+                request_id: approval.requestId,
                 approval_fingerprint: actualFingerprint,
+                auto_approved: autoApproved,
                 policy_rule_id: effectivePolicyRuleId,
                 policy_fingerprint: effectivePolicyFingerprint
             });
-        }
-        runtimeLog("info", "terminal_approval_send", {
-            conversation_id: conversation.conversation_id,
-            terminal_target: terminalControl.target,
-            key: approval.key,
-            keys: approval.keys,
-            label: approval.label,
-            decision_mode: approval.decisionMode,
-            request_id: approval.requestId,
-            approval_fingerprint: actualFingerprint,
-            auto_approved: autoApproved,
-            policy_rule_id: effectivePolicyRuleId,
-            policy_fingerprint: effectivePolicyFingerprint
-        });
-        const nativeTakeoverForUpdate = isRecord(lockedConversation.native_session_takeover)
-            ? { ...lockedConversation.native_session_takeover }
-            : {};
-        const resolvedApproval = isRecord(nativeTakeoverForUpdate.terminal_bridge_approval)
-            ? nativeTakeoverForUpdate.terminal_bridge_approval
-            : undefined;
-        const resolvedApprovalScreenDigest = stringValue(resolvedApproval?.screen_digest);
-        const resolvedApprovalState = isRecord(resolvedApproval?.approval_state)
-            ? resolvedApproval.approval_state
-            : undefined;
-        const resolvedTranscriptIdentity = claudeTranscriptApprovalIdentity(resolvedApprovalState);
-        const approvalResolvedAt = new Date().toISOString();
-        const agentTimeoutMinutes = Number(options.agentTimeoutMinutes ??
-            nativeTakeoverForUpdate.terminal_bridge_inactivity_timeout_minutes ??
-            DEFAULT_AGENT_TIMEOUT_MINUTES);
-        const agentHardTimeoutMinutes = positiveMinutes(options.agentHardTimeoutMinutes ??
-            nativeTakeoverForUpdate.terminal_bridge_hard_timeout_minutes ??
-            DEFAULT_AGENT_HARD_TIMEOUT_MINUTES, "--agent-hard-timeout-minutes");
-        const nextNativeTakeover = {
-            ...nativeTakeoverForUpdate,
-            terminal_bridge_approval: undefined,
-            terminal_bridge_approval_dispatch: undefined,
-            terminal_bridge_approval_resolved_at: approvalResolvedAt,
-            terminal_bridge_last_approval_fingerprint: actualFingerprint,
-            terminal_bridge_last_approval_screen_digest: resolvedApprovalScreenDigest,
-            terminal_bridge_last_approval_request_id: resolvedTranscriptIdentity?.requestId,
-            terminal_bridge_last_approval_evidence_fingerprint: resolvedTranscriptIdentity?.evidenceFingerprint,
-            terminal_bridge_last_approval_prompt_cleared_at: undefined,
-            terminal_bridge_last_approval_at: approvalResolvedAt,
-            terminal_bridge_last_approval_message_id: nativeTakeoverForUpdate.terminal_bridge_message_id,
-            terminal_bridge_monitor_lock_version: TERMINAL_BRIDGE_MONITOR_LOCK_VERSION,
-            terminal_bridge_monitor_started_at: approvalResolvedAt,
-            terminal_bridge_last_activity_at: approvalResolvedAt,
-            terminal_bridge_last_activity_reason: "approval resolved",
-            terminal_bridge_inactivity_timeout_minutes: agentTimeoutMinutes,
-            terminal_bridge_hard_timeout_minutes: agentHardTimeoutMinutes,
-            terminal_bridge_inactivity_deadline_at: deadlineAt(approvalResolvedAt, agentTimeoutMinutes),
-            terminal_bridge_hard_deadline_at: deadlineAt(stringValue(nativeTakeoverForUpdate.terminal_bridge_started_at) ?? approvalResolvedAt, agentHardTimeoutMinutes)
-        };
-        delete nextNativeTakeover.terminal_bridge_approval;
-        delete nextNativeTakeover.terminal_bridge_approval_dispatch;
-        delete nextNativeTakeover.terminal_bridge_last_approval_prompt_cleared_at;
-        const nextConversation = {
-            ...lockedConversation,
-            status: terminalBridgeEnabled(lockedConversation)
-                ? "waiting_for_agent"
-                : lockedConversation.status,
-            native_session_takeover: nextNativeTakeover,
-            updated_at: approvalResolvedAt
-        };
-        saveState(statePath, nextConversation);
-        releaseApprovalStateLock();
-        releaseApprovalTerminalLock();
-        const bridgeMonitor = ensureTerminalBridgeMonitorAfterApproval({
-            conversation: nextConversation,
-            statePath,
-            logPath,
-            terminalControl,
-            options
-        });
-        printJson({
-            conversation: nextConversation,
-            approved: true,
-            terminal_control: terminalControl,
-            key: approval.key,
-            keys: approval.keys,
-            label: approval.label,
-            decision_mode: approval.decisionMode,
-            request_id: approval.requestId,
-            approval_fingerprint: actualFingerprint,
-            auto_approved: autoApproved,
-            policy_rule_id: effectivePolicyRuleId,
-            policy_fingerprint: effectivePolicyFingerprint,
-            monitor_pid: bridgeMonitor.monitorPid ?? null,
-            monitor_handoff_pid: bridgeMonitor.handoffWatchdog?.pid ?? null
+            const nativeTakeoverForUpdate = isRecord(lockedConversation.native_session_takeover)
+                ? { ...lockedConversation.native_session_takeover }
+                : {};
+            const resolvedApproval = isRecord(nativeTakeoverForUpdate.terminal_bridge_approval)
+                ? nativeTakeoverForUpdate.terminal_bridge_approval
+                : undefined;
+            const resolvedApprovalScreenDigest = stringValue(resolvedApproval?.screen_digest);
+            const resolvedApprovalState = isRecord(resolvedApproval?.approval_state)
+                ? resolvedApproval.approval_state
+                : undefined;
+            const resolvedTranscriptIdentity = claudeTranscriptApprovalIdentity(resolvedApprovalState);
+            const approvalResolvedAt = new Date().toISOString();
+            const agentTimeoutMinutes = Number(options.agentTimeoutMinutes ??
+                nativeTakeoverForUpdate.terminal_bridge_inactivity_timeout_minutes ??
+                DEFAULT_AGENT_TIMEOUT_MINUTES);
+            const agentHardTimeoutMinutes = positiveMinutes(options.agentHardTimeoutMinutes ??
+                nativeTakeoverForUpdate.terminal_bridge_hard_timeout_minutes ??
+                DEFAULT_AGENT_HARD_TIMEOUT_MINUTES, "--agent-hard-timeout-minutes");
+            const nextNativeTakeover = {
+                ...nativeTakeoverForUpdate,
+                terminal_bridge_approval: undefined,
+                terminal_bridge_approval_dispatch: undefined,
+                terminal_bridge_approval_resolved_at: approvalResolvedAt,
+                terminal_bridge_last_approval_fingerprint: actualFingerprint,
+                terminal_bridge_last_approval_screen_digest: resolvedApprovalScreenDigest,
+                terminal_bridge_last_approval_request_id: resolvedTranscriptIdentity?.requestId,
+                terminal_bridge_last_approval_evidence_fingerprint: resolvedTranscriptIdentity?.evidenceFingerprint,
+                terminal_bridge_last_approval_prompt_cleared_at: undefined,
+                terminal_bridge_last_approval_at: approvalResolvedAt,
+                terminal_bridge_last_approval_message_id: nativeTakeoverForUpdate.terminal_bridge_message_id,
+                terminal_bridge_monitor_lock_version: TERMINAL_BRIDGE_MONITOR_LOCK_VERSION,
+                terminal_bridge_monitor_started_at: approvalResolvedAt,
+                terminal_bridge_last_activity_at: approvalResolvedAt,
+                terminal_bridge_last_activity_reason: "approval resolved",
+                terminal_bridge_inactivity_timeout_minutes: agentTimeoutMinutes,
+                terminal_bridge_hard_timeout_minutes: agentHardTimeoutMinutes,
+                terminal_bridge_inactivity_deadline_at: deadlineAt(approvalResolvedAt, agentTimeoutMinutes),
+                terminal_bridge_hard_deadline_at: deadlineAt(stringValue(nativeTakeoverForUpdate.terminal_bridge_started_at) ?? approvalResolvedAt, agentHardTimeoutMinutes)
+            };
+            delete nextNativeTakeover.terminal_bridge_approval;
+            delete nextNativeTakeover.terminal_bridge_approval_dispatch;
+            delete nextNativeTakeover.terminal_bridge_last_approval_prompt_cleared_at;
+            const nextConversation = {
+                ...lockedConversation,
+                status: terminalBridgeEnabled(lockedConversation)
+                    ? "waiting_for_agent"
+                    : lockedConversation.status,
+                native_session_takeover: nextNativeTakeover,
+                updated_at: approvalResolvedAt
+            };
+            saveState(statePath, nextConversation);
+            releaseApprovalStateLock();
+            releaseApprovalTerminalLock();
+            const bridgeMonitor = ensureTerminalBridgeMonitorAfterApproval({
+                conversation: nextConversation,
+                statePath,
+                logPath,
+                terminalControl,
+                options
+            });
+            printJson({
+                conversation: nextConversation,
+                approved: true,
+                terminal_control: terminalControl,
+                key: approval.key,
+                keys: approval.keys,
+                label: approval.label,
+                decision_mode: approval.decisionMode,
+                request_id: approval.requestId,
+                approval_fingerprint: actualFingerprint,
+                auto_approved: autoApproved,
+                policy_rule_id: effectivePolicyRuleId,
+                policy_fingerprint: effectivePolicyFingerprint,
+                monitor_pid: bridgeMonitor.monitorPid ?? null,
+                monitor_handoff_pid: bridgeMonitor.handoffWatchdog?.pid ?? null
+            });
         });
     }
     finally {
@@ -3171,7 +3766,7 @@ async function runTerminalConversationApprove({ options, conversationId, agent,
         releaseTerminalLock();
     }
 }
-async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, terminalSendLockHeld = false, terminalStateLockHeld = false, recordMessageAfterSend = false, recordRawAttachmentAfterSend = false }) {
+async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, terminalSendLockHeld = false, terminalStateLockHeld = false, storeWriterLeaseHeld = false, recordMessageAfterSend = false, recordRawAttachmentAfterSend = false }) {
     const bridge = terminalBridgeEnabled(conversation);
     if (!terminalSendLockHeld) {
         const releaseTerminalLock = acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), terminalControl), { timeoutMs: 30000 });
@@ -3187,6 +3782,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                 terminalControl,
                 terminalSendLockHeld: true,
                 terminalStateLockHeld,
+                storeWriterLeaseHeld,
                 recordMessageAfterSend,
                 recordRawAttachmentAfterSend
             });
@@ -3222,6 +3818,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                 terminalControl,
                 terminalSendLockHeld: true,
                 terminalStateLockHeld: true,
+                storeWriterLeaseHeld,
                 recordMessageAfterSend,
                 recordRawAttachmentAfterSend
             });
@@ -3230,6 +3827,24 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             releaseStateLock();
         }
     }
+    if (!storeWriterLeaseHeld) {
+        const writerStoreDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
+        return await withStoreWriterLeaseAsync(writerStoreDir, async () => runTerminalControlSend({
+            options,
+            conversation,
+            nextConversation,
+            statePath,
+            logPath,
+            executor,
+            message,
+            terminalControl,
+            terminalSendLockHeld: true,
+            terminalStateLockHeld,
+            storeWriterLeaseHeld: true,
+            recordMessageAfterSend,
+            recordRawAttachmentAfterSend
+        }));
+    }
     const terminalBridge = createTerminalAgentBridge(options);
     const bridgeStartedAt = new Date().toISOString();
     const agentTimeoutMinutes = Number(options.agentTimeoutMinutes ?? DEFAULT_AGENT_TIMEOUT_MINUTES);
@@ -3744,7 +4359,6 @@ function terminalSubmissionPayload(payload) {
 function createManagedTerminalConversationFromRawId({ options, conversationId, agent, pid, messageBody, terminalControl }) {
     const workspace = terminalControl.currentPath ?? process.cwd();
     const storeDir = expandHome(options.storeDir ?? options.logDir ?? defaultStoreDir(workspace));
-    cleanupIdleConversations(storeDir, options);
     const executor = resolveExecutor({
         kind: agent,
         session: conversationId
@@ -3969,8 +4583,15 @@ async function runRenew(options) {
     });
 }
 async function runReconcileMonitors(options) {
+    printJson(await reconcileMonitors(options, {
+        includeCallbackRecovery: true,
+        reason: "startup_reconciliation",
+        conversationId: undefined
+    }));
+}
+async function reconcileMonitors(options, { includeCallbackRecovery, reason, conversationId }) {
     const storeDir = storeDirFromOptions(options);
-    const conversations = listConversations(storeDir);
+    const conversations = listConversations(storeDir).filter((conversation) => conversationId === undefined || conversation.conversation_id === conversationId);
     const items = [];
     let ignored = 0;
     let launched = 0;
@@ -3987,30 +4608,32 @@ async function runReconcileMonitors(options) {
         const logPath = expandHome(stringValue(listedConversation.event_log_path) ??
             logPathForStatePath(statePath));
         try {
-            const callbackRecovery = prepareCallbackDeliveryReconciliation({
-                statePath,
-                logPath,
-                delayMs: options.callbackRetryDelayMs
-            });
-            if (callbackRecovery.handled) {
-                if (callbackRecovery.status === "launched") {
-                    launched += 1;
-                }
-                else if (callbackRecovery.status === "already_running") {
-                    alreadyRunning += 1;
-                }
-                else {
-                    skipped += 1;
-                }
-                items.push({
-                    conversation_id: callbackRecovery.conversationId,
-                    status: callbackRecovery.status,
-                    reason: callbackRecovery.reason,
-                    ...(callbackRecovery.monitorPid === undefined
-                        ? {}
-                        : { monitor_pid: callbackRecovery.monitorPid })
+            if (includeCallbackRecovery) {
+                const callbackRecovery = prepareCallbackDeliveryReconciliation({
+                    statePath,
+                    logPath,
+                    delayMs: options.callbackRetryDelayMs
                 });
-                continue;
+                if (callbackRecovery.handled) {
+                    if (callbackRecovery.status === "launched") {
+                        launched += 1;
+                    }
+                    else if (callbackRecovery.status === "already_running") {
+                        alreadyRunning += 1;
+                    }
+                    else {
+                        skipped += 1;
+                    }
+                    items.push({
+                        conversation_id: callbackRecovery.conversationId,
+                        status: callbackRecovery.status,
+                        reason: callbackRecovery.reason,
+                        ...(callbackRecovery.monitorPid === undefined
+                            ? {}
+                            : { monitor_pid: callbackRecovery.monitorPid })
+                    });
+                    continue;
+                }
             }
             const listedNativeTakeover = isRecord(listedConversation.native_session_takeover)
                 ? listedConversation.native_session_takeover
@@ -4125,7 +4748,7 @@ async function runReconcileMonitors(options) {
                 event: "terminal_bridge_monitor_launch",
                 pid: monitor.pid ?? null,
                 terminal_control: prepared.terminalControl,
-                reason: "startup_reconciliation",
+                reason,
                 agent_timeout_minutes: prepared.inactivityTimeoutMinutes,
                 agent_hard_timeout_minutes: prepared.hardTimeoutMinutes
             });
@@ -4138,7 +4761,7 @@ async function runReconcileMonitors(options) {
             items.push({
                 conversation_id: prepared.conversation.conversation_id,
                 status: "launched",
-                reason: "startup_reconciliation",
+                reason,
                 monitor_pid: monitor.pid ?? null
             });
         }
@@ -4151,7 +4774,7 @@ async function runReconcileMonitors(options) {
             });
         }
     }
-    printJson({
+    return {
         reconciled: true,
         store_dir: storeDir,
         checked: conversations.length,
@@ -4161,7 +4784,7 @@ async function runReconcileMonitors(options) {
         skipped,
         errors,
         items
-    });
+    };
 }
 function prepareCallbackDeliveryReconciliation({ statePath, logPath, delayMs }) {
     const releaseStateLock = acquireFileLock(`${statePath}.lock`);
@@ -4404,7 +5027,6 @@ function positiveMinutes(value, optionName) {
     return parsed;
 }
 async function runCancel(options) {
-    cleanupIdleConversations(storeDirFromOptions(options), options);
     const terminalConversation = await resolveTerminalConversationFromOptions(options);
     if (terminalConversation) {
         await runTerminalConversationCancel({
@@ -4484,75 +5106,78 @@ async function runTerminalControlCancel({ options, statePath, logPath, agent, te
     let releaseStateLock;
     try {
         releaseStateLock = acquireFileLock(`${statePath}.lock`);
-        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 ||
-            currentControl.target !== terminalControl.target ||
-            currentControl.socketPath !== terminalControl.socketPath) {
-            throw new Error("terminal control changed while waiting to cancel; refresh status and retry");
-        }
-        assertManagedTerminalDispatchOwner({
-            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 writerStoreDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
+        return await withStoreWriterLeaseAsync(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 ||
+                currentControl.target !== terminalControl.target ||
+                currentControl.socketPath !== terminalControl.socketPath) {
+                throw new Error("terminal control changed while waiting to cancel; refresh status and retry");
+            }
+            assertManagedTerminalDispatchOwner({
                 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 = new Date().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 = new Date().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 {
@@ -5983,7 +6608,7 @@ function terminalBridgeRuntimeDir() {
     const configured = stringValue(process.env.AKK_RUNTIME_DIR);
     return configured
         ? path.resolve(expandHome(configured))
-        : path.join(path.dirname(defaultStoreDir()), "runtime");
+        : path.join(path.dirname(defaultStoreDir()), "runtime-v2");
 }
 function terminalBridgeRuntimeKey(terminalControl) {
     return createHash("sha256")
@@ -5996,7 +6621,6 @@ function terminalBridgeRuntimeKey(terminalControl) {
 }
 function terminalBridgeDispatchLedgerPath(terminalControl) {
     const ledgerDir = path.join(terminalBridgeRuntimeDir(), "terminal-dispatch");
-    ensureDir(ledgerDir);
     return path.join(ledgerDir, `terminal-dispatch-${terminalBridgeRuntimeKey(terminalControl)}.json`);
 }
 function loadTerminalBridgeDispatchLedger(terminalControl) {
@@ -6043,6 +6667,7 @@ function orphanedTerminalDispatchForRecovery(terminalControl) {
 }
 function saveTerminalBridgeDispatchLedger(terminalControl, ledger) {
     const ledgerPath = terminalBridgeDispatchLedgerPath(terminalControl);
+    ensureDir(path.dirname(ledgerPath));
     if (fs.existsSync(ledgerPath) && fs.lstatSync(ledgerPath).isSymbolicLink()) {
         throw new Error(`terminal dispatch ledger is a symlink: ${ledgerPath}`);
     }
@@ -7046,6 +7671,7 @@ function runPreparedCallback(prepared, { emit = true } = {}) {
         }
         return result;
     }
+    assertStoreWriterCompatible(pathsForConversationDir(path.dirname(prepared.statePath)).storeDir);
     try {
         const deliveryKind = deliverCallbackToOpenClaw({
             options: prepared.options,
@@ -7591,7 +8217,13 @@ function loadConversationFromOptions(options) {
         throw new Error("--conversation or --state is required");
     }
     const conversation = options.state
-        ? loadState(statePath)
+        ? (() => {
+            const paths = pathsForConversationDir(path.dirname(statePath));
+            if (path.resolve(paths.statePath) !== path.resolve(statePath)) {
+                throw new Error(`AKK state path is not canonical: ${statePath}`);
+            }
+            return loadConversationById(path.basename(paths.conversationDir), paths.storeDir);
+        })()
         : loadConversationById(conversationId, storeDir);
     assertConfiguredWorkspace(options.workspace, conversation.workspace, `access to AKK conversation ${conversation.conversation_id}`);
     return {
@@ -8204,13 +8836,21 @@ function deliverStalledNotification({ statePath, logPath, conversation, message,
         stderr: textSummary(chatSendDelivery.stderr)
     });
 }
-function cleanupIdleConversations(storeDir, options = {}, now = new Date()) {
+function reconcileIdleConversations(storeDir, options = {}, now = new Date(), conversationId) {
     const timeoutMinutes = Number(options.idleTimeoutMinutes ?? DEFAULT_IDLE_TIMEOUT_MINUTES);
     if (!Number.isFinite(timeoutMinutes) || timeoutMinutes <= 0) {
-        return { checked: 0, closed: 0, idle_timeout_minutes: timeoutMinutes };
+        return {
+            checked: 0,
+            closed: 0,
+            skipped: 0,
+            idle_timeout_minutes: timeoutMinutes
+        };
     }
-    const conversations = listConversations(storeDir);
+    ensureStoreWritable(storeDir);
+    const conversations = listConversations(storeDir).filter((conversation) => (conversationId === undefined || conversation.conversation_id === conversationId) &&
+        matchesConfiguredWorkspace(options.workspace, conversation.workspace));
     let closed = 0;
+    let skipped = 0;
     for (const listedConversation of conversations) {
         if (listedConversation.status !== "idle" || !listedConversation.idle_since) {
             continue;
@@ -8230,6 +8870,7 @@ function cleanupIdleConversations(storeDir, options = {}, now = new Date()) {
         }
         catch (error) {
             if (isRecord(error) && error.code === "LOCK_TIMEOUT") {
+                skipped += 1;
                 continue;
             }
             throw error;
@@ -8288,6 +8929,7 @@ function cleanupIdleConversations(storeDir, options = {}, now = new Date()) {
     return {
         checked: conversations.length,
         closed,
+        skipped,
         idle_timeout_minutes: timeoutMinutes
     };
 }
@@ -8754,8 +9396,8 @@ function usage() {
   agent-knock-knock --help
   agent-knock-knock --version
   agent-knock-knock delegate --request <text> [--agent ${agentList}] [--workspace <path>] [--store-dir <dir>]
-  agent-knock-knock list [--store-dir <dir>] [--agent ${agentList}] [--status <status>] [--all] [--managed-only] [--no-approval-scan] [--terminal-debug]
-  agent-knock-knock status [--conversation <id|selector>] [--store-dir <dir>] [--trace]
+  agent-knock-knock list [--store-dir <dir>] [--agent ${agentList}] [--status <status>] [--all] [--reconcile] [--no-approval-scan] [--terminal-debug]
+  agent-knock-knock status [--conversation <id|selector>] [--store-dir <dir>] [--reconcile] [--trace]
   agent-knock-knock send [--conversation <id|selector>] --message <text> [--type answer|task|control] [--agent-timeout-minutes <minutes>] [--agent-hard-timeout-minutes <minutes>]
   agent-knock-knock approve [--conversation <id|selector>] --expected-approval-fingerprint <fingerprint>
   agent-knock-knock cancel [--conversation <id|selector>]