@adhdev/daemon-standalone 1.0.57 → 1.0.58-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-standalone",
-  "version": "1.0.57",
+  "version": "1.0.58-rc.2",
   "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": "*",
+    "@adhdev/session-host-core": "1.0.58-rc.2",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/xterm": "^6.0.0",
     "chalk": "^5.3.0",

package/vendor/mcp-server/index.js

@@ -1413,7 +1413,23 @@ var MESH_SEND_TASK_TOOL = {
         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." }
+      deliveryMode: { type: "string", enum: ["when_idle", "interrupt"], description: "CamelCase alias for delivery_mode." },
+      // GRAPH-MEASUREMENT-DIRECT — the decision record for the DIRECT surface.
+      //
+      // ★ WHY IT IS HERE AT ALL. This tool is the MAJORITY dispatch surface (~67%
+      // of dispatches in the graph-adoption investigation) and it carried no
+      // decision field, so two thirds of all routing judgements were structurally
+      // unmeasurable. `decision_missing` on mesh_enqueue_task described only the
+      // enqueue minority and was silent — not negative — about the rest.
+      //
+      // ★ OPTIONAL, exactly like mesh_enqueue_task's (see the note there): phase E
+      // measures and does not enforce, and a required field would reject every
+      // existing caller. Omission degrades to decision_missing, never an error.
+      orchestration_decision: {
+        type: "object",
+        description: "Record of your dispatch decision, for adoption measurement: {decision, direct_reason, ready_worker_tasks, known_graph_steps, capability_blockers}. On this DIRECT surface, direct_reason says why dispatching into an existing session beat queueing a task \u2014 one of same_subject_continuation, investigation_handoff, idle_session_reuse, queue_bypass_urgent, new_subject, legacy_client, operator_override. These are the cases the operating rules name: same-subject continuation, the investigate\u2192fix handoff, reusing an idle session for a follow-up/retry/cleanup delta, or a deliberate queue bypass. new_subject is the one the rules do NOT endorse \u2014 a genuinely new topic should get its own task even when a session sits idle \u2014 and reporting it returns an unsanctioned_direct_dispatch advisory. Report it honestly anyway: it is recorded, never refused. Optional and never rejected: omitting it is recorded as decision_missing. Provenance only \u2014 it never changes execution."
+      },
+      orchestrationDecision: { type: "object", description: "CamelCase alias for orchestration_decision." }
     },
     required: ["node_id", "session_id", "message", "difficulty"]
   }
@@ -1535,7 +1551,7 @@ var MESH_FAST_FORWARD_NODE_TOOL = {
       mode: { type: "string", enum: ["merge", "push"], description: "merge (default): git merge --ff-only to absorb upstream. push: strict ff-only push of local commits to origin/<branch>; refuses any non-fast-forward." },
       branch: { type: "string", description: "Optional guard: require the node's current branch to match this branch before planning/executing." },
       execute: { type: "boolean", description: "When true, apply the fast-forward/push if all safety gates pass. Defaults false/dry-run." },
-      dry_run: { type: "boolean", description: "Preview only. Defaults true unless execute=true; dry_run=true overrides execute." },
+      dry_run: { type: "boolean", description: "Preview only. Defaults true unless execute=true; dry_run=true overrides execute. dry_run=false is NOT an execute trigger \u2014 it only declines to veto, so passing it alone is rejected with dry_run_false_requires_execute rather than silently previewing. Use execute=true to apply." },
       update_submodules: { type: "boolean", description: 'mode="merge" only: when true, if the root fast-forward changes gitlinks, run only git submodule update --init --recursive and verify submodules clean.' },
       push_submodules: { type: "boolean", description: 'mode="push" only: also ff-only push submodule HEADs to their origin main. Gated by mesh policy allowAutoPublishSubmoduleMainCommits \u2014 skipped unless that policy is enabled. Defaults false (root push only).' }
     },
