@adhdev/daemon-core 0.9.82-rc.459 → 0.9.82-rc.460

package/dist/index.mjs

@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "7f95d1c8a5f682abdc7de49343d5bee688a9f16f" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "7f95d1c8" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.459" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-04T13:20:51.551Z" : void 0);
+  const commit = readInjected(true ? "f8ce1329d3bdef9564c4130a1e7f0b607738f3cd" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "f8ce1329" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.460" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-04T14:24:11.778Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3464,6 +3464,33 @@ import * as fs2 from "fs";
 import * as os2 from "os";
 import * as path8 from "path";
 function buildCoordinatorSystemPrompt(ctx) {
+  let prompt = assembleCoordinatorPrompt(ctx, {});
+  if (byteLength2(prompt) <= PROMPT_SOFT_CAP_BYTES) return prompt;
+  if (usesOverrideBase(ctx)) return prompt;
+  const shed = [];
+  prompt = assembleCoordinatorPrompt(ctx, { dropOperatingNotes: true });
+  shed.push("operating notes");
+  if (byteLength2(prompt) <= PROMPT_SOFT_CAP_BYTES) {
+    return appendTruncationNotice(prompt, shed);
+  }
+  prompt = assembleCoordinatorPrompt(ctx, { dropOperatingNotes: true, dropRecentActivity: true });
+  shed.push("recent activity");
+  return appendTruncationNotice(prompt, shed);
+}
+function usesOverrideBase(ctx) {
+  if (ctx.mesh.coordinator?.systemPromptOverride?.trim()) return true;
+  return readUserPromptFile(ctx.coordinatorCliType, "md") !== null;
+}
+function byteLength2(s2) {
+  return Buffer.byteLength(s2, "utf8");
+}
+function appendTruncationNotice(prompt, shed) {
+  if (shed.length === 0) return prompt;
+  return `${prompt}
+
+_Prompt exceeded the ${Math.floor(PROMPT_SOFT_CAP_BYTES / 1024)}KB soft cap; omitted to fit: ${shed.join(", ")}. Full detail remains in the ledger (\`mesh_task_history\` / \`mesh_record_note\`)._`;
+}
+function assembleCoordinatorPrompt(ctx, drop) {
   const { mesh, userInstruction, coordinatorCliType } = ctx;
   const meshOverride = mesh.coordinator?.systemPromptOverride?.trim();
   let base;
@@ -3474,7 +3501,7 @@ function buildCoordinatorSystemPrompt(ctx) {
     if (userOverride !== null) {
       base = expandPromptPlaceholders(userOverride, ctx);
     } else {
-      base = buildDefaultCoordinatorPrompt(ctx);
+      base = buildDefaultCoordinatorPrompt(ctx, drop);
     }
   }
   const sections = [base];
@@ -3492,7 +3519,7 @@ ${userInstruction}`);
   }
   return sections.join("\n\n");
 }
-function buildDefaultCoordinatorPrompt(ctx) {
+function buildDefaultCoordinatorPrompt(ctx, drop = {}) {
   const { mesh, status, coordinatorCliType } = ctx;
   const sections = [];
   sections.push(`You are a **Repo Mesh Coordinator** \u2014 a technical team lead who orchestrates work across multiple agent sessions on a shared Git repository.
@@ -3510,10 +3537,14 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
   if (ctx.missionSection?.trim()) {
     sections.push(ctx.missionSection.trim());
   }
-  const recentActivity = buildRecentActivitySection(ctx.recentActivity);
-  if (recentActivity) sections.push(recentActivity);
-  const operatingNotes = buildOperatingNotesSection(ctx.operatingNotes);
-  if (operatingNotes) sections.push(operatingNotes);
+  if (!drop.dropRecentActivity) {
+    const recentActivity = buildRecentActivitySection(ctx.recentActivity);
+    if (recentActivity) sections.push(recentActivity);
+  }
+  if (!drop.dropOperatingNotes) {
+    const operatingNotes = buildOperatingNotesSection(ctx.operatingNotes);
+    if (operatingNotes) sections.push(operatingNotes);
+  }
   sections.push(buildPolicySection(mergeAndNormalizePolicy(void 0, mesh.policy)));
   sections.push(TOOLS_SECTION);
   sections.push(TOOL_EXPOSURE_PREFLIGHT_SECTION);
@@ -3627,6 +3658,7 @@ function buildRecentActivitySection(activity) {
   const assigned = Number.isFinite(activity.assignedTasks) ? Number(activity.assignedTasks) : 0;
   const stalled = Number.isFinite(activity.stalledTasks) ? Number(activity.stalledTasks) : 0;
   const recentFailureCount = Number.isFinite(activity.recentFailureCount) ? Number(activity.recentFailureCount) : failures.length;
+  const windowMinutes = Number.isFinite(activity.windowMinutes) && Number(activity.windowMinutes) > 0 ? Math.floor(Number(activity.windowMinutes)) : 30;
   if (failures.length === 0 && pending === 0 && assigned === 0 && stalled === 0 && recentFailureCount === 0) {
     return "";
   }
@@ -3637,7 +3669,7 @@ function buildRecentActivitySection(activity) {
   if (pending > 0) counts.push(`**${pending}** pending`);
   if (assigned > 0) counts.push(`**${assigned}** assigned`);
   if (stalled > 0) counts.push(`**${stalled}** stalled`);
-  if (recentFailureCount > 0) counts.push(`**${recentFailureCount}** failed in the last 30 min`);
+  if (recentFailureCount > 0) counts.push(`**${recentFailureCount}** failed in the last ${windowMinutes} min`);
   if (counts.length) lines.push(`- Queue/ledger: ${counts.join(", ")}.`);
   if (activity.lastActivityAt) lines.push(`- Last ledger activity: ${activity.lastActivityAt}.`);
   if (failures.length > 0) {
@@ -3661,15 +3693,25 @@ function buildOperatingNotesSection(notes) {
     pattern_to_avoid: "pattern to avoid",
     recovery_lesson: "recovery lesson"
   };
+  const omittedCount = Math.max(0, valid.length - OPERATING_NOTES_PROMPT_CAP);
+  const shown = omittedCount > 0 ? valid.slice(-OPERATING_NOTES_PROMPT_CAP) : valid;
   const lines = ["## Operating Notes", ""];
   lines.push("Lessons earlier coordinators on this mesh recorded via `mesh_record_note`. Treat them as accumulated operating knowledge \u2014 apply them. When you learn a durable lesson (a provider quirk, a pattern to avoid, a recovery lesson), record it with `mesh_record_note` so future coordinators inherit it.");
   lines.push("");
-  for (const n of valid) {
+  for (const n of shown) {
     const cat = n.category && categoryLabel[n.category] ? `[${categoryLabel[n.category]}] ` : "";
-    lines.push(`- ${cat}${n.text.trim()}`);
+    lines.push(`- ${cat}${truncateNote(n.text.trim())}`);
+  }
+  if (omittedCount > 0) {
+    lines.push("");
+    lines.push(`_${omittedCount} older note${omittedCount === 1 ? "" : "s"} omitted (kept in ledger; prune with \`mesh_forget_note\`)._`);
   }
   return lines.join("\n");
 }
+function truncateNote(text) {
+  if (text.length <= OPERATING_NOTE_MAX_CHARS) return text;
+  return `${text.slice(0, OPERATING_NOTE_MAX_CHARS).trimEnd()}\u2026 [truncated]`;
+}
 function buildPolicySection(policy) {
   const rules = [];
   if (policy.requirePreTaskCheckpoint) rules.push("- Create a git checkpoint **before** starting each task");
@@ -3708,13 +3750,24 @@ function buildRulesSection(coordinatorCliType) {
 - **Honor per-node instructions.** When a node carries a \u{1F4CC} Node instruction in the nodes section, include the relevant parts of that instruction in the task message you send to that node. Don't paraphrase the instruction into your own words \u2014 quote it verbatim so the worker agent sees exactly what the user wrote.
 - **Mission status does not update itself.** When a mission's tasks are all done or the work is abandoned, explicitly call \`mesh_mission_upsert\` to set status \`completed\` or \`abandoned\`. Never leave a finished mission in \`active\`. All-cancelled tasks with no further work \u2192 \`abandoned\`.
 - **Never fabricate tool results.** Always call the actual tool.
-- **Keep the user informed.** One or two sentences after each delegation round.${coordinatorNote}`;
+- **Keep the user informed.** One or two sentences after each delegation round.${coordinatorNote}
+
+### Task Messaging Requirements
+
+When you compose the task message you dispatch to a node, include these requirements so the worker follows repo conventions the daemon can't enforce for it:
+
+- **OSS English commits.** If a task commits anything under \`oss/\` (an AGPL public repo whose history external contributors read), tell the worker explicitly that commit messages in \`oss/\` MUST be English. Root-level commits (proprietary packages) may use any language.
+- **Scoped test runs.** For a validation or code-change task, instruct the worker to run only the tests covering the changed files (\`vitest run <path>\` or \`-t <name>\`), not the whole suite. Run the full suite only when the task is explicitly a full-suite gate \u2014 a broad daemon-core run is minutes of wall-clock and the biggest source of worker slowness.
+- **Branch convergence state.** For a worktree task, require the completion report to classify the touched branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. A task that ends on a non-main branch is not complete unless the report names that state and the next step.`;
 }
-var TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION, ONBOARDING_SECTION;
+var PROMPT_SOFT_CAP_BYTES, OPERATING_NOTES_PROMPT_CAP, OPERATING_NOTE_MAX_CHARS, TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION, ONBOARDING_SECTION;
 var init_coordinator_prompt = __esm({
   "src/mesh/coordinator-prompt.ts"() {
     "use strict";
     init_repo_mesh_types();
+    PROMPT_SOFT_CAP_BYTES = 60 * 1024;
+    OPERATING_NOTES_PROMPT_CAP = 20;
+    OPERATING_NOTE_MAX_CHARS = 300;
     TOOLS_SECTION = `## Available Tools
 
 | Tool | Purpose |
@@ -4113,6 +4166,54 @@ var init_load_better_sqlite3 = __esm({
   }
 });
 
+// src/mesh/contracts.ts
+function defaultScopeForEvent(eventName) {
+  if (SYSTEM_EVENTS.has(eventName)) return "system";
+  if (TERMINAL_TASK_EVENTS.has(eventName)) return "unicast";
+  return "broadcast";
+}
+function coordinatorIdentityFromEmitFields(fields) {
+  const daemonId = typeof fields.daemonId === "string" && fields.daemonId.length > 0 ? fields.daemonId : void 0;
+  if (!daemonId) return void 0;
+  const coordinatorRunId = typeof fields.coordinatorRunId === "string" && fields.coordinatorRunId.length > 0 ? fields.coordinatorRunId : daemonId;
+  const sessionId = typeof fields.sessionId === "string" && fields.sessionId.length > 0 ? fields.sessionId : void 0;
+  return sessionId !== void 0 ? { daemonId, coordinatorRunId, sessionId } : { daemonId, coordinatorRunId };
+}
+function buildPendingEventEmitStamp(opts) {
+  if (!opts.dispatchedBy) return void 0;
+  let scope = opts.scope ?? defaultScopeForEvent(opts.eventName);
+  let intendedFor = opts.intendedFor;
+  if (scope === "unicast" && !intendedFor) {
+    scope = "broadcast";
+  }
+  if (scope !== "unicast") intendedFor = void 0;
+  return {
+    protocolVersion: MESH_PROTOCOL_VERSION_V2,
+    eventId: opts.eventId,
+    scope,
+    dispatchedBy: opts.dispatchedBy,
+    ...intendedFor ? { intendedFor } : {}
+  };
+}
+var MESH_PROTOCOL_VERSION_V2, TERMINAL_TASK_EVENTS, SYSTEM_EVENTS;
+var init_contracts = __esm({
+  "src/mesh/contracts.ts"() {
+    "use strict";
+    init_dist();
+    MESH_PROTOCOL_VERSION_V2 = "2.0";
+    TERMINAL_TASK_EVENTS = /* @__PURE__ */ new Set([
+      "agent:generating_completed",
+      "agent:stopped",
+      "refine:completed",
+      "refine:failed",
+      "refine:accepted"
+    ]);
+    SYSTEM_EVENTS = /* @__PURE__ */ new Set([
+      "mesh:dispatch_blocked"
+    ]);
+  }
+});
+
 // src/mesh/mesh-ledger.ts
 var mesh_ledger_exports = {};
 __export(mesh_ledger_exports, {
@@ -4124,6 +4225,7 @@ __export(mesh_ledger_exports, {
   __clearMeshLedgerForTests: () => __clearMeshLedgerForTests,
   appendLedgerEntry: () => appendLedgerEntry,
   appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
+  buildLedgerOriginatingCoordinatorStamp: () => buildLedgerOriginatingCoordinatorStamp,
   buildTaskCompletionEvidence: () => buildTaskCompletionEvidence,
   buildWorkerTaskFooter: () => buildWorkerTaskFooter,
   compactLedger: () => compactLedger,
@@ -4412,6 +4514,15 @@ function buildTaskCompletionEvidence(opts) {
     }
   };
 }
+function buildLedgerOriginatingCoordinatorStamp(fields) {
+  const originatingCoordinator = coordinatorIdentityFromEmitFields({
+    daemonId: fields.coordinatorDaemonId,
+    coordinatorRunId: fields.coordinatorRunId,
+    sessionId: fields.coordinatorSessionId
+  });
+  if (!originatingCoordinator) return void 0;
+  return { originatingCoordinator, protocolVersion: MESH_PROTOCOL_VERSION_V2 };
+}
 function appendLedgerEntry(meshId, partial) {
   if (partial.kind === OPERATING_NOTE_KIND) {
     const text = operatingNoteText(partial.payload);
@@ -4902,6 +5013,7 @@ var init_mesh_ledger = __esm({
     init_config();
     init_dist();
     init_mesh_runtime_store();
+    init_contracts();
     LEDGER_DIR_NAME = "mesh-ledger";
     MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
     COMPACT_THRESHOLD_BYTES = 2 * 1024 * 1024;
@@ -6179,7 +6291,18 @@ var init_mesh_runtime_store = __esm({
                 fingerprint TEXT,
                 queued_at INTEGER NOT NULL,
                 drained INTEGER NOT NULL DEFAULT 0,
-                drained_at INTEGER
+                drained_at INTEGER,
+                -- v2 protocol envelope (B2a). All nullable so pre-v2 rows and events
+                -- emitted before a coordinator identity is known coexist as v1. The
+                -- authoritative copy of each also rides inside the payload column; these
+                -- columns exist for queryable idempotency (event_id) and scope-based drain
+                -- filtering without JSON-parsing every row. dispatched_by / intended_for
+                -- hold the JSON-serialized CoordinatorIdentity.
+                protocol_version TEXT,
+                event_id TEXT,
+                scope TEXT,
+                dispatched_by TEXT,
+                intended_for TEXT
             );
 
             CREATE INDEX IF NOT EXISTS idx_mesh_pending_events_mesh_drained
@@ -6215,6 +6338,38 @@ var init_mesh_runtime_store = __esm({
                 mesh_id TEXT PRIMARY KEY,
                 cursor INTEGER NOT NULL DEFAULT 0
             );
+
+            -- T2 (B2b): persistent acked-hold state for in-flight direct dispatches.
+            -- The reconcile loop's PHASE-4 acked-hold (death-consequence counter,
+            -- fast-track idle streak, live-confirmed flag) used to live only in a
+            -- process-local Map (mesh-reconcile-loop.ts inFlightAckedHoldState), so a
+            -- daemon restart lost it \u2014 re-opening the door to the duplicate-emit / drop
+            -- window that the PHASE-4 transcript synth backstop then had to correct after
+            -- the fact. Persisting it lets the state survive a restart: the loop
+            -- rehydrates the Map from this table on first touch and stays read-through /
+            -- write-through against it thereafter. Keyed by task_id (one hold per
+            -- in-flight dispatch); mesh_id is carried for per-mesh listing / prune.
+            --   hold_reason         \u2014 'live' once a conclusive read confirmed the session
+            --                         reachable since the ack, else 'unconfirmed' (drives
+            --                         the death-backstop's liveConfirmedSinceAck gate).
+            --   held_at             \u2014 ms epoch the hold row was first created.
+            --   first_idle_since_ack \u2014 ms epoch of the FIRST tick in the current continuous
+            --                         idle-with-final-assistant run (fast-track streak); NULL
+            --                         when the streak is broken / not yet started.
+            --   read_failure_count  \u2014 consecutive read_chat failures since the last
+            --                         conclusive read (death backstop (a)).
+            CREATE TABLE IF NOT EXISTS mesh_inflight_hold (
+                task_id TEXT PRIMARY KEY,
+                mesh_id TEXT,
+                hold_reason TEXT,
+                held_at INTEGER,
+                first_idle_since_ack INTEGER,
+                read_failure_count INTEGER,
+                updated_at INTEGER
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_inflight_hold_mesh
+                ON mesh_inflight_hold(mesh_id);
         `);
         this.migrateMeshIsolationColumns();
       }
@@ -6262,6 +6417,17 @@ var init_mesh_runtime_store = __esm({
           if (!missionCols.has("source")) {
             this.db.exec(`ALTER TABLE mesh_missions ADD COLUMN source TEXT`);
           }
+          const pendingCols = this.tableColumns("mesh_pending_events");
+          for (const col of ["protocol_version", "event_id", "scope", "dispatched_by", "intended_for"]) {
+            if (!pendingCols.has(col)) {
+              this.db.exec(`ALTER TABLE mesh_pending_events ADD COLUMN ${col} TEXT`);
+            }
+          }
+          this.db.exec(`
+                CREATE INDEX IF NOT EXISTS idx_mesh_pending_events_event_id
+                    ON mesh_pending_events(mesh_id, event_id)
+                    WHERE event_id IS NOT NULL
+            `);
         } catch (err) {
           if (!loggedMigrationFailure) {
             loggedMigrationFailure = true;
@@ -6478,6 +6644,62 @@ var init_mesh_runtime_store = __esm({
           return current;
         });
       }
+      // ── Acked-Hold State (T2 / B2b) ──────────────────────────────────────────
+      //
+      // Persistent mirror of the reconcile loop's inFlightAckedHoldState Map. Keyed
+      // by task_id (one in-flight dispatch = one hold). These are plain read/write/
+      // delete/list accessors; the read-through/write-through cache and the restart
+      // rehydrate live in mesh-reconcile-loop.ts.
+      mapInflightHoldRow(r) {
+        if (!r) return null;
+        return {
+          taskId: r.task_id,
+          meshId: r.mesh_id ?? null,
+          holdReason: r.hold_reason ?? null,
+          heldAt: r.held_at ?? null,
+          firstIdleSinceAck: r.first_idle_since_ack ?? null,
+          readFailureCount: r.read_failure_count ?? null,
+          updatedAt: r.updated_at ?? null
+        };
+      }
+      upsertInflightHold(entry) {
+        const now = Date.now();
+        this.db.prepare(`
+            INSERT INTO mesh_inflight_hold
+                (task_id, mesh_id, hold_reason, held_at, first_idle_since_ack, read_failure_count, updated_at)
+            VALUES (@taskId, @meshId, @holdReason, @heldAt, @firstIdleSinceAck, @readFailureCount, @updatedAt)
+            ON CONFLICT(task_id) DO UPDATE SET
+                mesh_id = excluded.mesh_id,
+                hold_reason = excluded.hold_reason,
+                first_idle_since_ack = excluded.first_idle_since_ack,
+                read_failure_count = excluded.read_failure_count,
+                updated_at = excluded.updated_at
+        `).run({
+          taskId: entry.taskId,
+          meshId: entry.meshId ?? null,
+          holdReason: entry.holdReason ?? null,
+          heldAt: entry.heldAt ?? now,
+          firstIdleSinceAck: entry.firstIdleSinceAck ?? null,
+          readFailureCount: entry.readFailureCount ?? null,
+          updatedAt: now
+        });
+        this.maybeCheckpointWal();
+      }
+      getInflightHold(taskId) {
+        const row = this.db.prepare(
+          "SELECT * FROM mesh_inflight_hold WHERE task_id = ?"
+        ).get(taskId);
+        return this.mapInflightHoldRow(row);
+      }
+      listInflightHoldsByMesh(meshId) {
+        const rows = this.db.prepare(
+          "SELECT * FROM mesh_inflight_hold WHERE mesh_id = ?"
+        ).all(meshId);
+        return rows.map((r) => this.mapInflightHoldRow(r)).filter((r) => r !== null);
+      }
+      deleteInflightHold(taskId) {
+        this.db.prepare("DELETE FROM mesh_inflight_hold WHERE task_id = ?").run(taskId);
+      }
       /**
        * Count active (status='assigned') tasks on a (node, provider) combination,
        * matched by the assignedProviderType stamped on the payload at claim time.
@@ -7213,8 +7435,9 @@ var init_mesh_runtime_store = __esm({
       insertPendingEvent(event) {
         const result = this.db.prepare(
           `INSERT OR IGNORE INTO mesh_pending_events
-             (id, mesh_id, coordinator_daemon_id, event, payload, fingerprint, queued_at)
-             VALUES (?, ?, ?, ?, ?, ?, ?)`
+             (id, mesh_id, coordinator_daemon_id, event, payload, fingerprint, queued_at,
+              protocol_version, event_id, scope, dispatched_by, intended_for)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
         ).run(
           event.id,
           event.meshId,
@@ -7222,7 +7445,12 @@ var init_mesh_runtime_store = __esm({
           event.event,
           JSON.stringify(event.payload ?? {}),
           event.fingerprint ?? null,
-          event.queuedAt
+          event.queuedAt,
+          event.protocolVersion ?? null,
+          event.eventId ?? null,
+          event.scope ?? null,
+          event.dispatchedBy ?? null,
+          event.intendedFor ?? null
         );
         this.maybeCheckpointWal();
         return result.changes > 0;
@@ -11289,7 +11517,35 @@ function trimPendingEventsIfNeeded(path44) {
   } catch {
   }
 }
-function queuePendingMeshCoordinatorEvent(event) {
+function stampPendingEventV2(event, hint) {
+  if (event.protocolVersion === MESH_PROTOCOL_VERSION_V2 && readNonEmptyString2(event.eventId)) {
+    return event;
+  }
+  const dispatchedBy = hint?.dispatchedBy ?? coordinatorIdentityFromEmitFields({
+    daemonId: event.targetCoordinatorDaemonId,
+    coordinatorRunId: hint?.coordinatorRunId,
+    sessionId: event.targetCoordinatorSessionId
+  });
+  const intendedFor = hint?.intendedFor ?? dispatchedBy;
+  const stamp = buildPendingEventEmitStamp({
+    eventName: event.event,
+    eventId: randomUUID8(),
+    dispatchedBy,
+    intendedFor,
+    scope: hint?.scope
+  });
+  if (!stamp) return event;
+  return {
+    ...event,
+    protocolVersion: stamp.protocolVersion,
+    eventId: stamp.eventId,
+    scope: stamp.scope,
+    dispatchedBy: stamp.dispatchedBy,
+    ...stamp.intendedFor ? { intendedFor: stamp.intendedFor } : {}
+  };
+}
+function queuePendingMeshCoordinatorEvent(rawEvent, hint) {
+  const event = stampPendingEventV2(rawEvent, hint);
   try {
     if (hasPendingRefineTerminalEventDuplicate(event)) {
       LOG.info("MeshEvents", `Suppressed duplicate pending ${event.event} for refine job ${readRefineJobId2(event)}`);
@@ -11309,7 +11565,16 @@ function queuePendingMeshCoordinatorEvent(event) {
         event: event.event,
         payload: event,
         fingerprint: fingerprint || null,
-        queuedAt: event.queuedAt
+        queuedAt: event.queuedAt,
+        // v2 envelope columns (B2a) — all nullable so v1 rows coexist. The
+        // authoritative copy still rides inside `payload`; these columns exist
+        // for queryable idempotency (event_id) and scope-based drain filtering
+        // (scope / intended_for) without JSON-parsing every row.
+        protocolVersion: event.protocolVersion ?? null,
+        eventId: event.eventId ?? null,
+        scope: event.scope ?? null,
+        dispatchedBy: event.dispatchedBy ? JSON.stringify(event.dispatchedBy) : null,
+        intendedFor: event.intendedFor ? JSON.stringify(event.intendedFor) : null
       });
       sqliteOk = true;
     } catch {
@@ -11529,6 +11794,7 @@ var init_mesh_events_pending = __esm({
     init_mesh_runtime_store();
     init_mesh_events_utils();
     init_dist();
+    init_contracts();
     REFINE_TERMINAL_EVENTS = /* @__PURE__ */ new Set(["refine:completed", "refine:failed"]);
     TERMINAL_COMPLETION_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
     MAX_PENDING_EVENTS_BYTES = 100 * 1024;
@@ -13237,6 +13503,18 @@ function nodeActiveLoad(meshId, nodeId) {
 function resolveSchedulingStrategy(mesh) {
   return normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
 }
+function buildSchedulingPool(localCandidates, remoteCandidates) {
+  const pool = [...localCandidates, ...remoteCandidates].map((c) => ({
+    ...c,
+    nodeId: normalizeMeshNodeId(c.node) ?? c.nodeId
+  }));
+  const uniqueNodes = [...new Set(pool.map((c) => c.nodeId))].map((nodeId, index) => ({
+    nodeId,
+    node: pool.find((c) => meshNodeIdMatches({ id: c.nodeId }, nodeId))?.node,
+    index
+  }));
+  return { pool, uniqueNodes };
+}
 function orderEligibleNodes(meshId, strategy, nodes, opts) {
   if (strategy === "first_eligible" || nodes.length <= 1) {
     return nodes;
@@ -13775,12 +14053,11 @@ async function triggerMeshQueue(components, meshId) {
     for (const candidate of localCandidates) assignIdleCandidate(candidate);
     for (const candidate of remoteCandidates) assignIdleCandidate(candidate);
   } else {
-    const pool = [...localCandidates, ...remoteCandidates];
+    const { pool, uniqueNodes } = buildSchedulingPool(localCandidates, remoteCandidates);
     const baseIndex = /* @__PURE__ */ new Map();
     pool.forEach((c, i) => {
       if (!baseIndex.has(c.nodeId)) baseIndex.set(c.nodeId, i);
     });
-    const uniqueNodes = [...new Set(pool.map((c) => c.nodeId))].map((nodeId, index) => ({ nodeId, node: pool.find((c) => c.nodeId === nodeId)?.node, index }));
     const ranked = orderEligibleNodes(meshId, strategy, uniqueNodes, { bumpCursor: true });
     const rankIndex = new Map(ranked.map((r, i) => [r.nodeId, i]));
     const remaining = [...pool];
@@ -14898,7 +15175,7 @@ function flattenContent(content) {
   if (typeof content === "string") return content;
   return flattenMessageParts(normalizeMessageParts(content));
 }
-var init_contracts = __esm({
+var init_contracts2 = __esm({
   "src/providers/contracts.ts"() {
     "use strict";
     init_io_contracts();
@@ -15262,7 +15539,7 @@ var DEFAULT_FINAL_SUMMARY_MAX_CHARS, BUILTIN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_VI
 var init_chat_message_normalization = __esm({
   "src/providers/chat-message-normalization.ts"() {
     "use strict";
-    init_contracts();
+    init_contracts2();
     DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16e3;
     BUILTIN_CHAT_MESSAGE_KINDS = ["standard", "thought", "tool", "terminal", "system"];
     CHAT_MESSAGE_VISIBILITIES = ["user", "debug", "internal", "hidden"];
@@ -15501,7 +15778,7 @@ ${cleanBody}`;
 var init_control_effects = __esm({
   "src/providers/control-effects.ts"() {
     "use strict";
-    init_contracts();
+    init_contracts2();
     init_chat_message_normalization();
   }
 });
@@ -17679,6 +17956,85 @@ function resolveAckedTranscriptFastTrackGraceMs() {
 function inFlightSynthKey(meshId, taskId) {
   return `${meshId}::${taskId}`;
 }
+function taskIdFromSynthKey(meshId, synthKey) {
+  const prefix = `${meshId}::`;
+  return synthKey.startsWith(prefix) ? synthKey.slice(prefix.length) : synthKey;
+}
+function holdStore() {
+  try {
+    return MeshRuntimeStore.getInstance();
+  } catch {
+    return void 0;
+  }
+}
+function getHoldState(synthKey, meshId) {
+  const cached3 = inFlightAckedHoldState.get(synthKey);
+  if (cached3) return cached3;
+  const store = holdStore();
+  if (!store) return void 0;
+  let row;
+  try {
+    row = store.getInflightHold(taskIdFromSynthKey(meshId, synthKey));
+  } catch {
+    return void 0;
+  }
+  if (!row) return void 0;
+  const state = {
+    liveConfirmedSinceAck: row.holdReason === "live",
+    consecutiveReadFailures: row.readFailureCount ?? 0,
+    ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {}
+  };
+  inFlightAckedHoldState.set(synthKey, state);
+  return state;
+}
+function setHoldState(synthKey, meshId, state) {
+  inFlightAckedHoldState.set(synthKey, state);
+  const store = holdStore();
+  if (!store) return;
+  try {
+    store.upsertInflightHold({
+      taskId: taskIdFromSynthKey(meshId, synthKey),
+      meshId,
+      holdReason: state.liveConfirmedSinceAck ? "live" : "unconfirmed",
+      firstIdleSinceAck: state.transcriptIdleSinceMs ?? null,
+      readFailureCount: state.consecutiveReadFailures
+    });
+  } catch {
+  }
+}
+function deleteHoldState(synthKey, meshId) {
+  inFlightAckedHoldState.delete(synthKey);
+  const store = holdStore();
+  if (!store) return;
+  try {
+    store.deleteInflightHold(taskIdFromSynthKey(meshId, synthKey));
+  } catch {
+  }
+}
+function rehydrateAckedHoldsForMesh(meshId) {
+  if (rehydratedHoldMeshes.has(meshId)) return;
+  rehydratedHoldMeshes.add(meshId);
+  const store = holdStore();
+  if (!store) return;
+  let rows;
+  try {
+    rows = store.listInflightHoldsByMesh(meshId);
+  } catch {
+    return;
+  }
+  for (const row of rows) {
+    const synthKey = inFlightSynthKey(meshId, row.taskId);
+    if (inFlightAckedHoldState.has(synthKey)) continue;
+    inFlightAckedHoldState.set(synthKey, {
+      liveConfirmedSinceAck: row.holdReason === "live",
+      consecutiveReadFailures: row.readFailureCount ?? 0,
+      ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {}
+    });
+  }
+  if (rows.length > 0) {
+    LOG.info("MeshReconcile", `Rehydrated ${rows.length} persisted acked-hold row(s) for mesh ${meshId} after (re)start`);
+  }
+}
 function resolveCoordinatorDaemonIds(components) {
   const statusInstanceId = readNonEmptyString2(components.statusInstanceId);
   const machineId = readNonEmptyString2(loadConfig().machineId);
@@ -18470,15 +18826,27 @@ async function reprobeWorkerStatus(components, args) {
 }
 async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds, localDaemonId) {
   const dispatches = getActiveDirectDispatches(mesh.id);
-  if (dispatches.length === 0) return;
+  rehydrateAckedHoldsForMesh(mesh.id);
   const activeTaskKeys = new Set(
     dispatches.map((d) => readNonEmptyString2(d.taskId)).filter(Boolean).map((taskId) => inFlightSynthKey(mesh.id, taskId))
   );
+  const heldKeys = /* @__PURE__ */ new Set();
   for (const key2 of inFlightAckedHoldState.keys()) {
-    if (key2.startsWith(`${mesh.id}::`) && !activeTaskKeys.has(key2)) {
-      inFlightAckedHoldState.delete(key2);
+    if (key2.startsWith(`${mesh.id}::`)) heldKeys.add(key2);
+  }
+  const store = holdStore();
+  if (store) {
+    try {
+      for (const row of store.listInflightHoldsByMesh(mesh.id)) {
+        heldKeys.add(inFlightSynthKey(mesh.id, row.taskId));
+      }
+    } catch {
     }
   }
+  for (const key2 of heldKeys) {
+    if (!activeTaskKeys.has(key2)) deleteHoldState(key2, mesh.id);
+  }
+  if (dispatches.length === 0) return;
   const dispatchMeshCommand = components.dispatchMeshCommand;
   const nodeById = new Map(mesh.nodes.map((n) => [n.id, n]));
   for (const dispatch of dispatches) {
@@ -18525,25 +18893,25 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     if (!payload && !readFailed) continue;
     if (readFailed || !payload) {
       if (isAcked) {
-        const prior = inFlightAckedHoldState.get(synthKey);
+        const prior = getHoldState(synthKey, mesh.id);
         const failures = (prior?.consecutiveReadFailures ?? 0) + 1;
         const liveConfirmedSinceAck = prior?.liveConfirmedSinceAck ?? false;
-        inFlightAckedHoldState.set(synthKey, { liveConfirmedSinceAck, consecutiveReadFailures: failures });
+        setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck, consecutiveReadFailures: failures });
         if (liveConfirmedSinceAck && failures >= ACKED_DEATH_CONSECUTIVE_READ_FAILURES) {
           LOG.warn("MeshReconcile", `Acked-hold death signal: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read_chat failed ${failures}x consecutively after a live-confirmed ack \u2014 worker session presumed gone mid-turn; releasing the indefinite synth hold to the stranded-reclaim / orphan-prune nets`);
         }
       }
       continue;
     }
-    const priorHoldState = inFlightAckedHoldState.get(synthKey);
-    inFlightAckedHoldState.set(synthKey, {
+    const priorHoldState = getHoldState(synthKey, mesh.id);
+    setHoldState(synthKey, mesh.id, {
       liveConfirmedSinceAck: true,
       consecutiveReadFailures: 0,
       ...priorHoldState?.transcriptIdleSinceMs !== void 0 ? { transcriptIdleSinceMs: priorHoldState.transcriptIdleSinceMs } : {}
     });
     const nowMs = Date.now();
     if (readChatPayloadStatus(payload) !== "idle") {
-      inFlightAckedHoldState.set(synthKey, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
+      setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
       continue;
     }
     const messages = Array.isArray(payload.messages) ? payload.messages : [];
@@ -18552,12 +18920,12 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
       const ackedAtMs = Date.parse(readNonEmptyString2(dispatch.updatedAt));
       const sinceAckMs = Number.isFinite(ackedAtMs) ? nowMs - ackedAtMs : Number.POSITIVE_INFINITY;
       const deathDeadlineMs = resolveAckedDeathDeadlineMs();
-      const holdState = inFlightAckedHoldState.get(synthKey);
+      const holdState = getHoldState(synthKey, mesh.id);
       let fastTrackReady = false;
       if (evidence.finalSummary) {
         const idleSinceMs = holdState?.transcriptIdleSinceMs ?? nowMs;
         if (holdState && holdState.transcriptIdleSinceMs === void 0) {
-          inFlightAckedHoldState.set(synthKey, { ...holdState, transcriptIdleSinceMs: idleSinceMs });
+          setHoldState(synthKey, mesh.id, { ...holdState, transcriptIdleSinceMs: idleSinceMs });
         }
         const fastTrackGraceMs = resolveAckedTranscriptFastTrackGraceMs();
         const idleHeldMs = nowMs - idleSinceMs;
@@ -18566,7 +18934,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
           LOG.info("MeshReconcile", `Acked-hold transcript fast-track: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle WITH a final assistant message for ${Math.round(idleHeldMs / 1e3)}s continuous (grace ${Math.round(fastTrackGraceMs / 1e3)}s) \u2014 promoting the synth ahead of the ${Math.round(deathDeadlineMs / 1e3)}s death backstop; the worker's real emit was lost/late and a later one no-ops idempotently.`);
         }
       } else if (holdState?.transcriptIdleSinceMs !== void 0) {
-        inFlightAckedHoldState.set(synthKey, { ...holdState, transcriptIdleSinceMs: void 0 });
+        setHoldState(synthKey, mesh.id, { ...holdState, transcriptIdleSinceMs: void 0 });
       }
       if (!fastTrackReady && sinceAckMs < deathDeadlineMs) {
         LOG.info("MeshReconcile", `Acked-hold: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle ${Number.isFinite(sinceAckMs) ? Math.round(sinceAckMs / 1e3) + "s" : "\u221E"} since the generating_started ack \u2014 HOLDING synth (worker presumed alive; a later real emit is idempotent). Transcript fast-track promotes at ${Math.round(resolveAckedTranscriptFastTrackGraceMs() / 1e3)}s continuous idle-with-final-assistant; death backstop at ${Math.round(deathDeadlineMs / 1e3)}s or on consecutive read failures.`);
@@ -18577,7 +18945,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
       }
     }
     if (realTerminalEmitPendingForTask(mesh.id, taskId)) {
-      inFlightAckedHoldState.delete(synthKey);
+      deleteHoldState(synthKey, mesh.id);
       LOG.info("MeshReconcile", `Worker-emit priority: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) has a real terminal completion already queued \u2014 yielding synth to the worker's own emit`);
       continue;
     }
@@ -18597,7 +18965,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     }
     const reprobeStatus = await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
     if (reprobeStatus && reprobeStatus !== "idle") {
-      inFlightAckedHoldState.delete(synthKey);
+      deleteHoldState(synthKey, mesh.id);
       LOG.info("MeshReconcile", `Live re-probe defer: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read '${reprobeStatus}' at synth-commit time \u2014 worker resumed generating; deferring synth to a later tick`);
       continue;
     }
@@ -18739,7 +19107,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, rehydratedHoldMeshes, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -18766,6 +19134,7 @@ var init_mesh_reconcile_loop = __esm({
     DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS = 12e3;
     ACKED_DEATH_CONSECUTIVE_READ_FAILURES = 3;
     inFlightAckedHoldState = /* @__PURE__ */ new Map();
+    rehydratedHoldMeshes = /* @__PURE__ */ new Set();
     coordinatorModalParkState = /* @__PURE__ */ new Map();
     heldEventLedgerRecorded = /* @__PURE__ */ new Set();
     ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
@@ -27460,11 +27829,11 @@ var CdpDomHandlers = class {
 };
 
 // src/providers/ide-provider-instance.ts
-init_contracts();
+init_contracts2();
 import * as crypto2 from "crypto";
 
 // src/providers/extension-provider-instance.ts
-init_contracts();
+init_contracts2();
 
 // src/providers/status-monitor.ts
 var DEFAULT_MONITOR_CONFIG = {
@@ -29496,7 +29865,7 @@ init_logger();
 init_control_effects();
 
 // src/providers/read-chat-contract.ts
-init_contracts();
+init_contracts2();
 
 // src/providers/transcript-v2.ts
 var CHAT_CONTRACT_VERSION_V1 = "1.0";
@@ -30941,7 +31310,7 @@ import * as path17 from "path";
 import { randomUUID as randomUUID11 } from "crypto";
 
 // src/commands/chat-commands-read.ts
-init_contracts();
+init_contracts2();
 import * as path16 from "path";
 init_coordinator_registry();
 init_logger();
@@ -33197,7 +33566,7 @@ async function handleGetChatDebugBundle(h, args) {
 }
 
 // src/commands/chat-commands-write.ts
-init_contracts();
+init_contracts2();
 init_provider_input_support();
 init_approval_utils();
 init_logger();
@@ -37939,7 +38308,7 @@ import chalk from "chalk";
 init_summary_metadata();
 
 // src/providers/cli-provider-instance.ts
-init_contracts();
+init_contracts2();
 init_provider_input_support();
 import * as os20 from "os";
 import * as path26 from "path";
@@ -43711,7 +44080,7 @@ ${effect.notification.body || ""}`.trim();
 };
 
 // src/providers/acp-provider-instance.ts
-init_contracts();
+init_contracts2();
 init_provider_input_support();
 import * as path27 from "path";
 import { Readable, Writable } from "stream";
@@ -44963,7 +45332,7 @@ ${rawInput}` : rawInput;
 };
 
 // src/commands/cli-manager.ts
-init_contracts();
+init_contracts2();
 init_provider_input_support();
 init_logger();
 
@@ -56155,7 +56524,8 @@ function queueRefineJobEvent(self, event, handle, result) {
 }
 async function appendRefineJobLedger(self, kind, handle, result) {
   try {
-    const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+    const { appendLedgerEntry: appendLedgerEntry2, buildLedgerOriginatingCoordinatorStamp: buildLedgerOriginatingCoordinatorStamp2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+    const originatingStamp = kind === "task_dispatched" ? buildLedgerOriginatingCoordinatorStamp2({ coordinatorDaemonId: handle.targetCoordinatorDaemonId }) : void 0;
     appendLedgerEntry2(handle.meshId, {
       kind,
       nodeId: handle.targetNodeId,
@@ -56176,6 +56546,7 @@ async function appendRefineJobLedger(self, kind, handle, result) {
         },
         async: true,
         retryOfJobId: handle.retryOfJobId,
+        ...originatingStamp ? { originatingCoordinator: originatingStamp } : {},
         ...result ? {
           success: result.success === true,
           result,
@@ -57189,7 +57560,8 @@ function queueRefineBatchJobEvent(self, event, handle, result) {
 }
 async function appendRefineBatchJobLedger(self, kind, handle, result) {
   try {
-    const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+    const { appendLedgerEntry: appendLedgerEntry2, buildLedgerOriginatingCoordinatorStamp: buildLedgerOriginatingCoordinatorStamp2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+    const originatingStamp = kind === "task_dispatched" ? buildLedgerOriginatingCoordinatorStamp2({ coordinatorDaemonId: handle.targetCoordinatorDaemonId }) : void 0;
     appendLedgerEntry2(handle.meshId, {
       kind,
       nodeId: handle.batchLabel,
@@ -57209,6 +57581,7 @@ async function appendRefineBatchJobLedger(self, kind, handle, result) {
         },
         async: true,
         batch: true,
+        ...originatingStamp ? { originatingCoordinator: originatingStamp } : {},
         ...result ? {
           success: result.success === true,
           result