@adhdev/daemon-core 0.9.82-rc.291 → 0.9.82-rc.293

package/src/git/git-status.ts

@@ -143,11 +143,39 @@ const WEB_ONLY_PACKAGES = new Set([
   'terminal-render-web',
 ]);
 
+/**
+ * Root-level (non-package) files that demonstrably cannot change what the daemon
+ * runtime executes: convergence/verify markers, documentation, and license/notice
+ * text. A root commit that moves the oss gitlink while the oss commit only touched
+ * one of these is NOT a reason to rebuild/restart the daemon — flagging it produces
+ * the staleDaemonBuild false-positive this guard exists to suppress.
+ *
+ * Deliberately conservative: anything NOT matched here (root config like
+ * package.json / tsconfig / build scripts, `.txt` fixtures, lockfiles, unknown
+ * dotfiles) stays daemon-affecting, because a false-negative — staying silent when
+ * the daemon really IS stale — is worse than an over-warn. Markers are the common
+ * real-world case (e.g. `.verify-patch-equiv-rc292`), so they are matched broadly;
+ * docs are matched by the `docs/` prefix or a markdown/text-doc extension at a
+ * filename we recognize as documentation (README/CHANGELOG/LICENSE/NOTICE).
+ */
+function isNonRuntimeRootFile(file: string): boolean {
+  const base = file.slice(file.lastIndexOf('/') + 1);
+  // Verify/convergence markers: dotfiles whose name signals a transient marker.
+  if (/^\.(?:verify|marker|converge|ff-verify|patch-equiv|live-verify)\b/i.test(base)) return true;
+  // Documentation living under a docs/ tree (any depth, root or nested).
+  if (/(?:^|\/)docs\//i.test(file)) return true;
+  // Recognized top-level documentation / license files.
+  if (/^(?:README|CHANGELOG|LICENSE|NOTICE|AUTHORS|CONTRIBUTING|CODEOWNERS)(?:\.[A-Za-z0-9]+)?$/i.test(base)) {
+    return true;
+  }
+  return false;
+}
+
 /**
  * Determine whether the changes between buildCommit..HEAD touch any daemon-runtime
  * package. Returns isDaemonAffecting:true conservatively when the changed-file set
  * can't be obtained or any changed path is outside the known web-only package set
- * (including root-level / non-package files).
+ * AND is not a recognized non-runtime root file (marker/doc/license).
  */
 async function classifyDaemonBuildChange(
   repoPath: string,
@@ -166,24 +194,28 @@ async function classifyDaemonBuildChange(
       return { isDaemonAffecting: true, affectedPackages: [] };
     }
     const pkgs = new Set<string>();
-    let sawNonPackageOrUnknown = false;
+    // A non-package path that is NOT a recognized benign root file (marker/doc).
+    // Only these force daemon-affecting; benign markers/docs are ignored so a
+    // gitlink-moving root commit over a marker-only oss commit no longer over-warns.
+    let sawRuntimeAmbiguousNonPackage = false;
     for (const file of files) {
       const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
       if (!match) {
-        sawNonPackageOrUnknown = true;
+        if (!isNonRuntimeRootFile(file)) sawRuntimeAmbiguousNonPackage = true;
         continue;
       }
       pkgs.add(match[1]);
     }
     const affectedPackages = [...pkgs].sort();
-    // Daemon-affecting if: any non-package/root file changed, any unknown package
-    // changed, or any explicit daemon-runtime package changed. Only when EVERY
-    // changed file maps to a known web-only package is the daemon unaffected.
-    const allWebOnly =
-      !sawNonPackageOrUnknown &&
-      affectedPackages.length > 0 &&
+    // Daemon-affecting if: any runtime-ambiguous non-package file changed, any
+    // unknown package changed, or any explicit daemon-runtime package changed.
+    // The daemon is unaffected only when every changed file is either a known
+    // web-only package or a recognized benign root file (and at least one such
+    // file changed) — i.e. nothing runtime-ambiguous remains.
+    const allBenign =
+      !sawRuntimeAmbiguousNonPackage &&
       affectedPackages.every((p) => WEB_ONLY_PACKAGES.has(p) && !DAEMON_RUNTIME_PACKAGES.has(p));
-    return { isDaemonAffecting: !allWebOnly, affectedPackages };
+    return { isDaemonAffecting: !allBenign, affectedPackages };
   } catch {
     // diff probe failed → can't prove web-only; stay conservative.
     return { isDaemonAffecting: true, affectedPackages: [] };
@@ -229,11 +261,14 @@ async function detectDaemonBuildBehind(
         options,
       );
       const scopeLabel = scope === 'root' ? 'workspace' : scope;
+      const benignDetail = affectedPackages.length > 0
+        ? `only web packages changed (${affectedPackages.join(', ')})`
+        : 'only non-runtime files changed (markers/docs)';
       const warning = isDaemonAffecting
         ? `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}. ` +
           `Merged code is NOT live until the daemon is rebuilt/redeployed and restarted — a local dist rebuild alone does not update a cloud daemon.`
         : `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}, ` +
-          `but only web packages changed (${(affectedPackages || []).join(', ') || 'web'}). ` +
+          `but ${benignDetail}. ` +
           `Daemon restart NOT required — redeploy the web app to reflect the change.`;
       return {
         buildCommit: build.commit,

package/src/mesh/coordinator-prompt.ts

@@ -350,7 +350,7 @@ const WORKFLOW_SECTION = `## Orchestration Workflow
    c. **Targeted Tasks**: Use \`mesh_send_task\` only when you need to bypass the queue and force a specific node to execute a task immediately.
    d. For the first dispatch of a new task, provide a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
    e. For a continuation of the same issue in an existing session, send a concise **delta instruction**: current verified state, the exact failed/blocked step, the newly approved action, and final reporting requirements. Do not resend the full original task or open a new chat solely to continue the same work; that wastes coordinator and worker context.
-4. **Monitor** — Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`.
+4. **Monitor** — Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`. **Proactively parallelize new work.** When the user reports a new bug or asks for new work, start it immediately if it is independent of in-flight tasks and there is headroom under \`maxParallelTasks\` — do not wait for a current task to finish or for the user to prompt you to parallelize. Read-only diagnosis (\`live_debug_readonly\`) has no isolation or merge cost, so dispatch it in parallel right away. The no-polling / concurrency-limit rules constrain *re-checking or duplicating already-dispatched work*; they are **not** a reason to defer starting a new, independent task.
 5. **Verify** — When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** — Call \`mesh_checkpoint\` to save the work.
 7. **Converge branches** — Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
@@ -382,7 +382,7 @@ function buildRulesSection(coordinatorCliType?: string): string {
 - **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start fresh only for independent work, provider mismatch, transcript contamination, or required worktree isolation.
 - **Respect explicit provider requests.** Map: Hermes → \`hermes-cli\`, Claude/Claude Code → \`claude-cli\`, Codex → \`codex-cli\`, Gemini → \`gemini-cli\`, Antigravity → \`antigravity-cli\`. Never substitute the coordinator's own runtime.
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
-- **Limit parallelism.** Start with 1–2 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing.
+- **Limit parallelism.** Start with 1–2 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load — it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).
 - **Check history first.** Call \`mesh_task_history\` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.
 - **Converge branches.** After worktree tasks: refine/fast-forward, or classify as \`pushed_feature_branch_needs_merge\` / \`blocked_review\` / \`cleanup_candidate\` / \`not_mergeable\`. Clean up with \`mesh_remove_node\`.
 - **Refinery is config-driven.** \`mesh_refine_node\` must run validation from \`.adhdev/refine.{json,yaml,yml}\` or \`repo-mesh.refine.*\`. Heuristics are scaffolding only.

package/src/mesh/mesh-active-work.ts

@@ -1,5 +1,6 @@
 import type { MeshLedgerEntry } from './mesh-ledger.js';
 import type { MeshWorkQueueEntry, DirectDispatchRecord } from './mesh-work-queue.js';
+import { meshNodeIdMatches } from '@adhdev/mesh-shared';
 
 export type MeshActiveWorkSource = 'queue' | 'direct';
 export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval';
@@ -102,7 +103,7 @@ function elapsedSince(value: string | undefined, now: number): number {
 function sessionStatusFromNodes(nodes: any[] | undefined, nodeId?: string, sessionId?: string): { status?: MeshActiveWorkStatus; staleReason?: string } {
     if (!Array.isArray(nodes)) return {};
     if (!nodeId) return { staleReason: 'direct task has no node id' };
-    const node = nodes.find(item => readString(item?.id) === nodeId || readString(item?.nodeId) === nodeId || readString(item?.node_id) === nodeId);
+    const node = nodes.find(item => meshNodeIdMatches(item, nodeId));
     if (!node) return { staleReason: 'direct task node is no longer in the live mesh' };
     if (!sessionId) return {};
     const candidates: any[] = [];

package/src/mesh/mesh-events-coordinator.ts

@@ -13,7 +13,9 @@ import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
+import { enqueueUnresolvedDelegateForward, peekUnresolvedDelegateForwards, ackUnresolvedDelegateForward } from './mesh-unresolved-forward-outbox.js';
 import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
+import { normalizeMeshNodeId, meshNodeIdMatches } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
     hasDispatchAfterTerminal,
@@ -610,9 +612,11 @@ async function resolveUsableProvider(
 // target-routed task permanently pending with a misleading
 // `no_node_satisfies_required_tags` skip.
 function readMeshNodeId(node: any): string {
-    return readNonEmptyString(node?.id)
-        || readNonEmptyString(node?.nodeId)
-        || readNonEmptyString(node?.node_id);
+    // Delegate to the shared 3-way (id / nodeId / node_id) normalizer so this
+    // and every other mesh node-id read agree on identity. Coalesce to '' to
+    // preserve the existing string return contract for callers that do
+    // `=== task.targetNodeId` / `if (!nodeId)`.
+    return normalizeMeshNodeId(node) ?? '';
 }
 
 async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, meshId: string, mesh: any): Promise<boolean> {
@@ -895,7 +899,7 @@ async function maybeAutoFastForwardIdleNode(components: DaemonComponents, args:
     providerType?: string;
 }): Promise<void> {
     const mesh = getMeshWithCache(components, args.meshId);
-    const node = mesh?.nodes?.find((candidate: any) => candidate?.id === args.nodeId || candidate?.nodeId === args.nodeId);
+    const node = mesh?.nodes?.find((candidate: any) => meshNodeIdMatches(candidate, args.nodeId));
     const workspace = readNonEmptyString(node?.workspace);
     if (!workspace) return;
     if (!existsSync(workspace)) return;
@@ -1536,8 +1540,16 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
 //  - It fires only when the normal queue path did NOT run (isDelegate=false), so the
 //    event is never both queued locally and forwarded.
 //
-// Returns true when the event was handed off to the coordinator daemon (so the caller
-// skips the delivery_unroutable diagnostic); false when no fallback was possible.
+// Returns true when the event was durably accepted for delivery to the coordinator
+// daemon (so the caller skips the delivery_unroutable diagnostic); false when no
+// fallback was possible (no coordinator anchor / no dispatch transport).
+//
+// Durability: the directed push to the coordinator is the ONLY delivery route for an
+// unresolved-mesh worker (it is in no mesh.node the coordinator can pull). So instead
+// of a fire-and-forget push that drops on one transient P2P failure, the event is
+// persisted to the worker-side outbox FIRST and only acked after a successful push.
+// A best-effort immediate push keeps latency low on the happy path; a failed or
+// un-acked push leaves the durable row for setupMeshReconcileLoop's PHASE 0 to retry.
 function forwardUnresolvedDelegateEvent(
     components: DaemonComponents,
     routing: ReturnType<typeof resolveWorkerDelegateRouting>,
@@ -1561,16 +1573,52 @@ function forwardUnresolvedDelegateEvent(
         workspace: readNonEmptyString(routing.workspace) || readNonEmptyString(event.workspace) || undefined,
     };
 
+    // 1) Persist durably FIRST. Idempotent on fingerprint, so a re-fired completion
+    //    does not duplicate the outbox row. If persistence fails we still attempt the
+    //    push below (degrades to the old at-most-once behaviour rather than dropping
+    //    the chance entirely).
+    const persisted = enqueueUnresolvedDelegateForward(coordinatorDaemonId, eventName, payload);
+
+    // 2) Best-effort immediate push for low latency. On success, ack the outbox row so
+    //    the retry loop won't re-send it. On failure, leave it queued — PHASE 0 retries.
     Promise.resolve(components.dispatchMeshCommand(coordinatorDaemonId, 'mesh_forward_event', payload))
+        .then((result: any) => {
+            if (result && result.success === false) {
+                LOG.warn('MeshEvents', `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} rejected (${readNonEmptyString(result.error) || 'no reason'}) — left queued for retry`);
+                return;
+            }
+            // Acked. Mark the durable copy delivered so the retry loop skips it.
+            if (persisted) ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload);
+        })
         .catch((e: any) => {
-            // The coordinator may be momentarily unreachable; the diagnostic was already
-            // skipped, so leave a trace here so an operator can see the relay attempt failed.
-            LOG.warn('MeshEvents', `Fallback forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e}`);
+            // Coordinator momentarily unreachable; the durable row stays queued and the
+            // reconcile loop retries it. Trace so the relay attempt is visible.
+            LOG.warn('MeshEvents', `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e} — left queued for retry`);
         });
-    LOG.info('MeshEvents', `Fallback-forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || '(no workspace)'} to coordinator daemon ${coordinatorDaemonId}`);
+    LOG.info('MeshEvents', `Durably forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || '(no workspace)'} to coordinator daemon ${coordinatorDaemonId}`);
     return true;
 }
 
+// Ack a just-pushed outbox entry by re-deriving its row from the same coordinator +
+// event + payload. We don't thread the row id back from enqueue (the immediate push is
+// fire-then-ack), so locate it among the undrained entries by matching coordinator and
+// the flat payload's forward identity. A miss is harmless — the retry loop's own
+// receiver-side dedup suppresses a duplicate delivery.
+function ackUnresolvedDelegateForwardByFingerprint(
+    coordinatorDaemonId: string,
+    eventName: string,
+    payload: Record<string, unknown>,
+): void {
+    const match = peekUnresolvedDelegateForwards().find(entry =>
+        entry.coordinatorDaemonId === coordinatorDaemonId
+        && readNonEmptyString(entry.payload.event) === eventName
+        && readNonEmptyString(entry.payload.targetSessionId || entry.payload.sessionId || entry.payload.instanceId)
+            === readNonEmptyString(payload.targetSessionId || payload.sessionId || payload.instanceId)
+        && readNonEmptyString(entry.payload.workspace) === readNonEmptyString(payload.workspace),
+    );
+    if (match) ackUnresolvedDelegateForward(match.id);
+}
+
 export function setupMeshEventForwarding(components: DaemonComponents) {
     components.instanceManager.onEvent((event) => {
         // --- Coordinator idle auto-flush (fast path) ---

package/src/mesh/mesh-missions.ts

@@ -47,6 +47,25 @@ export interface MeshMissionSummary extends MeshMissionRecord {
     tasks: MeshMissionTaskAggregate;
 }
 
+/**
+ * Slim mission summary for the mesh_status compact (default) surface. Drops the
+ * full `goal` text — which can be hundreds of chars per mission and is repeated
+ * for every mission on every status call — keeping only a short preview plus a
+ * `goalTruncated` flag when the original was longer. The stored goal is never
+ * mutated; this is an output-only projection. Coordinators that need the full
+ * goal call mesh_status with verbose=true, or read the mission directly via
+ * mesh_mission_upsert / getMeshMission.
+ */
+export interface MeshMissionSlimSummary extends Omit<MeshMissionSummary, 'goal'> {
+    /** Short preview of the goal (≤ GOAL_PREVIEW_MAX chars), '' when goal empty. */
+    goalPreview: string;
+    /** True when the stored goal was longer than the preview (full text elided). */
+    goalTruncated: boolean;
+}
+
+/** Max chars of goal text retained in the slim (compact) mission summary. */
+export const GOAL_PREVIEW_MAX = 120;
+
 function normalizeMissionStatus(value: unknown): MeshMissionStatus {
     return MESH_MISSION_STATUSES.includes(value as MeshMissionStatus)
         ? value as MeshMissionStatus
@@ -125,17 +144,35 @@ export function getActiveMeshMissionSummaries(meshId: string): MeshMissionSummar
     return getMeshMissions(meshId, ['active']).map(mission => summarizeMeshMission(meshId, mission));
 }
 
+/** Project a full mission summary down to the slim (goal-elided) shape. */
+function slimMissionSummary(summary: MeshMissionSummary): MeshMissionSlimSummary {
+    const goal = typeof summary.goal === 'string' ? summary.goal : '';
+    const goalTruncated = goal.length > GOAL_PREVIEW_MAX;
+    const { goal: _omitGoal, ...rest } = summary;
+    return {
+        ...rest,
+        goalPreview: goalTruncated ? goal.slice(0, GOAL_PREVIEW_MAX) : goal,
+        goalTruncated,
+    };
+}
+
 /**
  * Mission summaries for the mesh_status dashboard surface: every active/paused
  * mission plus a capped, newest-first slice of completed/abandoned history so
  * the dashboard can render a collapsible "history" section without unbounded
  * payload growth. Returned newest-first within each group (active/paused first,
  * then history), so the frontend can split on `status` directly.
+ *
+ * Compact mode (the default) elides each mission's full `goal` text — which is
+ * repeated verbatim on every status poll and dominates the payload when a mesh
+ * has many missions — returning only a short `goalPreview` + `goalTruncated`
+ * flag. Pass `verbose: true` to get the full `goal` text per mission. The stored
+ * goal is untouched in both modes; this is an output-only projection.
  */
 export function getMeshStatusMissionSummaries(
     meshId: string,
-    options?: { historyLimit?: number },
-): MeshMissionSummary[] {
+    options?: { historyLimit?: number; verbose?: boolean },
+): MeshMissionSummary[] | MeshMissionSlimSummary[] {
     const historyLimit = Math.max(0, options?.historyLimit ?? 10);
     const all = getMeshMissions(meshId);
     const live = all.filter(m => m.status === 'active' || m.status === 'paused');
@@ -143,7 +180,8 @@ export function getMeshStatusMissionSummaries(
         .filter(m => m.status === 'completed' || m.status === 'abandoned')
         .sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''))
         .slice(0, historyLimit);
-    return [...live, ...history].map(mission => summarizeMeshMission(meshId, mission));
+    const full = [...live, ...history].map(mission => summarizeMeshMission(meshId, mission));
+    return options?.verbose ? full : full.map(slimMissionSummary);
 }
 
 /**

package/src/mesh/mesh-reconcile-loop.ts

@@ -49,6 +49,11 @@ import { drainPendingMeshCoordinatorEvents } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { handleMeshForwardEvent, shouldForceInjectMeshEvent, MESH_FORCE_INJECT_EVENTS } from './mesh-events-coordinator.js';
+import {
+    peekUnresolvedDelegateForwards,
+    ackUnresolvedDelegateForward,
+    expireStaleUnresolvedDelegateForwards,
+} from './mesh-unresolved-forward-outbox.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
 
 // Default reconcile cadence. approval/completion notifications to a live CLI
@@ -213,6 +218,20 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         try { return MeshRuntimeStore.getInstance(); } catch { return undefined; }
     })();
 
+    // ── PHASE 0: retry the worker-side unresolved-delegate forward outbox ──────
+    // Cloud-only (needs dispatchMeshCommand). A worker that is NOT a member of the
+    // coordinator's mesh cannot be reached by the coordinator's PHASE 1 pull (it is
+    // in no mesh.node), so its completion must be PUSHED to the coordinator. This
+    // drains the durable outbox enqueued by forwardUnresolvedDelegateEvent and retries
+    // any push that has not yet been acked. See mesh-unresolved-forward-outbox.ts.
+    if (dispatchMeshCommand) {
+        try {
+            await retryUnresolvedDelegateForwards(components);
+        } catch (e: any) {
+            LOG.warn('MeshReconcile', `Unresolved-delegate forward retry failed: ${e?.message || e}`);
+        }
+    }
+
     // ── PHASE 1: pull remote node queues for every mesh this daemon hosts ──────
     // Cloud-only (dispatchMeshCommand present). Runs whether or not a live CLI
     // coordinator exists — this is what lets an MCP/LLM coordinator ever see a
@@ -295,6 +314,42 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
     }
 }
 
+// Cloud-only: retry the worker-side unresolved-delegate forward outbox. For each
+// durably-queued entry, push it to its coordinator daemon over P2P (mesh_forward_event)
+// and ack (mark drained) ONLY on a successful, non-rejected response. A failed or
+// rejected push leaves the entry queued for the next tick — at-least-once delivery.
+// Stale entries (coordinator unreachable past the max age) are expired first so the
+// outbox can't grow without bound. The coordinator dedups duplicate deliveries on its
+// own fingerprint, so a retry that races the original immediate push is harmless.
+async function retryUnresolvedDelegateForwards(components: DaemonComponents): Promise<void> {
+    const dispatchMeshCommand = components.dispatchMeshCommand;
+    if (!dispatchMeshCommand) return;
+
+    // Drop entries that have exhausted their retry budget (fail-loud inside).
+    expireStaleUnresolvedDelegateForwards();
+
+    const entries = peekUnresolvedDelegateForwards();
+    if (entries.length === 0) return;
+
+    for (const entry of entries) {
+        let result: any;
+        try {
+            result = await dispatchMeshCommand(entry.coordinatorDaemonId, 'mesh_forward_event', entry.payload);
+        } catch (e: any) {
+            // Coordinator unreachable — keep the entry queued and try again next tick.
+            LOG.warn('MeshReconcile', `Retry forward to coordinator ${entry.coordinatorDaemonId} failed: ${e?.message || e} — left queued`);
+            continue;
+        }
+        if (result && result.success === false) {
+            LOG.warn('MeshReconcile', `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${readNonEmptyString(result.error) || 'no reason'}) — left queued`);
+            continue;
+        }
+        // Acked — mark the durable copy delivered.
+        ackUnresolvedDelegateForward(entry.id);
+        LOG.info('MeshReconcile', `Retried+delivered unresolved-delegate ${readNonEmptyString(entry.payload.event)} to coordinator ${entry.coordinatorDaemonId}`);
+    }
+}
+
 // Cloud-only: poll each remote worker node daemon for pending coordinator events
 // and re-inject them locally via handleMeshForwardEvent (which re-queues +
 // surfaces to the live coordinator on the next tick / immediately if idle).

package/src/mesh/mesh-runtime-store.ts

@@ -1396,4 +1396,34 @@ export class MeshRuntimeStore {
         ).get(meshId) as { cnt: number } | undefined;
         return row?.cnt ?? 0;
     }
+
+    /**
+     * Mark specific pending-event rows drained by id (ack). Used by the
+     * unresolved-delegate durable-forward outbox: an event is peeked (not drained)
+     * while its push to the coordinator is unconfirmed, then marked drained ONLY
+     * after the push is acked. A failed push leaves the row undrained so the next
+     * reconcile tick retries it. Returns the number of rows newly marked drained.
+     */
+    markPendingEventsDrainedById(ids: ReadonlyArray<string>): number {
+        const idList = ids.filter((id): id is string => typeof id === 'string' && id.length > 0);
+        if (idList.length === 0) return 0;
+        const now = Date.now();
+        return this.db.prepare(
+            `UPDATE mesh_pending_events SET drained = 1, drained_at = ? WHERE drained = 0 AND id IN (${idList.map(() => '?').join(',')})`
+        ).run(now, ...idList).changes;
+    }
+
+    /**
+     * Hard-delete pending-event rows by id (including the dedup fingerprint history).
+     * Used to expire an unresolved-delegate outbox entry that has exhausted its retry
+     * budget — fully removing it frees the fingerprint so a genuinely new completion
+     * for the same task could be re-queued later. Returns the number of rows deleted.
+     */
+    deletePendingEventsById(ids: ReadonlyArray<string>): number {
+        const idList = ids.filter((id): id is string => typeof id === 'string' && id.length > 0);
+        if (idList.length === 0) return 0;
+        return this.db.prepare(
+            `DELETE FROM mesh_pending_events WHERE id IN (${idList.map(() => '?').join(',')})`
+        ).run(...idList).changes;
+    }
 }

package/src/mesh/mesh-unresolved-forward-outbox.ts

@@ -0,0 +1,185 @@
+// ---------------------------------------------------------------------------
+// mesh-unresolved-forward-outbox — durable retry for unresolved-delegate forwards
+// ---------------------------------------------------------------------------
+// A REMOTE worker daemon that is P2P-remote-controlled by a coordinator is NOT a
+// member of the coordinator's mesh — it has no local mesh record. So when its
+// completion event reaches setupMeshEventForwarding, resolveWorkerDelegateRouting
+// returns mesh_unresolved: the worker carries the coordinator daemon anchor but no
+// resolvable mesh id, so the normal queue-then-coordinator-pull path can't be used
+// (the coordinator's reconcile PHASE 1 only pulls mesh.nodes, and this worker is in
+// none of them — see docs/refactoring/2026-06-16-mesh-completion-polling-single-model.md).
+//
+// The ONLY delivery route for this case is a directed push to the coordinator
+// daemon (mesh_forward_event over P2P). Previously that push was fire-and-forget:
+// a single dispatchMeshCommand whose rejection was only logged, so one transient
+// P2P failure dropped the completion forever (delivery_unroutable).
+//
+// This outbox makes that push DURABLE without inventing a new persistence layer:
+// it reuses the existing mesh_pending_events SQLite table (the same store every
+// other mesh coordinator event is persisted to), under a synthetic, reserved
+// "mesh id" namespace so it never collides with a real mesh's queue. The worker's
+// reconcile tick (PHASE 0) peeks the outbox, pushes each entry to its coordinator,
+// and marks it drained (acked) ONLY on a successful push — a failed push leaves the
+// row undrained for the next tick. Entries that exceed a max age are expired so the
+// outbox can't grow unbounded when a coordinator stays permanently unreachable.
+//
+// Idempotency:
+//   - Enqueue is idempotent on the event fingerprint (mesh_pending_events has a
+//     UNIQUE (mesh_id, fingerprint) index + INSERT OR IGNORE), so the same
+//     completion fired twice on the worker queues once.
+//   - The receiver dedups independently: handleMeshForwardEvent → injectMeshSystemMessage
+//     → queuePendingMeshCoordinatorEvent recomputes the fingerprint and suppresses a
+//     duplicate, so an at-least-once retry that double-delivers is harmless.
+// ---------------------------------------------------------------------------
+
+import { randomUUID } from 'crypto';
+import { LOG } from '../logging/logger.js';
+import { MeshRuntimeStore } from './mesh-runtime-store.js';
+import { buildPendingEventFingerprint, type PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
+import { readNonEmptyString } from './mesh-events-utils.js';
+
+// Reserved synthetic mesh id for the worker-side unresolved-forward outbox. The `::`
+// and leading `__` make it impossible to collide with a real mesh id (which are
+// `mesh_*` / `mreg_*` slugs). Scoping rows by coordinator_daemon_id inside this one
+// namespace lets a single worker forward to multiple coordinators.
+export const UNRESOLVED_FORWARD_OUTBOX_MESH_ID = '__unresolved_forward_outbox__';
+
+// Entries older than this are expired (dropped) rather than retried forever — a
+// coordinator that has been unreachable this long is treated as gone. Generous
+// enough to ride out a long coordinator outage / restart, bounded enough that a
+// permanently-dead coordinator can't accumulate outbox rows indefinitely.
+const UNRESOLVED_FORWARD_MAX_AGE_MS = 30 * 60 * 1000; // 30 minutes
+
+export interface UnresolvedForwardEntry {
+    /** Row id in mesh_pending_events; pass back to ack/expire after a push attempt. */
+    id: string;
+    /** The coordinator daemon to push this event to (mesh_forward_event target). */
+    coordinatorDaemonId: string;
+    /** The flat payload to forward (already shaped for handleMeshForwardEvent). */
+    payload: Record<string, unknown>;
+    /** When the entry was first enqueued (epoch ms) — used for age-based expiry. */
+    queuedAt: number;
+}
+
+function getStore(): MeshRuntimeStore | undefined {
+    try { return MeshRuntimeStore.getInstance(); } catch { return undefined; }
+}
+
+/**
+ * Durably enqueue an unresolved-delegate forward for a coordinator daemon. The
+ * `forwardPayload` is the flat shape handleMeshForwardEvent reads on the coordinator.
+ * Idempotent on the event fingerprint. Returns true when a new row was written (or a
+ * duplicate was harmlessly ignored), false on a hard persistence failure.
+ */
+export function enqueueUnresolvedDelegateForward(
+    coordinatorDaemonId: string,
+    eventName: string,
+    forwardPayload: Record<string, unknown>,
+): boolean {
+    const target = readNonEmptyString(coordinatorDaemonId);
+    const event = readNonEmptyString(eventName);
+    if (!target || !event) return false;
+    const store = getStore();
+    if (!store) return false;
+
+    const queuedAt = Date.now();
+    // Reuse the standard pending-event fingerprint so enqueue is idempotent AND the
+    // receiver's own dedup keys on a comparable identity. We synthesise the minimal
+    // PendingMeshCoordinatorEvent shape buildPendingEventFingerprint needs.
+    const fingerprintSource: PendingMeshCoordinatorEvent = {
+        event,
+        meshId: UNRESOLVED_FORWARD_OUTBOX_MESH_ID,
+        nodeLabel: readNonEmptyString(forwardPayload.nodeId) || readNonEmptyString(forwardPayload.workspace) || 'unresolved-delegate',
+        nodeId: readNonEmptyString(forwardPayload.nodeId) || undefined,
+        workspace: readNonEmptyString(forwardPayload.workspace) || undefined,
+        metadataEvent: forwardPayload,
+        queuedAt,
+        targetCoordinatorDaemonId: target,
+    };
+    // Scope the fingerprint to the coordinator so two coordinators awaiting the same
+    // worker session don't collapse into one outbox row.
+    const fingerprint = `${target}::${buildPendingEventFingerprint(fingerprintSource)}`;
+
+    try {
+        const inserted = store.insertPendingEvent({
+            id: randomUUID(),
+            meshId: UNRESOLVED_FORWARD_OUTBOX_MESH_ID,
+            coordinatorDaemonId: target,
+            event,
+            // Store the flat forward payload + the queue timestamp so the retry tick can
+            // rebuild the push args and apply age-based expiry without a schema change.
+            payload: { forwardPayload, coordinatorDaemonId: target, queuedAt },
+            fingerprint,
+            queuedAt,
+        });
+        if (inserted) {
+            LOG.info('MeshEvents', `Durably queued unresolved-delegate ${event} for coordinator ${target} (outbox)`);
+        }
+        return true;
+    } catch (e: any) {
+        LOG.warn('MeshEvents', `Failed to persist unresolved-delegate forward to outbox: ${e?.message || e}`);
+        return false;
+    }
+}
+
+/** Peek (non-destructive) every undrained outbox entry across all coordinators. */
+export function peekUnresolvedDelegateForwards(): UnresolvedForwardEntry[] {
+    const store = getStore();
+    if (!store) return [];
+    let rows: Array<{ id: string; event: string; payload: unknown }>;
+    try {
+        rows = store.peekPendingEvents(UNRESOLVED_FORWARD_OUTBOX_MESH_ID);
+    } catch {
+        return [];
+    }
+    const out: UnresolvedForwardEntry[] = [];
+    for (const row of rows) {
+        const stored = row.payload && typeof row.payload === 'object' ? row.payload as Record<string, unknown> : {};
+        const coordinatorDaemonId = readNonEmptyString(stored.coordinatorDaemonId);
+        const forwardPayload = stored.forwardPayload && typeof stored.forwardPayload === 'object'
+            ? stored.forwardPayload as Record<string, unknown>
+            : undefined;
+        if (!coordinatorDaemonId || !forwardPayload) continue;
+        const queuedAt = typeof stored.queuedAt === 'number' ? stored.queuedAt : 0;
+        out.push({ id: row.id, coordinatorDaemonId, payload: forwardPayload, queuedAt });
+    }
+    return out;
+}
+
+/** Mark an outbox entry delivered (acked) after a successful push. */
+export function ackUnresolvedDelegateForward(id: string): void {
+    const store = getStore();
+    if (!store) return;
+    try { store.markPendingEventsDrainedById([id]); } catch { /* best-effort */ }
+}
+
+/**
+ * Drop outbox entries that have exceeded the max retry age. Returns the count
+ * expired so the caller can log a fail-loud trace (a dropped completion is a real
+ * loss; it must be visible, not silent).
+ */
+export function expireStaleUnresolvedDelegateForwards(nowMs: number = Date.now()): number {
+    const entries = peekUnresolvedDelegateForwards();
+    const staleIds = entries
+        .filter(e => e.queuedAt > 0 && nowMs - e.queuedAt >= UNRESOLVED_FORWARD_MAX_AGE_MS)
+        .map(e => e.id);
+    if (staleIds.length === 0) return 0;
+    const store = getStore();
+    if (!store) return 0;
+    try {
+        const removed = store.deletePendingEventsById(staleIds);
+        if (removed > 0) {
+            LOG.warn('MeshEvents', `Expired ${removed} unresolved-delegate forward(s) after ${Math.round(UNRESOLVED_FORWARD_MAX_AGE_MS / 60000)}m of failed retries — coordinator unreachable, completion dropped`);
+        }
+        return removed;
+    } catch {
+        return 0;
+    }
+}
+
+/** Test helper: purge the entire outbox. */
+export function __clearUnresolvedDelegateForwardOutboxForTests(): void {
+    const store = getStore();
+    if (!store) return;
+    try { store.clearPendingEventsForMesh(UNRESOLVED_FORWARD_OUTBOX_MESH_ID); } catch { /* nothing to clear */ }
+}