@adhdev/daemon-standalone 1.0.56-rc.5 → 1.0.56-rc.7

package/public/index.html

@@ -7,7 +7,7 @@
     <meta name="description" content="ADHDev self-hosted dashboard for controlling AI agents" />
     <link rel="icon" href="/otter-logo.png" />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap" rel="stylesheet" />
-  <script type="module" crossorigin src="/assets/index-B43wNsru.js"></script>
+  <script type="module" crossorigin src="/assets/index-keXYbbIn.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-DgFmqOGd.js">
   <link rel="stylesheet" crossorigin href="/assets/index-BN4rzCA5.css">
 </head>

package/vendor/mcp-server/index.js

@@ -1085,7 +1085,17 @@ var MESH_ENQUEUE_TASK_TOOL = {
       block_duplicate: { type: "boolean", description: "G4 (duplicate detection, block mode). Default false = warn-only: if an in-flight (pending/assigned) task with the same message (+ target node when pinned) already exists, the task is still enqueued but the response carries duplicateSuspect. Set true to REFUSE the enqueue with code duplicate_suspect instead (structural TASKBUBBLE-DUP defense \u2014 use when re-sending a task that a slow prior turn may have already enqueued)." },
       blockDuplicate: { type: "boolean", description: "CamelCase alias for block_duplicate." },
       allow_duplicate: { type: "boolean", description: "G4. Set true to skip duplicate detection entirely (no warning, no block) for an intentional re-enqueue of the same instruction." },
-      allowDuplicate: { type: "boolean", description: "CamelCase alias for allow_duplicate." }
+      allowDuplicate: { type: "boolean", description: "CamelCase alias for allow_duplicate." },
+      // design :692 — "The single tool should require an orchestration_decision".
+      // OPTIONAL here on purpose: Phase F is warn-only (see the discovery-meta note
+      // above), and a required field would break legacy/external clients that
+      // predate it. An omitted record degrades to decision_missing, which is itself
+      // the signal — never an enqueue failure.
+      orchestration_decision: {
+        type: "object",
+        description: "Record of your planning decision, for adoption measurement: {decision, ready_worker_tasks, known_graph_steps, single_reason, capability_blockers}. On this single-task surface, single_reason says why one task was right \u2014 one of only_one_step_known, future_step_not_specifiable, same_session_continuation, legacy_client, operator_override. output_needed / workspace_unresolved / coordinator_action_between are NOT blockers any more (mesh_enqueue_batch covers them via inputs_from, workspace_ref and coordinator gates); reporting one returns a batch_capability_available warning. Optional and never rejected: omitting it is recorded as decision_missing, and declaring known_graph_steps >= 2 here is recorded as a declared eligible single. Provenance only \u2014 it never changes execution."
+      },
+      orchestrationDecision: { type: "object", description: "CamelCase alias for orchestration_decision." }
     },
     required: ["message", "difficulty"]
   }
@@ -1313,7 +1323,7 @@ var MESH_QUEUE_CANCEL_TOOL = {
 };
 var MESH_QUEUE_REQUEUE_TOOL = {
   name: "mesh_queue_requeue",
-  description: "Return a mesh queue task to pending for retry. By default clears stale assigned owner and target session so another live session can claim it. When the task has exceeded its retry cap it is auto-failed instead; use force=true to override.",
+  description: "Return a mesh queue task to pending for retry, optionally re-targeting it and/or REWRITING its instruction. By default clears stale assigned owner and target session so another live session can claim it. When the task has exceeded its retry cap it is auto-failed instead; use force=true to override. This is also the way OUT of parking: a task whose target-session pin went stale is PARKED (held, still addressed, claimable by nobody) and any requeue unparks it \u2014 see parkedTasks in mesh_view_queue.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1323,7 +1333,8 @@ var MESH_QUEUE_REQUEUE_TOOL = {
       target_session_id: { type: "string", description: "Optional replacement target runtime session ID." },
       clear_target_node: { type: "boolean", description: "When true, remove any existing target node constraint." },
       keep_target_session: { type: "boolean", description: "When true, preserve an existing target session if target_session_id is not provided. Defaults false to avoid stale session targets." },
-      force: { type: "boolean", description: "When true, bypass the retry cap and requeue even if maxRetries has been exceeded. Use only for explicit operator recovery." }
+      force: { type: "boolean", description: "When true, bypass the retry cap and requeue even if maxRetries has been exceeded. Use only for explicit operator recovery." },
+      message: { type: "string", description: "Optional REPLACEMENT instruction for the task. Use when the situation moved on while the task waited \u2014 the common case for a parked delta, e.g. the worker already finished the part your correction was about, so the original wording would now be wrong or redundant. Preserves the task id, mission linkage and dependents (unlike cancel + re-enqueue). Omitted or blank leaves the existing message untouched." }
     },
     required: ["task_id"]
   }
