@adhdev/daemon-core 0.9.82-rc.495 → 0.9.82-rc.497

package/dist/mesh/mesh-idle-reminder.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Idle-active-mission reminder.
+ *
+ * When a coordinator session becomes fully idle — no queue/direct work in flight,
+ * no pending coordinator events to drain — yet the mesh still carries `active`
+ * missions, inject a one-shot "[System] Coordinator idle with N active mission(s)"
+ * reminder into that coordinator session. This nudges the coordinator to decide a
+ * lingering mission's real outcome (close it, or continue it) rather than leaving it
+ * drifting in `active` after its work is actually done.
+ *
+ * Precedent: mesh-missions.ts `maybeEmitMissionCloseCandidate` — a terminal-edge,
+ * once-per-edge coordinator nudge with an idempotency marker. This mirrors that
+ * shape, but the "edge" is the coordinator's idle transition (fired by the fast-path
+ * in mesh-event-forwarding and the slow-path idle tick in mesh-reconcile-loop) and
+ * the idempotency marker is a time+mission-set debounce held in MeshRuntimeStore
+ * (getIdleReminderState / setIdleReminderState). Fully best-effort: a throw here must
+ * never break the drain/injection path that called it.
+ *
+ * Design invariants:
+ *  - Only fires when the mesh has ≥1 `active` mission AND is fully idle. Fully idle =
+ *    buildMeshActiveWork over queue + direct dispatches reports totalActiveCount === 0
+ *    && generatingCount === 0. We intentionally do NOT probe remote node sessions here
+ *    (expensive per-tick RPC): any non-terminal queue/direct work already makes
+ *    totalActiveCount > 0, so the idle check is conservative — it suppresses the
+ *    reminder whenever any work is outstanding, which is the safe direction.
+ *  - NEVER transitions a mission's status. It only surfaces a hint; the coordinator
+ *    decides via mesh_mission_upsert.
+ *  - Debounced per mission-set. Re-fires only when the debounce window has elapsed OR
+ *    the set of active mission ids changed (a mission was closed/added), so a mesh that
+ *    stays idle with the same active missions is nudged at most once per window.
+ *  - Opt-out via policy.idleActiveMissionReminder === false.
+ */
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+import type { RepoMeshPolicy } from '../repo-mesh-types.js';
+import { type MeshMissionRecord } from './mesh-missions.js';
+/** Coordinator instance the reminder is injected into (the idle CLI session). */
+type CoordinatorInstance = ReturnType<DaemonComponents['instanceManager']['getInstance']>;
+/**
+ * Debounce window: while the mesh stays idle with the SAME active-mission set, re-fire
+ * the reminder at most once per this interval. A changed mission set bypasses the window.
+ */
+export declare const IDLE_REMINDER_DEBOUNCE_MS = 300000;
+/** Stable hash of the active-mission id set (sorted, joined) for debounce comparison. */
+export declare function missionSetHash(missions: MeshMissionRecord[]): string;
+/**
+ * Decide whether a reminder should fire this call, given the debounce marker. Pure so it
+ * is independently testable. Re-fires when there is no prior marker, the debounce window
+ * has elapsed, or the active-mission set changed since the last reminder.
+ */
+export declare function shouldFireIdleReminder(last: {
+    emittedAt: number;
+    missionSetHash: string;
+} | null, hash: string, now: number, debounceMs?: number): boolean;
+/**
+ * Build the coordinator-facing reminder text. Deliberately terse — one line per mission
+ * (`title (id)`), NEVER the full goal (goals can be thousands of chars). When there are
+ * more than MISSION_LIST_CAP missions, name the first N and fold the remainder.
+ */
+export declare function buildIdleReminderMessage(missions: MeshMissionRecord[]): string;
+/**
+ * Fire-and-forget idle-active-mission reminder. Call this at a coordinator idle edge
+ * once the pending-event queue is empty (nothing else to inject). `coordinator` is the
+ * idle CLI session to inject into; `policy` is the mesh's policy (for the opt-out flag).
+ *
+ * Returns true iff a reminder was injected on this call.
+ */
+export declare function maybeInjectIdleActiveMissionReminder(meshId: string, coordinator: CoordinatorInstance, policy: RepoMeshPolicy | undefined, now?: number): boolean;
+export {};

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

