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

package/dist/index.mjs

@@ -437,10 +437,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "36bb91235b40db3d3fb1587850f0a213d040bcef" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "36bb9123" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:15.085Z" : 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 version = 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:18:44.739Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2629,6 +2629,51 @@ var init_hash = __esm({
 });
 
 // ../mesh-shared/dist/index.mjs
+var dist_exports = {};
+__export(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 : {};
 }
@@ -2652,6 +2697,21 @@ function readBoolean(...values) {
   }
   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() : "";
@@ -2792,12 +2852,48 @@ function pickBestTransitGitStatus(node, options) {
   }
   return best?.git;
 }
+function deriveSyntheticSessionId(record) {
+  const parts = [
+    readString2(record.workspace),
+    readString2(record.providerType, record.provider),
+    readString2(record.role),
+    readString2(record.state, record.status),
+    readString2(record.title),
+    readString2(record.createdAt, record.created_at),
+    readString2(record.startedAt, record.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 record = readRecord(entry);
+  const sessionId = readString2(record.sessionId, record.session_id, record.id) ?? deriveSyntheticSessionId(record);
+  if (!sessionId) return null;
+  return {
+    sessionId,
+    ...readString2(record.providerType, record.provider) ? { providerType: readString2(record.providerType, record.provider) } : {},
+    ...readString2(record.state, record.status) ? { state: readString2(record.state, record.status) } : {},
+    ...readString2(record.chatStatus, record.chat_status) ? { chatStatus: readString2(record.chatStatus, record.chat_status) } : {},
+    ...readString2(record.lifecycle) ? { lifecycle: readString2(record.lifecycle) } : {},
+    ...readString2(record.surfaceKind, record.surface_kind) ? { surfaceKind: readString2(record.surfaceKind, record.surface_kind) } : {},
+    ...readString2(record.recoveryState, record.recovery_state) ? { recoveryState: readString2(record.recoveryState, record.recovery_state) } : {},
+    ...readString2(record.workspace) ? { workspace: readString2(record.workspace) } : {},
+    ...readString2(record.title) ? { title: readString2(record.title) } : {},
+    ...readString2(record.role) ? { role: readString2(record.role) } : {},
+    ...readBoolean(record.isSelfCoordinator, record.is_self_coordinator) !== void 0 ? { isSelfCoordinator: readBoolean(record.isSelfCoordinator, record.is_self_coordinator) } : {},
+    ...readString2(record.statusNote, record.status_note) ? { statusNote: readString2(record.statusNote, record.status_note) } : {},
+    ...readString2(record.createdAt, record.created_at) ? { createdAt: readString2(record.createdAt, record.created_at) } : {},
+    ...readString2(record.startedAt, record.started_at) ? { startedAt: readString2(record.startedAt, record.started_at) } : {},
+    ...readString2(record.lastActivityAt, record.last_activity_at) ? { lastActivityAt: readString2(record.lastActivityAt, record.last_activity_at) } : {},
+    ...readBoolean(record.isCached, record.is_cached) !== void 0 ? { isCached: readBoolean(record.isCached, record.is_cached) } : {}
+  };
+}
 function normalizeMeshNodeId(node) {
   const record = node && typeof node === "object" ? node : {};
   return readString2(record.id, record.nodeId, record.node_id);
@@ -2980,9 +3076,30 @@ function deriveSlotsFromLegacy(input) {
     };
   });
 }