@@ -1343,7 +1354,13 @@ var MESH_SEND_TASK_TOOL = {
       read_only: { type: "boolean", description: "Snake-case alias for readonly." },
       mission_id: { type: "string", description: "Mission this task belongs to (mesh_mission record id, full/exact). When set, the directly dispatched task is attributed to the mission task aggregates exactly like mesh_enqueue_task, including terminal completion. Omit for an unattributed direct dispatch. An unresolvable id is REJECTED before dispatch (mission_not_found), never silently attached." },
       missionId: { type: "string", description: "CamelCase alias for mission_id." },
-      difficulty: { type: "string", enum: ["easy", "medium", "difficult", "freeform"], description: "REQUIRED task execution difficulty. Classify each task by how hard the work actually is. On a direct dispatch the target node/session is already chosen, so difficulty is not used to ROUTE \u2014 it is recorded on the task so scheduling analytics, mission aggregates and (critically) failure-recovery relaunch all see the same axis a queued task carries. A recovery relaunch inherits this value from the ledger, so an unclassified direct dispatch would silently downgrade its own retry." }
+      difficulty: { type: "string", enum: ["easy", "medium", "difficult", "freeform"], description: "REQUIRED task execution difficulty. Classify each task by how hard the work actually is. On a direct dispatch the target node/session is already chosen, so difficulty is not used to ROUTE \u2014 it is recorded on the task so scheduling analytics, mission aggregates and (critically) failure-recovery relaunch all see the same axis a queued task carries. A recovery relaunch inherits this value from the ledger, so an unclassified direct dispatch would silently downgrade its own retry." },
+      delivery_mode: {
+        type: "string",
+        enum: ["when_idle", "interrupt"],
+        description: "How to deliver when the target session is BUSY. Default 'when_idle': never disturbs the running turn \u2014 the task is queued and auto-delivered the moment the session goes idle. \u2605'interrupt' ABORTS the turn currently in flight by pressing the provider's own stop control (Ctrl-C, or ESC on antigravity-cli), then delivers this task once the session settles. THE WORK IN PROGRESS IS DISCARDED \u2014 whatever the agent had not yet finished is lost, and any partial edits it was mid-way through are left as they are. Use it only when the running turn is genuinely going the wrong way and finishing it is worse than losing it. If the target provider cannot interrupt (no stop control declared, or an empty stop key), the dispatch is REJECTED rather than quietly falling back to when_idle \u2014 so a steering attempt never reports success while the session actually runs on to completion under the old instructions. Re-send with 'when_idle' if delivery-after-completion is acceptable. Has no effect on an idle session (delivered immediately either way)."
+      },
+      deliveryMode: { type: "string", enum: ["when_idle", "interrupt"], description: "CamelCase alias for delivery_mode." }
     },
     required: ["node_id", "session_id", "message", "difficulty"]
   }