@@ -1898,7 +1914,7 @@ var MESH_PRUNE_STALE_DIRECT_TOOL = {
     type: "object",
     properties: {
       execute: { type: "boolean", description: "When true, actually delete the orphaned records. Defaults false (dry run). Ignored when dry_run=true." },
-      dry_run: { type: "boolean", description: "Force a preview without mutation even if execute=true. Defaults to dry-run behavior when execute is not set." },
+      dry_run: { type: "boolean", description: "Force a preview without mutation even if execute=true. Defaults to dry-run behavior when execute is not set. dry_run=false is NOT an execute trigger \u2014 passing it alone is rejected with dry_run_false_requires_execute rather than silently previewing. Use execute=true to prune." },
       include_terminal: { type: "boolean", description: "Also prune terminal (completed/failed) direct dispatch store rows in addition to orphans. Defaults false." }
     }
   }
@@ -2028,7 +2044,7 @@ var MESH_MAGI_REVIEW_TOOL = {
       require_independent_evidence: { type: "boolean", description: "Default true \u2014 high-impact claims with no file:line/source evidence are routed to needs_verification." },
       include_stale: { type: "boolean", description: "Default false. By default, panel slots whose node HEAD commit differs from the coordinator reference commit are EXCLUDED (they would investigate different code). Set true to fan out to them anyway \u2014 results will be git-skewed and a warning is surfaced. If exclusion drops the panel below 2 independent targets the call errors rather than degrading to N=1; include_stale=true is one way to recover." },
       wait: { type: "boolean", description: "Default true \u2014 collect replica outputs and return the synthesis. Set false to dispatch async and return a consensusGroupId handle; collect later with mesh_magi_collect." },
-      wait_timeout_ms: { type: "number", description: 'Max time to wait for replica completion before returning a partial "missing K of N" synthesis. Default ~4 min.' },
+      wait_timeout_ms: { type: "number", description: 'Max time to wait for replica completion before returning a partial "missing K of N" synthesis. Default 8 min, max 20 min.' },
       auto_cleanup: { type: "boolean", description: "Default = mesh policy magiSessionCleanup (ON / stop_and_delete unless overridden). Once all replicas are terminal, stop+delete ONLY the worker sessions THIS fan-out auto-launched (marker-verified) so repeated reviews don't accumulate idle worker sessions. Reused/coordinator/other sessions are never touched. Set false to preserve auto-launched worker sessions for inspection. No effect on a partial (non-terminal) collection." }
     },
     required: ["question", "task_kind"]
@@ -2044,7 +2060,7 @@ var MESH_MAGI_COLLECT_TOOL = {
       task_kind: { type: "string", enum: ["claim_audit", "rca", "design", "freeform"], description: "Optional override of the task_kind used to parse replica answers. Normally recovered automatically from the original dispatch \u2014 only set this if the dispatched ledger entry was pruned and auto-recovery falls back to claim_audit incorrectly." },
       require_independent_evidence: { type: "boolean", description: "Default true \u2014 high-impact claims with no file:line/source evidence are routed to needs_verification." },
       wait: { type: "boolean", description: "Default false (snapshot). Set true to block for outstanding replicas up to wait_timeout_ms before synthesizing." },
-      wait_timeout_ms: { type: "number", description: "When wait=true, max time to wait for remaining replica completion. Default ~4 min." },
+      wait_timeout_ms: { type: "number", description: "When wait=true, max time to wait for remaining replica completion. Default 8 min, max 20 min." },
       auto_cleanup: { type: "boolean", description: "Default = mesh policy magiSessionCleanup (ON / stop_and_delete). When the collection is terminal, stop+delete ONLY the worker sessions THIS fan-out auto-launched (marker-verified). Reused/coordinator/other sessions are never touched. Set false to preserve them. No effect on a partial (non-terminal) snapshot." },
       verbose: { type: "boolean", description: "Default false. When true, each synthesis.replicas[] entry also carries rawAnswer \u2014 the replica's raw end-user answer text (capped). Omitted by default to keep the payload small; the structured clusters already carry the parsed claims." }
     },
@@ -6515,9 +6531,12 @@ var import_daemon_core7 = require("@adhdev/daemon-core");
 var MAGI_MAX_REPLICAS = 12;
 var MAGI_MIN_TARGETS = 2;
 var MAGI_CLUSTER_JACCARD = 0.4;
-var MAGI_DEFAULT_WAIT_MS = 18e4;
-var MAGI_MAX_WAIT_MS = 6e5;
+var MAGI_DEFAULT_WAIT_MS = 48e4;
+var MAGI_MAX_WAIT_MS = 12e5;
 var MAGI_POLL_INTERVAL_MS = 5e3;