+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, MAGI_RAW_ANSWER_CAP, MESH_TASK_DIFFICULTIES, DEFAULT_DIFFICULTY_BRAINS, CANONICAL_MESH_TOOL_NAMES, CANONICAL_MESH_TOOL_COUNT, STATUS_PROBE_ARG_KEY;
 var init_dist = __esm({
   "../mesh-shared/dist/index.mjs"() {
@@ -3014,6 +3131,7 @@ var init_dist = __esm({
       "mesh_restart_daemon",
       "mesh_checkpoint",
       "mesh_approve",
+      "mesh_answer_question",
       "mesh_list_pending_approvals",
       "mesh_clone_node",
       "mesh_remove_node",
@@ -4451,6 +4569,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 record = opt && typeof opt === "object" ? opt : {};
+          const label = readNonEmptyString(record.label);
+          if (!label) return;
+          const description = readNonEmptyString(record.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) {
@@ -5952,6 +6106,7 @@ __export(mesh_work_queue_exports, {
   requeueTask: () => requeueTask,
   resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
   resolveNotBefore: () => resolveNotBefore,
+  takeCancelledTaskAssignment: () => takeCancelledTaskAssignment,
   taskDependenciesSatisfied: () => taskDependenciesSatisfied,
   updateDirectDispatchStatus: () => updateDirectDispatchStatus,
   updateSessionTaskStatus: () => updateSessionTaskStatus,
@@ -6512,6 +6667,10 @@ function updateTaskStatus(meshId, taskId, status, opts) {
   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)) {
+      LOG.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);
@@ -6537,17 +6696,34 @@ function cancelTask(meshId, taskId, opts) {
     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, () => {
@@ -6762,7 +6938,7 @@ function recordMeshToolCall(opts) {
     return { rateLimitExceeded: false, callsInWindow: 0, advisory: null };
   }
 }
-var ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, MESH_TASK_PRIORITIES, NOT_BEFORE_RELATIVE_THRESHOLD_MS, LIVE_DEBUG_READONLY_FORBIDDEN, NEGATION_CUES, NEGATION_WINDOW_TOKENS, GIT_MUTATION_SUBCOMMANDS, GIT_STASH_READONLY_SUBCOMMANDS, DEPENDENCY_FAILURE_TERMINALS, MAX_STRANDED_RECLAIMS, REDRIVE_RECLAIM_REASONS, REDRIVE_SUPERSEDE_WINDOW_MS;
+var ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, MESH_TASK_PRIORITIES, NOT_BEFORE_RELATIVE_THRESHOLD_MS, LIVE_DEBUG_READONLY_FORBIDDEN, NEGATION_CUES, NEGATION_WINDOW_TOKENS, GIT_MUTATION_SUBCOMMANDS, GIT_STASH_READONLY_SUBCOMMANDS, DEPENDENCY_FAILURE_TERMINALS, TERMINAL_TASK_STATUSES, lastCancelledTaskAssignment, MAX_STRANDED_RECLAIMS, REDRIVE_RECLAIM_REASONS, REDRIVE_SUPERSEDE_WINDOW_MS;
 var init_mesh_work_queue = __esm({
   "src/mesh/mesh-work-queue.ts"() {
     "use strict";
@@ -6829,6 +7005,8 @@ var init_mesh_work_queue = __esm({
     ]);
     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",
@@ -8929,7 +9107,7 @@ function compactLedger(meshId) {
 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);
 }
@@ -8989,11 +9167,11 @@ function normalizeMeshWorkerResult(input, source = "explicit_metadata") {
   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
@@ -10138,7 +10316,8 @@ var init_coordinator_prompt = __esm({
 | \`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 |
@@ -10376,7 +10555,7 @@ function readString5(value) {
 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 };
@@ -10406,14 +10585,14 @@ function isMergeCandidate(convergence) {
 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
   };
 }
@@ -13551,6 +13730,61 @@ var init_runtime_defaults = __esm({
 });
 
 // src/mesh/mesh-node-identity.ts
+var mesh_node_identity_exports = {};
+__export(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: () => readCachedInlineMeshActiveSessionDetails,
+  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
+});
 import * as fs5 from "fs";
 function readProviderPriorityFromPolicy(policy) {
   const record = policy && typeof policy === "object" && !Array.isArray(policy) ? policy : {};
@@ -14115,6 +14349,23 @@ function isMeshNodeHealthLaunchable(node) {
   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";
 }
@@ -15010,6 +15261,7 @@ function sessionStatusFromNodes(nodes, nodeId, sessionId) {
   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" };
@@ -15035,6 +15287,7 @@ function terminalMatchesDispatch(terminal, dispatch, taskId) {
 }
 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";
 }
@@ -15113,7 +15366,8 @@ function buildMeshActiveWorkSummary(activeWork) {
     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) {
@@ -15148,7 +15402,7 @@ function buildMeshActiveWork(opts) {
     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",
@@ -16144,6 +16398,11 @@ var init_mesh_event_classify = __esm({
       "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",
@@ -16161,6 +16420,7 @@ var init_mesh_event_classify = __esm({
     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"
     };
@@ -16168,13 +16428,26 @@ var init_mesh_event_classify = __esm({
       "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"
     ]);
   }
 });
@@ -17164,6 +17437,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
     }
   }
   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) {
@@ -17278,6 +17552,10 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
         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 });
@@ -20978,10 +21256,19 @@ function injectMeshSystemMessage(components, args) {
   }
   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) {
+      LOG.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);
@@ -21438,6 +21725,14 @@ function buildRelayMetadataEvent(payload) {
     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 } : {},
@@ -22863,7 +23158,8 @@ function drainAndDeliverApprovalNudges(meshId, drainDaemonIds, localDaemonId, me
 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;
   }
@@ -25343,8 +25639,15 @@ function buttonBlockApprovalCue(spec, text) {
   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 ?? []) {
@@ -25486,6 +25789,12 @@ function compile3(re, flags) {
     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`;
@@ -25610,6 +25919,7 @@ function buildParseApprovalFromTui(spec, visibleRegion) {
   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);
@@ -29984,6 +30294,57 @@ function normalizeInteractivePromptResponse(raw) {
   }
   return { promptId, answers };
 }
+function resolveInteractivePromptResponse(prompt, raw) {
+  if (!raw || typeof raw !== "object") throw new Error("Interactive prompt response must be an object");
+  const record = raw;
+  const promptId = readString(record.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 (record.answers && typeof record.answers === "object" && !Array.isArray(record.answers)) {
+    return normalizeInteractivePromptResponse(record);
+  }
+  if (!Array.isArray(record.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 = record.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",
@@ -48376,6 +48737,7 @@ async function waitForCliAdapterReady(adapter, options) {
 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;
@@ -48796,10 +49158,12 @@ var CliProviderInstance = class _CliProviderInstance {
   // `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;
@@ -49444,7 +49808,7 @@ var CliProviderInstance = class _CliProviderInstance {
       }
     } else if (event === "interactive_prompt_response" && data) {
       try {
-        const response = normalizeInteractivePromptResponse(data);
+        const response = this.activeInteractivePrompt && this.activeInteractivePrompt.promptId === data?.promptId && Array.isArray(data?.answers) ? resolveInteractivePromptResponse(this.activeInteractivePrompt, data) : normalizeInteractivePromptResponse(data);
         if (this.activeInteractivePrompt?.promptId === response.promptId) {
           this.activeInteractivePrompt = null;
         }
@@ -49983,7 +50347,12 @@ var CliProviderInstance = class _CliProviderInstance {
         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
         };
       }
     }
@@ -50481,6 +50850,24 @@ var CliProviderInstance = class _CliProviderInstance {
         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") {
+          LOG.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") {
           LOG.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})`);
@@ -51180,9 +51567,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
         });
@@ -60099,6 +60493,50 @@ var meshHostPairingHandlers = {
 };
 
 // src/commands/med-family/mesh-queue.ts
+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) => LOG.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) => LOG.warn("MeshQueue", `Remote stop of cancelled worker ${sessionId} on daemon ${daemonId} failed: ${e?.message || e}`));
+    } else {
+      LOG.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) {
+    LOG.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() : "";
@@ -60132,10 +60570,14 @@ var meshQueueHandlers = {
     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 };
@@ -60614,10 +61056,12 @@ var meshEventsHandlers = {
   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 = normalizeInteractivePromptResponse(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 : normalizeInteractivePromptResponse(rawResponse);
+    ctx.deps.instanceManager.sendEvent(sessionId, "interactive_prompt_response", payload);
     return { success: true };
   }
 };
@@ -62682,6 +63126,171 @@ function collectFastForwardGitlinkPaths(repoRoot, baseHead, branchHead) {
     return isSubmoduleFastForward(pathResolve2(repoRoot, path46), baseCommit, branchCommit);
   });
 }
+function isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit) {
+  if (!baseCommit || !branchCommit || baseCommit === branchCommit) return false;
+  try {
+    if (!fs34.existsSync(submoduleRepoPath)) return false;
+    execFileSync9(GIT2, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+    execFileSync9(GIT2, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+  } catch {
+    return false;
+  }
+  try {
+    execFileSync9(GIT2, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+    return false;
+  } catch {
+  }
+  try {
+    execFileSync9(GIT2, ["merge-base", "--is-ancestor", branchCommit, baseCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+    return false;
+  } catch {
+  }
+  try {
+    const mb = execFileSync9(GIT2, ["merge-base", baseCommit, branchCommit], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+    return !!mb;
+  } catch {
+    return false;
+  }
+}
+function ensureSubmoduleCommitLocal(submoduleRepoPath, baseSubmoduleRepoPath, commit) {
+  if (!commit) return;
+  try {
+    execFileSync9(GIT2, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+    return;
+  } catch {
+  }
+  try {
+    if (!fs34.existsSync(submoduleRepoPath) || !fs34.existsSync(baseSubmoduleRepoPath)) return;
+    execFileSync9(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 = pathResolve2(worktreeRoot, path46);
+    if (baseCommit) {
+      ensureSubmoduleCommitLocal(submoduleRepoPath, pathResolve2(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 {
+      execFileSync9(GIT2, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+      execFileSync9(GIT2, ["rebase", baseCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+      rebasedCommit = execFileSync9(GIT2, ["rev-parse", "HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+    } catch {
+      try {
+        execFileSync9(GIT2, ["rebase", "--abort"], { cwd: submoduleRepoPath, stdio: "ignore" });
+      } catch {
+      }
+      try {
+        execFileSync9(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 {
+      execFileSync9(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 execFileSync9(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 {
+      execFileSync9(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 = execFileSync9(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 = execFileSync9(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 {
+        execFileSync9(GIT2, ["checkout", "-q", "--detach", commit], { cwd: pathResolve2(worktreeRoot, p), stdio: "ignore" });
+      } catch {
+      }
+      try {
+        execFileSync9(GIT2, ["add", p], { cwd: worktreeRoot, stdio: "ignore" });
+      } catch {
+        return abort("rebase_error", conflicts);
+      }
+    }
+    progress = runRebase(["rebase", "--continue"]);
+  }
+  let branchHead;
+  try {
+    branchHead = execFileSync9(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);
@@ -63713,6 +64322,7 @@ async function computeBranchBaseDivergence(execFileAsync4, cwd, baseHead, branch
 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) {
@@ -63728,24 +64338,61 @@ async function refineSyncBaseStage(self, ctx) {
     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
+        });
+        LOG.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 {
-    execFileSync10("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 {
+      execFileSync10("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
+    }
   } catch (rebaseErr) {
-    try {
-      execFileSync10("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
-    } catch {
+    if (!rebaseErr?.alreadyAborted) {
+      try {
+        execFileSync10("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
+      } catch {
+      }
     }
     let submoduleHintPatchEquivalence;
     try {
@@ -66064,7 +66711,15 @@ var MESH_FORWARDABLE_SESSION_COMMANDS = /* @__PURE__ */ new Set([
   // 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) {