@adhdev/daemon-standalone 1.0.18-rc.10 → 1.0.18-rc.11

package/dist/index.js

@@ -30265,10 +30265,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "36bb91235b40db3d3fb1587850f0a213d040bcef" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "36bb9123" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.18-rc.10" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-22T07:21:47.865Z" : void 0);
+      const commit = readInjected(true ? "99f9c20bcf4ceec1e7ab2bfe6c8f641ca88da360" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "99f9c20b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.18-rc.11" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-22T10:19:28.847Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -32474,6 +32474,51 @@ ${error48.message || ""}`;
         import_node_crypto = require("crypto");
       }
     });
+    var dist_exports = {};
+    __export2(dist_exports, {
+      CANONICAL_MESH_TOOL_COUNT: () => CANONICAL_MESH_TOOL_COUNT,
+      CANONICAL_MESH_TOOL_NAMES: () => CANONICAL_MESH_TOOL_NAMES,
+      DEFAULT_DIFFICULTY_BRAINS: () => DEFAULT_DIFFICULTY_BRAINS,
+      MAGI_RAW_ANSWER_CAP: () => MAGI_RAW_ANSWER_CAP,
+      MESH_TASK_DIFFICULTIES: () => MESH_TASK_DIFFICULTIES,
+      STATUS_PROBE_ARG_KEY: () => STATUS_PROBE_ARG_KEY,
+      argsCarryStatusProbeMarker: () => argsCarryStatusProbeMarker,
+      canonicalDaemonId: () => canonicalDaemonId,
+      daemonIdsEquivalent: () => daemonIdsEquivalent,
+      deriveSlotsFromLegacy: () => deriveSlotsFromLegacy,
+      expandDaemonIdForms: () => expandDaemonIdForms,
+      hasGitStatusEvidence: () => hasGitStatusEvidence,
+      interpolateArgs: () => interpolateArgs,
+      interpolateString: () => interpolateString,
+      isMeshTaskDifficulty: () => isMeshTaskDifficulty,
+      joinRepoPath: () => joinRepoPath,
+      machineCoreFromDaemonId: () => machineCoreFromDaemonId,
+      meshNodeIdMatches: () => meshNodeIdMatches,
+      meshWorkspacesEquivalent: () => meshWorkspacesEquivalent,
+      normalizeBrainSlot: () => normalizeBrainSlot,
+      normalizeDifficultyBrainMap: () => normalizeDifficultyBrainMap,
+      normalizeGitStatus: () => normalizeGitStatus,
+      normalizeMeshNodeId: () => normalizeMeshNodeId,
+      normalizeMeshSessionRecord: () => normalizeMeshSessionRecord,
+      normalizeMeshWorkspaceForCompare: () => normalizeMeshWorkspaceForCompare,
+      normalizeNodeCapabilitySlot: () => normalizeNodeCapabilitySlot,
+      normalizeNodeCapabilitySlots: () => normalizeNodeCapabilitySlots,
+      normalizeThinkingLevel: () => normalizeThinkingLevel,
+      parseJsonRecord: () => parseJsonRecord,
+      pickBestTransitGitStatus: () => pickBestTransitGitStatus,
+      readBoolean: () => readBoolean,
+      readGitSubmodules: () => readGitSubmodules,
+      readNumber: () => readNumber,
+      readRecord: () => readRecord,
+      readString: () => readString2,
+      readStringArray: () => readStringArray2,
+      scoreGitStatusCandidate: () => scoreGitStatusCandidate,
+      scoreGitUpstreamFreshness: () => scoreGitUpstreamFreshness,
+      sessionIdsEquivalent: () => sessionIdsEquivalent,
+      stripStatusProbeMarker: () => stripStatusProbeMarker,
+      summarizeGitShape: () => summarizeGitShape,
+      withStatusProbeMarker: () => withStatusProbeMarker
+    });
     function readRecord(value) {
       return value && typeof value === "object" && !Array.isArray(value) ? value : {};
     }
@@ -32497,6 +32542,21 @@ ${error48.message || ""}`;
       }
       return void 0;
     }
+    function readStringArray2(value) {
+      return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+    }
+    function parseJsonRecord(value) {
+      if (!value) return {};
+      if (typeof value === "object") return readRecord(value);
+      if (typeof value !== "string") return {};
+      const trimmed = value.trim();
+      if (!trimmed) return {};
+      try {
+        return readRecord(JSON.parse(trimmed));
+      } catch {
+        return {};
+      }
+    }
     function joinRepoPath(root, relativePath) {
       const normalizedRoot = typeof root === "string" ? root.trim().replace(/[\\/]+$/, "") : "";
       const normalizedPath = typeof relativePath === "string" ? relativePath.trim() : "";
@@ -32637,12 +32697,48 @@ ${error48.message || ""}`;
       }
       return best?.git;
     }
+    function deriveSyntheticSessionId(record2) {
+      const parts = [
+        readString2(record2.workspace),
+        readString2(record2.providerType, record2.provider),
+        readString2(record2.role),
+        readString2(record2.state, record2.status),
+        readString2(record2.title),
+        readString2(record2.createdAt, record2.created_at),
+        readString2(record2.startedAt, record2.started_at)
+      ].filter((part) => Boolean(part));
+      if (parts.length === 0) return void 0;
+      return `synthetic:${parts.join("|")}`;
+    }
     function sessionIdsEquivalent(a, b) {
       const idA = readString2(a);
       const idB = readString2(b);
       if (!idA || !idB) return false;
       return idA === idB;
     }
+    function normalizeMeshSessionRecord(entry) {
+      const record2 = readRecord(entry);
+      const sessionId = readString2(record2.sessionId, record2.session_id, record2.id) ?? deriveSyntheticSessionId(record2);
+      if (!sessionId) return null;
+      return {
+        sessionId,
+        ...readString2(record2.providerType, record2.provider) ? { providerType: readString2(record2.providerType, record2.provider) } : {},
+        ...readString2(record2.state, record2.status) ? { state: readString2(record2.state, record2.status) } : {},
+        ...readString2(record2.chatStatus, record2.chat_status) ? { chatStatus: readString2(record2.chatStatus, record2.chat_status) } : {},
+        ...readString2(record2.lifecycle) ? { lifecycle: readString2(record2.lifecycle) } : {},
+        ...readString2(record2.surfaceKind, record2.surface_kind) ? { surfaceKind: readString2(record2.surfaceKind, record2.surface_kind) } : {},
+        ...readString2(record2.recoveryState, record2.recovery_state) ? { recoveryState: readString2(record2.recoveryState, record2.recovery_state) } : {},
+        ...readString2(record2.workspace) ? { workspace: readString2(record2.workspace) } : {},
+        ...readString2(record2.title) ? { title: readString2(record2.title) } : {},
+        ...readString2(record2.role) ? { role: readString2(record2.role) } : {},
+        ...readBoolean(record2.isSelfCoordinator, record2.is_self_coordinator) !== void 0 ? { isSelfCoordinator: readBoolean(record2.isSelfCoordinator, record2.is_self_coordinator) } : {},
+        ...readString2(record2.statusNote, record2.status_note) ? { statusNote: readString2(record2.statusNote, record2.status_note) } : {},
+        ...readString2(record2.createdAt, record2.created_at) ? { createdAt: readString2(record2.createdAt, record2.created_at) } : {},
+        ...readString2(record2.startedAt, record2.started_at) ? { startedAt: readString2(record2.startedAt, record2.started_at) } : {},
+        ...readString2(record2.lastActivityAt, record2.last_activity_at) ? { lastActivityAt: readString2(record2.lastActivityAt, record2.last_activity_at) } : {},
+        ...readBoolean(record2.isCached, record2.is_cached) !== void 0 ? { isCached: readBoolean(record2.isCached, record2.is_cached) } : {}
+      };
+    }
     function normalizeMeshNodeId(node) {
       const record2 = node && typeof node === "object" ? node : {};
       return readString2(record2.id, record2.nodeId, record2.node_id);
@@ -32825,9 +32921,30 @@ ${error48.message || ""}`;
         };
       });
     }
