@scotthuang/agent-knock-knock 0.6.1 → 0.7.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;
@@ -1327,7 +1350,12 @@ function environmentWithoutGatewayTokens() {
 }
 async function runList(options) {
     const storeDir = expandHome(options.storeDir ?? options.logDir ?? defaultStoreDir(process.cwd()));
-    const cleanup = cleanupIdleConversations(storeDir, options);
+    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;
@@ -1361,7 +1389,8 @@ async function runList(options) {
     });
     printJson({
         store_dir: storeDir,
-        cleanup,
+        store: inspectStoreCompatibility(storeDir),
+        reconciliation,
         action_contracts: listActionContracts(),
         delegated,
         terminal_controlled: terminalControlled,
@@ -1379,8 +1408,40 @@ async function runList(options) {
         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 = {
@@ -1640,13 +1701,34 @@ function managedListApprovalState(conversation) {
 }
 function listActionContracts() {
     return {
-        version: 1,
+        version: 2,
         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.",
             "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: {
+            status: {
+                delegated: "task_lifecycle",
+                terminal_controlled: "process_liveness",
+                authoritative_for_tool_calls: false
+            },
+            activity_state: {
+                terminal_controlled: "screen_activity_classification",
+                authoritative_for_tool_calls: false
+            },
+            commands: {
+                meaning: "legacy_compatibility_flags_with_mixed_semantics",
+                deprecated: true,
+                authoritative_for_tool_calls: false
+            },
+            available_actions: {
+                meaning: "currently_safe_actions",
+                authoritative_for_tool_calls: true
+            }
+        },
         actions: {
             send: {
                 tool: "agent_knock_knock_send",
@@ -1841,7 +1923,6 @@ function isSessionSelectorSyntax(value) {
 }
 async function sessionSelectorCandidates(commandName, options) {
     const storeDir = storeDirFromOptions(options);
-    cleanupIdleConversations(storeDir, options);
     const storedConversations = listConversations(storeDir);
     const workspaceConversations = storedConversations
         .filter((conversation) => matchesConfiguredWorkspace(options.workspace, conversation.workspace));
@@ -1935,7 +2016,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, {
@@ -1949,6 +2046,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,
@@ -1963,13 +2062,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),
@@ -2006,6 +2104,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 {
@@ -2476,7 +2606,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) {
@@ -2493,6 +2622,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({
@@ -2578,7 +2708,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({
@@ -2752,6 +2881,7 @@ async function runApprove(options) {
         }
     };
     let releaseStateLock;
+    let approvalDispatchReserved = false;
     const releaseApprovalStateLock = () => {
         if (releaseStateLock) {
             const release = releaseStateLock;
@@ -2759,323 +2889,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.action !== "approve") {
+                            return {
+                                approved: false,
+                                reason: `executor-side auto-approval policy rejected the current request: ${executorPolicyDecision.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 (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");
+                        return { approved: true };
                     }
-                    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");
-                    }
-                    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 {
@@ -3150,7 +3287,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 });
@@ -3166,6 +3303,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                 terminalControl,
                 terminalSendLockHeld: true,
                 terminalStateLockHeld,
+                storeWriterLeaseHeld,
                 recordMessageAfterSend,
                 recordRawAttachmentAfterSend
             });
@@ -3201,6 +3339,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                 terminalControl,
                 terminalSendLockHeld: true,
                 terminalStateLockHeld: true,
+                storeWriterLeaseHeld,
                 recordMessageAfterSend,
                 recordRawAttachmentAfterSend
             });
@@ -3209,6 +3348,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);
@@ -3723,7 +3880,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
@@ -3948,8 +4104,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;
@@ -3966,30 +4129,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
@@ -4104,7 +4269,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
             });
@@ -4117,7 +4282,7 @@ async function runReconcileMonitors(options) {
             items.push({
                 conversation_id: prepared.conversation.conversation_id,
                 status: "launched",
-                reason: "startup_reconciliation",
+                reason,
                 monitor_pid: monitor.pid ?? null
             });
         }
@@ -4130,7 +4295,7 @@ async function runReconcileMonitors(options) {
             });
         }
     }
-    printJson({
+    return {
         reconciled: true,
         store_dir: storeDir,
         checked: conversations.length,
@@ -4140,7 +4305,7 @@ async function runReconcileMonitors(options) {
         skipped,
         errors,
         items
-    });
+    };
 }
 function prepareCallbackDeliveryReconciliation({ statePath, logPath, delayMs }) {
     const releaseStateLock = acquireFileLock(`${statePath}.lock`);
@@ -4383,7 +4548,6 @@ function positiveMinutes(value, optionName) {
     return parsed;
 }
 async function runCancel(options) {
-    cleanupIdleConversations(storeDirFromOptions(options), options);
     const terminalConversation = await resolveTerminalConversationFromOptions(options);
     if (terminalConversation) {
         await runTerminalConversationCancel({
@@ -4463,75 +4627,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 {
@@ -5962,7 +6129,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")
@@ -5975,7 +6142,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) {
@@ -6022,6 +6188,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}`);
     }
@@ -7025,6 +7192,7 @@ function runPreparedCallback(prepared, { emit = true } = {}) {
         }
         return result;
     }
+    assertStoreWriterCompatible(pathsForConversationDir(path.dirname(prepared.statePath)).storeDir);
     try {
         const deliveryKind = deliverCallbackToOpenClaw({
             options: prepared.options,
@@ -7570,7 +7738,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 {
@@ -8183,13 +8357,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;
@@ -8209,6 +8391,7 @@ function cleanupIdleConversations(storeDir, options = {}, now = new Date()) {
         }
         catch (error) {
             if (isRecord(error) && error.code === "LOCK_TIMEOUT") {
+                skipped += 1;
                 continue;
             }
             throw error;
@@ -8267,6 +8450,7 @@ function cleanupIdleConversations(storeDir, options = {}, now = new Date()) {
     return {
         checked: conversations.length,
         closed,
+        skipped,
         idle_timeout_minutes: timeoutMinutes
     };
 }
@@ -8733,8 +8917,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] [--managed-only] [--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>]