@adhdev/daemon-standalone 1.0.58-rc.33 → 1.0.58-rc.34

package/dist/index.js

@@ -36911,10 +36911,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "f2c2218bbcbabe7c7d59bf055c0a3acce18cce18" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "f2c2218b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.33" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-28T11:56:21.824Z" : void 0);
+      const commit = readInjected(true ? "c56a70dfe6a9124c996b31104841e9838acb3a7e" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "c56a70df" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.34" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-28T18:02:34.248Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -47477,17 +47477,17 @@ Next step: ${nextStep}`;
       }
       return { delivered, failed, rescheduled };
     }
-    function enqueueSessionOrdered(sessionKey, fn) {
-      const prior = sessionOrderChains.get(sessionKey) ?? Promise.resolve();
+    function enqueueSessionOrdered(sessionKey2, fn) {
+      const prior = sessionOrderChains.get(sessionKey2) ?? Promise.resolve();
       const next = prior.then(fn, fn);
-      sessionOrderChains.set(sessionKey, next.catch(() => void 0));
+      sessionOrderChains.set(sessionKey2, next.catch(() => void 0));
       return next;
     }
-    function runSessionEvidenceCollection(sessionKey, collect) {
-      return enqueueSessionOrdered(sessionKey, collect);
+    function runSessionEvidenceCollection(sessionKey2, collect) {
+      return enqueueSessionOrdered(sessionKey2, collect);
     }
-    function runSessionDestructiveAction(sessionKey, act) {
-      return enqueueSessionOrdered(sessionKey, act);
+    function runSessionDestructiveAction(sessionKey2, act) {
+      return enqueueSessionOrdered(sessionKey2, act);
     }
     function safeEvidenceJson(evidence) {
       const sanitized = {};
@@ -48299,6 +48299,10 @@ ${blocks.join("\n\n")}`;
       set3.add(minted.token);
       return minted;
     }
+    function verifyWorkerTaskToken(token) {
+      if (typeof token !== "string" || !token.trim()) return null;
+      return LIVE_TOKENS.get(token.trim()) || null;
+    }
     function tokensForTask(meshId, taskId) {
       const set3 = TOKENS_BY_TASK.get(taskKey(meshId, taskId));
       if (!set3) return [];
@@ -48329,6 +48333,67 @@ ${blocks.join("\n\n")}`;
       }
       return removed;
     }
+    function sessionKey(meshId, sessionId) {
+      return `${meshId}\0${sessionId}`;
+    }
+    function mintWorkerSessionBind(input) {
+      const meshId = String(input.meshId || "").trim();
+      const sessionId = String(input.sessionId || "").trim();
+      if (!meshId || !sessionId) {
+        throw new Error("mintWorkerSessionBind requires both meshId and sessionId");
+      }
+      for (const existing of bindsForSession(meshId, sessionId)) revokeWorkerSessionBind(existing.bind);
+      const minted = {
+        bind: `${WORKER_BIND_CANARY_PREFIX}${crypto2.randomBytes(32).toString("base64url")}`,
+        meshId,
+        sessionId,
+        ...input.nodeId ? { nodeId: String(input.nodeId).trim() } : {},
+        ...input.spawnedForTaskId ? { spawnedForTaskId: String(input.spawnedForTaskId).trim() } : {},
+        mintedAtMs: Date.now()
+      };
+      LIVE_BINDS.set(minted.bind, minted);
+      const key2 = sessionKey(meshId, sessionId);
+      let set3 = BINDS_BY_SESSION.get(key2);
+      if (!set3) {
+        set3 = /* @__PURE__ */ new Set();
+        BINDS_BY_SESSION.set(key2, set3);
+      }
+      set3.add(minted.bind);
+      return minted;
+    }
+    function bindsForSession(meshId, sessionId) {
+      const set3 = BINDS_BY_SESSION.get(sessionKey(meshId, sessionId));
+      if (!set3) return [];
+      const out = [];
+      for (const secret of set3) {
+        const found = LIVE_BINDS.get(secret);
+        if (found) out.push(found);
+      }
+      return out;
+    }
+    function verifyWorkerSessionBind(bind) {
+      if (typeof bind !== "string" || !bind.trim()) return null;
+      return LIVE_BINDS.get(bind.trim()) || null;
+    }
+    function revokeWorkerSessionBind(bind) {
+      const found = LIVE_BINDS.get(bind);
+      if (!found) return false;
+      LIVE_BINDS.delete(bind);
+      const key2 = sessionKey(found.meshId, found.sessionId);
+      const set3 = BINDS_BY_SESSION.get(key2);
+      if (set3) {
+        set3.delete(bind);
+        if (set3.size === 0) BINDS_BY_SESSION.delete(key2);
+      }
+      return true;
+    }
+    function findWorkerTaskTokenForSession(meshId, taskId, sessionId) {
+      const wanted = String(sessionId || "").trim();
+      for (const candidate of tokensForTask(meshId, taskId)) {
+        if (!candidate.sessionId || candidate.sessionId === wanted) return candidate;
+      }
+      return null;
+    }
     function findWorkerPrivateHomeSpec(providerType) {
       const type2 = String(providerType || "").trim();
       if (!type2) return null;
@@ -48405,15 +48470,13 @@ ${blocks.join("\n\n")}`;
       }
       const servers = {};
       if (input.server) {
+        const entryEnv = {};
+        if (input.token) entryEnv.ADHDEV_WORKER_TASK_TOKEN = input.token;
+        if (input.bind) entryEnv.ADHDEV_WORKER_SESSION_BIND = input.bind;
         servers[input.serverName] = buildMeshCoordinatorMcpServerEntry(input.format, {
           command: input.server.command,
           args: input.server.args,
-          // The token rides INSIDE the config, not in the worker's process
-          // env. Both are readable by the worker either way (§3 "남는
-          // 리스크"), but keeping it here means the value travels only to the
-          // process that reads this file, and never lands in a spawn env that
-          // gets inherited further down a process tree.
-          ...input.token ? { env: { ADHDEV_WORKER_TASK_TOKEN: input.token } } : {}
+          ...Object.keys(entryEnv).length ? { env: entryEnv } : {}
         });
       }
       const config2 = { [getMcpServersKey(input.format)]: servers };
@@ -48463,6 +48526,14 @@ ${blocks.join("\n\n")}`;
         notes.push(`${declaredPath} is home-rooted but ${input.providerType} has no private HOME \u2014 refusing to overwrite the coordinator config`);
         return result;
       }
+      let pendingBind = null;
+      if (input.server && input.bindContext?.meshId && input.bindContext?.sessionId) {
+        try {
+          pendingBind = mintWorkerSessionBind(input.bindContext);
+        } catch (err) {
+          notes.push(`worker session bind mint failed (${err?.message || err})`);
+        }
+      }
       try {
         result.configPath = writeWorkerMcpConfig({
           declaredPath,
@@ -48471,21 +48542,50 @@ ${blocks.join("\n\n")}`;
           workspace: input.workspace,
           workerHome: result.workerHome,
           server: input.server,
-          token: input.token
+          token: input.token,
+          ...pendingBind ? { bind: pendingBind.bind } : {}
         });
-        notes.push(`worker MCP config written to ${result.configPath}`);
+        if (pendingBind) result.bind = pendingBind.bind;
+        notes.push(
+          `worker MCP config written to ${result.configPath}` + (pendingBind ? ` (session bind issued for ${pendingBind.sessionId})` : "")
+        );
       } catch (err) {
+        if (pendingBind) revokeWorkerSessionBind(pendingBind.bind);
         notes.push(`worker MCP config write failed (${err?.message || err})`);
         LOG2.warn("WorkerMcp", `config write failed for ${input.providerType}: ${err?.message || err}`);
       }
       return result;
     }
+    function exchangeWorkerSessionBind(bind, resolveCurrentTask) {
+      const binding = verifyWorkerSessionBind(bind);
+      if (!binding) return null;
+      let current = null;
+      try {
+        current = resolveCurrentTask(binding.meshId, binding.sessionId);
+      } catch {
+        return null;
+      }
+      if (!current?.taskId) return null;
+      const token = findWorkerTaskTokenForSession(binding.meshId, current.taskId, binding.sessionId);
+      if (!token) return null;
+      return {
+        token: token.token,
+        meshId: binding.meshId,
+        taskId: current.taskId,
+        ...token.attemptId ? { attemptId: token.attemptId } : {},
+        sessionId: binding.sessionId,
+        ...binding.nodeId ? { nodeId: binding.nodeId } : {}
+      };
+    }
     var crypto2;
     var os13;
     var path222;
     var import_fs6;
     var LIVE_TOKENS;
     var TOKENS_BY_TASK;
+    var LIVE_BINDS;
+    var BINDS_BY_SESSION;
+    var WORKER_BIND_CANARY_PREFIX;
     var WORKER_PRIVATE_HOME_SPECS;
     var WORKER_HOME_PLACEHOLDER;
     var init_worker_mcp_isolation = __esm2({
@@ -48500,6 +48600,9 @@ ${blocks.join("\n\n")}`;
         init_mesh_coordinator_config();
         LIVE_TOKENS = /* @__PURE__ */ new Map();
         TOKENS_BY_TASK = /* @__PURE__ */ new Map();
+        LIVE_BINDS = /* @__PURE__ */ new Map();
+        BINDS_BY_SESSION = /* @__PURE__ */ new Map();
+        WORKER_BIND_CANARY_PREFIX = "wsb_";
         WORKER_PRIVATE_HOME_SPECS = [
           {
             providerType: "antigravity-cli",
@@ -58229,6 +58332,26 @@ CREATE TABLE IF NOT EXISTS sq_archive (
           "outcome",
           "terminalKind",
           "event",
+          // ── Stage 4B additions (2026-08-28) ────────────────────────────────────
+          // Added for the intentional-cleanup-stop consumer (mesh-event-suppression
+          // `hasRecentIntentionalCleanupStop`). Each was verified against EVERY
+          // producer in the tree before being asserted non-content:
+          //
+          //   `source`             — a closed set of snake_case slugs naming the code
+          //                          path that wrote the entry ('direct',
+          //                          'mesh_cleanup_sessions', 'operator_cleanup', …).
+          //                          Machine-authored discriminators, never prose.
+          //   `intentionalStopReason` — one literal producer
+          //                          (`router-worktree-cleanup.ts`), value
+          //                          `'operator_cleanup'`.
+          //
+          // ★ `source` is the widest of the two — it is written at many call sites,
+          // so the MAX_PROJECTED_STRING cap is doing real work here rather than being
+          // a formality. A caller who ever assigns prose to `source` gets truncated,
+          // not leaked wholesale; but the per-key assertion above is what keeps it
+          // out, and it must be re-checked if a producer starts composing this value.
+          "source",
+          "intentionalStopReason",
           // Booleans
           "retryable",
           "rebound",
@@ -58238,6 +58361,9 @@ CREATE TABLE IF NOT EXISTS sq_archive (
           "requestedForce",
           "removedByRemoteDaemon",
           "completedViaReady",
+          // Stage 4B: strictly boolean at every producer (mesh-termination-bridge,
+          // router-worktree-cleanup) — the intentional/accidental stop discriminator.
+          "intentional",
           // Counters
           "attempt",
           "attemptCount",
@@ -58315,6 +58441,9 @@ CREATE TABLE IF NOT EXISTS sq_archive (
     function sessionTranscriptTopic(sessionId) {
       return `session.${safeSessionId(sessionId)}.transcript`;
     }
+    function meshHandoffTopic(meshId) {
+      return `mesh.${safeMeshId(meshId)}.handoff`;
+    }
     function meshEventsPolicy() {
       return {
         kind: "append",
@@ -58335,6 +58464,15 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         finalityAuthority: ADHDEV_AUTHORITY_ID
       };
     }
+    function meshHandoffPolicy() {
+      return {
+        kind: "append",
+        retention: { mode: "full" },
+        replication: "full-sync",
+        access: "content",
+        finalityAuthority: ADHDEV_AUTHORITY_ID
+      };
+    }
     function sessionTranscriptPolicy(ringSize = SESSION_TRANSCRIPT_RING) {
       return {
         kind: "append",
@@ -58383,6 +58521,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         if (seen.has(topic)) continue;
         seen.add(topic);
         defs.push({ topic, policy: meshEventsPolicy() });
+        defs.push({ topic: meshHandoffTopic(meshId), policy: meshHandoffPolicy() });
       }
       return defs;
     }
@@ -59350,6 +59489,12 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       }
       return false;
     }
+    function readIntentionalCleanupStopEntries(meshId, since) {
+      return readProjectedEntries(meshId, {
+        kind: ["session_stopped", "task_failed", "task_stalled"],
+        since
+      });
+    }
     function meshReplicaDiagnostics(meshId) {
       const servingFromReplica = isMeshReadModelReady(meshId);
       const events = servingFromReplica ? queryMeshReadModel(meshId) : [];
@@ -63745,6 +63890,49 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         MESH_TERMINAL_QUEUE_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
       }
     });
+    function selectTurnEventsForTask(db, meshId, taskId) {
+      const rows = db.prepare(`
+        SELECT * FROM mesh_turn_events WHERE mesh_id = ? AND task_id = ? ORDER BY recorded_at ASC, event_id ASC
+    `).all(meshId, taskId);
+      return rows.map((r) => ({
+        eventId: r.event_id,
+        attemptId: r.attempt_id,
+        kind: r.kind,
+        dedupeKey: r.dedupe_key ?? "",
+        payload: r.payload,
+        occurredAtMs: r.occurred_at_ms,
+        recordedAt: r.recorded_at
+      }));
+    }
+    function selectTurnEventsByKind(db, meshId, kind, limit) {
+      const rows = db.prepare(`
+        SELECT * FROM mesh_turn_events WHERE mesh_id = ? AND kind = ?
+        ORDER BY recorded_at DESC, event_id DESC LIMIT ?
+    `).all(meshId, kind, Math.max(1, Math.floor(limit)));
+      return rows.map((r) => ({
+        eventId: r.event_id,
+        attemptId: r.attempt_id,
+        taskId: r.task_id,
+        kind: r.kind,
+        dedupeKey: r.dedupe_key ?? "",
+        payload: r.payload,
+        occurredAtMs: r.occurred_at_ms,
+        recordedAt: r.recorded_at
+      }));
+    }
+    function deleteTurnEventsByKindOlderThan(db, kind, cutoffIso, meshId) {
+      const info = meshId ? db.prepare(`
+            DELETE FROM mesh_turn_events WHERE mesh_id = ? AND kind = ? AND recorded_at < ?
+        `).run(meshId, kind, cutoffIso) : db.prepare(`
+            DELETE FROM mesh_turn_events WHERE kind = ? AND recorded_at < ?
+        `).run(kind, cutoffIso);
+      return info.changes ?? 0;
+    }
+    var init_mesh_turn_event_queries = __esm2({
+      "src/mesh/mesh-turn-event-queries.ts"() {
+        "use strict";
+      }
+    });
     function loadDatabaseCtor() {
       if (DatabaseCtor) return DatabaseCtor;
       DatabaseCtor = loadBetterSqlite3();
@@ -63825,6 +64013,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         init_dist();
         init_mesh_claim_refusal();
         init_mesh_runtime_store_turn_rows();
+        init_mesh_turn_event_queries();
         init_mesh_runtime_store_turn_rows();
         loggedMigrationFailure = false;
         loggedStrayCleanup = false;
@@ -64231,6 +64420,10 @@ CREATE TABLE IF NOT EXISTS sq_archive (
             CREATE INDEX IF NOT EXISTS idx_mesh_turn_events_task
                 ON mesh_turn_events(mesh_id, task_id, kind);
 
+            -- WORKER-MCP (design \xA75): by-kind probes; see mesh-turn-event-queries.ts.
+            CREATE INDEX IF NOT EXISTS idx_mesh_turn_events_kind
+                ON mesh_turn_events(mesh_id, kind, recorded_at);
+
             -- TURN-LEDGER (Stage 5): durable outbound delivery state (coordinator-bound
             -- completion / ACK notifications) for restart recovery. A row is enqueued in
             -- the SAME transaction as the reducer's terminal commit, so a crash between
@@ -66365,19 +66558,16 @@ CREATE TABLE IF NOT EXISTS sq_archive (
             ).get(attemptId, kind, dedupeKey);
             return row !== void 0;
           }
+          /** Turn events for one task, oldest first. SQL: mesh-turn-event-queries.ts. */
           listTurnEventsForTask(meshId, taskId) {
-            const rows = this.db.prepare(`
-            SELECT * FROM mesh_turn_events WHERE mesh_id = ? AND task_id = ? ORDER BY recorded_at ASC, event_id ASC
-        `).all(meshId, taskId);
-            return rows.map((r) => ({
-              eventId: r.event_id,
-              attemptId: r.attempt_id,
-              kind: r.kind,
-              dedupeKey: r.dedupe_key ?? "",
-              payload: r.payload,
-              occurredAtMs: r.occurred_at_ms,
-              recordedAt: r.recorded_at
-            }));
+            return selectTurnEventsForTask(this.db, meshId, taskId);
+          }
+          /** By-KIND turn-event queries. SQL + index rationale: mesh-turn-event-queries.ts. */
+          listTurnEventsByKind(meshId, kind, limit = 200) {
+            return selectTurnEventsByKind(this.db, meshId, kind, limit);
+          }
+          deleteTurnEventsByKindOlderThan(kind, cutoffIso, meshId) {
+            return deleteTurnEventsByKindOlderThan(this.db, kind, cutoffIso, meshId);
           }
           // ── TURN-LEDGER (Stage 5): durable outbound delivery (outbox) ────────────
           /** Enqueue an outbound notification. INSERT OR IGNORE on the row id = exactly-once. */
@@ -70310,6 +70500,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       execUnderPty: () => execUnderPty,
       inspectMeshCoordinatorMcpServerPaths: () => inspectMeshCoordinatorMcpServerPaths,
       resolveMeshCoordinatorSetup: () => resolveMeshCoordinatorSetup,
+      resolveWorkerMcpServerLaunch: () => resolveWorkerMcpServerLaunch,
       stripCoordinatorWrapperFile: () => stripCoordinatorWrapperFile
     });
     function isHermesProvider(provider, cliType) {
@@ -70513,6 +70704,21 @@ ${(0, import_node_path3.resolve)(workspace || os14.tmpdir())}`;
     function resolveAdhdevCommand(explicitCommand) {
       return explicitCommand?.trim() || process.env.ADHDEV_COORDINATOR_MCP_COMMAND?.trim() || DEFAULT_ADHDEV_MCP_COMMAND;
     }
+    function resolveWorkerMcpServerLaunch(options) {
+      const transport = resolveMcpTransport(options?.adhdevMcpTransport);
+      const port = resolveMcpPort(options?.adhdevMcpPort);
+      const directEntryPath = resolveAdhdevMcpEntryPath(options?.adhdevMcpEntryPath);
+      if (directEntryPath) {
+        const args2 = [directEntryPath, "--mode", transport, "--worker"];
+        if (port !== void 0) args2.push("--port", String(port));
+        return { command: resolveNodeExecutable(options?.nodeExecutable), args: args2 };
+      }
+      const command = resolveAdhdevCommand(options?.adhdevMcpCommand);
+      const directMcpEntrypoint = (0, import_node_path3.basename)(command).startsWith("adhdev-mcp") || command.includes("/vendor/mcp-server/") || command.includes("\\vendor\\mcp-server\\");
+      const args = [...directMcpEntrypoint ? [] : ["mcp"], "--mode", transport, "--worker"];
+      if (port !== void 0) args.push("--port", String(port));
+      return { command, args };
+    }
     function inspectMeshCoordinatorMcpServerPaths(mcpServer, options = {}) {
       const embeddedPaths = [mcpServer.command, ...mcpServer.args].filter((value) => (0, import_node_path3.isAbsolute)(value));
       if (embeddedPaths.length === 0) {
@@ -70831,6 +71037,16 @@ ${rendered}`, "utf-8");
     function getCoordinatorForSession(sessionId) {
       return _registry.get(sessionId);
     }
+    function pruneDeadMeshCoordinators(liveSessionIds) {
+      const pruned = [];
+      for (const entry of [..._registry.values()]) {
+        if (liveSessionIds.has(entry.sessionId)) continue;
+        _registry.delete(entry.sessionId);
+        pruned.push(entry);
+      }
+      if (pruned.length > 0) saveRegistry();
+      return pruned;
+    }
     function listCoordinatorsForWorkspace(workspace) {
       return [..._registry.values()].filter((e) => e.workspace === workspace);
     }
@@ -74440,6 +74656,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return null;
     }
+    function expiryRiskScore(remainingPercent2, timeLeftFraction) {
+      if (!(remainingPercent2 > 0)) return 0;
+      return remainingPercent2 * remainingPercent2 / (remainingPercent2 + 100 * timeLeftFraction);
+    }
     function expiryRiskForRanking(node, providerType, axis, policy, now = Date.now(), context) {
       const entry = quotaEntryFor(node, providerType, context, now);
       if (!entry) return void 0;
@@ -74456,8 +74676,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const windowMinutes3 = Number(window?.windowMinutes);
       const fallbackMinutes = axis === "session" ? DEFAULT_SESSION_WINDOW_MINUTES : DEFAULT_WEEKLY_WINDOW_MINUTES;
       const windowMs = (Number.isFinite(windowMinutes3) && windowMinutes3 > 0 ? windowMinutes3 : fallbackMinutes) * 60 * 1e3;
-      const elapsedFraction = Math.min(1, Math.max(0, 1 - (resetsAt - reporterNowMs) / windowMs));
-      return { remainingPercent: remaining, risk: remaining * elapsedFraction };
+      const timeLeftFraction = Math.min(1, Math.max(0, (resetsAt - reporterNowMs) / windowMs));
+      return { remainingPercent: remaining, risk: expiryRiskScore(remaining, timeLeftFraction) };
     }
     function rankProvidersByQuotaGate(node, orderedProviderTypes, policy, now = Date.now(), context) {
       const clear = [];
@@ -79706,6 +79926,592 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
         "use strict";
       }
     });
+    var worker_report_exports = {};
+    __export2(worker_report_exports, {
+      WORKER_BLOCKERS_MAX: () => WORKER_BLOCKERS_MAX,
+      WORKER_BRANCH_STATES: () => WORKER_BRANCH_STATES,
+      WORKER_FOLLOW_UPS_MAX: () => WORKER_FOLLOW_UPS_MAX,
+      WORKER_GUIDANCE_MAX_CHARS: () => WORKER_GUIDANCE_MAX_CHARS,
+      WORKER_HANDOFF_EVENT_KIND: () => WORKER_HANDOFF_EVENT_KIND,
+      WORKER_INTENT_MAX_CHARS: () => WORKER_INTENT_MAX_CHARS,
+      WORKER_LIST_ITEM_MAX_CHARS: () => WORKER_LIST_ITEM_MAX_CHARS,
+      WORKER_PROGRESS_EVENT_KIND: () => WORKER_PROGRESS_EVENT_KIND,
+      WORKER_REPORT_EVENT_KIND: () => WORKER_REPORT_EVENT_KIND,
+      WORKER_SUMMARY_MAX_CHARS: () => WORKER_SUMMARY_MAX_CHARS,
+      WORKER_TOUCHED_FILES_MAX: () => WORKER_TOUCHED_FILES_MAX,
+      acceptWorkerCompletionReport: () => acceptWorkerCompletionReport,
+      acceptWorkerProgressUpdate: () => acceptWorkerProgressUpdate,
+      configureHandoffNoteSink: () => configureHandoffNoteSink,
+      resolveWorkerIdentity: () => resolveWorkerIdentity,
+      validateWorkerCompletionReport: () => validateWorkerCompletionReport
+    });
+    function validateWorkerCompletionReport(raw) {
+      const errors = [];
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return { errors: [{ field: "", message: "report must be an object" }] };
+      }
+      const input = raw;
+      const KNOWN = /* @__PURE__ */ new Set(["outcome", "summary", "handoffNotes", "touchedFiles", "branchState", "blockers"]);
+      for (const key2 of Object.keys(input)) {
+        if (!KNOWN.has(key2)) {
+          errors.push({ field: key2, message: `unknown field '${key2}' (expected one of: ${[...KNOWN].join(", ")})` });
+        }
+      }
+      const outcome = input.outcome;
+      if (outcome !== "completed" && outcome !== "blocked" && outcome !== "failed") {
+        errors.push({ field: "outcome", message: "outcome must be one of 'completed' | 'blocked' | 'failed'" });
+      }
+      const summary = typeof input.summary === "string" ? input.summary.trim() : "";
+      if (!summary) {
+        errors.push({ field: "summary", message: "summary is required and must be a non-empty string" });
+      } else if (summary.length > WORKER_SUMMARY_MAX_CHARS) {
+        errors.push({
+          field: "summary",
+          message: `summary is ${summary.length} chars, over the ${WORKER_SUMMARY_MAX_CHARS} limit \u2014 shorten it rather than relying on truncation`
+        });
+      }
+      const touchedFiles = validateStringList(input.touchedFiles, "touchedFiles", WORKER_TOUCHED_FILES_MAX, errors);
+      const blockers = validateStringList(input.blockers, "blockers", WORKER_BLOCKERS_MAX, errors);
+      if (input.branchState !== void 0 && !WORKER_BRANCH_STATES.includes(input.branchState)) {
+        errors.push({
+          field: "branchState",
+          message: `branchState must be one of: ${WORKER_BRANCH_STATES.join(", ")}`
+        });
+      }
+      let handoffNotes;
+      if (input.handoffNotes !== void 0) {
+        const notes = input.handoffNotes;
+        if (!notes || typeof notes !== "object" || Array.isArray(notes)) {
+          errors.push({ field: "handoffNotes", message: "handoffNotes must be an object" });
+        } else {
+          const n = notes;
+          const KNOWN_NOTES = /* @__PURE__ */ new Set(["intent", "conflictGuidance", "touchedFiles", "followUps"]);
+          for (const key2 of Object.keys(n)) {
+            if (!KNOWN_NOTES.has(key2)) {
+              errors.push({ field: `handoffNotes.${key2}`, message: `unknown field '${key2}'` });
+            }
+          }
+          const intent = typeof n.intent === "string" ? n.intent.trim() : "";
+          if (!intent) {
+            errors.push({ field: "handoffNotes.intent", message: "intent is required \u2014 it is the part a diff cannot convey" });
+          } else if (intent.length > WORKER_INTENT_MAX_CHARS) {
+            errors.push({ field: "handoffNotes.intent", message: `intent is over the ${WORKER_INTENT_MAX_CHARS} char limit` });
+          }
+          let guidance;
+          if (n.conflictGuidance !== void 0) {
+            if (typeof n.conflictGuidance !== "string") {
+              errors.push({ field: "handoffNotes.conflictGuidance", message: "conflictGuidance must be a string" });
+            } else if (n.conflictGuidance.trim().length > WORKER_GUIDANCE_MAX_CHARS) {
+              errors.push({ field: "handoffNotes.conflictGuidance", message: `conflictGuidance is over the ${WORKER_GUIDANCE_MAX_CHARS} char limit` });
+            } else {
+              guidance = n.conflictGuidance.trim() || void 0;
+            }
+          }
+          const noteFiles = validateStringList(n.touchedFiles, "handoffNotes.touchedFiles", WORKER_TOUCHED_FILES_MAX, errors);
+          if (n.touchedFiles === void 0 || !noteFiles?.length) {
+            errors.push({
+              field: "handoffNotes.touchedFiles",
+              message: "touchedFiles is required and must be non-empty \u2014 it is what matches this note to future work"
+            });
+          }
+          const followUps = validateStringList(n.followUps, "handoffNotes.followUps", WORKER_FOLLOW_UPS_MAX, errors);
+          if (intent && noteFiles?.length) {
+            handoffNotes = {
+              intent,
+              ...guidance ? { conflictGuidance: guidance } : {},
+              touchedFiles: noteFiles,
+              ...followUps?.length ? { followUps } : {}
+            };
+          }
+        }
+      }
+      if (errors.length) return { errors };
+      return {
+        report: {
+          outcome,
+          summary,
+          ...handoffNotes ? { handoffNotes } : {},
+          ...touchedFiles?.length ? { touchedFiles } : {},
+          ...input.branchState ? { branchState: input.branchState } : {},
+          ...blockers?.length ? { blockers } : {}
+        },
+        errors: []
+      };
+    }
+    function validateStringList(value, field2, max, errors) {
+      if (value === void 0) return void 0;
+      if (!Array.isArray(value)) {
+        errors.push({ field: field2, message: `${field2} must be an array of strings` });
+        return void 0;
+      }
+      if (value.length > max) {
+        errors.push({ field: field2, message: `${field2} has ${value.length} entries, over the ${max} limit` });
+        return void 0;
+      }
+      const out = [];
+      for (const item of value) {
+        if (typeof item !== "string") {
+          errors.push({ field: field2, message: `${field2} must contain only strings` });
+          return void 0;
+        }
+        const trimmed = item.trim();
+        if (!trimmed) continue;
+        if (trimmed.length > WORKER_LIST_ITEM_MAX_CHARS) {
+          errors.push({ field: field2, message: `${field2} contains an entry over the ${WORKER_LIST_ITEM_MAX_CHARS} char limit` });
+          return void 0;
+        }
+        out.push(trimmed);
+      }
+      return out;
+    }
+    function resolveWorkerIdentity(credential) {
+      const direct = verifyWorkerTaskToken(credential.token);
+      if (direct) {
+        return {
+          token: direct.token,
+          meshId: direct.meshId,
+          taskId: direct.taskId,
+          ...direct.attemptId ? { attemptId: direct.attemptId } : {},
+          sessionId: direct.sessionId || "",
+          ...direct.nodeId ? { nodeId: direct.nodeId } : {}
+        };
+      }
+      return exchangeWorkerSessionBind(credential.bind, resolveCurrentTaskForSession);
+    }
+    function resolveCurrentTaskForSession(meshId, sessionId) {
+      try {
+        const entry = MeshRuntimeStore.getInstance().findAssignedBySession(meshId, sessionId);
+        if (!entry?.id) return null;
+        return {
+          taskId: entry.id,
+          ...entry.attemptId ? { attemptId: entry.attemptId } : {}
+        };
+      } catch {
+        return null;
+      }
+    }
+    function configureHandoffNoteSink(sink) {
+      handoffSink = sink;
+    }
+    function acceptWorkerCompletionReport(credential, report, opts = {}) {
+      const identity = resolveWorkerIdentity(credential);
+      if (!identity) return { accepted: false, refusal: "unauthenticated" };
+      const nowMs = opts.nowMs ?? Date.now();
+      const nowIso = new Date(nowMs).toISOString();
+      const store = MeshRuntimeStore.getInstance();
+      if (identity.attemptId) {
+        try {
+          store.insertTurnEvent({
+            eventId: (0, import_crypto15.randomUUID)(),
+            meshId: identity.meshId,
+            attemptId: identity.attemptId,
+            taskId: identity.taskId,
+            kind: WORKER_REPORT_EVENT_KIND,
+            // UNIQUE(attempt_id, kind, dedupe_key) makes a re-call for the
+            // same outcome insert-once, matching the reducer's own idempotency.
+            dedupeKey: report.outcome,
+            payload: JSON.stringify({
+              outcome: report.outcome,
+              summaryLength: report.summary.length,
+              touchedFileCount: report.touchedFiles?.length ?? 0,
+              blockerCount: report.blockers?.length ?? 0,
+              hasHandoffNotes: !!report.handoffNotes,
+              ...report.branchState ? { branchState: report.branchState } : {}
+            }),
+            occurredAtMs: nowMs,
+            recordedAt: nowIso
+          });
+        } catch (e) {
+          LOG2.warn("WorkerReport", `Failed to record report evidence for task ${identity.taskId}: ${e?.message || e}`);
+        }
+      }
+      let handoffNoteRecorded = false;
+      if (report.handoffNotes) {
+        handoffNoteRecorded = recordHandoffNote(identity, report.handoffNotes, nowMs, nowIso);
+      }
+      const terminalStatus = report.outcome === "completed" ? "completed" : "failed";
+      let commit;
+      try {
+        commit = commitTaskTerminalAndAdvanceGraph({
+          meshId: identity.meshId,
+          taskId: identity.taskId,
+          status: terminalStatus,
+          ...identity.sessionId ? { sessionId: identity.sessionId } : {},
+          ...identity.attemptId ? { attemptId: identity.attemptId } : {},
+          occurredAtMs: nowMs,
+          // ★A NEW proposal source. The reducer's causal checks apply to it
+          // exactly as they do to a provider event — a valid token does not
+          // buy an exemption from stale-attempt or session-mismatch.
+          source: "worker_tool_report",
+          reason: report.outcome === "blocked" ? `worker_reported_blocked:${(report.blockers || []).length}` : `worker_reported:${report.outcome}`,
+          envelope: {
+            finalSummary: report.summary,
+            ...report.touchedFiles?.length ? { artifacts: { touchedFiles: report.touchedFiles } } : {},
+            evidence: {
+              // The grade this report earns (design §4 등급표): declared by
+              // the worker, so it is complete by construction and carries
+              // no truncation risk the way a screen scrape does.
+              summarySource: "tool_report",
+              mayBeTruncated: false,
+              reportedOutcome: report.outcome,
+              ...report.branchState ? { branchState: report.branchState } : {},
+              ...report.blockers?.length ? { blockers: report.blockers.join("; ") } : {}
+            },
+            ...identity.nodeId ? { nodeId: identity.nodeId } : {},
+            completedAt: nowIso
+          }
+        });
+      } catch (e) {
+        LOG2.warn("WorkerReport", `Terminal commit threw for task ${identity.taskId}: ${e?.message || e}`);
+        return { accepted: false, refusal: "rejected_by_reducer", detail: e?.message || String(e) };
+      }
+      if (!commit.committed) {
+        return { accepted: false, refusal: "unknown_task", detail: `no queue row for task ${identity.taskId}` };
+      }
+      LOG2.info(
+        "WorkerReport",
+        `Accepted ${report.outcome} report for task ${identity.taskId}` + (identity.attemptId ? ` attempt ${identity.attemptId}` : "") + (commit.duplicate ? " (duplicate replay)" : "") + (handoffNoteRecorded ? " with handoff note" : "")
+      );
+      return {
+        accepted: true,
+        taskId: identity.taskId,
+        ...identity.attemptId ? { attemptId: identity.attemptId } : {},
+        outcome: report.outcome,
+        duplicate: commit.duplicate,
+        handoffNoteRecorded
+      };
+    }
+    function acceptWorkerProgressUpdate(credential, note, opts = {}) {
+      const identity = resolveWorkerIdentity(credential);
+      if (!identity) return { accepted: false, refusal: "unauthenticated" };
+      if (!identity.attemptId) return { accepted: true, taskId: identity.taskId };
+      const nowMs = opts.nowMs ?? Date.now();
+      try {
+        MeshRuntimeStore.getInstance().insertTurnEvent({
+          eventId: (0, import_crypto15.randomUUID)(),
+          meshId: identity.meshId,
+          attemptId: identity.attemptId,
+          taskId: identity.taskId,
+          kind: WORKER_PROGRESS_EVENT_KIND,
+          // Distinct per call — progress updates are a SEQUENCE, unlike the
+          // completion report where the UNIQUE constraint provides idempotency.
+          dedupeKey: `${nowMs}`,
+          payload: JSON.stringify({ noteLength: note.length }),
+          occurredAtMs: nowMs,
+          recordedAt: new Date(nowMs).toISOString()
+        });
+      } catch (e) {
+        LOG2.warn("WorkerReport", `Failed to record progress update for task ${identity.taskId}: ${e?.message || e}`);
+      }
+      return { accepted: true, taskId: identity.taskId };
+    }
+    function recordHandoffNote(identity, notes, nowMs, nowIso) {
+      if (identity.attemptId) {
+        try {
+          MeshRuntimeStore.getInstance().insertTurnEvent({
+            eventId: (0, import_crypto15.randomUUID)(),
+            meshId: identity.meshId,
+            attemptId: identity.attemptId,
+            taskId: identity.taskId,
+            kind: WORKER_HANDOFF_EVENT_KIND,
+            dedupeKey: "",
+            payload: JSON.stringify({
+              touchedFiles: notes.touchedFiles,
+              intentLength: notes.intent.length,
+              hasConflictGuidance: !!notes.conflictGuidance,
+              followUpCount: notes.followUps?.length ?? 0,
+              ...identity.sessionId ? { sessionId: identity.sessionId } : {},
+              ...identity.nodeId ? { nodeId: identity.nodeId } : {}
+            }),
+            occurredAtMs: nowMs,
+            recordedAt: nowIso
+          });
+        } catch (e) {
+          LOG2.warn("WorkerReport", `Failed to index handoff note for task ${identity.taskId}: ${e?.message || e}`);
+          return false;
+        }
+      }
+      if (handoffSink) {
+        try {
+          handoffSink({
+            meshId: identity.meshId,
+            taskId: identity.taskId,
+            ...identity.attemptId ? { attemptId: identity.attemptId } : {},
+            ...identity.sessionId ? { sessionId: identity.sessionId } : {},
+            ...identity.nodeId ? { nodeId: identity.nodeId } : {},
+            notes,
+            recordedAtIso: nowIso
+          });
+        } catch (e) {
+          LOG2.warn("WorkerReport", `Handoff note sink threw for task ${identity.taskId}: ${e?.message || e}`);
+        }
+      }
+      return true;
+    }
+    var import_crypto15;
+    var WORKER_BRANCH_STATES;
+    var WORKER_REPORT_EVENT_KIND;
+    var WORKER_PROGRESS_EVENT_KIND;
+    var WORKER_HANDOFF_EVENT_KIND;
+    var WORKER_SUMMARY_MAX_CHARS;
+    var WORKER_INTENT_MAX_CHARS;
+    var WORKER_GUIDANCE_MAX_CHARS;
+    var WORKER_TOUCHED_FILES_MAX;
+    var WORKER_LIST_ITEM_MAX_CHARS;
+    var WORKER_BLOCKERS_MAX;
+    var WORKER_FOLLOW_UPS_MAX;
+    var handoffSink;
+    var init_worker_report = __esm2({
+      "src/mesh/worker-report.ts"() {
+        "use strict";
+        import_crypto15 = require("crypto");
+        init_logger();
+        init_mesh_runtime_store();
+        init_mesh_graph_transition_runner();
+        init_worker_mcp_isolation();
+        WORKER_BRANCH_STATES = [
+          "merged_to_main",
+          "pushed_feature_branch_needs_merge",
+          "blocked_review",
+          "cleanup_candidate",
+          "not_mergeable"
+        ];
+        WORKER_REPORT_EVENT_KIND = "worker_tool_report";
+        WORKER_PROGRESS_EVENT_KIND = "worker_progress_update";
+        WORKER_HANDOFF_EVENT_KIND = "worker_handoff_note";
+        WORKER_SUMMARY_MAX_CHARS = 8e3;
+        WORKER_INTENT_MAX_CHARS = 4e3;
+        WORKER_GUIDANCE_MAX_CHARS = 4e3;
+        WORKER_TOUCHED_FILES_MAX = 200;
+        WORKER_LIST_ITEM_MAX_CHARS = 500;
+        WORKER_BLOCKERS_MAX = 50;
+        WORKER_FOLLOW_UPS_MAX = 50;
+        handoffSink = null;
+      }
+    });
+    function noteKey(meshId, taskId) {
+      return `${meshId}\0${taskId}`;
+    }
+    function configureHandoffNotesSeqscribe(handle) {
+      seqscribeHandle = handle;
+    }
+    function storeHandoffNote(note) {
+      NOTE_TEXT_STORE.set(noteKey(note.meshId, note.taskId), note);
+      const handle = seqscribeHandle;
+      if (!handle) return;
+      const topic = meshHandoffTopic(note.meshId);
+      if (!handle.topics.some((d) => d.topic === topic)) {
+        return;
+      }
+      void handle.node.log(topic).append(HANDOFF_ENTRY_KIND, {
+        taskId: note.taskId,
+        ...note.attemptId ? { attemptId: note.attemptId } : {},
+        ...note.nodeId ? { nodeId: note.nodeId } : {},
+        recordedAt: note.recordedAtIso,
+        intent: note.notes.intent,
+        ...note.notes.conflictGuidance ? { conflictGuidance: note.notes.conflictGuidance } : {},
+        touchedFiles: note.notes.touchedFiles,
+        ...note.notes.followUps?.length ? { followUps: note.notes.followUps } : {}
+      }).catch((e) => {
+        LOG2.warn("HandoffNotes", `Failed to append handoff note for task ${note.taskId}: ${e?.message || e}`);
+      });
+    }
+    function selectRelevantHandoffNotes(input) {
+      const store = MeshRuntimeStore.getInstance();
+      let rows;
+      try {
+        rows = store.listTurnEventsByKind(input.meshId, WORKER_HANDOFF_EVENT_KIND, 200);
+      } catch (e) {
+        LOG2.warn("HandoffNotes", `Handoff note lookup failed for mesh ${input.meshId}: ${e?.message || e}`);
+        return [];
+      }
+      const wantedFiles = new Set((input.touchedFiles || []).map(normalizeFilePath).filter(Boolean));
+      const cutoffMs = (input.nowMs ?? Date.now()) - HANDOFF_RETENTION_MS;
+      const byFiles = [];
+      const byMission = [];
+      const byBranch = [];
+      const seenTasks = /* @__PURE__ */ new Set([input.taskId]);
+      for (const row of rows) {
+        if (seenTasks.has(row.taskId)) continue;
+        const recordedMs = Date.parse(row.recordedAt);
+        if (Number.isFinite(recordedMs) && recordedMs < cutoffMs) continue;
+        const stored = NOTE_TEXT_STORE.get(noteKey(input.meshId, row.taskId));
+        if (!stored) continue;
+        let meta3 = {};
+        try {
+          meta3 = JSON.parse(row.payload);
+        } catch {
+        }
+        const noteFiles = Array.isArray(meta3.touchedFiles) ? meta3.touchedFiles.filter((f) => typeof f === "string") : stored.notes.touchedFiles;
+        const overlap = wantedFiles.size ? noteFiles.filter((f) => wantedFiles.has(normalizeFilePath(f))) : [];
+        if (overlap.length) {
+          seenTasks.add(row.taskId);
+          byFiles.push({ ...stored, reason: "touched_files", overlap });
+          continue;
+        }
+        if (input.missionId && input.lookupMissionId?.(row.taskId) === input.missionId) {
+          seenTasks.add(row.taskId);
+          byMission.push({ ...stored, reason: "same_mission" });
+          continue;
+        }
+        if (input.branch && input.lookupBranch?.(row.taskId) === input.branch) {
+          seenTasks.add(row.taskId);
+          byBranch.push({ ...stored, reason: "same_branch" });
+        }
+      }
+      return [...byFiles, ...byMission, ...byBranch];
+    }
+    function normalizeFilePath(value) {
+      return String(value || "").trim().replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
+    }
+    function renderHandoffNotesBlock(notes, opts = {}) {
+      if (!notes.length) return null;
+      const maxNotes = opts.maxNotes ?? HANDOFF_ENCLOSE_MAX_NOTES;
+      const maxBytes = opts.maxBytes ?? HANDOFF_ENCLOSE_MAX_BYTES;
+      const header = "## Handoff notes from related work\n\n_Left by earlier agents whose changes overlap yours. They cannot be asked follow-up questions._\n";
+      const parts = [];
+      let used = Buffer.byteLength(header, "utf8");
+      let included = 0;
+      for (const note of notes) {
+        if (included >= maxNotes) break;
+        const rendered = renderOneNote(note);
+        const cost = Buffer.byteLength(rendered, "utf8");
+        if (included > 0 && used + cost > maxBytes) break;
+        parts.push(rendered);
+        used += cost;
+        included += 1;
+      }
+      const omitted = notes.length - included;
+      const omissionLine = omitted > 0 ? `
+_${omitted} further related note(s) omitted to fit the enclosure budget \u2014 the most relevant are shown first._
+` : "";
+      return { text: `${header}${parts.join("")}${omissionLine}`, included, omitted };
+    }
+    function renderOneNote(note) {
+      const why = note.reason === "touched_files" ? `overlapping files: ${(note.overlap || []).join(", ")}` : note.reason === "same_mission" ? "same mission" : "same branch";
+      const lines = [`
+### From task ${note.taskId} (${why})
+`];
+      lines.push(`- **Intent:** ${note.notes.intent}
+`);
+      if (note.notes.conflictGuidance) {
+        lines.push(`- **If you conflict with this:** ${note.notes.conflictGuidance}
+`);
+      }
+      if (note.notes.touchedFiles.length) {
+        lines.push(`- **Touched:** ${note.notes.touchedFiles.join(", ")}
+`);
+      }
+      if (note.notes.followUps?.length) {
+        lines.push(`- **Left undone:** ${note.notes.followUps.join("; ")}
+`);
+      }
+      return lines.join("");
+    }
+    function composeTaskDispatchBody(message, input) {
+      let selected = [];
+      try {
+        selected = selectRelevantHandoffNotes(input);
+      } catch (e) {
+        LOG2.warn("HandoffNotes", `Handoff selection failed for task ${input.taskId}: ${e?.message || e}`);
+        return { body: message, enclosedNotes: 0, omittedNotes: 0 };
+      }
+      const block2 = renderHandoffNotesBlock(selected);
+      if (!block2) return { body: message, enclosedNotes: 0, omittedNotes: 0 };
+      return {
+        body: `${message}
+
+---
+
+${block2.text}`,
+        enclosedNotes: block2.included,
+        omittedNotes: block2.omitted
+      };
+    }
+    function pruneExpiredHandoffNotes(nowMs = Date.now()) {
+      const cutoffIso = new Date(nowMs - HANDOFF_RETENTION_MS).toISOString();
+      let removed = 0;
+      try {
+        removed = MeshRuntimeStore.getInstance().deleteTurnEventsByKindOlderThan(WORKER_HANDOFF_EVENT_KIND, cutoffIso);
+      } catch (e) {
+        LOG2.warn("HandoffNotes", `Handoff retention sweep failed: ${e?.message || e}`);
+      }
+      const cutoffMs = nowMs - HANDOFF_RETENTION_MS;
+      for (const [key2, note] of NOTE_TEXT_STORE) {
+        const recordedMs = Date.parse(note.recordedAtIso);
+        if (Number.isFinite(recordedMs) && recordedMs < cutoffMs) NOTE_TEXT_STORE.delete(key2);
+      }
+      return removed;
+    }
+    var HANDOFF_ENTRY_KIND;
+    var HANDOFF_RETENTION_DAYS;
+    var HANDOFF_RETENTION_MS;
+    var HANDOFF_ENCLOSE_MAX_NOTES;
+    var HANDOFF_ENCLOSE_MAX_BYTES;
+    var NOTE_TEXT_STORE;
+    var seqscribeHandle;
+    var init_worker_handoff_notes = __esm2({
+      "src/mesh/worker-handoff-notes.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_runtime_store();
+        init_worker_report();
+        init_topics2();
+        HANDOFF_ENTRY_KIND = "worker.handoff";
+        HANDOFF_RETENTION_DAYS = 30;
+        HANDOFF_RETENTION_MS = HANDOFF_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+        HANDOFF_ENCLOSE_MAX_NOTES = 5;
+        HANDOFF_ENCLOSE_MAX_BYTES = 8 * 1024;
+        NOTE_TEXT_STORE = /* @__PURE__ */ new Map();
+        seqscribeHandle = null;
+      }
+    });
+    function readNonEmpty2(value) {
+      return typeof value === "string" && value.trim() ? value.trim() : void 0;
+    }
+    function resolveDispatchMessage(task, meshId, node) {
+      if (!isWorkerMcpEnabled()) return task.message;
+      try {
+        const touchedFiles = task.touchedFiles;
+        const branch = readNonEmpty2(node?.worktreeBranch);
+        const composed = composeTaskDispatchBody(task.message, {
+          meshId,
+          taskId: task.id,
+          ...Array.isArray(touchedFiles) ? { touchedFiles } : {},
+          ...task.missionId ? { missionId: task.missionId } : {},
+          ...branch ? { branch } : {},
+          // Injected rather than imported by the note module: resolving a
+          // note's mission means reading a QUEUE row, and the note module
+          // must not depend on the queue (it is read by the queue).
+          lookupMissionId: (candidateTaskId) => {
+            try {
+              return MeshRuntimeStore.getInstance().findQueueEntryById(meshId, candidateTaskId)?.missionId;
+            } catch {
+              return void 0;
+            }
+          }
+        });
+        if (composed.enclosedNotes > 0) {
+          LOG2.info(
+            "HandoffNotes",
+            `Enclosed ${composed.enclosedNotes} handoff note(s) with task ${task.id}` + (composed.omittedNotes ? ` (${composed.omittedNotes} omitted to fit)` : "")
+          );
+        }
+        return composed.body;
+      } catch (e) {
+        LOG2.warn("HandoffNotes", `Failed to compose dispatch body for ${task.id}: ${e?.message || e}`);
+        return task.message;
+      }
+    }
+    var init_worker_handoff_dispatch = __esm2({
+      "src/mesh/worker-handoff-dispatch.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_runtime_store();
+        init_worker_mcp_isolation();
+        init_worker_handoff_notes();
+      }
+    });
     function localCoordinatorDaemonId2() {
       return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
     }