+function resolveMagiWaitTimeoutMs(raw) {
+  return Math.min(MAGI_MAX_WAIT_MS, Math.max(MAGI_POLL_INTERVAL_MS, Number(raw) || MAGI_DEFAULT_WAIT_MS));
+}
 var VALID_TASK_KINDS = ["claim_audit", "rca", "design", "freeform"];
 var DEFAULT_TASK_KIND = "claim_audit";
 function normalizeMagiTaskKind(raw) {
@@ -6898,7 +6917,11 @@ function synthesizeMagiResponses(responses, opts = {}) {
     const replicasMissing = Math.max(0, replicasExpected - replicasAnswered);
     const lossDominated = replicasMissing > 0 && replicasMissing >= replicasAnswered;
     if (lossDominated) {
-      independenceBanner = `independence not achieved \u2014 only ${replicasAnswered} of ${replicasExpected} replica(s) answered (${replicasMissing} missing/dropped), collapsing the answering set to ${distinctProviders} provider(s) and ${distinctNodes} machine(s). This is a replica-loss/collection failure, not a low-diversity panel \u2014 inspect the dropped replicas (stale/unparseable/no-session) before re-reading the diversity spans. Agreements are routed to needs_verification.`;
+      const notAnswered = responses.filter((r) => !(r.source.ok && r.response));
+      const pendingCount = notAnswered.filter((r) => r.source.error === "replica_deadline_exceeded").length;
+      const failedCount = notAnswered.length - pendingCount;
+      const dropBreakdown = pendingCount > 0 && failedCount > 0 ? ` (${pendingCount} still pending past the deadline \u2014 re-collect may recover them; ${failedCount} genuinely failed/unparseable/stale \u2014 those need a panel swap)` : pendingCount > 0 ? ` (all ${pendingCount} still pending past the deadline \u2014 re-collect with mesh_magi_collect may recover them, this is NOT a failed panel)` : ` (all ${failedCount} genuinely failed/unparseable/stale \u2014 re-collecting will not recover them, consider a panel swap)`;
+      independenceBanner = `independence not achieved \u2014 only ${replicasAnswered} of ${replicasExpected} replica(s) answered (${replicasMissing} missing/dropped), collapsing the answering set to ${distinctProviders} provider(s) and ${distinctNodes} machine(s). This is a replica-loss/collection failure, not a low-diversity panel${dropBreakdown}. Agreements are routed to needs_verification.`;
     } else {
       independenceBanner = `independence not achieved \u2014 the answering replicas span ${distinctProviders} provider(s) and ${distinctNodes} machine(s); their agreements are source-coupled and routed to needs_verification.`;
     }
@@ -7295,6 +7318,8 @@ async function meshMagiKindPanelSet(ctx, args) {
   const scope = magiPanelScope(meshId, ctx.mesh.name);
   try {
     const current = (0, import_daemon_core6.getMagiKindPanel)(kind, meshId) ?? [];
+    const ignoredFields = (0, import_daemon_core6.collectIgnoredMagiSlotFields)(args.slots);
+    const ignoredNote = ignoredFields.length ? { ignoredFields, ignoredFieldsNote: "These keys are not part of the MAGI slot schema and were DROPPED (the panel was still saved without them). A MAGI panel decides WHO answers independently; per-slot routing axes like thinkingLevel/difficulty/maxParallel belong on the node capability slots (mesh_node_slots_set)." } : {};
     if (!write) {
       const preview = (0, import_daemon_core6.normalizeMagiSlots)(args.slots, ctx.mesh.nodes.map((n) => n.id));
       return JSON.stringify({
@@ -7305,6 +7330,7 @@ async function meshMagiKindPanelSet(ctx, args) {
         replacement: true,
         currentSlots: current,
         slots: preview,
+        ...ignoredNote,
         note: `Dry-run only \u2014 no file written. This is a WHOLESALE replacement of the kind's slot list for mesh '${meshId}' (machine-local ~/.adhdev/meshes.json); the currentSlots would be fully replaced. Other meshes on this machine are unaffected. Re-run with write=true after explicit user approval.`
       }, null, 2);
     }
@@ -7317,6 +7343,7 @@ async function meshMagiKindPanelSet(ctx, args) {
       replacement: true,
       previousSlots: current,
       slots,
+      ...ignoredNote,
       nextAction: "Verify with mesh_magi_kind_panel_list, then mesh_magi_review({ task_kind }) resolves this binding."
     }, null, 2);
   } catch (e) {
@@ -7431,7 +7458,7 @@ async function meshMagiReview(ctx, args) {
   const mode = readString(args.mode);
   const requireIndependentEvidence = (args.require_independent_evidence ?? args.requireIndependentEvidence) !== false;
   const wait = args.wait !== false;
-  const waitTimeoutMs = Math.min(MAGI_MAX_WAIT_MS, Math.max(MAGI_POLL_INTERVAL_MS, Number(args.wait_timeout_ms ?? args.waitTimeoutMs) || MAGI_DEFAULT_WAIT_MS));
+  const waitTimeoutMs = resolveMagiWaitTimeoutMs(args.wait_timeout_ms ?? args.waitTimeoutMs);
   const consensusGroupId = `magi_${(0, import_node_crypto.randomUUID)().replace(/-/g, "")}`;
   const titleQ = question.length > 80 ? `${question.slice(0, 77)}...` : question;
   const mission = (0, import_daemon_core6.upsertMeshMission)(ctx.mesh.id, {
@@ -7606,7 +7633,7 @@ async function meshMagiCollect(ctx, args) {
   }
   const requireIndependentEvidence = (args.require_independent_evidence ?? args.requireIndependentEvidence) !== false;
   const wait = args.wait === true;
-  const timeoutMs = wait ? Math.min(MAGI_MAX_WAIT_MS, Math.max(MAGI_POLL_INTERVAL_MS, Number(args.wait_timeout_ms ?? args.waitTimeoutMs) || MAGI_DEFAULT_WAIT_MS)) : 0;
+  const timeoutMs = wait ? resolveMagiWaitTimeoutMs(args.wait_timeout_ms ?? args.waitTimeoutMs) : 0;
   const replicaTaskIds = replicaTasks.map((t) => readString(t.id)).filter(Boolean);
   const collected = await collectMagiResponses(ctx, { replicaTaskIds, timeoutMs, taskKind });
   const synthesis = synthesizeMagiResponses(collected.responses, {
@@ -8050,7 +8077,7 @@ ${magiOutputContractFor(kind)}`;
         finalized.set(taskId, prov);
         return true;
       }
-      source.error = isSchemaFailure ? `schema_invalid: ${kindResult.failReason}` : "unparseable_output";
+      source.error = isSchemaFailure ? `schema_invalid: ${kindResult.failReason}` : "replica_deadline_exceeded";
       finalized.set(taskId, { source, response: emptyResponse() });
       return true;
     }
@@ -8277,6 +8304,15 @@ function computeIdleDispatchAckRisk(sessionWasIdle, dispatchPreRecorded, session
 }
 async function meshPruneStaleDirect(ctx, args = {}) {
   await refreshMeshFromDaemon(ctx);
+  if (args.dry_run === false && args.execute !== true) {
+    return JSON.stringify({
+      success: false,
+      code: "dry_run_false_requires_execute",
+      executed: false,
+      error: "dry_run:false alone does not execute \u2014 it only declines to veto. Pass execute:true to actually prune.",
+      nextAction: "Re-run mesh_prune_stale_direct(execute: true) to prune, or omit dry_run to preview."
+    }, null, 2);
+  }
   const execute = args.execute === true && args.dry_run !== true;
   const includeTerminal = args.include_terminal === true;
   const liveNodes = await collectMeshViewQueueNodesWithLiveSessions(ctx);
@@ -8363,6 +8399,16 @@ async function meshSendTask(ctx, args) {
     });
   }
   const difficulty = difficultyRaw;
+  const rawDecision = args.orchestration_decision ?? args.orchestrationDecision;
+  const decisionMissing = rawDecision === void 0 || rawDecision === null;
+  const orchestration = (0, import_daemon_core6.normalizeOrchestrationDecision)(rawDecision, "direct");
+  const orchestrationWarning = {
+    ...orchestration.unsanctionedDirect ? {
+      unsanctionedDirect: orchestration.unsanctionedDirect,
+      unsanctionedDirectHint: import_daemon_core6.MESH_UNSANCTIONED_DIRECT_HINT
+    } : {},
+    ...decisionMissing ? { orchestrationDecisionMissing: true } : {}
+  };
   const modeValidation = (0, import_daemon_core6.validateMeshTaskModeRequest)(requestedTaskMode, message, readonly);
   if (!modeValidation.valid) {
     return JSON.stringify({
@@ -8519,6 +8565,17 @@ async function meshSendTask(ctx, args) {
             ...readonly ? { readonly: true } : {},
             dispatchedAt
           });
+          (0, import_daemon_core6.recordDirectDispatchDecision)(ctx.mesh.id, {
+            taskId,
+            via: "p2p_direct",
+            nodeId: args.node_id,
+            ...dispatchedSessionId ? { sessionId: dispatchedSessionId } : {},
+            ...missionId ? { missionId } : {},
+            ...ctx.coordinatorSessionId ? { coordinatorSessionId: ctx.coordinatorSessionId } : {},
+            decision: orchestration.decision,
+            ...decisionMissing ? { decisionMissing: true } : {},
+            ...orchestration.unsanctionedDirect ? { unsanctionedDirect: orchestration.unsanctionedDirect.reportedReason } : {}
+          });
         } catch {
         }
       }
@@ -8531,7 +8588,10 @@ async function meshSendTask(ctx, args) {
         taskMode,
         ...result2.success && result2.providerType ? { providerType: result2.providerType } : {},
         dispatched: result2.success === true,
-        ...result2.success ? buildMissionInactiveWarning(ctx, missionId) ?? {} : {}
+        ...result2.success ? buildMissionInactiveWarning(ctx, missionId) ?? {} : {},
+        // GRAPH-MEASUREMENT-DIRECT: advisory only, and only on a dispatch that
+        // actually happened — a failed dispatch made no routing decision to report on.
+        ...result2.success ? orchestrationWarning : {}
       });
     }
     if (args.session_id) {
@@ -8836,6 +8896,17 @@ async function meshSendTask(ctx, args) {
           ...readonly ? { readonly: true } : {},
           dispatchedAt
         });
+        (0, import_daemon_core6.recordDirectDispatchDecision)(ctx.mesh.id, {
+          taskId,
+          via: "local_direct",
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          ...missionId ? { missionId } : {},
+          ...ctx.coordinatorSessionId ? { coordinatorSessionId: ctx.coordinatorSessionId } : {},
+          decision: orchestration.decision,
+          ...decisionMissing ? { decisionMissing: true } : {},
+          ...orchestration.unsanctionedDirect ? { unsanctionedDirect: orchestration.unsanctionedDirect.reportedReason } : {}
+        });
       } catch {
       }
       let deliveryId;
@@ -8869,7 +8940,9 @@ async function meshSendTask(ctx, args) {
         // session whose dispatch row did NOT survive pre-record. A successfully
         // pre-recorded idle dispatch (the NOTIF-DROP / CANON-A path) is not at risk.
         ...computeIdleDispatchAckRisk(sessionWasIdle, dispatchPreRecorded, args.session_id),
-        ...buildMissionInactiveWarning(ctx, missionId) ?? {}
+        ...buildMissionInactiveWarning(ctx, missionId) ?? {},
+        // GRAPH-MEASUREMENT-DIRECT: advisory only — never blocks, never re-routes.
+        ...orchestrationWarning
       });
     }
     const task = (0, import_daemon_core6.enqueueTask)(ctx.mesh.id, message, {
@@ -9423,6 +9496,20 @@ async function meshFastForwardNode(ctx, args) {
       blockingReasons: ["node_read_only"]
     }, null, 2);
   }
+  if (args.dry_run === false && args.execute !== true) {
+    return JSON.stringify({
+      success: false,
+      code: "dry_run_false_requires_execute",
+      nodeId: args.node_id,
+      workspace: node.workspace,
+      allowed: false,
+      willRun: false,
+      executed: false,
+      blockingReasons: ["dry_run_false_requires_execute"],
+      error: "dry_run:false alone does not execute \u2014 it only declines to veto. Pass execute:true to actually apply the fast-forward.",
+      nextAction: `Re-run mesh_fast_forward_node(node_id: "${args.node_id}", execute: true) to apply, or omit dry_run to preview.`
+    }, null, 2);
+  }
   try {
     const dryRun = args.dry_run === true || args.execute !== true;
     const result = await commandForNode(ctx, node, "fast_forward_mesh_node", {