@adhdev/daemon-core 0.9.82-rc.494 → 0.9.82-rc.496

package/dist/commands/router-refine.d.ts

@@ -20,8 +20,8 @@ export declare function buildRefineJobHandle(self: DaemonCommandRouter, args: {
  * The full `CommandRouterResult` (with `validationSummary.commandsRun[]` carrying
  * per-command stdout/stderr, `rejectedCommands`, `suggestions`, `suggestedConfig`,
  * the full `patchEquivalence`, and `submoduleReachability.entries[]`/`.unreachable[]`)
- * routinely exceeds 70KB and overflows the coordinator token limit when it rides on a
- * `mesh_wait_events` payload. The full detail is still persisted verbatim to the ledger
+ * routinely exceeds 70KB and overflows the coordinator token limit when surfaced as a
+ * coordinator event payload. The full detail is still persisted verbatim to the ledger
  * (`appendRefineJobLedger`) and `terminalRefineJobs`, so slimming only the EVENT loses
  * nothing — the coordinator can pull the full record on demand via
  * `evidence.ledgerCommand` / `taskHistoryKind`.

package/dist/index.d.ts

@@ -62,6 +62,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/dist/index.js

@@ -175,7 +175,10 @@ var init_repo_mesh_types = __esm({
       // auto-launched sessions are cleaned — see RepoMeshMagiSessionCleanupMode.
       magiSessionCleanup: "stop_and_delete",
       autoFastForward: { enabled: true },
-      maxTaskRetries: 1
+      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
     };
     SESSION_CLEANUP_MODES = /* @__PURE__ */ new Set([
       "preserve",
@@ -414,10 +417,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "c05e29374bd592e460427419beb06a7fde594f4b" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "c05e2937" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.494" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-10T09:19:42.151Z" : void 0);
+  const commit = readInjected(true ? "bafa66a406e7efc123493af30c0779646ea02c5c" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "bafa66a4" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.496" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-11T16:11:16.059Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2930,7 +2933,6 @@ var init_dist = __esm({
       "mesh_forget_note",
       "mesh_reconcile_ledger",
       "mesh_requeue_held_events",
-      "mesh_wait_events",
       "mesh_mission_upsert",
       "mesh_mission_list",
       "mesh_review_inbox",
@@ -3944,7 +3946,6 @@ var init_coordinator_prompt = __esm({
 | \`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 \u2014 answer "what happened on node X / what failed since T" without scanning transcripts |
 | \`mesh_reconcile_ledger\` | Reconcile daemon-local ledgers over P2P \u2014 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 \u2014 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 \u2014 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) |
@@ -6499,6 +6500,13 @@ var init_mesh_runtime_store = __esm({
       db;
       dbPath;
       migratedMeshIds = /* @__PURE__ */ new Set();
+      // 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.
+      idleReminderState = /* @__PURE__ */ new Map();
       fingerprintSweepCounter = 0;
       walWriteCounter = 0;
       // Independent cadence for the tool-call-log sweep. Must NOT share walWriteCounter:
@@ -8094,6 +8102,22 @@ var init_mesh_runtime_store = __esm({
           "UPDATE mesh_missions SET close_candidate_emitted_at = ? WHERE mesh_id = ? AND id = ?"
         ).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) {
+        return this.idleReminderState.get(meshId) ?? null;
+      }
+      /** Record that an idle-active-mission reminder just fired for a mesh (debounce marker). */
+      setIdleReminderState(meshId, state) {
+        this.idleReminderState.set(meshId, state);
+      }
+      /** Clear the idle-reminder debounce marker for a mesh — mesh deletion / test cleanup. */
+      clearIdleReminderState(meshId) {
+        this.idleReminderState.delete(meshId);
+      }
       /** Remove all missions for a mesh — mesh deletion / test cleanup. */
       clearMissionsForMesh(meshId) {
         return this.db.prepare("DELETE FROM mesh_missions WHERE mesh_id = ?").run(meshId).changes;
@@ -12601,6 +12625,72 @@ var init_mesh_active_work = __esm({
   }
 });
 
+// src/mesh/mesh-idle-reminder.ts
+function missionSetHash(missions) {
+  return missions.map((m) => m.id).sort().join(",");
+}
+function shouldFireIdleReminder(last, hash, now, debounceMs = IDLE_REMINDER_DEBOUNCE_MS) {
+  if (!last) return true;
+  if (now - last.emittedAt > debounceMs) return true;
+  return hash !== last.missionSetHash;
+}
+function buildIdleReminderMessage(missions) {
+  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(`- \u2026and ${overflow} more`);
+  return `[System] Coordinator idle with ${missions.length} active mission(s):
+${lines.join("\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.`;
+}
+function maybeInjectIdleActiveMissionReminder(meshId, coordinator, policy, now = Date.now()) {
+  try {
+    if (!coordinator) return false;
+    if (policy?.idleActiveMissionReminder === false) return false;
+    const activeMissions = getMeshMissions(meshId, ["active"]);
+    if (activeMissions.length === 0) return false;
+    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;
+    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 }
+    });
+    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) {
+    LOG.warn("MeshIdleReminder", `maybeInjectIdleActiveMissionReminder failed for mesh ${meshId}: ${e?.message || e}`);
+    return false;
+  }
+}
+var IDLE_REMINDER_DEBOUNCE_MS, MISSION_LIST_CAP;
+var init_mesh_idle_reminder = __esm({
+  "src/mesh/mesh-idle-reminder.ts"() {
+    "use strict";
+    init_logger();
+    init_mesh_runtime_store();
+    init_mesh_missions();
+    init_mesh_work_queue();
+    init_mesh_ledger();
+    init_mesh_active_work();
+    IDLE_REMINDER_DEBOUNCE_MS = 3e5;
+    MISSION_LIST_CAP = 10;
+  }
+});
+
 // src/mesh/mesh-magi-status.ts
 var mesh_magi_status_exports = {};
 __export(mesh_magi_status_exports, {
@@ -20478,6 +20568,12 @@ function setupMeshEventForwarding(components) {
                       ...forcePending ? { force: true } : {}
                     });
                   }
+                } else {
+                  maybeInjectIdleActiveMissionReminder(
+                    coordinatorMeshId,
+                    flushSource,
+                    getMesh(coordinatorMeshId)?.policy
+                  );
                 }
               } catch (e) {
                 LOG.warn("MeshEvents", `Failed to auto-flush pending coordinator events: ${e?.message || e}`);
@@ -20537,6 +20633,7 @@ var init_mesh_event_forwarding = __esm({
     init_mesh_work_queue();
     init_mesh_delivery_policy();
     init_mesh_runtime_store();
+    init_mesh_idle_reminder();
     init_mesh_events_pending();
     init_mesh_routing();
     init_mesh_host_ownership();
@@ -20871,7 +20968,7 @@ async function collectLiveNodesWithSessions(components, mesh, selfIds, localDaem
     let statusResult;
     try {
       if (isLocalNode) {
-        statusResult = await components.commandHandler.handle("get_status_metadata", {});
+        statusResult = await components.router.execute("get_status_metadata", {}, "mesh");
       } else if (dispatchMeshCommand) {
         statusResult = await dispatchMeshCommand(nodeDaemonId, "get_status_metadata", {});
       } else {
@@ -21838,7 +21935,14 @@ async function runMeshReconcileTick(components) {
     }
     if (store) {
       try {
-        if (store.pendingEventCount(meshId) === 0) continue;
+        if (store.pendingEventCount(meshId) === 0) {
+          maybeInjectIdleActiveMissionReminder(
+            meshId,
+            targetCoordinators[0].instance,
+            getMesh(meshId)?.policy
+          );
+          continue;
+        }
       } catch {
       }
     }
@@ -22012,6 +22116,7 @@ var init_mesh_reconcile_loop = __esm({
     "use strict";
     init_config();
     init_mesh_config();
+    init_mesh_idle_reminder();
     init_logger();
     init_mesh_events_pending();
     init_mesh_ledger();
@@ -27945,6 +28050,7 @@ __export(index_exports, {
   GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
   GitCommandError: () => GitCommandError,
   GitWorkspaceMonitor: () => GitWorkspaceMonitor,
+  IDLE_REMINDER_DEBOUNCE_MS: () => IDLE_REMINDER_DEBOUNCE_MS,
   IdeProviderInstance: () => IdeProviderInstance,
   InMemoryGitSnapshotStore: () => InMemoryGitSnapshotStore,
   LOG: () => LOG,
@@ -28005,6 +28111,7 @@ __export(index_exports, {
   buildClaudeInteractiveToolResult: () => buildClaudeInteractiveToolResult,
   buildCompactStaleDirectWorkSummary: () => buildCompactStaleDirectWorkSummary,
   buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
+  buildIdleReminderMessage: () => buildIdleReminderMessage,
   buildIpcStatusHttpResponse: () => buildIpcStatusHttpResponse,
   buildMachineInfo: () => buildMachineInfo,
   buildMeshActiveWork: () => buildMeshActiveWork,
@@ -28179,11 +28286,13 @@ __export(index_exports, {
   markSessionDeliveriesTerminal: () => markSessionDeliveriesTerminal,
   markSetupComplete: () => markSetupComplete,
   markStaleDirectDispatches: () => markStaleDirectDispatches,
+  maybeInjectIdleActiveMissionReminder: () => maybeInjectIdleActiveMissionReminder,
   maybeRunDaemonUpgradeHelperFromEnv: () => maybeRunDaemonUpgradeHelperFromEnv,
   mergeAndNormalizePolicy: () => mergeAndNormalizePolicy,
   meshNodeIdMatches: () => meshNodeIdMatches,
   meshTaskNotBeforeReady: () => meshTaskNotBeforeReady,
   meshTaskPriorityRank: () => meshTaskPriorityRank,
+  missionSetHash: () => missionSetHash,
   namedKeyToAnsi: () => namedKeyToAnsi,
   namedKeysToAnsi: () => namedKeysToAnsi,
   nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
@@ -28280,6 +28389,7 @@ __export(index_exports, {
   setupIdeInstance: () => setupIdeInstance,
   shouldAutoRestoreHostedSessionsOnStartup: () => shouldAutoRestoreHostedSessionsOnStartup,
   shouldCollectTraceCategory: () => shouldCollectTraceCategory,
+  shouldFireIdleReminder: () => shouldFireIdleReminder,
   shutdownDaemonComponents: () => shutdownDaemonComponents,
   spawnDetachedDaemonUpgradeHelper: () => spawnDetachedDaemonUpgradeHelper,
   startDaemonDevSupport: () => startDaemonDevSupport,
@@ -29679,6 +29789,7 @@ function buildMeshLedgerReconciliationEvidence(meshId, replicas) {
 // src/index.ts
 init_mesh_work_queue();
 init_mesh_active_work();
+init_mesh_idle_reminder();
 init_mesh_refine_status();
 init_mesh_magi_status();
 init_mesh_scheduling_runtime();
@@ -29689,8 +29800,8 @@ init_mesh_events_utils();
 init_mesh_delivery_policy();
 
 // src/mesh/p2p-relay-failure.ts
-var NO_FALLBACK_REASON = "Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.";
-var P2P_NEXT_ACTION = "Check daemon/P2P health, wait briefly for connection establishment, then do one bounded retry or requeue the mesh task after clearing stale target session metadata.";
+var NO_FALLBACK_REASON = "This mesh operation needs a live peer-to-peer connection to the node, which is not open right now. This is often transient \u2014 the peer may be connecting, slow via TURN relay, or briefly offline. Wait a moment and retry, or re-establish the node's connection. Mesh commands use P2P only by design \u2014 there is no cloud/WS relay fallback.";
+var P2P_NEXT_ACTION = "The peer connection is recoverable. Wait a moment for the connection to establish (especially over TURN relay), then retry. If the node remains unreachable, check that the target daemon is running and online, then re-establish its connection.";
 var NON_P2P_NEXT_ACTION = "Inspect the provider/command error and fix the underlying logic or configuration before retrying.";
 function messageFromError(error) {
   if (error instanceof Error) return error.message;
@@ -70765,6 +70876,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   GOAL_PREVIEW_MAX,
   GitCommandError,
   GitWorkspaceMonitor,
+  IDLE_REMINDER_DEBOUNCE_MS,
   IdeProviderInstance,
   InMemoryGitSnapshotStore,
   LOG,
@@ -70825,6 +70937,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   buildClaudeInteractiveToolResult,
   buildCompactStaleDirectWorkSummary,
   buildCoordinatorSystemPrompt,
+  buildIdleReminderMessage,
   buildIpcStatusHttpResponse,
   buildMachineInfo,
   buildMeshActiveWork,
@@ -70999,11 +71112,13 @@ var V1_CONTRACT_VERSION = "1.0.0";
   markSessionDeliveriesTerminal,
   markSetupComplete,
   markStaleDirectDispatches,
+  maybeInjectIdleActiveMissionReminder,
   maybeRunDaemonUpgradeHelperFromEnv,
   mergeAndNormalizePolicy,
   meshNodeIdMatches,
   meshTaskNotBeforeReady,
   meshTaskPriorityRank,
+  missionSetHash,
   namedKeyToAnsi,
   namedKeysToAnsi,
   nodeSatisfiesRequiredTags,
@@ -71100,6 +71215,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   setupIdeInstance,
   shouldAutoRestoreHostedSessionsOnStartup,
   shouldCollectTraceCategory,
+  shouldFireIdleReminder,
   shutdownDaemonComponents,
   spawnDetachedDaemonUpgradeHelper,
   startDaemonDevSupport,