@@ -80217,6 +81023,7 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
           LOG2.warn("WorkerMcp", `Failed to mint worker task token for ${task.id}: ${e?.message || e}`);
         }
       }
+      const dispatchMessage = resolveDispatchMessage(task, meshId, node);
       if (dispatchAttemptId) {
         try {
           const attemptRow = MeshRuntimeStore.getInstance().getTurnAttempt(dispatchAttemptId);
@@ -80260,7 +81067,9 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
               targetSessionId: sessionId,
               cliType: providerType,
               action: "send_chat",
-              message: task.message,
+              // Handoff-note enclosure applies to the DISPATCHED body only;
+              // task.message stays the authored text (see composition above).
+              message: dispatchMessage,
               // DISPATCH-SOURCE-TRACE: call-site tag echoed in the worker daemon log.
               dispatchSource: "mesh-queue-assignment:tryAssignQueueTask:remote",
               meshContext: {
@@ -80336,7 +81145,8 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
           targetSessionId: sessionId,
           cliType: providerType,
           action: "send_chat",
-          message: task.message,
+          // Same enclosure as the remote arm — one composed body, both paths.
+          message: dispatchMessage,
           // DISPATCH-SOURCE-TRACE: call-site tag echoed in the daemon log.
           dispatchSource: "mesh-queue-assignment:tryAssignQueueTask:local",
           meshContext: {
@@ -81169,6 +81979,7 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
         init_mesh_autolaunch_integrity();
         init_mesh_difficulty_floor();
         init_worker_mcp_isolation();
+        init_worker_handoff_dispatch();
         init_mesh_candidacy_predicates();
         init_mesh_difficulty_floor();
         init_mesh_auto_fast_forward();
@@ -81361,7 +82172,7 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
       const fingerprint = `${target}::${buildPendingEventFingerprint(fingerprintSource)}`;
       try {
         const inserted = store.insertPendingEvent({
-          id: (0, import_crypto15.randomUUID)(),
+          id: (0, import_crypto16.randomUUID)(),
           meshId: UNRESOLVED_FORWARD_OUTBOX_MESH_ID,
           coordinatorDaemonId: target,
           event,
@@ -81424,14 +82235,14 @@ Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', targe
         return 0;
       }
     }
-    var import_crypto15;
+    var import_crypto16;
     var UNRESOLVED_FORWARD_OUTBOX_MESH_ID;
     var UNRESOLVED_FORWARD_MAX_AGE_MS;
     var retryNudgeHandler;
     var init_mesh_unresolved_forward_outbox = __esm2({
       "src/mesh/mesh-unresolved-forward-outbox.ts"() {
         "use strict";
-        import_crypto15 = require("crypto");
+        import_crypto16 = require("crypto");
         init_logger();
         init_mesh_runtime_store();
         init_mesh_events_pending();
@@ -83740,10 +84551,7 @@ ${cleanBody}`;
     function hasRecentIntentionalCleanupStop(meshId, sessionId, nodeId) {
       if (!sessionId && !nodeId) return false;
       const cutoff = Date.now() - INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
-      const entries = readLedgerEntries(meshId, {
-        kind: ["session_stopped", "task_failed", "task_stalled"],
-        since: new Date(cutoff).toISOString()
-      });
+      const entries = readIntentionalCleanupStopEntries(meshId, new Date(cutoff).toISOString());
       for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
         if (!isIntentionalCleanupStopEntry(entry)) continue;
@@ -86044,6 +86852,7 @@ ${cleanBody}`;
       let sessionHostRuntimes = 0;
       let rotationEvicted = 0;
       let rotationEvictedBytes = 0;
+      let handoffNotes = 0;
       try {
         ledgerJsonl = pruneExpiredLedgerJsonl(now);
       } catch (e) {
@@ -86069,6 +86878,14 @@ ${cleanBody}`;
       } catch (e) {
         LOG2.warn("DiskRetention", `Ledger rotation cap sweep failed: ${e?.message || e}`);
       }
+      try {
+        handoffNotes = pruneExpiredHandoffNotes(now);
+        if (handoffNotes > 0) {
+          LOG2.info("DiskRetention", `Pruned ${handoffNotes} handoff note row(s) older than ${HANDOFF_RETENTION_DAYS}d`);
+        }
+      } catch (e) {
+        LOG2.warn("DiskRetention", `Handoff note prune failed: ${e?.message || e}`);
+      }
       let diskLevel = "ok";
       try {
         const status = checkDiskSpace(getConfigDir2());
@@ -86077,7 +86894,7 @@ ${cleanBody}`;
       } catch (e) {
         LOG2.warn("DiskRetention", `Disk space check failed: ${e?.message || e}`);
       }
-      return { ledgerJsonl, dbBackups, sessionHostRuntimes, rotationEvicted, rotationEvictedBytes, diskLevel };
+      return { ledgerJsonl, dbBackups, sessionHostRuntimes, rotationEvicted, rotationEvictedBytes, handoffNotes, diskLevel };
     }
     async function detectAndSignalOrphanWorktrees(mesh, now = Date.now()) {
       const nodes = Array.isArray(mesh.nodes) ? mesh.nodes : [];
@@ -86146,6 +86963,7 @@ ${cleanBody}`;
         init_git_worktree();
         init_logger();
         init_disk_space_preflight();
+        init_worker_handoff_notes();
         DAY_MS2 = 24 * 60 * 60 * 1e3;
         LEDGER_JSONL_MAX_AGE_MS = 30 * DAY_MS2;
         SESSION_HOST_RUNTIME_MAX_AGE_MS = 14 * DAY_MS2;
@@ -98818,6 +99636,7 @@ ${e?.stderr || ""}`;
       isExtensionInstalled: () => isExtensionInstalled,
       isGitCommandName: () => isGitCommandName,
       isIdeRunning: () => isIdeRunning,
+      isIntentionalCleanupStopEntry: () => isIntentionalCleanupStopEntry,
       isInternalChatMessage: () => isInternalChatMessage,
       isManagedStatusWaiting: () => isManagedStatusWaiting,
       isManagedStatusWorking: () => isManagedStatusWorking,
@@ -98954,6 +99773,7 @@ ${e?.stderr || ""}`;
       projectFleetStatusEntry: () => projectFleetStatusEntry,
       projectGraphPublicPolicy: () => projectGraphPublicPolicy,
       projectMeshLedgerEntry: () => projectMeshLedgerEntry,
+      pruneDeadMeshCoordinators: () => pruneDeadMeshCoordinators,
       pruneOperatingNotes: () => pruneOperatingNotes,
       pruneStaleDirectDispatches: () => pruneStaleDirectDispatches,
       queryMeshReadModel: () => queryMeshReadModel,
@@ -98969,6 +99789,7 @@ ${e?.stderr || ""}`;
       readCodexCliSession: () => readSession2,
       readDiskSpace: () => readDiskSpace,
       readHermesCliSession: () => readSession4,
+      readIntentionalCleanupStopEntries: () => readIntentionalCleanupStopEntries,
       readKeyStaleAdvisory: () => readKeyStaleAdvisory,
       readLatestCodexRateLimits: () => readLatestCodexRateLimits,
       readLedgerEntries: () => readLedgerEntries,
@@ -99425,12 +100246,17 @@ ${e?.stderr || ""}`;
       }
       if (navIndex < 0) return parseClaudeHeaderlessInteractiveTuiQuestion(page, index);
       if (!page.screenText.includes("Enter to select")) return null;
+      for (let i = navIndex + 1; i < lines.length; i += 1) {
+        const candidate = lines[i].trim();
+        if (!candidate || /^─+$/.test(candidate)) continue;
+        if (candidate === "Review your answers" || candidate === "Ready to submit your answers?") return null;
+        if (CLAUDE_TUI_OPTION_PATTERN.test(lines[i])) break;
+      }
       let question = "";
       let questionLineIndex = -1;
       for (let i = navIndex + 1; i < lines.length; i += 1) {
         const candidate = lines[i].trim();
         if (!candidate || /^─+$/.test(candidate)) continue;
-        if (candidate === "Review your answers" || candidate === "Ready to submit your answers?") return null;
         question = candidate;
         questionLineIndex = i;
         break;
@@ -106285,15 +107111,15 @@ ${effect.notification.body || ""}`.trim();
     function decideCliReadChatSource(args) {
       const supportsNative = supportsCliNativeTranscript(args.providerType, args.provider);
       const observation = buildObservationForCli(args, supportsNative);
-      const sessionKey = chatSourceSessionKey(args.providerType, args.sessionId);
-      const priorSnapshot = CHAT_SOURCE_REGISTRY.snapshotRecord(sessionKey);
-      const priorState = priorSnapshot?.state ?? CHAT_SOURCE_REGISTRY.getState(sessionKey);
+      const sessionKey2 = chatSourceSessionKey(args.providerType, args.sessionId);
+      const priorSnapshot = CHAT_SOURCE_REGISTRY.snapshotRecord(sessionKey2);
+      const priorState = priorSnapshot?.state ?? CHAT_SOURCE_REGISTRY.getState(sessionKey2);
       const eligibleForStickyHold = args.trustedExactNativeIdentity === true && (priorState.name === "NativeLocked" || priorState.name === "Recovering");
-      let decision = CHAT_SOURCE_REGISTRY.observe(sessionKey, observation);
+      let decision = CHAT_SOURCE_REGISTRY.observe(sessionKey2, observation);
       const heldNativeMessages = observation.kind === "native_present" ? extractNativeMessagesFromResult(args.providerType, args.nativeHistoryResult) : [];
       const mayHoldNativeSlice = heldNativeMessages.length > 0 && args.safeMapping === true;
       if (eligibleForStickyHold && decision.selected === "pty-parser" && mayHoldNativeSlice) {
-        CHAT_SOURCE_REGISTRY.restoreRecord(sessionKey, priorSnapshot);
+        CHAT_SOURCE_REGISTRY.restoreRecord(sessionKey2, priorSnapshot);
         const messageSource2 = buildCliMessageSourceProvenance({
           selected: "native-history",
           provider: args.providerType,
@@ -106334,8 +107160,8 @@ ${effect.notification.body || ""}`.trim();
         };
       }
       if (decision.selected === "pty-parser" && args.trustedExactNativeIdentity === true && args.safeMapping && args.ptyMessages.length === 0 && observation.kind === "native_present" && observation.coverage !== "partial" && observation.messages.length > 0) {
-        CHAT_SOURCE_REGISTRY.clear(sessionKey);
-        decision = CHAT_SOURCE_REGISTRY.observe(sessionKey, observation);
+        CHAT_SOURCE_REGISTRY.clear(sessionKey2);
+        decision = CHAT_SOURCE_REGISTRY.observe(sessionKey2, observation);
       }
       const nativeMessages = observation.kind === "native_present" ? extractNativeMessagesFromResult(args.providerType, args.nativeHistoryResult) : [];
       const nativeSource = typeof args.nativeHistoryResult?.source === "string" ? args.nativeHistoryResult.source : void 0;
@@ -114390,6 +115216,93 @@ ${marker}`,
         };
       }
     };
+    var workerReportHandlers = {
+      /**
+       * Exchange a session bind for the caller's current task identity.
+       *
+       * Exposed as its own command so the MCP server can answer "do I have a task
+       * right now" — which is what decides whether it publishes the reporting
+       * tools at all — without having to submit a report to find out.
+       *
+       * ★The task TOKEN is deliberately NOT returned. The caller does not need it:
+       * it presents the bind again on the actual report, and the daemon re-resolves.
+       * Returning the token would put a second live secret on the wire for no gain.
+       */
+      worker_resolve_task: async (_ctx, args) => {
+        try {
+          const { resolveWorkerIdentity: resolveWorkerIdentity2 } = await Promise.resolve().then(() => (init_worker_report(), worker_report_exports));
+          const identity = resolveWorkerIdentity2({ token: args?.token, bind: args?.bind });
+          if (!identity) {
+            return {
+              success: false,
+              error: "worker_not_bound",
+              hint: "No live task is bound to this worker session. A report is only possible while a task is assigned."
+            };
+          }
+          return {
+            success: true,
+            meshId: identity.meshId,
+            taskId: identity.taskId,
+            ...identity.attemptId ? { attemptId: identity.attemptId } : {},
+            ...identity.sessionId ? { sessionId: identity.sessionId } : {},
+            ...identity.nodeId ? { nodeId: identity.nodeId } : {}
+          };
+        } catch (e) {
+          return { success: false, error: e?.message || String(e) };
+        }
+      },
+      /**
+       * Accept a structured completion report.
+       *
+       * Validation errors come back as a STRUCTURED list rather than a single
+       * string so the MCP layer can hand the worker something it can act on
+       * field-by-field — the retry loop is the whole reason the schema is enforced
+       * at the tool layer instead of being parsed out of prose.
+       */
+      worker_report_completion: async (_ctx, args) => {
+        try {
+          const { validateWorkerCompletionReport: validateWorkerCompletionReport2, acceptWorkerCompletionReport: acceptWorkerCompletionReport2 } = await Promise.resolve().then(() => (init_worker_report(), worker_report_exports));
+          const { report, errors } = validateWorkerCompletionReport2(args?.report);
+          if (!report) {
+            return { success: false, error: "invalid_report", validationErrors: errors };
+          }
+          const result = acceptWorkerCompletionReport2({ token: args?.token, bind: args?.bind }, report);
+          if (!result.accepted) {
+            return {
+              success: false,
+              error: result.refusal,
+              ...result.detail ? { detail: result.detail } : {},
+              hint: result.refusal === "unauthenticated" ? "No live task is bound to this worker session \u2014 the task may already be terminal or reassigned." : "The completion was refused by the turn ledger; the task state is authoritative."
+            };
+          }
+          return {
+            success: true,
+            taskId: result.taskId,
+            ...result.attemptId ? { attemptId: result.attemptId } : {},
+            outcome: result.outcome,
+            duplicate: result.duplicate,
+            handoffNoteRecorded: result.handoffNoteRecorded
+          };
+        } catch (e) {
+          return { success: false, error: e?.message || String(e) };
+        }
+      },
+      /** Record a mid-task progress note. Never terminal. */
+      worker_progress_update: async (_ctx, args) => {
+        const note = typeof args?.note === "string" ? args.note.trim() : "";
+        if (!note) return { success: false, error: "note required" };
+        try {
+          const { acceptWorkerProgressUpdate: acceptWorkerProgressUpdate2 } = await Promise.resolve().then(() => (init_worker_report(), worker_report_exports));
+          const result = acceptWorkerProgressUpdate2({ token: args?.token, bind: args?.bind }, note);
+          if (!result.accepted) {
+            return { success: false, error: result.refusal || "unauthenticated" };
+          }
+          return { success: true, ...result.taskId ? { taskId: result.taskId } : {} };
+        } catch (e) {
+          return { success: false, error: e?.message || String(e) };
+        }
+      }
+    };
     var lowFamilyRegistry = new Map(
       Object.entries({
         ...sessionHostHandlers,
@@ -114401,7 +115314,8 @@ ${marker}`,
         ...notificationHandlers,
         ...daemonLifecycleHandlers,
         ...meshLedgerHandlers,
-        ...meshNodeLogsHandlers
+        ...meshNodeLogsHandlers,
+        ...workerReportHandlers
       })
     );
     init_dist();
@@ -118642,7 +119556,7 @@ ${marker}`,
               await new Promise((resolve32) => setTimeout(resolve32, 180));
             }
           }
-          this.assertFocusedClaudeTuiReview(prompt);
+          await this.assertFocusedClaudeTuiReview(prompt);
           this.driver.dispatch({ kind: "pty_write", data: "\r" });
           await new Promise((resolve32) => setTimeout(resolve32, 180));
         } else {
@@ -119164,6 +120078,7 @@ ${marker}`,
       }
       maybeCaptureClaudeTuiPrompt() {
         if (this.interactivePromptScheme() !== "claude_tui" || this.activeInteractivePrompt || this.claudeTuiPromptCaptureInFlight) return;
+        if (this.latestState?.status === "generating") return;
         const screenText = this.driver.snapshot();
         if (!screenText.includes("Enter to select")) {
           const now = Date.now();
@@ -119276,8 +120191,31 @@ ${marker}`,
         const observed = focused?.question ? `; focused question is "${focused.question}"` : "";
         throw new Error(`Claude TUI focused question does not match the active interactive prompt (expected "${expected.question}"${observed})`);
       }
-      assertFocusedClaudeTuiReview(prompt) {
-        const screenText = this.readClaudeTuiSnapshotForAnswer();
+      /**
+       * Wait for the review page to actually be on screen before the final Enter.
+       *
+       * The last answer keystroke is what navigates the picker onto its review
+       * page, and the TUI repaint is not instantaneous. Gating on a single
+       * snapshot taken a fixed delay after that keypress races the repaint: on a
+       * slow frame the assertion still sees the previous question page and fails
+       * closed, refusing an answer that was in fact correct (live defect
+       * 2026-08-28). Poll on the same bounded budget the capture path already
+       * uses (snapshotSettledClaudeTuiPage) and accept the first frame that reads
+       * as the review page; on timeout fall through to the last frame so a
+       * genuinely wrong screen still fails closed with its real content.
+       */
+      async snapshotSettledClaudeTuiReview() {
+        let screenText = this.readClaudeTuiSnapshotForAnswer();
+        const deadline = Date.now() + _SpecCliAdapter.CLAUDE_TUI_PAGE_SETTLE_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+          if (!readFocusedClaudeTuiQuestion(screenText) && isClaudeTuiReviewScreen(screenText)) return screenText;
+          await new Promise((resolve32) => setTimeout(resolve32, _SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
+          screenText = this.readClaudeTuiSnapshotForAnswer();
+        }
+        return screenText;
+      }
+      async assertFocusedClaudeTuiReview(prompt) {
+        const screenText = await this.snapshotSettledClaudeTuiReview();
         const focused = readFocusedClaudeTuiQuestion(screenText);
         if (focused || !isClaudeTuiReviewScreen(screenText)) {
           const observed = focused?.question ? `; focused question is "${focused.question}"` : "";
@@ -119613,6 +120551,7 @@ ${marker}`,
       }
     }
     init_worker_mcp_isolation();
+    init_mesh_coordinator();
     init_summary_metadata();
     var os26 = __toESM2(require("os"));
     var crypto6 = __toESM2(require("crypto"));
@@ -126130,11 +127069,13 @@ ${rawInput}` : rawInput;
         providerType: input.cliType,
         workspace: input.workspace,
         sessionKey: input.sessionKey || input.workspace,
-        mcpConfig: input.mcpConfig
-        // Phase A writes an EMPTY worker config (no servers). The worker tool
-        // surface and its server entry arrive in Phase B; until then the
-        // isolation win is simply that the coordinator's 60-tool entry is not
-        // in the file the worker reads.
+        mcpConfig: input.mcpConfig,
+        // Phase B: with a mesh+session to bind, the worker gets a MINIMAL MCP
+        // server (`--mode worker`) plus the bind it exchanges for its task
+        // token. Without one, Phase A's shape stands — a config with no servers
+        // at all, whose isolation win is that the coordinator's 60-tool entry is
+        // absent from the file the worker reads.
+        ...input.bindContext ? { bindContext: input.bindContext, server: resolveWorkerMcpServerLaunch() } : {}
       });
       const envSet = input.isolation?.env?.set;
       if (workerIsolation && envSet && typeof envSet === "object") {
@@ -126367,12 +127308,12 @@ ${rawInput}` : rawInput;
        * Returns the guard key on admission, or null when the submission is a
        * duplicate and must be suppressed.
        */
-      beginMeshDispatchSubmission(sessionKey, taskId, content) {
+      beginMeshDispatchSubmission(sessionKey2, taskId, content) {
         const now = Date.now();
         for (const [k, at] of this.meshDispatchSubmissions) {
           if (now - at > MESH_DISPATCH_SUBMIT_DEDUP_WINDOW_MS) this.meshDispatchSubmissions.delete(k);
         }
-        const guardKey = `${sessionKey}:${taskId}:${shortHash(content, 24)}`;
+        const guardKey = `${sessionKey2}:${taskId}:${shortHash(content, 24)}`;
         if (this.meshDispatchSubmissions.has(guardKey)) return null;
         this.meshDispatchSubmissions.set(guardKey, now);
         return guardKey;
@@ -126580,7 +127521,7 @@ ${rawInput}` : rawInput;
 Enable and detect this provider from the Machine Providers page before starting a runtime.`
           );
         }
-        const key2 = crypto7.randomUUID();
+        const key2 = options?.presetSessionKey?.trim() || crypto7.randomUUID();
         {
           const coordinatorMeshId = options?.settingsOverride?.meshCoordinatorFor;
           if (typeof coordinatorMeshId === "string" && coordinatorMeshId.trim()) {
@@ -126874,6 +127815,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const key2 = `${r.workspace}::${r.cliType}`;
           workspaceTypeCounts.set(key2, (workspaceTypeCounts.get(key2) || 0) + 1);
         }
+        const rebindAdoptedSessionIds = /* @__PURE__ */ new Set();
         for (const record2 of sessions) {
           if (!record2?.runtimeId || !record2?.cliType || !record2?.workspace) continue;
           if (!shouldRestoreHostedRuntime(record2, managerTag)) {
@@ -126916,6 +127858,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               const siblingCount = workspaceTypeCounts.get(`${record2.workspace}::${record2.cliType}`) || 1;
               if (!coordinatorPresentById && siblingCount === 1) {
                 coordinatorEntry = candidate;
+                if (candidate.sessionId) rebindAdoptedSessionIds.add(candidate.sessionId);
                 LOG2.info(
                   "CLI",
                   `\u21BB Rebound coordinator mark by workspace for ${record2.runtimeKey || record2.runtimeId} (mesh ${candidate.meshId} @ ${record2.workspace}); registry key did not match runtimeId`
@@ -126972,6 +127915,19 @@ Run 'adhdev doctor' for detailed diagnostics.`
             LOG2.warn("CLI", `Failed to restore hosted runtime ${record2.runtimeId}: ${error48?.message || error48}`);
           }
         }
+        if (!records && typeof this.deps.listHostedCliRuntimes === "function") {
+          const liveSessionIds = new Set(restoredRuntimeIds);
+          for (const r of sessions) {
+            if (r?.runtimeId) liveSessionIds.add(r.runtimeId);
+          }
+          for (const sessionId of rebindAdoptedSessionIds) liveSessionIds.add(sessionId);
+          for (const entry of pruneDeadMeshCoordinators(liveSessionIds)) {
+            LOG2.info(
+              "CLI",
+              `\u{1F9F9} Pruned stale mesh coordinator entry ${entry.sessionId} (mesh ${entry.meshId}${entry.workspace ? ` @ ${entry.workspace}` : ""}, started ${new Date(entry.startedAt || 0).toISOString()}): session is not among the ${liveSessionIds.size} live hosted runtime(s) after daemon restart`
+            );
+          }
+        }
         if (restored > 0) {
           this.deps.onStatusChange();
         }
@@ -127096,6 +128052,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 };
               }
             }
+            const delegatedSessionKey = settingsOverride?.launchedByCoordinator === true ? crypto7.randomUUID() : void 0;
+            const delegatedMeshId = typeof settingsOverride?.meshNodeFor === "string" ? settingsOverride.meshNodeFor.trim() : "";
             const delegatedLaunch = settingsOverride?.launchedByCoordinator === true ? buildCoordinatorDelegatedCliLaunchOptions({
               cliType,
               workspace: dir,
@@ -127109,7 +128067,18 @@ Run 'adhdev doctor' for detailed diagnostics.`
               // Prefer the auto-launch task binding so two workers on
               // one workspace get distinct private HOMEs; fall back to
               // the mesh node, then the workspace alone.
-              sessionKey: (typeof settingsOverride?.autoLaunchedForQueueTaskId === "string" ? settingsOverride.autoLaunchedForQueueTaskId.trim() : "") || (typeof settingsOverride?.meshNodeId === "string" ? settingsOverride.meshNodeId.trim() : "") || dir
+              sessionKey: (typeof settingsOverride?.autoLaunchedForQueueTaskId === "string" ? settingsOverride.autoLaunchedForQueueTaskId.trim() : "") || (typeof settingsOverride?.meshNodeId === "string" ? settingsOverride.meshNodeId.trim() : "") || dir,
+              // Present ⇒ the worker gets a reporting surface (Phase B).
+              // Absent (a delegated launch with no mesh context) ⇒ the
+              // Phase A shape: isolation only, no worker server.
+              ...delegatedMeshId && delegatedSessionKey ? {
+                bindContext: {
+                  meshId: delegatedMeshId,
+                  sessionId: delegatedSessionKey,
+                  ...typeof settingsOverride?.meshNodeId === "string" && settingsOverride.meshNodeId.trim() ? { nodeId: settingsOverride.meshNodeId.trim() } : {},
+                  ...typeof settingsOverride?.autoLaunchedForQueueTaskId === "string" && settingsOverride.autoLaunchedForQueueTaskId.trim() ? { spawnedForTaskId: settingsOverride.autoLaunchedForQueueTaskId.trim() } : {}
+                }
+              } : {}
             }) : null;
             if (delegatedLaunch?.workerIsolation?.notes.length) {
               LOG2.info("WorkerMcp", `[${cliType}] ${delegatedLaunch.workerIsolation.notes.join("; ")}`);
@@ -127137,6 +128106,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 resumeSessionId: args?.resumeSessionId,
                 settingsOverride,
                 extraEnv: delegatedLaunch ? delegatedLaunch.env : args?.env,
+                ...delegatedSessionKey ? { presetSessionKey: delegatedSessionKey } : {},
                 ...typeof args?.initialThinkingLevel === "string" && args.initialThinkingLevel.trim() ? { initialThinkingLevel: args.initialThinkingLevel.trim() } : {}
               }
             );
@@ -130487,7 +131457,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     init_contract();
     var fs47 = __toESM2(require("fs"));
     var path522 = __toESM2(require("path"));
-    var import_crypto16 = require("crypto");
+    var import_crypto17 = require("crypto");
     init_contract();
     var TREE_DIGEST_ALGORITHM = "adhdev-provider-tree-sha256-v1";
     function computeProviderTreeDigest(rootDir, providerType) {
@@ -130501,7 +131471,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         );
       }
       relPaths.sort();
-      const hash2 = (0, import_crypto16.createHash)("sha256");
+      const hash2 = (0, import_crypto17.createHash)("sha256");
       for (const relPath of relPaths) {
         const absPath = path522.join(rootDir, ...relPath.split("/"));
         const bytes = fs47.readFileSync(absPath);
@@ -134658,11 +135628,11 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           let node;
           const { migrateProviderRolesToSlots: migrateProviderRolesToSlots2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           if (meshRecord.inline) {
-            const { randomUUID: randomUUID20 } = await import("crypto");
+            const { randomUUID: randomUUID21 } = await import("crypto");
             const clonedPolicy = { ...sourceNode.policy || {} };
             migrateProviderRolesToSlots2(clonedPolicy);
             node = {
-              id: `node_${randomUUID20().replace(/-/g, "")}`,
+              id: `node_${randomUUID21().replace(/-/g, "")}`,
               workspace: result.worktreePath,
               repoRoot: result.worktreePath,
               daemonId: sourceNode.daemonId,
@@ -147548,7 +148518,7 @@ data: ${JSON.stringify(msg.data)}
         });
       }
     };
-    var import_crypto17 = require("crypto");
+    var import_crypto18 = require("crypto");
     var import_session_host_core12 = require_dist();
     var BASE_KEY_SEQUENCES = {
       enter: "\r",
@@ -147646,7 +148616,7 @@ data: ${JSON.stringify(msg.data)}
         const sessionId = String(options.sessionId || "").trim();
         if (!sessionId) throw new Error("sessionId is required");
         const mode = options.mode || "read";
-        const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto17.randomUUID)().slice(0, 8)}`;
+        const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto18.randomUUID)().slice(0, 8)}`;
         const client = options.client || new import_session_host_core12.SessionHostClient({ endpoint: options.endpoint });
         await client.connect();
         const attachResponse = await client.request({
@@ -148426,7 +149396,7 @@ data: ${JSON.stringify(msg.data)}
     init_mesh_reconcile_loop();
     var import_fs23 = require("fs");
     var import_path24 = require("path");
-    var import_crypto18 = require("crypto");
+    var import_crypto19 = require("crypto");
     init_logger();
     init_mesh_ledger();
     init_mesh_runtime_store();
@@ -148460,7 +149430,7 @@ data: ${JSON.stringify(msg.data)}
       try {
         const fingerprint = buildPendingEventFingerprint(event);
         MeshRuntimeStore.getInstance().insertPendingEvent({
-          id: (0, import_crypto18.randomUUID)(),
+          id: (0, import_crypto19.randomUUID)(),
           meshId: event.meshId,
           coordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
           event: event.event,
@@ -149401,6 +150371,8 @@ data: ${JSON.stringify(msg.data)}
     }
     init_mesh_read_readiness();
     init_mesh_dual_write();
+    init_worker_handoff_notes();
+    init_worker_report();
     init_dist();
     init_topics2();
     var FLEET_STATUS_SUB_VIEW = "tail";
@@ -150123,6 +151095,8 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         configureMeshReadModel(components.seqscribeNode ?? null);
         configureFleetStatusShadow(components.seqscribeNode ?? null);
         configureFleetStatusParity(components.seqscribeNode ?? null);
+        configureHandoffNotesSeqscribe(components.seqscribeNode ?? null);
+        configureHandoffNoteSink(storeHandoffNote);
         if (components.seqscribeNode) {
           pruneStaleConsumersAtBoot();
           components.seqscribeParityLoop = startMeshParityLoop(components.seqscribeNode);
@@ -150247,6 +151221,14 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         configureMeshReadModel(null);
       } catch {
       }
+      try {
+        configureHandoffNotesSeqscribe(null);
+      } catch {
+      }
+      try {
+        configureHandoffNoteSink(null);
+      } catch {
+      }
       try {
         if (agentStreamManager) {
           await agentStreamManager.dispose(cdpManagers);