@adhdev/daemon-core 0.9.82-rc.469 → 0.9.82-rc.470

package/dist/mesh/mesh-active-work.d.ts

@@ -75,6 +75,35 @@ export interface BuildMeshActiveWorkOptions {
     /** Include terminal direct rows (idle/failed) for handoff/recent-work surfaces. Defaults false. */
     includeTerminalDirect?: boolean;
 }
+/**
+ * One session awaiting an approval decision — the derived row `mesh_list_pending_approvals`
+ * returns and the UI approvals inbox renders. A thin projection of the `awaiting_approval`
+ * MeshActiveWorkRecord: it carries exactly what a coordinator needs to route a follow-up
+ * mesh_approve(node_id, session_id) and what the inbox needs to label the item. No new
+ * store or data source — derived from the same buildMeshActiveWork records.
+ */
+export interface MeshPendingApproval {
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    taskId: string;
+    taskTitle: string;
+    /** Always 'awaiting_approval' — kept explicit so consumers can render/assert on it. */
+    status: 'awaiting_approval';
+    /** ISO timestamp the underlying task was created/dispatched — the "waiting since" anchor. */
+    waitingSince: string;
+    /** Milliseconds the record has been outstanding (elapsed from dispatch/create). */
+    waitingMs: number;
+}
+/**
+ * Derive the mesh-wide pending-approval inbox from already-built active-work records.
+ * Pure filter+projection over `status === 'awaiting_approval'` — no new store, no probe;
+ * the caller supplies the records (typically buildMeshActiveWork(...).activeWork so the
+ * enumeration reuses the exact classification `mesh_status` already computes). Records
+ * without a node/session are skipped: an approval that cannot be routed to a live
+ * node+session via mesh_approve is not actionable inbox content.
+ */
+export declare function collectPendingApprovals(activeWork: MeshActiveWorkRecord[]): MeshPendingApproval[];
 export declare function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]): MeshActiveWorkSummary;
 export declare function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): {
     activeWork: MeshActiveWorkRecord[];

package/dist/mesh/mesh-ledger.d.ts

@@ -115,6 +115,12 @@ export interface ReadLedgerOptions {
     tail?: number;
     since?: string;
     kind?: MeshLedgerKind[];
+    /**
+     * Filter to entries whose nodeId is equivalent to this daemon id. Matched via
+     * daemonIdsEquivalent (not raw ===) so caller-supplied identifiers in any form
+     * (mach_X vs daemon_mach_X) resolve correctly — see the canon-identity defect class.
+     */
+    node?: string;
 }
 export interface ReadLedgerSliceOptions {
     /** Return entries strictly after this entry id. If not found, starts from the beginning of the filtered set. */

package/dist/mesh/mesh-missions.d.ts

@@ -35,6 +35,13 @@ export interface MeshMissionRecord {
      * missions are bounded out of the default list once completed.
      */
     source?: MeshMissionSource;
+    /**
+     * G3: idempotency marker for the mission_close_candidate nudge. ISO timestamp of
+     * the last emit; absent/undefined when the mission has not (or no longer) been in a
+     * fully-terminal state. Owned by maybeEmitMissionCloseCandidate — never set by a
+     * regular upsert. See summarizeMissionTasks / maybeEmitMissionCloseCandidate.
+     */
+    closeCandidateEmittedAt?: string;
     createdAt: string;
     updatedAt: string;
 }
@@ -96,6 +103,36 @@ export declare function getMeshMission(meshId: string, missionId: string): MeshM
 /** Aggregate task statuses for a mission at query time (no stored progress). */
 export declare function summarizeMissionTasks(meshId: string, missionId: string): MeshMissionTaskAggregate;
 export declare function summarizeMeshMission(meshId: string, mission: MeshMissionRecord): MeshMissionSummary;
+/**
+ * G3 — all-tasks-terminal detection: true when a mission has at least one task and
+ * every task has reached a terminal status (no pending, no assigned). This is the
+ * derived signal (never a stored flag) that a mission has no more work in flight and
+ * is a candidate for the coordinator to close. A mission with zero tasks is NOT a
+ * candidate — an empty mission is a freshly-created plan, not a finished one.
+ */
+export declare function isMissionAllTasksTerminal(aggregate: MeshMissionTaskAggregate): boolean;
+/**
+ * G3 (step ①) — emit a `mission_close_candidate` coordinator nudge the first time an
+ * ACTIVE mission's tasks all become terminal, and reset the idempotency marker when a
+ * mission leaves the terminal state. Call this after any task-status mutation that can
+ * change a mission's aggregate (completion / failure / cancel / dependency-failure /
+ * new task). Fire-and-forget and fully best-effort — a throw here must never break the
+ * task mutation that triggered it.
+ *
+ * Design invariants (docs/MESH_PROMPT_ARCH_REVIEW_2026-07.md §9-1 G3):
+ *  - NEVER transitions the mission status. This only publishes a "consider closing"
+ *    hint; the coordinator/human decides via mesh_mission_upsert.
+ *  - Idempotent per all-terminal EDGE. The mission's close_candidate_emitted_at marker
+ *    guarantees exactly one emit per terminal transition; while the mission stays
+ *    all-terminal, subsequent calls no-op (no per-tick spam). When the mission returns
+ *    to non-terminal (a new/re-opened task), the marker is cleared so a later
+ *    re-completion nudges again.
+ *  - Only ACTIVE missions nudge. A paused/completed/abandoned mission is never a
+ *    close candidate (already decided, or intentionally on hold).
+ *
+ * Returns true iff an event was emitted on this call.
+ */
+export declare function maybeEmitMissionCloseCandidate(meshId: string, missionId: string): boolean;
 /** Active mission summaries for mesh_status / coordinator prompt injection. */
 export declare function getActiveMeshMissionSummaries(meshId: string): MeshMissionSummary[];
 /**

package/dist/mesh/mesh-runtime-store.d.ts

@@ -435,6 +435,7 @@ export declare class MeshRuntimeStore {
         goal: string;
         status: string;
         source?: string;
+        closeCandidateEmittedAt?: string;
         createdAt: string;
         updatedAt: string;
     } | null;
@@ -445,9 +446,19 @@ export declare class MeshRuntimeStore {
         goal: string;
         status: string;
         source?: string;
+        closeCandidateEmittedAt?: string;
         createdAt: string;
         updatedAt: string;
     }>;
+    /**
+     * G3: set/clear the mission_close_candidate idempotency marker. Passing an ISO
+     * timestamp records that the all-terminal nudge has been emitted for this mission;
+     * passing null clears it (mission returned to a non-terminal state, so a future
+     * re-completion may nudge again). Touches ONLY this column — never the mission's
+     * updated_at — so the marker write is invisible to updatedAt-ordered surfaces and
+     * does not masquerade as mission activity. Returns rows changed (0 if no such mission).
+     */
+    setMissionCloseCandidateEmittedAt(meshId: string, missionId: string, emittedAt: string | null): number;
     /** Remove all missions for a mesh — mesh deletion / test cleanup. */
     clearMissionsForMesh(meshId: string): number;
     /** Remove all pending-event rows (drained included) for a mesh — mesh deletion / test cleanup. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.469",
+  "version": "0.9.82-rc.470",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.469",
-    "@adhdev/session-host-core": "0.9.82-rc.469",
+    "@adhdev/mesh-shared": "0.9.82-rc.470",
+    "@adhdev/session-host-core": "0.9.82-rc.470",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/index.ts

@@ -278,9 +278,9 @@ export type { AnyLedgerSlice, MeshLedgerReconciliationEvidence, MeshLedgerReplic
 // ── Mesh Work Queue (GUPP) ──
 export { enqueueTask, recordDirectDispatchTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, getMeshQueueRevision, normalizeMeshTaskMode, validateMeshTaskModeRequest, isTaskReadonly, buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, normalizeMeshCapabilityTags, resolveConvergeRequiredTags, insertDirectDispatch, getActiveDirectDispatches, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, markStaleDirectDispatches, deleteDirectDispatchesByTaskId, recordMeshToolCall, assertNoDependencyCycle, hasPendingDependents, describeTaskDependencyState, taskDependenciesSatisfied, normalizeMeshTaskPriority, meshTaskPriorityRank, resolveNotBefore, meshTaskNotBeforeReady, MESH_TASK_PRIORITIES, NOT_BEFORE_RELATIVE_THRESHOLD_MS } from './mesh/mesh-work-queue.js';
 export type { MeshWorkQueueEntry, MeshTaskStatus, MeshTaskMode, MeshTaskPriority, MeshWorkQueueStats, MeshQueueMutationOptions, MeshTaskModeValidationResult, DirectDispatchRecord, MeshToolCallRateResult } from './mesh/mesh-work-queue.js';
-export { buildCompactStaleDirectWorkSummary, buildMeshActiveWork, buildMeshActiveWorkSummary, classifyStaleDirectForPrune, pruneStaleDirectDispatches, PRUNABLE_ORPHAN_STALE_REASONS } from './mesh/mesh-active-work.js';
+export { buildCompactStaleDirectWorkSummary, buildMeshActiveWork, buildMeshActiveWorkSummary, collectPendingApprovals, classifyStaleDirectForPrune, pruneStaleDirectDispatches, PRUNABLE_ORPHAN_STALE_REASONS } from './mesh/mesh-active-work.js';
 export type { StaleDirectPruneClassification, StaleDirectPruneResult, PruneStaleDirectDispatchesOptions } from './mesh/mesh-active-work.js';
-export type { MeshActiveWorkRecord, MeshActiveWorkStatus, MeshActiveWorkSummary, MeshActiveWorkSource, MeshStaleDirectWorkSummary } from './mesh/mesh-active-work.js';
+export type { MeshActiveWorkRecord, MeshActiveWorkStatus, MeshActiveWorkSummary, MeshActiveWorkSource, MeshStaleDirectWorkSummary, MeshPendingApproval } from './mesh/mesh-active-work.js';
 export { buildMeshAsyncRefineJobs, summarizeMeshAsyncRefineJobs, STALE_TERMINAL_REFINE_WINDOW_MS, RECENT_TERMINAL_REFINE_CAP } from './mesh/mesh-refine-status.js';
 export type { MeshAsyncRefineJobStatus, MeshAsyncRefineJobSummary, MeshAsyncRefineJobsSummary } from './mesh/mesh-refine-status.js';
 export { buildMeshMagiActivity, summarizeMeshMagiActivity, getMeshMagiActivityByGroup, STALE_MAGI_WINDOW_MS, RECENT_MAGI_CAP, MAGI_NEEDS_VERIFICATION_PREVIEW_CAP } from './mesh/mesh-magi-status.js';

package/src/mesh/coordinator-prompt.ts

@@ -621,8 +621,10 @@ const TOOLS_SECTION = `## Available Tools
 | \`mesh_read_chat\` | Read recent chat messages from a delegated agent session |
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger — dispatches, completions, failures. Use to understand what has been done before deciding next steps |
+| \`mesh_ledger_query\` | Read-only ledger query along the kind/time/node axes (complement to task-axis mesh_task_history): filter by kind, since, node, tail — answer "what happened on node X / what failed since T" without scanning transcripts |
 | \`mesh_reconcile_ledger\` | Reconcile daemon-local ledgers over P2P — import missing entries from remote nodes into the coordinator local ledger |
 | \`mesh_requeue_held_events\` | Restore recoverable held coordinator events (T6 quarantine / pending-trim) back to the pending queue; lossless, no double-requeue |
+| \`mesh_wait_events\` | Long-poll blocking wait for coordinator events (worker completions/approvals/nudges) up to timeoutMs — drains immediately if any are pending, else blocks until they arrive. Use this instead of busy-polling mesh_status/mesh_view_queue after dispatching work |
 | \`mesh_review_inbox\` | List local worktree nodes needing human review — merge candidates and Refinery-blocked results with evidence/diff summaries |
 | \`mesh_record_note\` | Record a durable, provider-neutral operating note (provider quirk / pattern to avoid / recovery lesson). Future coordinators see it under "## Operating Notes" at launch |
 | \`mesh_forget_note\` | Retract a stale/wrong operating note by note_id or exact text so it stops riding into future coordinators' prompts (append-only tombstone; history preserved) |
@@ -632,6 +634,7 @@ const TOOLS_SECTION = `## Available Tools
 | \`mesh_restart_daemon\` | Update a node's daemon to the latest published version on its channel and restart it (the dashboard "preview update" path, as a mesh command) |
 | \`mesh_checkpoint\` | Create a git checkpoint on a node |
 | \`mesh_approve\` | Approve/reject a pending agent action |
+| \`mesh_list_pending_approvals\` | List every session across the mesh awaiting an approval decision (the approval inbox) — read-only; enumerate all blocked sessions at once, then drive a mesh_approve for each |
 | \`mesh_clone_node\` | Create a worktree node for isolated parallel branch work |
 | \`mesh_refine_node\` | Validate and merge a completed worktree node back into its base branch |
 | \`mesh_refine_batch\` | Batch Refinery: converge multiple sibling worktree nodes onto the base branch in one conflict-aware sequential pipeline |

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

@@ -273,6 +273,56 @@ function buildLedgerDirectDispatchRecord(
     return { record, terminalRow };
 }
 
+/**
+ * One session awaiting an approval decision — the derived row `mesh_list_pending_approvals`
+ * returns and the UI approvals inbox renders. A thin projection of the `awaiting_approval`
+ * MeshActiveWorkRecord: it carries exactly what a coordinator needs to route a follow-up
+ * mesh_approve(node_id, session_id) and what the inbox needs to label the item. No new
+ * store or data source — derived from the same buildMeshActiveWork records.
+ */
+export interface MeshPendingApproval {
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    taskId: string;
+    taskTitle: string;
+    /** Always 'awaiting_approval' — kept explicit so consumers can render/assert on it. */
+    status: 'awaiting_approval';
+    /** ISO timestamp the underlying task was created/dispatched — the "waiting since" anchor. */
+    waitingSince: string;
+    /** Milliseconds the record has been outstanding (elapsed from dispatch/create). */
+    waitingMs: number;
+}
+
+/**
+ * Derive the mesh-wide pending-approval inbox from already-built active-work records.
+ * Pure filter+projection over `status === 'awaiting_approval'` — no new store, no probe;
+ * the caller supplies the records (typically buildMeshActiveWork(...).activeWork so the
+ * enumeration reuses the exact classification `mesh_status` already computes). Records
+ * without a node/session are skipped: an approval that cannot be routed to a live
+ * node+session via mesh_approve is not actionable inbox content.
+ */
+export function collectPendingApprovals(activeWork: MeshActiveWorkRecord[]): MeshPendingApproval[] {
+    const approvals: MeshPendingApproval[] = [];
+    for (const record of activeWork) {
+        if (record.status !== 'awaiting_approval') continue;
+        if (!record.nodeId || !record.sessionId) continue;
+        approvals.push({
+            nodeId: record.nodeId,
+            sessionId: record.sessionId,
+            providerType: record.providerType,
+            taskId: record.taskId,
+            taskTitle: record.taskTitle,
+            status: 'awaiting_approval',
+            waitingSince: record.dispatchedAt || record.createdAt,
+            waitingMs: record.elapsedMs,
+        });
+    }
+    // Longest-waiting first — the coordinator/inbox should address the most-stalled approval first.
+    approvals.sort((a, b) => b.waitingMs - a.waitingMs);
+    return approvals;
+}
+
 export function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]): MeshActiveWorkSummary {
     const statusCounts: Record<MeshActiveWorkStatus, number> = {
         pending: 0,

package/src/mesh/mesh-event-classify.ts

@@ -16,6 +16,11 @@ const MESH_COORDINATOR_EVENTS = new Set([
     'refine:failed',
     'worktree_bootstrap_complete',
     'worktree_bootstrap_failed',
+    // G3: mission-hygiene nudge. Emitted once when all of a mission's tasks first
+    // become terminal — a "consider closing this mission" hint for the coordinator.
+    // Purely informational: NOT force-injected (no blocked coordinator waits on it)
+    // and NOT an approval; it never drives a mission status transition on its own.
+    'mission_close_candidate',
 ]);
 
 export const EVENT_TO_LEDGER_KIND: Record<string, MeshLedgerKind> = {

package/src/mesh/mesh-ledger.ts

@@ -209,6 +209,12 @@ export interface ReadLedgerOptions {
     tail?: number;
     since?: string;
     kind?: MeshLedgerKind[];
+    /**
+     * Filter to entries whose nodeId is equivalent to this daemon id. Matched via
+     * daemonIdsEquivalent (not raw ===) so caller-supplied identifiers in any form
+     * (mach_X vs daemon_mach_X) resolve correctly — see the canon-identity defect class.
+     */
+    node?: string;
 }
 
 export interface ReadLedgerSliceOptions {
@@ -1088,6 +1094,10 @@ export function readLedgerEntries(meshId: string, opts?: ReadLedgerOptions): Mes
         const kindSet = new Set(opts.kind);
         entries = entries.filter(e => kindSet.has(e.kind));
     }
+    if (opts?.node && opts.node.trim()) {
+        const node = opts.node.trim();
+        entries = entries.filter(e => e.nodeId && daemonIdsEquivalent(e.nodeId, node));
+    }
     if (opts?.tail && opts.tail > 0 && entries.length > opts.tail) {
         entries = entries.slice(-opts.tail);
     }

package/src/mesh/mesh-missions.ts

@@ -13,10 +13,12 @@
  */
 
 import { randomUUID } from 'crypto';
+import { LOG } from '../logging/logger.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { getQueue } from './mesh-work-queue.js';
 import { computeMeshMissionStats, type MeshMissionStats } from './mesh-task-stats.js';
 import { appendLedgerEntry } from './mesh-ledger.js';
+import { queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 
 /**
  * Max chars of mission goal text written into a ledger entry payload. Mission
@@ -56,6 +58,13 @@ export interface MeshMissionRecord {
      * missions are bounded out of the default list once completed.
      */
     source?: MeshMissionSource;
+    /**
+     * G3: idempotency marker for the mission_close_candidate nudge. ISO timestamp of
+     * the last emit; absent/undefined when the mission has not (or no longer) been in a
+     * fully-terminal state. Owned by maybeEmitMissionCloseCandidate — never set by a
+     * regular upsert. See summarizeMissionTasks / maybeEmitMissionCloseCandidate.
+     */
+    closeCandidateEmittedAt?: string;
     createdAt: string;
     updatedAt: string;
 }
@@ -269,6 +278,116 @@ export function summarizeMeshMission(meshId: string, mission: MeshMissionRecord)
     return { ...mission, tasks: summarizeMissionTasks(meshId, mission.id) };
 }
 
+/**
+ * G3 — all-tasks-terminal detection: true when a mission has at least one task and
+ * every task has reached a terminal status (no pending, no assigned). This is the
+ * derived signal (never a stored flag) that a mission has no more work in flight and
+ * is a candidate for the coordinator to close. A mission with zero tasks is NOT a
+ * candidate — an empty mission is a freshly-created plan, not a finished one.
+ */
+export function isMissionAllTasksTerminal(aggregate: MeshMissionTaskAggregate): boolean {
+    return aggregate.total > 0 && aggregate.pending === 0 && aggregate.assigned === 0;
+}
+
+/**
+ * G3 (step ①) — emit a `mission_close_candidate` coordinator nudge the first time an
+ * ACTIVE mission's tasks all become terminal, and reset the idempotency marker when a
+ * mission leaves the terminal state. Call this after any task-status mutation that can
+ * change a mission's aggregate (completion / failure / cancel / dependency-failure /
+ * new task). Fire-and-forget and fully best-effort — a throw here must never break the
+ * task mutation that triggered it.
+ *
+ * Design invariants (docs/MESH_PROMPT_ARCH_REVIEW_2026-07.md §9-1 G3):
+ *  - NEVER transitions the mission status. This only publishes a "consider closing"
+ *    hint; the coordinator/human decides via mesh_mission_upsert.
+ *  - Idempotent per all-terminal EDGE. The mission's close_candidate_emitted_at marker
+ *    guarantees exactly one emit per terminal transition; while the mission stays
+ *    all-terminal, subsequent calls no-op (no per-tick spam). When the mission returns
+ *    to non-terminal (a new/re-opened task), the marker is cleared so a later
+ *    re-completion nudges again.
+ *  - Only ACTIVE missions nudge. A paused/completed/abandoned mission is never a
+ *    close candidate (already decided, or intentionally on hold).
+ *
+ * Returns true iff an event was emitted on this call.
+ */
+export function maybeEmitMissionCloseCandidate(meshId: string, missionId: string): boolean {
+    try {
+        const mission = getMeshMission(meshId, missionId);
+        if (!mission) return false;
+        const store = MeshRuntimeStore.getInstance();
+        const aggregate = summarizeMissionTasks(meshId, missionId);
+        const allTerminal = isMissionAllTasksTerminal(aggregate);
+        const alreadyEmitted = typeof mission.closeCandidateEmittedAt === 'string' && mission.closeCandidateEmittedAt.length > 0;
+
+        // Reset edge: mission is no longer all-terminal (new/re-opened task) but still
+        // carries a stale marker → clear it so a future re-completion can nudge again.
+        // Applies regardless of mission status (a re-opened completed mission also resets).
+        if (!allTerminal) {
+            if (alreadyEmitted) store.setMissionCloseCandidateEmittedAt(meshId, missionId, null);
+            return false;
+        }
+
+        // All-terminal, but only an ACTIVE mission is a close candidate. A paused mission
+        // is intentionally on hold; a completed/abandoned one is already decided. We do
+        // NOT mark in these cases — if the mission is later reactivated while still
+        // all-terminal, it should nudge then.
+        if (mission.status !== 'active') return false;
+
+        // Idempotency: already nudged for this terminal edge → no-op (no per-tick spam).
+        if (alreadyEmitted) return false;
+
+        const emittedAt = new Date().toISOString();
+        emitMissionCloseCandidateEvent(meshId, mission, aggregate, emittedAt);
+        // Mark AFTER a successful emit path so a mid-emit throw leaves the marker unset
+        // and the next mutation retries rather than silently dropping the only nudge.
+        store.setMissionCloseCandidateEmittedAt(meshId, missionId, emittedAt);
+        return true;
+    } catch (e: any) {
+        LOG.warn('MeshMissions', `maybeEmitMissionCloseCandidate failed for mission ${missionId} on mesh ${meshId}: ${e?.message || e}`);
+        return false;
+    }
+}
+
+/**
+ * Build and queue the mission_close_candidate pending coordinator event. Broadcast
+ * scope (defaultScopeForEvent → 'broadcast' since it is neither a terminal-task nor a
+ * system event), so it reaches any coordinator on the mesh without needing an
+ * intendedFor identity — a mission-hygiene hint is not tied to a single dispatcher.
+ */
+function emitMissionCloseCandidateEvent(
+    meshId: string,
+    mission: MeshMissionRecord,
+    aggregate: MeshMissionTaskAggregate,
+    emittedAt: string,
+): void {
+    const coordinatorMessage =
+        `Mission "${mission.title}" (id: ${mission.id}) has no tasks left in flight — all ${aggregate.total} `
+        + `task(s) are terminal (${aggregate.completed} completed, ${aggregate.failed} failed, ${aggregate.cancelled} cancelled). `
+        + `It is a candidate to close. Review its outcome and, if done, set its status with `
+        + `mesh_mission_upsert(mission_id: "${mission.id}", status: "completed" | "abandoned"). `
+        + `This is only a hint — the mission stays 'active' until you decide.`;
+    queuePendingMeshCoordinatorEvent({
+        event: 'mission_close_candidate',
+        meshId,
+        nodeLabel: '',
+        metadataEvent: {
+            missionId: mission.id,
+            title: mission.title,
+            status: mission.status,
+            aggregate: {
+                total: aggregate.total,
+                completed: aggregate.completed,
+                failed: aggregate.failed,
+                cancelled: aggregate.cancelled,
+            },
+            lastActivityAt: aggregate.lastActivityAt,
+            emittedAt,
+        },
+        coordinatorMessage,
+        queuedAt: Date.parse(emittedAt) || 0,
+    });
+}
+
 /** Active mission summaries for mesh_status / coordinator prompt injection. */
 export function getActiveMeshMissionSummaries(meshId: string): MeshMissionSummary[] {
     return getMeshMissions(meshId, ['active']).map(mission => summarizeMeshMission(meshId, mission));

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

@@ -346,6 +346,14 @@ export class MeshRuntimeStore {
                 goal TEXT NOT NULL DEFAULT '',
                 status TEXT NOT NULL DEFAULT 'active',
                 source TEXT,
+                -- G3: idempotency marker for the mission_close_candidate coordinator
+                -- event. Set to the emit timestamp when all of a mission's tasks first
+                -- become terminal (so the "consider closing this" nudge fires exactly
+                -- once per all-terminal edge), and cleared back to NULL when the mission
+                -- returns to a non-terminal state (new/re-opened task) so a later
+                -- re-completion can nudge again. Never drives a status transition — the
+                -- coordinator/human still decides via mesh_mission_upsert.
+                close_candidate_emitted_at TEXT,
                 created_at TEXT NOT NULL,
                 updated_at TEXT NOT NULL
             );
@@ -462,6 +470,13 @@ export class MeshRuntimeStore {
             if (!missionCols.has('source')) {
                 this.db.exec(`ALTER TABLE mesh_missions ADD COLUMN source TEXT`);
             }
+            // 3b. mesh_missions.close_candidate_emitted_at (G3): nullable idempotency
+            //     marker for the mission_close_candidate coordinator nudge. Pre-existing
+            //     rows keep it NULL — treated as "not yet emitted", so the first
+            //     all-terminal detection after this migration emits once, then marks it.
+            if (!missionCols.has('close_candidate_emitted_at')) {
+                this.db.exec(`ALTER TABLE mesh_missions ADD COLUMN close_candidate_emitted_at TEXT`);
+            }
 
             // 4. mesh_pending_events v2 envelope columns (B2a). A pre-v2 DB has the
             //    table (CREATE IF NOT EXISTS is a no-op) without these columns, so add
@@ -1988,6 +2003,9 @@ export class MeshRuntimeStore {
         // with a non-null incoming value (COALESCE(excluded, existing)), so a later
         // status/goal upsert that omits source never clears a previously-stamped
         // 'magi'/'coordinator' tag.
+        // close_candidate_emitted_at is deliberately NOT in the UPDATE set: the G3
+        // idempotency marker is owned solely by setMissionCloseCandidateEmittedAt, so a
+        // title/goal/status upsert here never clears or overwrites it.
         this.db.prepare(
             `INSERT INTO mesh_missions (id, mesh_id, title, goal, status, source, created_at, updated_at)
              VALUES (?, ?, ?, ?, ?, ?, ?, ?)
@@ -2010,15 +2028,15 @@ export class MeshRuntimeStore {
         this.maybeCheckpointWal();
     }
 
-    getMission(meshId: string, missionId: string): { id: string; meshId: string; title: string; goal: string; status: string; source?: string; createdAt: string; updatedAt: string } | null {
+    getMission(meshId: string, missionId: string): { id: string; meshId: string; title: string; goal: string; status: string; source?: string; closeCandidateEmittedAt?: string; createdAt: string; updatedAt: string } | null {
         const row = this.db.prepare(
             'SELECT * FROM mesh_missions WHERE mesh_id = ? AND id = ?'
         ).get(meshId, missionId) as Record<string, string> | undefined;
         if (!row) return null;
-        return { id: row.id, meshId: row.mesh_id, title: row.title, goal: row.goal, status: row.status, source: row.source ?? undefined, createdAt: row.created_at, updatedAt: row.updated_at };
+        return { id: row.id, meshId: row.mesh_id, title: row.title, goal: row.goal, status: row.status, source: row.source ?? undefined, closeCandidateEmittedAt: row.close_candidate_emitted_at ?? undefined, createdAt: row.created_at, updatedAt: row.updated_at };
     }
 
-    getMissions(meshId: string, statuses?: string[]): Array<{ id: string; meshId: string; title: string; goal: string; status: string; source?: string; createdAt: string; updatedAt: string }> {
+    getMissions(meshId: string, statuses?: string[]): Array<{ id: string; meshId: string; title: string; goal: string; status: string; source?: string; closeCandidateEmittedAt?: string; createdAt: string; updatedAt: string }> {
         let rows: Array<Record<string, string>>;
         if (statuses?.length) {
             const placeholders = statuses.map(() => '?').join(', ');
@@ -2030,7 +2048,21 @@ export class MeshRuntimeStore {
                 'SELECT * FROM mesh_missions WHERE mesh_id = ? ORDER BY updated_at DESC'
             ).all(meshId) as Array<Record<string, string>>;
         }
-        return rows.map(row => ({ id: row.id, meshId: row.mesh_id, title: row.title, goal: row.goal, status: row.status, source: row.source ?? undefined, createdAt: row.created_at, updatedAt: row.updated_at }));
+        return rows.map(row => ({ id: row.id, meshId: row.mesh_id, title: row.title, goal: row.goal, status: row.status, source: row.source ?? undefined, closeCandidateEmittedAt: row.close_candidate_emitted_at ?? undefined, createdAt: row.created_at, updatedAt: row.updated_at }));
+    }
+
+    /**
+     * G3: set/clear the mission_close_candidate idempotency marker. Passing an ISO
+     * timestamp records that the all-terminal nudge has been emitted for this mission;
+     * passing null clears it (mission returned to a non-terminal state, so a future
+     * re-completion may nudge again). Touches ONLY this column — never the mission's
+     * updated_at — so the marker write is invisible to updatedAt-ordered surfaces and
+     * does not masquerade as mission activity. Returns rows changed (0 if no such mission).
+     */
+    setMissionCloseCandidateEmittedAt(meshId: string, missionId: string, emittedAt: string | null): number {
+        return this.db.prepare(
+            'UPDATE mesh_missions SET close_candidate_emitted_at = ? WHERE mesh_id = ? AND id = ?'
+        ).run(emittedAt, meshId, missionId).changes;
     }
 
     /** Remove all missions for a mesh — mesh deletion / test cleanup. */