+    function interpolateArgs(args, context) {
+      const result = {};
+      for (const [k, v] of Object.entries(args)) {
+        result[k] = typeof v === "string" ? interpolateString(v, context) : v;
+      }
+      return result;
+    }
+    function interpolateString(template, ctx) {
+      return template.replace(/\{\{(\w+)\}\}/g, (_, key2) => {
+        const val = ctx[key2];
+        return val !== void 0 ? String(val) : `{{${key2}}}`;
+      });
+    }
     function withStatusProbeMarker(args = {}) {
       return { ...args, [STATUS_PROBE_ARG_KEY]: true };
     }
+    function argsCarryStatusProbeMarker(args) {
+      return !!args && typeof args === "object" && args[STATUS_PROBE_ARG_KEY] === true;
+    }
+    function stripStatusProbeMarker(args) {
+      if (!argsCarryStatusProbeMarker(args)) return args;
+      const { [STATUS_PROBE_ARG_KEY]: _drop, ...rest } = args;
+      return rest;
+    }
     var DAEMON_ID_PREFIXES;
     var MAGI_RAW_ANSWER_CAP;
     var MESH_TASK_DIFFICULTIES;
@@ -32865,6 +32982,7 @@ ${error48.message || ""}`;
           "mesh_restart_daemon",
           "mesh_checkpoint",
           "mesh_approve",
+          "mesh_answer_question",
           "mesh_list_pending_approvals",
           "mesh_clone_node",
           "mesh_remove_node",
@@ -34314,6 +34432,42 @@ ${surfaced}`;
       if (args.event === "agent:waiting_approval") {
         return `[System] ${args.nodeLabel} is waiting for approval to proceed${metadata}. You may use mesh_read_chat and mesh_approve to handle it.`;
       }
+      if (args.event === "agent:waiting_choice") {
+        const prompt = args.metadataEvent.interactivePrompt;
+        const promptId = readNonEmptyString(args.metadataEvent.promptId) || prompt && readNonEmptyString(prompt.promptId);
+        const lines = [
+          `[System] ${args.nodeLabel} is asking a question and is waiting for your answer${metadata}.`
+        ];
+        const questions = Array.isArray(prompt?.questions) ? prompt.questions : [];
+        if (questions.length > 0) {
+          for (const q of questions) {
+            const header = readNonEmptyString(q.header);
+            const question = readNonEmptyString(q.question);
+            const multiSelect = q.multiSelect === true;
+            if (question) {
+              lines.push(`
+**${header ? `${header}: ` : ""}${question}**${multiSelect ? " (select one or more)" : ""}`);
+            }
+            const options = Array.isArray(q.options) ? q.options : [];
+            options.forEach((opt, i) => {
+              const record2 = opt && typeof opt === "object" ? opt : {};
+              const label = readNonEmptyString(record2.label);
+              if (!label) return;
+              const description = readNonEmptyString(record2.description);
+              lines.push(`  ${i + 1}. ${label}${description ? ` \u2014 ${description}` : ""}`);
+            });
+          }
+        } else {
+          const modalMessage = readNonEmptyString(args.metadataEvent.modalMessage);
+          if (modalMessage) lines.push(`
+${modalMessage}`);
+        }
+        lines.push(
+          `
+Answer with mesh_answer_question(node_id, session_id${promptId ? `, promptId: "${promptId}"` : ""}, answers). Do NOT use mesh_approve \u2014 that only resolves yes/no consent modals, not a question. Use mesh_read_chat once if you need the full context first.`
+        );
+        return lines.join("\n");
+      }
       if (args.event === "agent:stopped") {
         const rc = args.recoveryContext;
         if (rc && rc.consecutiveNodeFailures > 0) {
@@ -35831,6 +35985,7 @@ Next step: ${nextStep}`;
       requeueTask: () => requeueTask,
       resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
       resolveNotBefore: () => resolveNotBefore,
+      takeCancelledTaskAssignment: () => takeCancelledTaskAssignment,
       taskDependenciesSatisfied: () => taskDependenciesSatisfied,
       updateDirectDispatchStatus: () => updateDirectDispatchStatus,
       updateSessionTaskStatus: () => updateSessionTaskStatus,
@@ -36390,6 +36545,10 @@ Next step: ${nextStep}`;
       const result = withQueueLock(meshId, () => {
         const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
+        if (!opts?.force && TERMINAL_TASK_STATUSES.has(entry.status) && !TERMINAL_TASK_STATUSES.has(status)) {
+          LOG2.debug("MeshQueue", `Refusing updateTaskStatus(${taskId} \u2192 ${status}) on mesh ${meshId}: row is terminal (${entry.status}). A late writer (e.g. dispatch-failure requeue) must not resurrect a cancelled/completed/failed task. Pass force to override.`);
+          return { entry, cascaded: [] };
+        }
         entry.status = status;
         MeshRuntimeStore.getInstance().updateQueueEntry(entry);
         if (status !== "assigned") endTaskDispatchInFlight(meshId, taskId);
@@ -36415,17 +36574,34 @@ Next step: ${nextStep}`;
         const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
         const now = (/* @__PURE__ */ new Date()).toISOString();
+        const priorAssignment = entry.assignedSessionId ? {
+          sessionId: entry.assignedSessionId,
+          nodeId: entry.assignedNodeId,
+          providerType: entry.assignedProviderType
+        } : void 0;
         entry.status = "cancelled";
         entry.cancelledAt = now;
         if (opts?.reason) entry.cancelReason = opts.reason;
+        delete entry.assignedNodeId;
+        delete entry.assignedSessionId;
+        delete entry.assignedProviderType;
+        delete entry.dispatchTimestamp;
+        entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
         MeshRuntimeStore.getInstance().updateQueueEntry(entry);
         endTaskDispatchInFlight(meshId, taskId);
         const cascaded = propagateDependencyFailure(meshId, taskId);
-        return { entry, cascaded };
+        return { entry, cascaded, priorAssignment };
       });
       if (result) scheduleMissionCloseCandidateCheck(meshId, [result.entry, ...result.cascaded]);
+      if (result?.priorAssignment) lastCancelledTaskAssignment.set(`${meshId}::${taskId}`, result.priorAssignment);
       return result ? result.entry : null;
     }
+    function takeCancelledTaskAssignment(meshId, taskId) {
+      const key2 = `${meshId}::${taskId}`;
+      const value = lastCancelledTaskAssignment.get(key2);
+      if (value) lastCancelledTaskAssignment.delete(key2);
+      return value;
+    }
     function requeueTask(meshId, taskId, opts) {
       requireMeshHostQueueOwner(opts);
       const result = withQueueLock(meshId, () => {
@@ -36652,6 +36828,8 @@ Next step: ${nextStep}`;
     var GIT_MUTATION_SUBCOMMANDS;
     var GIT_STASH_READONLY_SUBCOMMANDS;
     var DEPENDENCY_FAILURE_TERMINALS;
+    var TERMINAL_TASK_STATUSES;
+    var lastCancelledTaskAssignment;
     var MAX_STRANDED_RECLAIMS;
     var REDRIVE_RECLAIM_REASONS;
     var REDRIVE_SUPERSEDE_WINDOW_MS;
@@ -36722,6 +36900,8 @@ Next step: ${nextStep}`;
         ]);
         GIT_STASH_READONLY_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "show"]);
         DEPENDENCY_FAILURE_TERMINALS = /* @__PURE__ */ new Set(["failed", "cancelled"]);
+        TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+        lastCancelledTaskAssignment = /* @__PURE__ */ new Map();
         MAX_STRANDED_RECLAIMS = 3;
         REDRIVE_RECLAIM_REASONS = /* @__PURE__ */ new Set([
           "delivered_no_turn_deadline",
@@ -38822,7 +39002,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     function readNonEmptyString2(value) {
       return typeof value === "string" && value.trim() ? value.trim() : void 0;
     }
-    function readStringArray2(value) {
+    function readStringArray3(value) {
       if (!Array.isArray(value)) return [];
       return value.map((item) => readNonEmptyString2(item)).filter(Boolean);
     }
@@ -38882,11 +39062,11 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       return {
         status,
         ...readNonEmptyString2(raw.classification) ? { classification: readNonEmptyString2(raw.classification) } : {},
-        changedFiles: readStringArray2(raw.changedFiles),
+        changedFiles: readStringArray3(raw.changedFiles),
         validationResults: normalizeValidationResults(raw.validationResults),
         ...gitStatus ? { gitStatus } : {},
         processArtifacts: normalizeProcessArtifacts(raw.processArtifacts),
-        errors: readStringArray2(raw.errors),
+        errors: readStringArray3(raw.errors),
         ...readNonEmptyString2(raw.nextAction) ? { nextAction: readNonEmptyString2(raw.nextAction) } : {},
         requiresUserAction: raw.requiresUserAction === true,
         source
@@ -40065,7 +40245,8 @@ When you compose the task message you dispatch to a node, include these requirem
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |
 | \`mesh_restart_daemon\` | Update a node's daemon to the latest published version on its channel and restart it (the dashboard "preview update" path, as a mesh command) |
 | \`mesh_checkpoint\` | Create a git checkpoint on a node |
-| \`mesh_approve\` | Approve/reject a pending agent action |
+| \`mesh_approve\` | Approve/reject a pending agent action (a yes/no tool-consent modal) |
+| \`mesh_answer_question\` | Answer a delegated session's multi-choice QUESTION (AskUserQuestion / status awaiting_choice). NOT an approval \u2014 it offers labelled options (possibly multi-select or freeform). Pass the promptId from the agent:waiting_choice event + one answer per question (select by option label or 1-based index). Use this, never mesh_approve, for a question |
 | \`mesh_list_pending_approvals\` | List every session across the mesh awaiting an approval decision (the approval inbox) \u2014 read-only; enumerate all blocked sessions at once, then drive a mesh_approve for each |
 | \`mesh_clone_node\` | Create a worktree node for isolated parallel branch work |
 | \`mesh_refine_node\` | Validate and merge a completed worktree node back into its base branch |
@@ -40301,7 +40482,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
     function readRecord4(value) {
       return value && typeof value === "object" && !Array.isArray(value) ? value : null;
     }
-    function readStringArray3(value, max) {
+    function readStringArray4(value, max) {
       if (!Array.isArray(value)) return { values: [], truncated: false };
       const values = value.filter((item) => typeof item === "string" && item.trim().length > 0);
       return { values: values.slice(0, max), truncated: values.length > max };
@@ -40331,14 +40512,14 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
     function readWorkerArtifact(value) {
       const worker = readRecord4(value);
       if (!worker) return null;
-      const changed = readStringArray3(worker.changedFiles, MAX_CHANGED_FILES);
+      const changed = readStringArray4(worker.changedFiles, MAX_CHANGED_FILES);
       return {
         status: readString5(worker.status) ?? "unknown",
         ...readString5(worker.classification) ? { classification: readString5(worker.classification) } : {},
         changedFiles: changed.values,
         ...changed.truncated ? { changedFilesTruncated: true } : {},
         validationResults: Array.isArray(worker.validationResults) ? worker.validationResults.map((item) => readRecord4(item)).filter((item) => item !== null) : [],
-        errors: readStringArray3(worker.errors, 20).values,
+        errors: readStringArray4(worker.errors, 20).values,
         requiresUserAction: worker.requiresUserAction === true
       };
     }
@@ -43503,6 +43684,61 @@ ${rendered}`, "utf-8");
         );
       }
     });