@@ -1506,7 +1523,7 @@ var MESH_CHECKPOINT_TOOL = {
 };
 var MESH_MISSION_UPSERT_TOOL = {
   name: "mesh_mission_upsert",
-  description: "Create or update a persistent mission record so the plan survives coordinator restarts. Create a mission before enqueueing a multi-task batch, attach tasks via mesh_enqueue_task mission_id, and update status to completed/abandoned when the outcome is decided. Progress is derived from task statuses \u2014 there is no separate progress field. Single mission: pass title (and optionally mission_id to update an existing one). Bulk status transition (e.g. one-time stale cleanup): pass mission_ids (array) + status to apply that status to many missions at once; title/goal are ignored and a per-mission result array is returned. mission_ids takes precedence over mission_id when both are given.",
+  description: "Create or update a persistent mission record so the plan survives coordinator restarts. Create a mission before enqueueing a multi-task batch, then submit that plan as ONE mesh_enqueue_batch carrying the mission_id (a top-level mission_id applies to every entry; mesh_enqueue_task is the single-step fallback). Update status to completed/abandoned when the outcome is decided. Progress is derived from task statuses \u2014 there is no separate progress field. Single mission: pass title (and optionally mission_id to update an existing one). Bulk status transition (e.g. one-time stale cleanup): pass mission_ids (array) + status to apply that status to many missions at once; title/goal are ignored and a per-mission result array is returned. mission_ids takes precedence over mission_id when both are given.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1636,7 +1653,7 @@ var MESH_PLAN_ONBOARDING_TOOL = {
 };
 var MESH_ADD_NODE_TOOL = {
   name: "mesh_add_node",
-  description: "Register a workspace as a node in an EXISTING mesh \u2014 the second bootstrap step after mesh_create (or to add more nodes later). Mirrors `adhdev mesh add-node <mesh_id>` with --workspace / --read-only / --provider-priority. A node is a repo checkout on a daemon that the coordinator can launch agents on and delegate tasks to. mesh_id is REQUIRED in standard mode (pass the id returned by mesh_create); in mesh mode it defaults to the active mesh. workspace is the absolute path to the repo checkout ON THE DAEMON that owns it \u2014 the local base node is added by the daemon that created the mesh. This is a persistent mesh write: call mesh_plan_onboarding first and obtain explicit user approval. The implementation re-runs that preflight before writing. NOTE: this registers an EXISTING directory as a node (including auto-detected linked worktrees). To CREATE a fresh git worktree + branch for isolated parallel work, use mesh_clone_node instead \u2014 that runs the actual `git worktree add`. Returns node_id + workspace so you can immediately target the node with mesh_launch_session / mesh_send_task / mesh_enqueue_task.",
+  description: "Register a workspace as a node in an EXISTING mesh \u2014 the second bootstrap step after mesh_create (or to add more nodes later). Mirrors `adhdev mesh add-node <mesh_id>` with --workspace / --read-only / --provider-priority. A node is a repo checkout on a daemon that the coordinator can launch agents on and delegate tasks to. mesh_id is REQUIRED in standard mode (pass the id returned by mesh_create); in mesh mode it defaults to the active mesh. workspace is the absolute path to the repo checkout ON THE DAEMON that owns it \u2014 the local base node is added by the daemon that created the mesh. This is a persistent mesh write: call mesh_plan_onboarding first and obtain explicit user approval. The implementation re-runs that preflight before writing. NOTE: this registers an EXISTING directory as a node (including auto-detected linked worktrees). To CREATE a fresh git worktree + branch for isolated parallel work, use mesh_clone_node instead \u2014 that runs the actual `git worktree add`. Returns node_id + workspace so you can immediately target the node with mesh_launch_session / mesh_send_task / mesh_enqueue_task. That immediate-targeting path is right when the node is the only thing you were waiting on; when the work behind it is a multi-step plan, prefer declaring the whole plan in one mesh_enqueue_batch instead of registering, then enqueueing step by step.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1655,7 +1672,7 @@ var MESH_ADD_NODE_TOOL = {
 };
 var MESH_CLONE_NODE_TOOL = {
   name: "mesh_clone_node",
-  description: "Create a new worktree-based node from an existing node for isolated parallel work. Creates a git worktree on a new branch so multiple tasks can run on separate branches simultaneously. This writes a branch, worktree and mesh node: call mesh_plan_onboarding with operation=clone_worktree and obtain explicit user approval first; the implementation re-runs the clean/source preflight.",
+  description: "Create a new worktree-based node from an existing node for isolated parallel work. Creates a git worktree on a new branch so multiple tasks can run on separate branches simultaneously. This writes a branch, worktree and mesh node: call mesh_plan_onboarding with operation=clone_worktree and obtain explicit user approval first; the implementation re-runs the clean/source preflight. Call this directly when you need the worktree NOW and will target it right away. When the worktree only exists to host a plan you already know, that plan can be submitted as one mesh_enqueue_batch: declare the worktree in the top-level `workspaces` array and point its tasks at it with `workspace_ref`, so preparation happens as part of the graph instead of a manual clone followed by step-by-step enqueues.",
   inputSchema: {
     type: "object",
     properties: {
@@ -5042,6 +5059,7 @@ async function meshGraphGateRelease(ctx, args) {
       duplicate: result.duplicate
     });
     const queueTrigger = result.materializedNodeIds.length > 0 ? await triggerMeshQueueAndReport(ctx) : void 0;
+    const releasedNothingDownstream = !result.duplicate && result.materializedNodeIds.length === 0 && result.downstreamNodeCount === 0 && result.graphCompleted !== true;
     return JSON.stringify({
       success: true,
       released: true,
@@ -5054,6 +5072,10 @@ async function meshGraphGateRelease(ctx, args) {
       outcome,
       materializedNodeIds: result.materializedNodeIds,
       materializedCount: result.materializedNodeIds.length,
+      ...result.downstreamNodeCount !== void 0 ? { downstreamNodeCount: result.downstreamNodeCount } : {},
+      ...releasedNothingDownstream ? {
+        noDownstreamAdvisory: "This gate opened nothing downstream: no task declared it in gated_by, so claiming and releasing it bought no scheduling while the rest of the graph is still outstanding. Declare the next step in the same batch and point it at this gate with gated_by, so releasing the gate dispatches it \u2014 or drop the gate and enqueue that step directly."
+      } : {},
       ...queueTrigger ? { queueTrigger } : {},
       ...result.duplicate ? { duplicateHint: "This idempotency_key + payload was already committed; nothing changed. Re-sending an identical release is safe." } : {}
     });
@@ -5293,6 +5315,17 @@ async function meshEnqueueTask(ctx, args) {
   } = normalized.value;
   const allowDuplicate = args.allowDuplicate === true || args.allow_duplicate === true;
   const blockDuplicate = args.blockDuplicate === true || args.block_duplicate === true;
+  const rawDecision = args.orchestration_decision ?? args.orchestrationDecision;
+  const decisionMissing = rawDecision === void 0 || rawDecision === null;
+  const orchestration = (0, import_daemon_core6.normalizeOrchestrationDecision)(rawDecision, "single");
+  const orchestrationWarning = {
+    ...orchestration.batchCapabilityAvailable ? { batchCapabilityAvailable: orchestration.batchCapabilityAvailable } : {},
+    ...orchestration.declaredEligibleSingle ? {
+      declaredEligibleSingle: true,
+      declaredEligibleSingleHint: import_daemon_core6.MESH_DECLARED_ELIGIBLE_SINGLE_HINT
+    } : {},
+    ...decisionMissing ? { orchestrationDecisionMissing: true } : {}
+  };
   const duplicateSuspect = allowDuplicate ? null : findInFlightDuplicate(ctx, message, targetNodeId);
   if (duplicateSuspect && blockDuplicate) {
     return JSON.stringify({
@@ -5318,6 +5351,15 @@ async function meshEnqueueTask(ctx, args) {
       ...maxRetries !== void 0 ? { maxRetries } : {},
       ...ctx.coordinatorSessionId ? { sourceCoordinatorSessionId: ctx.coordinatorSessionId } : {}
     });
+    (0, import_daemon_core6.recordSingleEnqueueDecision)(ctx.mesh.id, {
+      taskId: task.id,
+      ...missionId ? { missionId } : {},
+      ...ctx.coordinatorSessionId ? { coordinatorSessionId: ctx.coordinatorSessionId } : {},
+      decision: orchestration.decision,
+      ...decisionMissing ? { decisionMissing: true } : {},
+      ...orchestration.declaredEligibleSingle ? { declaredEligibleSingle: true } : {},
+      ...orchestration.batchCapabilityAvailable ? { batchCapabilityAvailable: orchestration.batchCapabilityAvailable.reportedReason } : {}
+    });
     const duplicateWarning = duplicateSuspect ? { duplicateSuspect: { taskId: duplicateSuspect.id, status: duplicateSuspect.status, assignedNodeId: duplicateSuspect.assignedNodeId, targetNodeId: duplicateSuspect.targetNodeId }, duplicateSuspectHint: "An in-flight task with the same message+target already exists. This new task was enqueued anyway (warn-only). Cancel one via mesh_queue_cancel if it is an accidental re-enqueue, or pass allow_duplicate=true to silence this, or block_duplicate=true to refuse next time." } : {};
     const missionWarning = buildMissionInactiveWarning(ctx, missionId) ?? {};
     const worktreeAdvisory = buildUntargetedCodeChangeWorktreeAdvisory({
@@ -5347,6 +5389,7 @@ async function meshEnqueueTask(ctx, args) {
         ...duplicateWarning,
         ...missionWarning,
         ...worktreeAdvisory,
+        ...orchestrationWarning,
         queueTrigger,
         ...buildQueueTriggerGuidance(queueTrigger)
       });
@@ -5375,6 +5418,7 @@ async function meshEnqueueTask(ctx, args) {
         ...duplicateWarning,
         ...missionWarning,
         ...worktreeAdvisory,
+        ...orchestrationWarning,
         queueTrigger,
         ...buildQueueTriggerGuidance(queueTrigger)
       });
@@ -5717,6 +5761,16 @@ async function meshViewQueue(ctx, args) {
       via: e.payload?.via,
       failedAt: e.payload?.dispatchFailedAt || e.timestamp
     }));
+    const parkedTasks = fullQueue.filter((task) => task?.parked?.reason).map((task) => ({
+      taskId: task.id,
+      parkedAt: task.parked.parkedAt,
+      reason: task.parked.reason,
+      originalTargetSessionId: task.parked.targetSessionId,
+      originalTargetNodeId: task.parked.targetNodeId,
+      currentTargetSessionId: task.targetSessionId,
+      missionId: task.missionId,
+      message: summarizeTaskMessage(task.message)
+    }));
     const staleAssignedTasks = maintenance.staleAssignedTasks || [];
     const requestedHistoricalRows = queue.some((task) => HISTORICAL_QUEUE_STATUSES.has(String(task?.status || "")));
     const pollingGuidance = buildActiveWorkPollingGuidance(activeWorkEvidence.summary);
@@ -5771,6 +5825,11 @@ async function meshViewQueue(ctx, args) {
       historicalCount: summary.historicalCount,
       visibleActiveCount: visibleSummary.activeCount,
       visibleHistoricalCount: visibleSummary.historicalCount,
+      ...parkedTasks.length > 0 ? {
+        parkedTasks,
+        parkedTaskCount: parkedTasks.length,
+        parkedTaskNote: "PARKED tasks are held for an explicit coordinator decision and are claimable by NOBODY \u2014 their delta was addressed to a session whose pin went stale, and the daemon deliberately will not re-home it onto another session. Nothing will move them until you act. Exits: mesh_queue_requeue(task_id, target_session_id=<live session>) to re-target, or with clear_target_session=true to let any compatible session take it; add message=<rewritten instruction> to the same call if the situation moved on while it waited; mesh_queue_cancel(task_id) if it is moot. Any requeue unparks the task. Left untouched they are failed (with a notification) once past the parked-task retention window."
+      } : {},
       staleAssignedTasks: compact ? staleAssignedTasks.slice(0, 10).map(compactQueueRow) : staleAssignedTasks,
       staleAssignedCount: maintenance.staleAssignedCount,
       queueMaintenance: maintenanceForResponse,
@@ -5876,6 +5935,7 @@ async function meshQueueRequeue(ctx, args) {
     const clearTargetNode = args.clear_target_node === true || args.clearTargetNode === true;
     const clearTargetSession = targetSessionId ? false : !keepTargetSession;
     const force = args.force === true;
+    const message = typeof args.message === "string" && args.message.trim() ? args.message : void 0;
     if (ctx.transport instanceof IpcTransport) {
       const raw = await ctx.transport.command("requeue_mesh_queue_task", {
         meshId: ctx.mesh.id,
@@ -5885,7 +5945,8 @@ async function meshQueueRequeue(ctx, args) {
         ...targetSessionId ? { targetSessionId } : {},
         clearTargetNode,
         clearTargetSession,
-        force
+        force,
+        ...message ? { message } : {}
       });
       const result = unwrapCommandPayload(raw) || {};
       if (result.success === false) {
@@ -5916,7 +5977,8 @@ async function meshQueueRequeue(ctx, args) {
       targetSessionId,
       clearTargetNode,
       clearTargetSession,
-      force
+      force,
+      ...message ? { message } : {}
     });
     if (!task) return JSON.stringify({ success: false, error: `Queue task '${taskId}' not found` });
     if (task.status === "failed" && task.cancelReason?.startsWith("max_retries_exceeded")) {
@@ -8389,8 +8451,107 @@ async function meshSendTask(ctx, args) {
       }
       if (explicitTargetSession && !isIdleSessionRecord(explicitTargetSession) && !isTerminalSessionRecord(explicitTargetSession)) {
         const sessionStatus = typeof explicitTargetSession?.status === "string" ? explicitTargetSession.status : "unknown";
-        const { resolveDeliveryDecision } = await import("@adhdev/daemon-core");
-        const policyResult = resolveDeliveryDecision(sessionStatus, { kind: "task" });
+        const { resolveDeliveryDecision, normalizeDeliveryMode } = await import("@adhdev/daemon-core");
+        const modeInput = args.delivery_mode ?? args.deliveryMode;
+        const { mode: deliveryMode, unrecognized: unrecognizedDeliveryMode } = normalizeDeliveryMode(modeInput);
+        let interruptSupported = false;
+        let interruptUnsupportedMessage;
+        let interruptConfidence;
+        if (deliveryMode === "interrupt") {
+          try {
+            const probe = unwrapCommandPayload(await commandForNode(ctx, node, "agent_command", {
+              targetSessionId: args.session_id,
+              agentType: resolvedProviderType,
+              cliType: resolvedProviderType,
+              providerType: resolvedProviderType,
+              action: "interrupt_capability"
+            }));
+            interruptSupported = probe?.supported === true;
+            interruptUnsupportedMessage = typeof probe?.message === "string" ? probe.message : void 0;
+            interruptConfidence = typeof probe?.confidence === "string" ? probe.confidence : void 0;
+          } catch (e) {
+            interruptSupported = false;
+            interruptUnsupportedMessage = `Could not determine interrupt capability for provider '${resolvedProviderType}' on node '${args.node_id}': ${e?.message || e}. Refusing to interrupt on an unverified capability.`;
+          }
+        }
+        const policyResult = resolveDeliveryDecision(sessionStatus, {
+          kind: "task",
+          deliveryMode,
+          interruptSupported,
+          ...interruptUnsupportedMessage ? { interruptUnsupportedMessage } : {}
+        });
+        if (policyResult.decision === "rejected" && policyResult.reason === "interrupt_unsupported_for_provider") {
+          return JSON.stringify({
+            success: false,
+            dispatched: false,
+            decision: "interrupt_unsupported",
+            reason: policyResult.reason,
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            sessionStatus,
+            providerType: resolvedProviderType,
+            requestedDeliveryMode: deliveryMode,
+            message: policyResult.message,
+            nextAction: `Re-send this task with delivery_mode 'when_idle' to have it delivered when session '${args.session_id}' finishes on its own, or stop the session and launch a fresh one if the in-flight work must not complete.`
+          });
+        }
+        if (policyResult.decision === "interrupt") {
+          const interruptResult = unwrapCommandPayload(await commandForNode(ctx, node, "agent_command", {
+            targetSessionId: args.session_id,
+            agentType: resolvedProviderType,
+            cliType: resolvedProviderType,
+            providerType: resolvedProviderType,
+            action: "interrupt_turn",
+            dispatchSource: "mesh-tools-session:mesh_send_task:interrupt"
+          }));
+          if (interruptResult?.success !== true || interruptResult?.interrupted !== true) {
+            return JSON.stringify({
+              success: false,
+              dispatched: false,
+              decision: "interrupt_failed",
+              reason: interruptResult?.reason || "interrupt_rejected",
+              nodeId: args.node_id,
+              sessionId: args.session_id,
+              sessionStatus,
+              providerType: resolvedProviderType,
+              error: interruptResult?.error || "The provider did not accept the interrupt.",
+              nextAction: `Nothing was cancelled and nothing was delivered. Re-send with delivery_mode 'when_idle', or inspect the session with mesh_read_terminal before retrying.`
+            });
+          }
+          const interruptedTask = (0, import_daemon_core6.enqueueTask)(ctx.mesh.id, message, {
+            targetNodeId: args.node_id,
+            targetSessionId: args.session_id,
+            taskMode,
+            difficulty,
+            ...readonly ? { readonly: true } : {},
+            ...missionId ? { missionId } : {},
+            ...ctx.coordinatorSessionId ? { sourceCoordinatorSessionId: ctx.coordinatorSessionId } : {}
+          });
+          return JSON.stringify({
+            success: true,
+            dispatched: false,
+            decision: "interrupted_and_queued",
+            taskId: interruptedTask.id,
+            reason: policyResult.reason,
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            sessionStatus,
+            providerType: resolvedProviderType,
+            taskMode: taskMode || void 0,
+            interrupt: {
+              sent: true,
+              key: interruptResult?.keyName,
+              // 'declared' means the stop key is declared by the spec but the
+              // busy->idle effect was not measured live for this provider.
+              confidence: interruptResult?.confidence || interruptConfidence || "declared"
+            },
+            turnDiscarded: true,
+            message: `Interrupted the in-flight turn on session '${args.session_id}' via ${interruptResult?.keyName || "the stop control"}. That turn was cancelled and its unfinished work is lost. Task '${interruptedTask.id}' is pinned to this session and delivers as soon as it reports idle.`,
+            nextAction: interruptResult?.confidence === "proven" ? `Track with mesh_status; no manual resend needed.` : `Interrupt support for '${resolvedProviderType}' is DECLARED by its spec but not live-verified. Confirm with mesh_status that the session returned to idle and picked up the task; if it did not, use mesh_read_terminal to inspect.`,
+            ...unrecognizedDeliveryMode ? { deliveryModeWarning: `Unrecognized delivery_mode '${unrecognizedDeliveryMode}' ignored.` } : {},
+            ...buildMissionInactiveWarning(ctx, missionId) ?? {}
+          });
+        }
         if (policyResult.decision === "queued") {
           const queuedTask = (0, import_daemon_core6.enqueueTask)(ctx.mesh.id, message, {
             targetNodeId: args.node_id,
@@ -8413,6 +8574,12 @@ async function meshSendTask(ctx, args) {
             taskMode: taskMode || void 0,
             message: policyResult.message,
             nextAction: `Task '${queuedTask.id}' is queued and pinned to session '${args.session_id}' \u2014 it auto-delivers the moment the session goes idle. Use mesh_status or mesh_task_history to track it; no manual resend needed.`,
+            // A misspelled delivery_mode silently became when_idle. Say so — a
+            // caller who meant to interrupt must not read this queued result as
+            // "my steering landed".
+            ...unrecognizedDeliveryMode ? {
+              deliveryModeWarning: `Unrecognized delivery_mode '${unrecognizedDeliveryMode}' was ignored; this task was queued (when_idle) and the running turn was NOT interrupted. Valid values are 'when_idle' and 'interrupt'.`
+            } : {},
             ...buildMissionInactiveWarning(ctx, missionId) ?? {}
           });
         }