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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-standalone",
-  "version": "1.0.56-rc.4",
+  "version": "1.0.56-rc.6",
   "description": "ADHDev standalone daemon — embedded HTTP/WS server for local dashboard",
   "main": "dist/index.js",
   "bin": {
@@ -37,7 +37,7 @@
   "license": "AGPL-3.0-or-later",
   "dependencies": {
     "@adhdev/ghostty-vt-node": "*",
-    "@adhdev/session-host-core": "1.0.56-rc.4",
+    "@adhdev/session-host-core": "1.0.56-rc.6",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/xterm": "^6.0.0",
     "chalk": "^5.3.0",

package/vendor/mcp-server/index.js

@@ -627,8 +627,9 @@ function buildMagiPanelProposal(detected, opts = {}) {
 var CANONICAL_MESH_TOOL_NAMES = [
   "mesh_status",
   "mesh_list_nodes",
-  "mesh_enqueue_task",
+  // GRAPH-ORCHESTRATION Phase F — batch before task, mirroring ALL_MESH_TOOLS.
   "mesh_enqueue_batch",
+  "mesh_enqueue_task",
   "mesh_view_queue",
   // GRAPH-ORCHESTRATION Phase E — the coordinator gate + graph view surface.
   "mesh_graph_view",
@@ -1030,9 +1031,30 @@ var MESH_LIST_NODES_TOOL = {
     }
   }
 };
+var ENQUEUE_TOOL_GROUP = "mesh.enqueue";
+var ENQUEUE_TOOL_GROUP_MEMBERS = ["mesh_enqueue_batch", "mesh_enqueue_task"];
+var ENQUEUE_DISCOVERY_KEYWORDS = ["enqueue", "delegate", "task", "graph", "dependency"];
+var ENQUEUE_RANK_QUERIES = ["enqueue", "delegate"];
+var ENQUEUE_BATCH_DISCOVERY_META = {
+  toolGroup: ENQUEUE_TOOL_GROUP,
+  toolGroupMembers: ENQUEUE_TOOL_GROUP_MEMBERS,
+  discoveryKeywords: ENQUEUE_DISCOVERY_KEYWORDS,
+  discoveryRankQueries: ENQUEUE_RANK_QUERIES,
+  discoveryRank: 0,
+  enqueueRole: "default"
+};
+var ENQUEUE_TASK_DISCOVERY_META = {
+  toolGroup: ENQUEUE_TOOL_GROUP,
+  toolGroupMembers: ENQUEUE_TOOL_GROUP_MEMBERS,
+  discoveryKeywords: ENQUEUE_DISCOVERY_KEYWORDS,
+  discoveryRankQueries: ENQUEUE_RANK_QUERIES,
+  discoveryRank: 10,
+  enqueueRole: "single_task_fallback"
+};
 var MESH_ENQUEUE_TASK_TOOL = {
   name: "mesh_enqueue_task",
-  description: "Add a new task to the mesh work queue. Idle nodes will automatically pull and execute tasks from this queue. Use this instead of mesh_send_task when you do not need to target a specific node. For a dependency-wired MULTI-task graph prefer mesh_enqueue_batch: it inserts the whole set atomically and lets depends_on reference batch-local refs, so no half-registered chain can be left behind. Supports task-level priority (high tasks are pulled ahead of older normal/low tasks), not_before delayed execution (hold a task pending until a time), maxRetries (auto-fail after N requeues), and duplicate detection (by default warns in the response when an in-flight task with the same message+target already exists; pass block_duplicate=true to refuse instead, or allow_duplicate=true to silence the warning).",
+  description: "SINGLE-TASK FALLBACK. Use only when exactly one new worker task is currently known and no downstream graph step can yet be declared. If two or more steps are known\u2014including steps that need outputs, worktree preparation, a condition, or a coordinator action\u2014load and use mesh_enqueue_batch instead. Same-session continuation belongs in mesh_send_task. Adds the task to the mesh work queue; idle nodes automatically pull and execute from it. Use this instead of mesh_send_task when you do not need to target a specific node. Supports task-level priority (high tasks are pulled ahead of older normal/low tasks), not_before delayed execution (hold a task pending until a time), maxRetries (auto-fail after N requeues), and duplicate detection (by default warns in the response when an in-flight task with the same message+target already exists; pass block_duplicate=true to refuse instead, or allow_duplicate=true to silence the warning).",
+  _meta: ENQUEUE_TASK_DISCOVERY_META,
   inputSchema: {
     type: "object",
     properties: {
@@ -1063,14 +1085,25 @@ 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"]
   }
 };
 var MESH_ENQUEUE_BATCH_TOOL = {
   name: "mesh_enqueue_batch",
-  description: "G5: atomically enqueue a dependency-wired set of tasks \u2014 either EVERY task in the batch is inserted or NONE is (a mid-batch error such as a dependency cycle, invalid difficulty, or guardrail violation rolls the whole batch back). Use this instead of N sequential mesh_enqueue_task calls whenever you are wiring a multi-task graph: give each task a batch-local `ref` label and name sibling refs in `depends_on` (forward references allowed \u2014 array order does not matter). A depends_on value that is not a ref in this batch must be an EXISTING queue task id; anything else is rejected. Per-task fields are the same as mesh_enqueue_task. Top-level mission_id applies to every task that lacks its own. Beyond plain ordering it also accepts a full orchestration graph, so you can submit the WHOLE known plan once instead of enqueueing each step as the previous one finishes: `inputs_from` binds selected predecessor outputs into a later task (no hand-copying worker text), `run_if` branches on those outputs, `gates` declare steps that stop for a coordinator action (Refinery landing, approval, CI wait, publish, deploy) with downstream tasks pointing at them via `gated_by`, and `workspaces` + `workspace_ref` prepare a worktree later for a task that needs one. These are strictly additive: a batch using only message/depends_on behaves exactly as before. Only graph-using batches create a graph, inspectable with mesh_graph_view.",
+  description: "DEFAULT enqueue surface for a plan with two or more known graph steps. Atomically persists the graph plan and worker queue entries. Supports batch-local refs, completion dependencies, selected predecessor outputs through `inputs_from`, declarative `run_if`, delayed `workspace_ref` preparation, and coordinator gates. Worker dispatch still requires the shared dependency predicate: all active worker dependencies completed and no system block. Git workspace preparation is a compensated saga and is reported separately from DB atomicity. Atomicity in detail: either EVERY task in the batch is inserted or NONE is (a mid-batch error such as a dependency cycle, invalid difficulty, or guardrail violation rolls the whole batch back). Give each task a batch-local `ref` label and name sibling refs in `depends_on` (forward references allowed \u2014 array order does not matter). A depends_on value that is not a ref in this batch must be an EXISTING queue task id; anything else is rejected. Per-task fields are the same as mesh_enqueue_task. Top-level mission_id applies to every task that lacks its own. `inputs_from` binds selected predecessor outputs into a later task (no hand-copying worker text), `run_if` branches on those outputs, `gates` declare steps that stop for a coordinator action (Refinery landing, approval, CI wait, publish, deploy) with downstream tasks pointing at them via `gated_by`, and `workspaces` + `workspace_ref` prepare a worktree later for a task that needs one. These are strictly additive: a batch using only message/depends_on behaves exactly as before. Only graph-using batches create a graph, inspectable with mesh_graph_view.",
+  _meta: ENQUEUE_BATCH_DISCOVERY_META,
   inputSchema: {
     type: "object",
     properties: {
@@ -1483,7 +1516,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: {
@@ -1613,7 +1646,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: {
@@ -1632,7 +1665,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: {
@@ -2083,8 +2116,11 @@ var MESH_COORDINATOR_PROMPT_APPEND_SET_TOOL = {
 var ALL_MESH_TOOLS = [
   MESH_STATUS_TOOL,
   MESH_LIST_NODES_TOOL,
-  MESH_ENQUEUE_TASK_TOOL,
+  // GRAPH-ORCHESTRATION Phase F — batch BEFORE task. Registry order is what a
+  // client that lists tools without ranking sees first, so the default enqueue
+  // surface leads and the single-task fallback follows it.
   MESH_ENQUEUE_BATCH_TOOL,
+  MESH_ENQUEUE_TASK_TOOL,
   MESH_VIEW_QUEUE_TOOL,
   // GRAPH-ORCHESTRATION Phase E — placed next to the queue/enqueue tools so a
   // coordinator that loaded the batch schema also discovers how to pass a gate.
@@ -2669,6 +2705,15 @@ function annotateRapidReadChatAdvisory(payload, options) {
 // src/tools/mesh-tools-internal.ts
 var import_daemon_core6 = require("@adhdev/daemon-core");
 var import_node_crypto = require("crypto");
+function recordMeshCoordinatorToolCall(ctx, tool) {
+  const sessionId = ctx.coordinatorSessionId ?? null;
+  return (0, import_daemon_core5.recordMeshToolCall)({
+    meshId: ctx.mesh.id,
+    tool,
+    sessionId,
+    callerRole: sessionId ? "coordinator" : "unknown"
+  });
+}
 var SESSION_PROVIDER_METADATA_TTL_MS = 30 * 6e4;
 var meshSessionProviderMetadata = /* @__PURE__ */ new Map();
 function getSessionMetadata(key) {
@@ -4229,7 +4274,7 @@ function summarizePendingEventProtocolMetrics(pendingEvents) {
   };
 }
 async function meshStatus(ctx, args = {}) {
-  const rateResult = (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_status" });
+  const rateResult = recordMeshCoordinatorToolCall(ctx, "mesh_status");
   const compact = args.verbose === true ? false : args.compact ?? true;
   await refreshMeshFromDaemon(ctx);
   const { mesh, transport } = ctx;
@@ -4863,7 +4908,7 @@ function resolveGateSession(ctx, explicit) {
   return readString(explicit) || ctx.coordinatorSessionId || void 0;
 }
 async function meshGraphGateClaim(ctx, args) {
-  (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_graph_gate_claim" });
+  recordMeshCoordinatorToolCall(ctx, "mesh_graph_gate_claim");
   const gateId = readString(args.gate_id) || readString(args.gateId);
   if (!gateId) {
     return JSON.stringify({
@@ -4958,7 +5003,7 @@ function describeClaimRefusal(reason, state) {
   }
 }
 async function meshGraphGateRelease(ctx, args) {
-  (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_graph_gate_release" });
+  recordMeshCoordinatorToolCall(ctx, "mesh_graph_gate_release");
   const gateId = readString(args.gate_id) || readString(args.gateId);
   const fencingToken = readString(args.fencing_token) || readString(args.fencingToken);
   const leaseGeneration = readNumber(args.lease_generation ?? args.leaseGeneration);
@@ -5007,6 +5052,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,
@@ -5019,6 +5065,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." } : {}
     });
@@ -5040,7 +5090,7 @@ async function meshGraphGateRelease(ctx, args) {
   }
 }
 async function meshGraphView(ctx, args) {
-  (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_graph_view" });
+  recordMeshCoordinatorToolCall(ctx, "mesh_graph_view");
   try {
     await refreshMeshFromDaemon(ctx);
     const graphId = readString(args.graph_id) || readString(args.graphId);
@@ -5258,6 +5308,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({
@@ -5283,6 +5344,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({
@@ -5312,6 +5382,7 @@ async function meshEnqueueTask(ctx, args) {
         ...duplicateWarning,
         ...missionWarning,
         ...worktreeAdvisory,
+        ...orchestrationWarning,
         queueTrigger,
         ...buildQueueTriggerGuidance(queueTrigger)
       });
@@ -5340,6 +5411,7 @@ async function meshEnqueueTask(ctx, args) {
         ...duplicateWarning,
         ...missionWarning,
         ...worktreeAdvisory,
+        ...orchestrationWarning,
         queueTrigger,
         ...buildQueueTriggerGuidance(queueTrigger)
       });
@@ -5637,7 +5709,7 @@ async function meshEnqueueBatch(ctx, args) {
   });
 }
 async function meshViewQueue(ctx, args) {
-  const rateResult = (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_view_queue" });
+  const rateResult = recordMeshCoordinatorToolCall(ctx, "mesh_view_queue");
   const compact = args.verbose === true ? false : args.compact ?? true;
   try {
     await refreshMeshFromDaemon(ctx);
@@ -8944,7 +9016,7 @@ async function meshAnswerQuestion(ctx, args) {
   return JSON.stringify(result, null, 2);
 }
 async function meshListPendingApprovals(ctx, _args = {}) {
-  (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_list_pending_approvals" });
+  recordMeshCoordinatorToolCall(ctx, "mesh_list_pending_approvals");
   await refreshMeshFromDaemon(ctx);
   const liveNodes = await collectMeshViewQueueNodesWithLiveSessions(ctx);
   let ledgerEntries = (0, import_daemon_core6.readLedgerEntries)(ctx.mesh.id, { tail: 200 });