+    var mesh_node_identity_exports = {};
+    __export2(mesh_node_identity_exports, {
+      MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS: () => MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS,
+      MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS: () => MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS,
+      MESH_DIRECT_PROBE_REUSE_MS: () => MESH_DIRECT_PROBE_REUSE_MS,
+      MESH_DIRECT_PROBE_TIMEOUT_MS: () => MESH_DIRECT_PROBE_TIMEOUT_MS,
+      MESH_NODE_LIVE_TRUTH_MARKER: () => MESH_NODE_LIVE_TRUTH_MARKER,
+      MeshGitProbeCache: () => MeshGitProbeCache,
+      applyCachedInlineMeshNodeStatus: () => applyCachedInlineMeshNodeStatus,
+      applyInlineMeshBranchConvergence: () => applyInlineMeshBranchConvergence,
+      awaitWithWarmupDeadline: () => awaitWithWarmupDeadline,
+      buildHistoricalMeshSessions: () => buildHistoricalMeshSessions,
+      buildInlineMeshTransitGitStatus: () => buildInlineMeshTransitGitStatus,
+      buildLivePeerGitConnection: () => buildLivePeerGitConnection,
+      buildMeshNodeDataFreshness: () => buildMeshNodeDataFreshness,
+      buildMeshNodeDisplayLabel: () => buildMeshNodeDisplayLabel,
+      buildMeshNodeMachineIdentity: () => buildMeshNodeMachineIdentity,
+      buildMeshNodeProbeFreshness: () => buildMeshNodeProbeFreshness,
+      collectLiveMeshSessionRecords: () => collectLiveMeshSessionRecords,
+      collectMeshNodeHostedSessionIds: () => collectMeshNodeHostedSessionIds,
+      deriveMeshNodeHealthFromGit: () => deriveMeshNodeHealthFromGit,
+      finalizeMeshNodeStatus: () => finalizeMeshNodeStatus,
+      foldMeshNodeIdentityToCanonical: () => foldMeshNodeIdentityToCanonical,
+      hydrateInlineMeshDirectTruth: () => hydrateInlineMeshDirectTruth,
+      inlineMeshCarriesTransientNodeTruth: () => inlineMeshCarriesTransientNodeTruth,
+      isDeadLocalWorktreeNode: () => isDeadLocalWorktreeNode,
+      isMeshNodeFreshEnoughToLaunch: () => isMeshNodeFreshEnoughToLaunch,
+      isMeshNodeHealthLaunchable: () => isMeshNodeHealthLaunchable,
+      logRepoMeshStatusDebug: () => logRepoMeshStatusDebug,
+      normalizeInlineMeshNodeIdentity: () => normalizeInlineMeshNodeIdentity,
+      normalizeProviderRoles: () => normalizeProviderRoles,
+      persistNodeReporterPlatform: () => persistNodeReporterPlatform,
+      probeRemoteMeshGitStatusWithRetry: () => probeRemoteMeshGitStatusWithRetry,
+      readBooleanValue: () => readBooleanValue,
+      readCachedInlineMeshActiveSessionDetails: () => readCachedInlineMeshActiveSessionDetails2,
+      readCachedInlineMeshActiveSessions: () => readCachedInlineMeshActiveSessions,
+      readInlineMeshNodeId: () => readInlineMeshNodeId,
+      readLiveMeshNodeWorkspace: () => readLiveMeshNodeWorkspace,
+      readMeshNodeDaemonId: () => readMeshNodeDaemonId,
+      readMeshNodeHostname: () => readMeshNodeHostname,
+      readMeshNodeMachineId: () => readMeshNodeMachineId,
+      readObjectRecord: () => readObjectRecord,
+      readProviderPriorityFromPolicy: () => readProviderPriorityFromPolicy,
+      readStringValue: () => readStringValue,
+      reconcileInlineMeshCache: () => reconcileInlineMeshCache,
+      recordInlineMeshDirectGitTruth: () => recordInlineMeshDirectGitTruth,
+      resolveEffectiveMeshNodeHealth: () => resolveEffectiveMeshNodeHealth,
+      resolveMeshNodeAttribution: () => resolveMeshNodeAttribution,
+      resolveProviderTypeFromPriority: () => resolveProviderTypeFromPriority,
+      sanitizeInlineMesh: () => sanitizeInlineMesh,
+      shouldRefreshStalePendingAggregate: () => shouldRefreshStalePendingAggregate,
+      summarizeInlineMeshBranchConvergence: () => summarizeInlineMeshBranchConvergence,
+      summarizeMeshSessionRecord: () => summarizeMeshSessionRecord,
+      summarizeRepoMeshStatusDebug: () => summarizeRepoMeshStatusDebug
+    });
     function readProviderPriorityFromPolicy(policy) {
       const record2 = policy && typeof policy === "object" && !Array.isArray(policy) ? policy : {};
       const raw = record2.providerPriority;
@@ -44066,6 +44302,23 @@ ${rendered}`, "utf-8");
       const health = resolveEffectiveMeshNodeHealth(node);
       return health === "online" || health === "unknown";
     }
+    function resolveEffectiveNodeGit(node) {
+      const git = readObjectRecord(node?.git);
+      if (Object.keys(git).length > 0) return git;
+      const cachedStatus = readObjectRecord(node?.cachedStatus);
+      return readObjectRecord(cachedStatus.git);
+    }
+    function isMeshNodeFreshEnoughToLaunch(node, opts) {
+      const git = resolveEffectiveNodeGit(node);
+      if (Object.keys(git).length === 0) return true;
+      if (readBooleanValue(git.isGitRepo) === false) return true;
+      const submoduleDrift = getGitSubmoduleDriftState(git);
+      if (submoduleDrift.outOfSync) return false;
+      const behind = readNumberValue(git.behind);
+      if (behind === void 0) return true;
+      const maxBehind = Number.isFinite(opts?.maxBehind) && opts?.maxBehind >= 0 ? Math.floor(opts.maxBehind) : 0;
+      return behind <= maxBehind;
+    }
     function readMeshNodeLabel(status, node) {
       return readStringValue(status.nodeId, normalizeMeshNodeId(node)) ?? "unknown";
     }
@@ -44970,6 +45223,7 @@ ${rendered}`, "utf-8");
       if (!session) return { staleReason: "direct task session is not present in live session records" };
       if (typeof session === "string") return {};
       const raw = `${readString6(session.status) || ""} ${readString6(session.lifecycle) || ""} ${readString6(session.state) || ""} ${readString6(session.activeChat?.status) || ""}`.toLowerCase();