@@ -13,6 +13,7 @@ export declare class MeshRuntimeStore {
     private readonly db;
     private readonly dbPath;
     private readonly migratedMeshIds;
+    private readonly idleReminderState;
     private fingerprintSweepCounter;
     private walWriteCounter;
     private toolCallLogCounter;
@@ -503,6 +504,22 @@ export declare class MeshRuntimeStore {
      * does not masquerade as mission activity. Returns rows changed (0 if no such mission).
      */
     setMissionCloseCandidateEmittedAt(meshId: string, missionId: string, emittedAt: string | null): number;
+    /**
+     * Read the last idle-active-mission-reminder debounce marker for a mesh, or null if
+     * none has fired this process. In-memory only (see idleReminderState) — best-effort
+     * spam guard for a coordinator nudge, intentionally not SQLite-backed.
+     */
+    getIdleReminderState(meshId: string): {
+        emittedAt: number;
+        missionSetHash: string;
+    } | null;
+    /** Record that an idle-active-mission reminder just fired for a mesh (debounce marker). */
+    setIdleReminderState(meshId: string, state: {
+        emittedAt: number;
+        missionSetHash: string;
+    }): void;
+    /** Clear the idle-reminder debounce marker for a mesh — mesh deletion / test cleanup. */
+    clearIdleReminderState(meshId: string): void;
     /** 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/dist/repo-mesh-types.d.ts

@@ -264,6 +264,16 @@ export interface RepoMeshPolicy {
      * Defaults to 1 (allow one retry). Set to 0 to disable auto-recovery advice.
      */
     maxTaskRetries?: number;
+    /**
+     * When true (default), the daemon injects a one-shot "[System] Coordinator idle
+     * with N active mission(s)" reminder into an idle coordinator session whenever the
+     * mesh is fully idle (no queue/direct work in flight, no pending coordinator events)
+     * yet still has `active` missions. This nudges the coordinator to close or continue
+     * missions that would otherwise drift in `active` while their real outcome is decided.
+     * Idempotent/debounced per mission-set (see maybeInjectIdleActiveMissionReminder).
+     * Set to false to suppress the reminder entirely.
+     */
+    idleActiveMissionReminder?: boolean;
 }
 export interface RepoMeshRelatedRepo {
     /** Stable display label for an explicitly configured associated checkout. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.495",
+  "version": "0.9.82-rc.497",
   "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.495",
-    "@adhdev/session-host-core": "0.9.82-rc.495",
+    "@adhdev/mesh-shared": "0.9.82-rc.497",
+    "@adhdev/session-host-core": "0.9.82-rc.497",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/index.ts

@@ -280,6 +280,7 @@ export type { MeshWorkQueueEntry, MeshTaskStatus, MeshTaskMode, MeshTaskPriority
 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, MeshPendingApproval } from './mesh/mesh-active-work.js';
+export { maybeInjectIdleActiveMissionReminder, shouldFireIdleReminder, buildIdleReminderMessage, missionSetHash, IDLE_REMINDER_DEBOUNCE_MS } from './mesh/mesh-idle-reminder.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/mesh-event-forwarding.ts

@@ -7,6 +7,7 @@ import type { SessionRecoveryContext } from './mesh-ledger.js';
 import { updateSessionTaskStatus, enqueueTask, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches, hasPendingDependents, getQueue } from './mesh-work-queue.js';
 import { markSessionDeliveriesTerminal, updateSessionDeliveryStatus } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore, pruneMeshRuntimeRetention } from './mesh-runtime-store.js';
+import { maybeInjectIdleActiveMissionReminder } from './mesh-idle-reminder.js';
 import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, prunePendingMeshCoordinatorEventsRetention, readV2EnvelopeFromWire, type PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
@@ -1948,6 +1949,17 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
                                             ...(forcePending ? { force: true } : {}),
                                         });
                                     }
+                                } else {
+                                    // Nothing to flush → this idle edge left the coordinator with an
+                                    // empty inbox. If the mesh is fully idle but still has active
+                                    // missions, nudge (once/debounced) so a lingering mission is not
+                                    // left drifting in 'active'. Suppressed when events WERE injected,
+                                    // so we never pile a reminder on top of real completion traffic.
+                                    maybeInjectIdleActiveMissionReminder(
+                                        coordinatorMeshId,
+                                        flushSource,
+                                        getMesh(coordinatorMeshId)?.policy,
+                                    );
                                 }
                             } catch (e: any) {
                                 LOG.warn('MeshEvents', `Failed to auto-flush pending coordinator events: ${e?.message || e}`);

package/src/mesh/mesh-idle-reminder.ts

@@ -0,0 +1,153 @@
+/**
+ * Idle-active-mission reminder.
+ *
+ * When a coordinator session becomes fully idle — no queue/direct work in flight,
+ * no pending coordinator events to drain — yet the mesh still carries `active`
+ * missions, inject a one-shot "[System] Coordinator idle with N active mission(s)"
+ * reminder into that coordinator session. This nudges the coordinator to decide a
+ * lingering mission's real outcome (close it, or continue it) rather than leaving it
+ * drifting in `active` after its work is actually done.
+ *
+ * Precedent: mesh-missions.ts `maybeEmitMissionCloseCandidate` — a terminal-edge,
+ * once-per-edge coordinator nudge with an idempotency marker. This mirrors that
+ * shape, but the "edge" is the coordinator's idle transition (fired by the fast-path
+ * in mesh-event-forwarding and the slow-path idle tick in mesh-reconcile-loop) and
+ * the idempotency marker is a time+mission-set debounce held in MeshRuntimeStore
+ * (getIdleReminderState / setIdleReminderState). Fully best-effort: a throw here must
+ * never break the drain/injection path that called it.
+ *
+ * Design invariants:
+ *  - Only fires when the mesh has ≥1 `active` mission AND is fully idle. Fully idle =
+ *    buildMeshActiveWork over queue + direct dispatches reports totalActiveCount === 0
+ *    && generatingCount === 0. We intentionally do NOT probe remote node sessions here
+ *    (expensive per-tick RPC): any non-terminal queue/direct work already makes
+ *    totalActiveCount > 0, so the idle check is conservative — it suppresses the
+ *    reminder whenever any work is outstanding, which is the safe direction.
+ *  - NEVER transitions a mission's status. It only surfaces a hint; the coordinator
+ *    decides via mesh_mission_upsert.
+ *  - Debounced per mission-set. Re-fires only when the debounce window has elapsed OR
+ *    the set of active mission ids changed (a mission was closed/added), so a mesh that
+ *    stays idle with the same active missions is nudged at most once per window.
+ *  - Opt-out via policy.idleActiveMissionReminder === false.
+ */
+
+import { LOG } from '../logging/logger.js';
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+import type { RepoMeshPolicy } from '../repo-mesh-types.js';
+import { MeshRuntimeStore } from './mesh-runtime-store.js';
+import { getMeshMissions, type MeshMissionRecord } from './mesh-missions.js';
+import { getQueue, getActiveDirectDispatches } from './mesh-work-queue.js';
+import { readLedgerEntries } from './mesh-ledger.js';
+import { buildMeshActiveWork } from './mesh-active-work.js';
+
+/** Coordinator instance the reminder is injected into (the idle CLI session). */
+type CoordinatorInstance = ReturnType<DaemonComponents['instanceManager']['getInstance']>;
+
+/**
+ * Debounce window: while the mesh stays idle with the SAME active-mission set, re-fire
+ * the reminder at most once per this interval. A changed mission set bypasses the window.
+ */
+export const IDLE_REMINDER_DEBOUNCE_MS = 300_000; // 5 minutes
+
+/** How many missions to name individually before folding the rest into "and M more". */
+const MISSION_LIST_CAP = 10;
+
+/** Stable hash of the active-mission id set (sorted, joined) for debounce comparison. */
+export function missionSetHash(missions: MeshMissionRecord[]): string {
+    return missions.map(m => m.id).sort().join(',');
+}
+
+/**
+ * Decide whether a reminder should fire this call, given the debounce marker. Pure so it
+ * is independently testable. Re-fires when there is no prior marker, the debounce window
+ * has elapsed, or the active-mission set changed since the last reminder.
+ */
+export function shouldFireIdleReminder(
+    last: { emittedAt: number; missionSetHash: string } | null,
+    hash: string,
+    now: number,
+    debounceMs: number = IDLE_REMINDER_DEBOUNCE_MS,
+): boolean {
+    if (!last) return true;
+    if (now - last.emittedAt > debounceMs) return true;
+    return hash !== last.missionSetHash;
+}
+
+/**
+ * Build the coordinator-facing reminder text. Deliberately terse — one line per mission
+ * (`title (id)`), NEVER the full goal (goals can be thousands of chars). When there are
+ * more than MISSION_LIST_CAP missions, name the first N and fold the remainder.
+ */
+export function buildIdleReminderMessage(missions: MeshMissionRecord[]): string {
+    const shown = missions.slice(0, MISSION_LIST_CAP);
+    const lines = shown.map(m => `- ${m.title} (${m.id})`);
+    const overflow = missions.length - shown.length;
+    if (overflow > 0) lines.push(`- …and ${overflow} more`);
+    return (
+        `[System] Coordinator idle with ${missions.length} active mission(s):\n`
+        + `${lines.join('\n')}\n`
+        + `The mesh has no work in flight. For each mission, decide its outcome: continue it `
+        + `(enqueue/dispatch the remaining work) or close it with `
+        + `mesh_mission_upsert(mission_id, status: "completed" | "abandoned"). `
+        + `Do not leave a finished mission in 'active'. This is a one-time reminder.`
+    );
+}
+
+/**
+ * Fire-and-forget idle-active-mission reminder. Call this at a coordinator idle edge
+ * once the pending-event queue is empty (nothing else to inject). `coordinator` is the
+ * idle CLI session to inject into; `policy` is the mesh's policy (for the opt-out flag).
+ *
+ * Returns true iff a reminder was injected on this call.
+ */
+export function maybeInjectIdleActiveMissionReminder(
+    meshId: string,
+    coordinator: CoordinatorInstance,
+    policy: RepoMeshPolicy | undefined,
+    now: number = Date.now(),
+): boolean {
+    try {
+        if (!coordinator) return false;
+        // Opt-out: default is ON; only an explicit false disables it.
+        if (policy?.idleActiveMissionReminder === false) return false;
+
+        // Active missions gate — no active mission, nothing to remind about.
+        const activeMissions = getMeshMissions(meshId, ['active']);
+        if (activeMissions.length === 0) return false;
+
+        // Fully-idle gate — any non-terminal queue/direct work suppresses the reminder.
+        // We pass no `nodes`: totalActiveCount already counts pending/assigned queue tasks
+        // and un-acknowledged direct dispatches from the store alone, so the check stays
+        // cheap (no per-node status RPC) and conservative.
+        const summary = buildMeshActiveWork({
+            meshId,
+            queue: getQueue(meshId),
+            directDispatches: getActiveDirectDispatches(meshId),
+            ledgerEntries: readLedgerEntries(meshId, { tail: 200 }),
+            now,
+        }).summary;
+        if (summary.totalActiveCount !== 0 || summary.generatingCount !== 0) return false;
+
+        // Debounce — same mission set within the window is nudged at most once.
+        const store = MeshRuntimeStore.getInstance();
+        const hash = missionSetHash(activeMissions);
+        const last = store.getIdleReminderState(meshId);
+        if (!shouldFireIdleReminder(last, hash, now)) return false;
+
+        const message = buildIdleReminderMessage(activeMissions);
+        coordinator.onEvent('send_message', {
+            input: { text: message, textFallback: message },
+        });
+        // Mark AFTER a successful inject so a mid-inject throw retries next edge rather
+        // than silently swallowing the only reminder.
+        store.setIdleReminderState(meshId, { emittedAt: now, missionSetHash: hash });
+        LOG.info(
+            'MeshIdleReminder',
+            `Injected idle reminder for mesh ${meshId} (${activeMissions.length} active mission(s), fully idle)`,
+        );
+        return true;
+    } catch (e: any) {
+        LOG.warn('MeshIdleReminder', `maybeInjectIdleActiveMissionReminder failed for mesh ${meshId}: ${e?.message || e}`);
+        return false;
+    }
+}

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

@@ -42,7 +42,8 @@
 
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import { loadConfig } from '../config/config.js';
-import { listMeshes } from '../config/mesh-config.js';
+import { listMeshes, getMesh } from '../config/mesh-config.js';
+import { maybeInjectIdleActiveMissionReminder } from './mesh-idle-reminder.js';
 import { LOG, getLogLevel } from '../logging/logger.js';
 import { drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, buildPendingEventFingerprint, queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
@@ -1407,7 +1408,19 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         // O(1) guard: skip the drain entirely when the queue is empty.
         if (store) {
             try {
-                if (store.pendingEventCount(meshId) === 0) continue;
+                if (store.pendingEventCount(meshId) === 0) {
+                    // An idle coordinator is present (the no-idle short-circuit already
+                    // `continue`d above) and the pending queue is empty → this mesh is at a
+                    // fully-idle edge with nothing to inject. Nudge (once/debounced) if it
+                    // still has active missions but no work in flight, so a lingering mission
+                    // is not left drifting in 'active'. Best-effort; never blocks the loop.
+                    maybeInjectIdleActiveMissionReminder(
+                        meshId,
+                        targetCoordinators[0].instance,
+                        getMesh(meshId)?.policy,
+                    );
+                    continue;
+                }
             } catch { /* fall through to drain */ }
         }
 

package/src/mesh/mesh-remote-event-pull.ts

@@ -198,7 +198,14 @@ export async function collectLiveNodesWithSessions(
         let statusResult: unknown;
         try {
             if (isLocalNode) {
-                statusResult = await components.commandHandler.handle('get_status_metadata', {});
+                // get_status_metadata is a LOW-family registry command, not a
+                // DaemonCommandHandler switch case — so it must be dispatched
+                // through the router (which consults lowFamilyRegistry before
+                // delegating to commandHandler). Calling commandHandler.handle()
+                // directly falls through to `Unknown command: get_status_metadata`
+                // and leaves the local node's live-session list empty in the mesh
+                // graph. See router.execute() / low-family/index.ts.
+                statusResult = await components.router.execute('get_status_metadata', {}, 'mesh');
             } else if (dispatchMeshCommand) {
                 statusResult = await dispatchMeshCommand(nodeDaemonId, 'get_status_metadata', {});
             } else {

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

@@ -116,6 +116,13 @@ export class MeshRuntimeStore {
     private readonly db: DatabaseHandle;
     private readonly dbPath: string;
     private readonly migratedMeshIds = new Set<string>();
+    // Idle-active-mission-reminder debounce (mesh-idle-reminder.ts). In-memory only:
+    // this is a spam guard for a best-effort coordinator nudge, so a daemon restart
+    // resetting it (at most one extra reminder) is harmless — no SQLite persistence
+    // is warranted. Keyed by meshId; the value records when the last reminder fired
+    // and the hash of the active-mission id set it named, so a changed mission set
+    // re-fires before the time window elapses.
+    private readonly idleReminderState = new Map<string, { emittedAt: number; missionSetHash: string }>();
     private fingerprintSweepCounter = 0;
     private walWriteCounter = 0;
     // Independent cadence for the tool-call-log sweep. Must NOT share walWriteCounter:
@@ -2164,6 +2171,25 @@ export class MeshRuntimeStore {
         ).run(emittedAt, meshId, missionId).changes;
     }
 
+    /**
+     * Read the last idle-active-mission-reminder debounce marker for a mesh, or null if
+     * none has fired this process. In-memory only (see idleReminderState) — best-effort
+     * spam guard for a coordinator nudge, intentionally not SQLite-backed.
+     */
+    getIdleReminderState(meshId: string): { emittedAt: number; missionSetHash: string } | null {
+        return this.idleReminderState.get(meshId) ?? null;
+    }
+
+    /** Record that an idle-active-mission reminder just fired for a mesh (debounce marker). */
+    setIdleReminderState(meshId: string, state: { emittedAt: number; missionSetHash: string }): void {
+        this.idleReminderState.set(meshId, state);
+    }
+
+    /** Clear the idle-reminder debounce marker for a mesh — mesh deletion / test cleanup. */
+    clearIdleReminderState(meshId: string): void {
+        this.idleReminderState.delete(meshId);
+    }
+
     /** Remove all missions for a mesh — mesh deletion / test cleanup. */
     clearMissionsForMesh(meshId: string): number {
         return this.db.prepare('DELETE FROM mesh_missions WHERE mesh_id = ?').run(meshId).changes;

package/src/repo-mesh-types.ts

@@ -359,6 +359,16 @@ export interface RepoMeshPolicy {
      * Defaults to 1 (allow one retry). Set to 0 to disable auto-recovery advice.
      */
     maxTaskRetries?: number;
+    /**
+     * When true (default), the daemon injects a one-shot "[System] Coordinator idle
+     * with N active mission(s)" reminder into an idle coordinator session whenever the
+     * mesh is fully idle (no queue/direct work in flight, no pending coordinator events)
+     * yet still has `active` missions. This nudges the coordinator to close or continue
+     * missions that would otherwise drift in `active` while their real outcome is decided.
+     * Idempotent/debounced per mission-set (see maybeInjectIdleActiveMissionReminder).
+     * Set to false to suppress the reminder entirely.
+     */
+    idleActiveMissionReminder?: boolean;
 }
 
 export interface RepoMeshRelatedRepo {
@@ -478,6 +488,9 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     magiSessionCleanup: 'stop_and_delete',
     autoFastForward: { enabled: true },
     maxTaskRetries: 1,
+    // Nudge the coordinator when the mesh is fully idle but active missions linger,
+    // so a mission is never left drifting in `active` after its work is really done.
+    idleActiveMissionReminder: true,
 };
 
 // ─── Policy normalization (single source of truth) ──────────────────────────