@adhdev/daemon-standalone 1.0.56-rc.6 → 1.0.56-rc.8

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

@@ -1323,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: {
@@ -1333,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"]
   }
@@ -1353,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"]
   }
@@ -5754,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);
@@ -5808,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,
@@ -5913,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,
@@ -5922,7 +5945,8 @@ async function meshQueueRequeue(ctx, args) {
         ...targetSessionId ? { targetSessionId } : {},
         clearTargetNode,
         clearTargetSession,
-        force
+        force,
+        ...message ? { message } : {}
       });
       const result = unwrapCommandPayload(raw) || {};
       if (result.success === false) {
@@ -5953,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")) {
@@ -8426,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,
@@ -8450,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) ?? {}
           });
         }