+      if (raw.includes("waiting_choice") || raw.includes("choice")) return { status: "awaiting_choice" };
       if (raw.includes("approval")) return { status: "awaiting_approval" };
       if (raw.includes("generating") || raw.includes("running") || raw.includes("busy")) return { status: "generating" };
       if (raw.includes("failed") || raw.includes("stopped") || raw.includes("terminated") || raw.includes("exited")) return { status: "failed" };
@@ -44995,6 +45249,7 @@ ${rendered}`, "utf-8");
     }
     function statusFromTerminal(entry) {
       if (entry.kind === "task_approval_needed") return "awaiting_approval";
+      if (entry.kind === "task_question_pending") return "awaiting_choice";
       if (entry.kind === "task_completed") return "idle";
       return "failed";
     }
@@ -45073,7 +45328,8 @@ ${rendered}`, "utf-8");
         generating: 0,
         idle: 0,
         failed: 0,
-        awaiting_approval: 0
+        awaiting_approval: 0,
+        awaiting_choice: 0
       };
       const sourceCounts = { queue: 0, direct: 0 };
       for (const item of activeWork) {
@@ -45108,7 +45364,7 @@ ${rendered}`, "utf-8");
         const queueNodeId = task.assignedNodeId || task.targetNodeId;
         const queueSessionId = task.assignedSessionId || task.targetSessionId;
         const queueLive = task.status === "assigned" ? sessionStatusFromNodes(opts.nodes, queueNodeId ?? void 0, queueSessionId ?? void 0) : {};
-        const queueStatus = queueLive.status === "awaiting_approval" || queueLive.status === "generating" ? queueLive.status : task.status;
+        const queueStatus = queueLive.status === "awaiting_approval" || queueLive.status === "awaiting_choice" || queueLive.status === "generating" ? queueLive.status : task.status;
         records.push({
           taskId: task.id,
           source: "queue",
@@ -46104,6 +46360,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           "agent:generating_started",
           "agent:generating_completed",
           "agent:waiting_approval",
+          // A worker parked on an AskUserQuestion multi-choice prompt. DISTINCT from
+          // agent:waiting_approval (a yes/no tool-consent modal): a question is answered
+          // with mesh_answer_question, never mesh_approve (mission f1d25e11). Carries the
+          // full InteractivePrompt payload so the coordinator can render + answer.
+          "agent:waiting_choice",
           "agent:stopped",
           "agent:ready",
           "monitor:no_progress",
@@ -46121,6 +46382,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         EVENT_TO_LEDGER_KIND = {
           "agent:generating_completed": "task_completed",
           "agent:waiting_approval": "task_approval_needed",
+          "agent:waiting_choice": "task_question_pending",
           "agent:stopped": "task_failed",
           "monitor:no_progress": "task_stalled"
         };
@@ -46128,13 +46390,26 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           "agent:generating_completed",
           "agent:stopped",
           "agent:waiting_approval",
+          // A worker's question (waiting_choice) is real-time and the coordinator may be
+          // generating when it arrives; force-inject it like approval so the busy coordinator
+          // learns it must answer (mesh_answer_question) rather than the nudge sitting in the
+          // adapter's outbound queue until the coordinator idles on its own (mission f1d25e11).
+          "agent:waiting_choice",
           "refine:completed",
           "refine:failed",
           "worktree_bootstrap_complete",
           "worktree_bootstrap_failed"
         ]);
         MESH_APPROVAL_EVENTS = /* @__PURE__ */ new Set([
-          "agent:waiting_approval"
+          "agent:waiting_approval",
+          // agent:waiting_choice (a worker's AskUserQuestion) shares the approval class's
+          // real-time-nudge / level-backed contract: its authoritative state is recorded at
+          // LEVEL the moment it is processed (task_question_pending → mesh_status
+          // awaiting_choice), so the pending event is only a NUDGE and can be delivered to a
+          // busy coordinator's inbox (and dropped) without data loss — the level state
+          // re-derives it. It is therefore exempt from the idle-edge hold completions require,
+          // exactly like an approval nudge (mission f1d25e11).
+          "agent:waiting_choice"
         ]);
       }
     });
@@ -47117,6 +47392,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         }
       }
       if (!pending.length) return false;
+      const freshnessGate = { maxBehind: resolveAutoFastForwardPolicy(mesh).maxBehind };
       const maxParallelTasks = resolveMaxParallelTasks(mesh?.policy?.maxParallelTasks);
       const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks);
       for (const task of pending) {
@@ -47231,6 +47507,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_not_launch_ready", nodeId });
             continue;
           }
+          if (!isMeshNodeFreshEnoughToLaunch(node, freshnessGate)) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_stale_behind_upstream", nodeId });
+            continue;
+          }
           const launchTarget = resolveAutoLaunchTarget(components, node);
           if (launchTarget.mode === "skip") {
             markAutoLaunch(meshId, task.id, { status: "skipped", reason: launchTarget.reason || "auto_launch_unavailable", nodeId });
@@ -50964,10 +51244,19 @@ ${cleanBody}`;
       }
       function markSessionTerminal(sessionId, outcome, occurredAtMs, opts) {
         const eventTaskId = readNonEmptyString(args.metadataEvent.taskId) || void 0;
-        const task = updateSessionTaskStatus(args.meshId, sessionId, outcome, {
+        const completionDiagnostic = args.metadataEvent.completionDiagnostic && typeof args.metadataEvent.completionDiagnostic === "object" ? args.metadataEvent.completionDiagnostic : void 0;
+        const emittedAfterFinalizationTimeout = completionDiagnostic?.emittedAfterFinalizationTimeout === true;
+        const weakCompleted = outcome === "completed" && isWeakCompletionEvidence(args.metadataEvent) && !emittedAfterFinalizationTimeout;
+        const task = weakCompleted ? updateSessionTaskStatus(args.meshId, sessionId, "assigned", {
+          occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : void 0,
+          taskId: eventTaskId
+        }) : updateSessionTaskStatus(args.meshId, sessionId, outcome, {
           occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : void 0,
           taskId: eventTaskId
         });
+        if (weakCompleted && task) {
+          LOG2.info("MeshQueue", `Weak completion (${readNonEmptyString(args.metadataEvent.evidenceLevel) || "missing_final_assistant"}) kept queue task ${task.id} tentative (session ${sessionId}); reconcile owns the genuine terminal`);
+        }
         const leaveDirectDispatchActive = !task && opts?.tentativeIfDirect === true || !eventTaskId && !sessionHasActiveAssignment(args.meshId, sessionId);
         if (!leaveDirectDispatchActive) {
           updateDirectDispatchStatus(args.meshId, sessionId, outcome, eventTaskId);
@@ -51424,6 +51713,14 @@ ${cleanBody}`;
         retryOfJobId: readNonEmptyString(payload.retryOfJobId),
         ...relayModalMessage ? { modalMessage: relayModalMessage } : {},
         ...relayModalButtons && relayModalButtons.length > 0 ? { modalButtons: relayModalButtons } : {},
+        // agent:waiting_choice (mission f1d25e11): carry the FULL structured question
+        // payload across the machine boundary so a REMOTE worker's AskUserQuestion reaches
+        // the coordinator with every question + option intact — the coordinator renders
+        // these and answers with mesh_answer_question. The local in-process forward path
+        // preserves the whole event for free; this mirrors the fields for the remote relay.
+        ...payload.interactivePrompt && typeof payload.interactivePrompt === "object" && !Array.isArray(payload.interactivePrompt) ? { interactivePrompt: payload.interactivePrompt } : {},
+        ...readNonEmptyString(payload.promptId) ? { promptId: readNonEmptyString(payload.promptId) } : {},
+        ...payload.multiSelect === true ? { multiSelect: true } : {},
         ...payload.result && typeof payload.result === "object" && !Array.isArray(payload.result) ? { result: payload.result } : {},
         ...payload.completionDiagnostic && typeof payload.completionDiagnostic === "object" && !Array.isArray(payload.completionDiagnostic) ? { completionDiagnostic: payload.completionDiagnostic } : {},
         ...payload.workerResult && typeof payload.workerResult === "object" && !Array.isArray(payload.workerResult) ? { workerResult: payload.workerResult } : {},
@@ -52842,7 +53139,8 @@ ${cleanBody}`;
     function assignedRowLiveStatusIsAwaitingApproval(mesh, nodeId, sessionId) {
       if (!nodeId || !sessionId) return false;
       try {
-        return sessionStatusFromNodes(mesh.nodes, nodeId, sessionId).status === "awaiting_approval";
+        const liveStatus = sessionStatusFromNodes(mesh.nodes, nodeId, sessionId).status;
+        return liveStatus === "awaiting_approval" || liveStatus === "awaiting_choice";
       } catch {
         return false;
       }
@@ -55324,8 +55622,15 @@ ${cleanBody}`;
       if (pickApprovalButton(labels).index < 0) return false;
       return hasNegativeApprovalOption(labels);
     }
+    function isAskUserQuestionPickerSignature(text) {
+      if (!text) return false;
+      const hasSelectFooter = /Enter to select/i.test(text) && /Esc to cancel/i.test(text);
+      if (!hasSelectFooter) return false;
+      return /Type something\.?|Chat about this/i.test(text);
+    }
     function modalMatches(spec, input) {
       const text = input.screenText ?? "";
+      if (isAskUserQuestionPickerSignature(text)) return false;
       const question = compile2(spec.questionPattern, spec.questionFlags ?? "i");
       if (question.test(text)) return true;
       for (const variant of spec.questionVariants ?? []) {
@@ -55465,6 +55770,12 @@ ${cleanBody}`;
         throw new Error(`Invalid regex /${re}/${flags ?? ""}: ${e.message}`);
       }
     }
+    function isAskUserQuestionPickerSignature2(text) {
+      if (!text) return false;
+      const hasSelectFooter = /Enter to select/i.test(text) && /Esc to cancel/i.test(text);
+      if (!hasSelectFooter) return false;
+      return /Type something\.?|Chat about this/i.test(text);
+    }
     function findQuestionLineIndex(spec, lines) {
       const primary = compile3(spec.questionPattern, spec.questionFlags ?? "i");
       const buttonFlags = spec.buttonFlags && spec.buttonFlags.includes("m") ? spec.buttonFlags : `${spec.buttonFlags ?? ""}m`;
@@ -55589,6 +55900,7 @@ ${cleanBody}`;
       return function parseApproval(input) {
         const rawText = input.screenText ?? input.buffer ?? "";
         if (!rawText) return null;
+        if (isAskUserQuestionPickerSignature2(rawText)) return null;
         const text = visibleRegion ? applyVisibleRegion(visibleRegion, rawText) : rawText;
         const lines = text.split("\n");
         const question = findQuestionLineIndex(spec, lines);
@@ -60413,6 +60725,57 @@ ${lastSnapshot}`;
       }
       return { promptId, answers };
     }
+    function resolveInteractivePromptResponse(prompt, raw) {
+      if (!raw || typeof raw !== "object") throw new Error("Interactive prompt response must be an object");
+      const record2 = raw;
+      const promptId = readString(record2.promptId);
+      if (!promptId) throw new Error("promptId must be a non-empty string");
+      if (promptId !== prompt.promptId) throw new Error("Interactive prompt response does not match active prompt");
+      if (record2.answers && typeof record2.answers === "object" && !Array.isArray(record2.answers)) {
+        return normalizeInteractivePromptResponse2(record2);
+      }
+      if (!Array.isArray(record2.answers)) throw new Error("answers must be an array or a questionId-keyed object");
+      const resolveOneLabel = (question, sel) => {
+        if (typeof sel === "number" && Number.isFinite(sel)) {
+          const idx = Math.trunc(sel) - 1;
+          const option = question.options[idx];
+          if (!option) throw new Error(`Option index ${sel} out of range for ${question.questionId}`);
+          return option.label;
+        }
+        const label = readString(sel);
+        if (!label) throw new Error(`Empty selection for ${question.questionId}`);
+        const exact = question.options.find((o) => o.label === label);
+        if (exact) return exact.label;
+        const asIndex = Number(label);
+        if (Number.isInteger(asIndex)) {
+          const option = question.options[asIndex - 1];
+          if (option) return option.label;
+        }
+        throw new Error(`Unknown option for ${question.questionId}: ${label}`);
+      };
+      const answers = {};
+      const entries = record2.answers;
+      entries.forEach((entryRaw, index) => {
+        if (!entryRaw || typeof entryRaw !== "object" || Array.isArray(entryRaw)) return;
+        const entry = entryRaw;
+        const questionId = readString(entry.questionId);
+        const question = (questionId ? prompt.questions.find((q) => q.questionId === questionId) : void 0) ?? prompt.questions[index];
+        if (!question) throw new Error(`No matching question for answer entry ${index}`);
+        const freeformText = readString(entry.freeform) ?? readString(entry.freeformText);
+        const selectedLabels = [];
+        const select = entry.select;
+        if (Array.isArray(select)) {
+          for (const sel of select) selectedLabels.push(resolveOneLabel(question, sel));
+        } else if (select !== void 0 && select !== null) {
+          selectedLabels.push(resolveOneLabel(question, select));
+        }
+        answers[question.questionId] = {
+          selectedLabels,
+          ...freeformText ? { freeformText } : {}
+        };
+      });
+      return { promptId, answers };
+    }
     function buildClaudeInteractiveToolResult(response) {
       return JSON.stringify({
         type: "user",
@@ -78593,6 +78956,7 @@ ${body}
     var STATUS_HYDRATION_TAIL_LIMIT = 200;
     var COMPLETED_FINALIZATION_RETRY_MS = 1e3;
     var COMPLETED_FINALIZATION_MAX_WAIT_MS = 3e4;
+    var CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS = 2e4;
     var NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4e3;
     var PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS = 1200;
     var ANTIGRAVITY_HOLD_QUIET_DWELL_MS = 3e3;
@@ -79007,10 +79371,12 @@ ${body}
       // `waiting_choice` overlay in getState(); the raw adapter status stays idle/generating,
       // so detectStatusTransition()'s status-keyed arms never fire and no push-worthy
       // agent:* event is emitted — the owner misses the "ACTION REQUIRED" prompt when the
-      // app is backgrounded. We emit one agent:waiting_approval on ENTRY into the prompt
-      // state (reusing the existing server push path, no cloud change) and dedupe on this
-      // key so repeated status ticks with the same prompt do not re-fire. '' means no
-      // prompt is currently active (cleared when the prompt is answered/gone).
+      // app is backgrounded. We emit one agent:waiting_choice on ENTRY into the prompt
+      // state (its own coordinator event, NOT the approval channel — a multi-choice
+      // question is answered with mesh_answer_question, never mesh_approve) carrying the
+      // FULL InteractivePrompt payload, and dedupe on this key so repeated status ticks
+      // with the same prompt do not re-fire. '' means no prompt is currently active
+      // (cleared when the prompt is answered/gone).
       lastInteractivePromptEventKey = "";
       autoApproveBusy = false;
       autoApproveBusyTimer = null;
@@ -79655,7 +80021,7 @@ ${body}
           }
         } else if (event === "interactive_prompt_response" && data) {
           try {
-            const response = normalizeInteractivePromptResponse2(data);
+            const response = this.activeInteractivePrompt && this.activeInteractivePrompt.promptId === data?.promptId && Array.isArray(data?.answers) ? resolveInteractivePromptResponse(this.activeInteractivePrompt, data) : normalizeInteractivePromptResponse2(data);
             if (this.activeInteractivePrompt?.promptId === response.promptId) {
               this.activeInteractivePrompt = null;
             }
@@ -80194,7 +80560,12 @@ ${body}
             return {
               reason: "missing_final_assistant",
               terminal: this.provider.requiresFinalAssistantBeforeIdle === true,
-              allowTimeout: allowMissingAssistantTimeout
+              allowTimeout: allowMissingAssistantTimeout,
+              // PTY-parsed provider (codex-cli): no external transcript trails the idle
+              // transition, so the CANON-C decoupled emit must observe the min-elapsed floor
+              // rather than fire at the first-poll waitedMs. (claude-cli's external-native
+              // branch above is exempt — its transcript legitimately lands moments later.)
+              noExternalTranscriptSource: true
             };
           }
         }
@@ -80692,6 +81063,24 @@ ${body}
             this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
             return;
           }
+          if (isTranscriptEvidenceGate && blockReason === "missing_final_assistant" && block2.noExternalTranscriptSource === true && waitedMs < CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS) {
+            if (pending.loggedBlockReason !== "canon_c_min_elapsed_floor") {
+              LOG2.info("CLI", `[${this.type}] holding CANON-C decoupled emit until min-elapsed floor (waitedMs=${waitedMs} floor=${CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS}); no final assistant yet (${blockReason})`);
+              if (this.isMeshWorkerSession()) {
+                traceMeshEventDrop("completion_gate_hold", this.meshTraceCtx(), `canon_c_min_elapsed_floor waited=${waitedMs}ms`);
+              }
+              if (this.completionTraceOn()) this.recordCompletionGateTrace("hold", {
+                blockReason,
+                latestVisibleStatus,
+                terminal: block2.terminal === true,
+                canonCMinElapsedFloor: true,
+                waitedMs
+              });
+              pending.loggedBlockReason = "canon_c_min_elapsed_floor";
+            }
+            this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
+            return;
+          }
           if (this.type === "antigravity-cli" && block2.holdForTranscript === true && waitedMs < ANTIGRAVITY_HOLD_HARD_CAP_MS && this.antigravityHoldPtyStillActive()) {
             if (pending.loggedBlockReason !== "antigravity_hold_pty_active") {
               LOG2.info("CLI", `[${this.type}] 30s cap reached but PTY still generating; holding antigravity completion past cap (waitedMs=${waitedMs} hardCap=${ANTIGRAVITY_HOLD_HARD_CAP_MS}) (${blockReason})`);
@@ -81391,9 +81780,16 @@ ${buttons.join("\n")}`;
             const modalMessage = firstQuestion ? firstQuestion.header ? `${firstQuestion.header}: ${firstQuestion.question}` : firstQuestion.question : void 0;
             const modalButtons = firstQuestion?.options?.map((option) => option.label);
             this.pushEvent({
-              event: "agent:waiting_approval",
+              event: "agent:waiting_choice",
               chatTitle,
               timestamp: now,
+              // Structured, authoritative payload — the coordinator renders these and
+              // answers via mesh_answer_question. Carried whole (all questions, all
+              // options) so multi-question / multi-select prompts round-trip fully.
+              interactivePrompt,
+              promptId: interactivePrompt.promptId,
+              multiSelect: firstQuestion?.multiSelect === true,
+              // Push-notification-friendly projection (server push path reads these).
               modalMessage,
               modalButtons
             });
@@ -90261,6 +90657,50 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       }
     };
+    init_logger();
+    async function stopCancelledTaskWorker(ctx, meshId, prior) {
+      const { sessionId, nodeId, providerType } = prior;
+      const stopArgs = {
+        targetSessionId: sessionId,
+        ...providerType ? { cliType: providerType } : {},
+        mode: "hard",
+        reason: "mesh_task_cancelled"
+      };
+      try {
+        const cliManager = ctx.deps.cliManager;
+        const isLocal = cliManager?.adapters?.has?.(sessionId) === true;
+        if (isLocal) {
+          if (!stopArgs.cliType) {
+            const localType = cliManager?.adapters?.get?.(sessionId)?.cliType;
+            if (localType) stopArgs.cliType = localType;
+          }
+          await Promise.resolve(cliManager?.handleCliCommand?.("stop_cli", stopArgs)).catch((e) => LOG2.warn("MeshQueue", `Local stop of cancelled worker ${sessionId} failed: ${e?.message || e}`));
+          return;
+        }
+        const dispatch = ctx.deps.dispatchMeshCommand;
+        let daemonId;
+        if (nodeId) {
+          try {
+            const [{ getMesh: getMesh2 }, { meshNodeIdMatches: meshNodeIdMatches2 }, { readMeshNodeDaemonId: readMeshNodeDaemonId2 }] = await Promise.all([
+              Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)),
+              Promise.resolve().then(() => (init_dist(), dist_exports)),
+              Promise.resolve().then(() => (init_mesh_node_identity(), mesh_node_identity_exports))
+            ]);
+            const mesh = getMesh2(meshId);
+            const node = mesh?.nodes?.find((n) => meshNodeIdMatches2(n, nodeId));
+            daemonId = node ? readMeshNodeDaemonId2(node) || void 0 : void 0;
+          } catch {
+          }
+        }
+        if (daemonId && dispatch) {
+          await Promise.resolve(dispatch(daemonId, "stop_cli", stopArgs)).catch((e) => LOG2.warn("MeshQueue", `Remote stop of cancelled worker ${sessionId} on daemon ${daemonId} failed: ${e?.message || e}`));
+        } else {
+          LOG2.warn("MeshQueue", `Cannot stop cancelled worker ${sessionId}: no local adapter and no resolvable remote daemon id (node ${nodeId ?? "?"}). Row is already terminal; if the worker completes it strand-fails harmlessly.`);
+        }
+      } catch (e) {
+        LOG2.warn("MeshQueue", `stopCancelledTaskWorker error for ${sessionId}: ${e?.message || e}`);
+      }
+    }
     var meshQueueHandlers = {
       get_mesh_queue: async (_ctx, args) => {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
@@ -90294,10 +90734,14 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue cancellation");
         if (ownerFailure) return ownerFailure;
         try {
-          const { cancelTask: cancelTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
+          const { cancelTask: cancelTask2, takeCancelledTaskAssignment: takeCancelledTaskAssignment2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
           const reason = typeof args?.reason === "string" ? args.reason : void 0;
           const task = cancelTask2(meshId, taskId, { reason });
           if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
+          const prior = takeCancelledTaskAssignment2(meshId, taskId);
+          if (prior?.sessionId) {
+            void stopCancelledTaskWorker(ctx, meshId, prior);
+          }
           return { success: true, task };
         } catch (e) {
           return { success: false, error: e.message };
@@ -90764,10 +91208,12 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       interactive_prompt_response: async (ctx, args) => {
         const sessionId = typeof args?.targetSessionId === "string" && args.targetSessionId.trim() ? args.targetSessionId.trim() : typeof args?.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : "";
         if (!sessionId) return { success: false, error: "targetSessionId required" };
-        const response = normalizeInteractivePromptResponse2(args?.response ?? args);
+        const rawResponse = args?.response ?? args;
         const instance = ctx.deps.instanceManager.getInstance(sessionId);
         if (!instance) return { success: false, error: `No running instance for session ${sessionId}` };
-        ctx.deps.instanceManager.sendEvent(sessionId, "interactive_prompt_response", response);
+        const isFriendlyArrayForm = rawResponse && typeof rawResponse === "object" && Array.isArray(rawResponse.answers);
+        const payload = isFriendlyArrayForm ? rawResponse : normalizeInteractivePromptResponse2(rawResponse);
+        ctx.deps.instanceManager.sendEvent(sessionId, "interactive_prompt_response", payload);
         return { success: true };
       }
     };
@@ -92808,6 +93254,171 @@ ${mergeTreeErr?.stderr || ""}`;
         return isSubmoduleFastForward((0, import_path15.resolve)(repoRoot, path46), baseCommit, branchCommit);
       });
     }
+    function isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit) {
+      if (!baseCommit || !branchCommit || baseCommit === branchCommit) return false;
+      try {
+        if (!fs34.existsSync(submoduleRepoPath)) return false;
+        (0, import_node_child_process6.execFileSync)(GIT2, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process6.execFileSync)(GIT2, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+      } catch {
+        return false;
+      }
+      try {
+        (0, import_node_child_process6.execFileSync)(GIT2, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return false;
+      } catch {
+      }
+      try {
+        (0, import_node_child_process6.execFileSync)(GIT2, ["merge-base", "--is-ancestor", branchCommit, baseCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return false;
+      } catch {
+      }
+      try {
+        const mb = (0, import_node_child_process6.execFileSync)(GIT2, ["merge-base", baseCommit, branchCommit], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        return !!mb;
+      } catch {
+        return false;
+      }
+    }
+    function ensureSubmoduleCommitLocal(submoduleRepoPath, baseSubmoduleRepoPath, commit) {
+      if (!commit) return;
+      try {
+        (0, import_node_child_process6.execFileSync)(GIT2, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return;
+      } catch {
+      }
+      try {
+        if (!fs34.existsSync(submoduleRepoPath) || !fs34.existsSync(baseSubmoduleRepoPath)) return;
+        (0, import_node_child_process6.execFileSync)(GIT2, ["-c", "protocol.file.allow=always", "fetch", "-q", baseSubmoduleRepoPath, "+refs/heads/*:refs/adhdev-refine-base/*"], {
+          cwd: submoduleRepoPath,
+          stdio: ["ignore", "ignore", "pipe"]
+        });
+      } catch {
+      }
+    }
+    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
+      const changed = readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead);
+      if (changed.length === 0) {
+        return { converged: false, reason: "no_changed_gitlinks", resolutions: [], gitlinks: [] };
+      }
+      const gitlinks = [];
+      const resolutions = [];
+      let sawDiverged = false;
+      for (const path46 of changed) {
+        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path46);
+        const branchCommit = readTreeObject(worktreeRoot, branchHead, path46);
+        const submoduleRepoPath = (0, import_path15.resolve)(worktreeRoot, path46);
+        if (baseCommit) {
+          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path15.resolve)(baseRepoRoot, path46), baseCommit);
+        }
+        if (!baseCommit || !branchCommit || !isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit)) {
+          gitlinks.push({ path: path46, baseCommit, branchCommit, action: "skipped_not_diverged" });
+          continue;
+        }
+        sawDiverged = true;
+        let rebasedCommit;
+        try {
+          (0, import_node_child_process6.execFileSync)(GIT2, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+          (0, import_node_child_process6.execFileSync)(GIT2, ["rebase", baseCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+          rebasedCommit = (0, import_node_child_process6.execFileSync)(GIT2, ["rev-parse", "HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        } catch {
+          try {
+            (0, import_node_child_process6.execFileSync)(GIT2, ["rebase", "--abort"], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          try {
+            (0, import_node_child_process6.execFileSync)(GIT2, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          gitlinks.push({ path: path46, baseCommit, branchCommit, action: "rebase_conflict" });
+          return { converged: false, reason: "rebase_conflict", resolutions: [], gitlinks };
+        }
+        gitlinks.push({ path: path46, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
+        resolutions.push({ path: path46, baseCommit, branchCommit, rebasedCommit });
+      }
+      if (!sawDiverged) {
+        return { converged: false, reason: "not_diverged", resolutions: [], gitlinks };
+      }
+      return { converged: resolutions.length > 0, resolutions, gitlinks };
+    }
+    function rootRebaseResolvingGitlinks(worktreeRoot, baseHead, resolutions) {
+      const resolveByPath = new Map(resolutions.map((r) => [r.path, r.rebasedCommit]));
+      const runRebase = (args) => {
+        try {
+          (0, import_node_child_process6.execFileSync)(GIT2, args, {
+            cwd: worktreeRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            // A rebase editor prompt would hang; keep it non-interactive.
+            env: { ...process.env, GIT_EDITOR: "true", GIT_SEQUENCE_EDITOR: "true" }
+          });
+          return { ok: true };
+        } catch {
+          return { ok: false };
+        }
+      };
+      const unmergedPaths = () => {
+        try {
+          return (0, import_node_child_process6.execFileSync)(GIT2, ["diff", "--name-only", "--diff-filter=U"], { cwd: worktreeRoot, encoding: "utf8" }).split("\n").map((s2) => s2.trim()).filter(Boolean);
+        } catch {
+          return [];
+        }
+      };
+      const abort = (reason, conflictPaths) => {
+        try {
+          (0, import_node_child_process6.execFileSync)(GIT2, ["rebase", "--abort"], { cwd: worktreeRoot, stdio: "ignore" });
+        } catch {
+        }
+        return { ok: false, reason, conflictPaths };
+      };
+      let progress = runRebase(["rebase", baseHead]);
+      let guard = 0;
+      while (!progress.ok) {
+        if (guard++ > 100) return abort("rebase_error");
+        const conflicts = unmergedPaths();
+        if (conflicts.length === 0) {
+          return abort("rebase_error");
+        }
+        const unresolvable = conflicts.filter((p) => !resolveByPath.has(p));
+        if (unresolvable.length > 0) {
+          const unresolvableGitlink = unresolvable.some((p) => {
+            try {
+              const staged = (0, import_node_child_process6.execFileSync)(GIT2, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
+              return /^160000\s/m.test(staged);
+            } catch {
+              return false;
+            }
+          });
+          const allGitlink = unresolvable.every((p) => {
+            try {
+              const staged = (0, import_node_child_process6.execFileSync)(GIT2, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
+              return /^160000\s/m.test(staged);
+            } catch {
+              return false;
+            }
+          });
+          return abort(allGitlink && unresolvableGitlink ? "unexpected_gitlink" : "non_gitlink_conflict", conflicts);
+        }
+        for (const p of conflicts) {
+          const commit = resolveByPath.get(p);
+          try {
+            (0, import_node_child_process6.execFileSync)(GIT2, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path15.resolve)(worktreeRoot, p), stdio: "ignore" });
+          } catch {
+          }
+          try {
+            (0, import_node_child_process6.execFileSync)(GIT2, ["add", p], { cwd: worktreeRoot, stdio: "ignore" });
+          } catch {
+            return abort("rebase_error", conflicts);
+          }
+        }
+        progress = runRebase(["rebase", "--continue"]);
+      }
+      let branchHead;
+      try {
+        branchHead = (0, import_node_child_process6.execFileSync)(GIT2, ["rev-parse", "HEAD"], { cwd: worktreeRoot, encoding: "utf8" }).trim();
+      } catch {
+      }
+      return { ok: true, branchHead };
+    }
     function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
       const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path46) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path46);
@@ -93837,6 +94448,7 @@ ${mergeTreeErr?.stderr || ""}`;
     async function refineSyncBaseStage(self, ctx) {
       const { repoRoot, baseHead, node, branch, baseBranch, refineStages, execFileAsync: execFileAsync4 } = ctx;
       let branchHead = ctx.branchHead;
+      let gitlinkResolutions = [];
       const syncStarted = Date.now();
       const divergence = await computeBranchBaseDivergence(execFileAsync4, node.workspace, baseHead, branchHead);
       if (divergence.behind === 0) {
@@ -93852,24 +94464,61 @@ ${mergeTreeErr?.stderr || ""}`;
         const preRebasePe = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
         const alreadyMerged = !preRebasePe.actualPatchId && !!preRebasePe.expectedPatchId;
         const submoduleConflict = preRebasePe.actionableHint?.kind === "submodule_conflict";
-        if (alreadyMerged || submoduleConflict) {
+        if (alreadyMerged) {
           recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
             ahead: divergence.ahead,
             behind: divergence.behind,
             rebased: false,
-            reason: alreadyMerged ? "already_merged_via_other_path_skip_rebase" : "submodule_conflict_defer_to_patch_equivalence"
+            reason: "already_merged_via_other_path_skip_rebase"
           });
           return { kind: "continue", ctx };
         }
+        if (submoduleConflict) {
+          const converge = convergeDivergedSubmoduleGitlinks(node.workspace, repoRoot, baseHead, branchHead);
+          if (converge.converged) {
+            gitlinkResolutions = converge.resolutions;
+            recordMeshRefineStage(refineStages, "submodule_gitlink_converge", "passed", syncStarted, {
+              reason: "submodule_diverged_auto_rebased",
+              gitlinks: converge.gitlinks
+            });
+            LOG2.info("Mesh", `[Refinery] Auto-converged diverged submodule gitlink(s) onto base for node ${node.id}: ` + converge.resolutions.map((r) => `${r.path}\u2192${r.rebasedCommit.slice(0, 12)}`).join(", "));
+          } else {
+            recordMeshRefineStage(refineStages, "submodule_gitlink_converge", "skipped", syncStarted, {
+              reason: "submodule_conflict_defer_to_patch_equivalence",
+              convergeReason: converge.reason,
+              gitlinks: converge.gitlinks
+            });
+            recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
+              ahead: divergence.ahead,
+              behind: divergence.behind,
+              rebased: false,
+              reason: "submodule_conflict_defer_to_patch_equivalence"
+            });
+            return { kind: "continue", ctx };
+          }
+        }
       } catch {
       }
       const rebaseStarted = Date.now();
       try {
-        (0, import_node_child_process7.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
+        if (gitlinkResolutions.length > 0) {
+          const gitlinkRebase = rootRebaseResolvingGitlinks(node.workspace, baseHead, gitlinkResolutions);
+          if (!gitlinkRebase.ok) {
+            const err = new Error(`gitlink-aware rebase aborted: ${gitlinkRebase.reason || "unknown"}`);
+            err.gitlinkRebaseReason = gitlinkRebase.reason;
+            err.gitlinkRebaseConflicts = gitlinkRebase.conflictPaths;
+            err.alreadyAborted = true;
+            throw err;
+          }
+        } else {
+          (0, import_node_child_process7.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
+        }
       } catch (rebaseErr) {
-        try {
-          (0, import_node_child_process7.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
-        } catch {
+        if (!rebaseErr?.alreadyAborted) {
+          try {
+            (0, import_node_child_process7.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
+          } catch {
+          }
         }
         let submoduleHintPatchEquivalence;
         try {
@@ -96176,7 +96825,15 @@ ${e?.stderr || ""}`;
       // returns 'Session not found' (same class as mission 6938892f). Unlike read_terminal this
       // MUTATES the worker PTY, so forwarding to the real owner (not a wrong local session) is
       // doubly important. The daemon re-enforces the destructive-key confirm gate after the forward.
-      "send_keys"
+      "send_keys",
+      // interactive_prompt_response (mesh_answer_question, mission f1d25e11): the coordinator
+      // answers a REMOTE worker's AskUserQuestion (waiting_choice). The answer must reach the
+      // OWNING worker session's live instance — its activeInteractivePrompt (the authoritative
+      // prompt the labels/indexes resolve against) and its adapter.setInteractivePromptResponse
+      // live only there. Without forwarding, the coordinator's local high-family handler returns
+      // 'No running instance for session …' and the question is never answered — the exact
+      // remote-worker forwarding gap of mission 6938892f, now closed for questions too.
+      "interactive_prompt_response"
     ]);
     function normalizeCommandSource(source) {
       switch (source) {