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

package/dist/mesh/mesh-completion-synthesis.d.ts

@@ -0,0 +1,4 @@
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+import type { LocalMeshEntry } from '../repo-mesh-types.js';
+export declare function reconcileUnterminatedDirectDispatches(components: DaemonComponents, mesh: LocalMeshEntry, selfIds: string[], localDaemonId: string | undefined): Promise<void>;
+export declare function autoPruneStaleDirectDispatches(components: DaemonComponents, mesh: LocalMeshEntry, selfIds: string[], localDaemonId: string | undefined, minAgeMs: number): Promise<void>;

package/dist/mesh/mesh-delivery-policy.d.ts

@@ -96,33 +96,6 @@ export declare function getActiveSessionDeliveries(meshId: string, sessionId?: s
     createdAt: string;
     updatedAt: string;
 }[];
-/**
- * Record a completion conflict diagnostic when a duplicate event points to
- * different task/session than the already-seen event with the same fingerprint.
- */
-export declare function recordCompletionConflict(opts: {
-    meshId: string;
-    fingerprint: string;
-    conflictingTaskId?: string;
-    conflictingSessionId?: string;
-    originalTaskId?: string;
-    originalSessionId?: string;
-    event: string;
-}): void;
-/**
- * Get recent completion conflicts for diagnostic inspection.
- */
-export declare function getRecentCompletionConflicts(meshId: string, limitMs?: number): {
-    id: string;
-    meshId: string;
-    fingerprint: string;
-    conflictingTaskId: string | null;
-    conflictingSessionId: string | null;
-    originalTaskId: string | null;
-    originalSessionId: string | null;
-    event: string;
-    createdAt: string;
-}[];
 export declare function __clearSessionDeliveriesForTests(meshId: string): void;
 /**
  * Mark all active (queued/delivering/delivered/acked) deliveries for a session as completed or failed.

package/dist/mesh/mesh-events-pending.d.ts

@@ -201,6 +201,46 @@ export declare function __clearMeshPendingEventsForTests(meshId: string): void;
  * version-skewed remote relays, so tests inject those rows directly through this.
  */
 export declare function __persistUnstampedPendingEventForTests(event: PendingMeshCoordinatorEvent): boolean;
+/** Narrowing filter for {@link requeueHeldMeshCoordinatorEvents}, scoped within one mesh. */
+export interface MeshHeldEventRequeueFilter {
+    /** Restore only held events whose worker task id matches (from the held event's metadata/taskId). */
+    taskId?: string;
+    /** Restore only held events originating from this node. */
+    nodeId?: string;
+    /** Restore only held events of this event name (e.g. 'session:completed'). */
+    event?: string;
+    /** Restore only held entries recorded at/after this ISO timestamp. */
+    since?: string;
+    /** Restore only held entries with this hold reason (e.g. 'pending_trim_dropped'). */
+    reason?: string;
+}
+export interface MeshHeldEventRequeueResult {
+    meshId: string;
+    /** event_held entries considered after the filter. */
+    matched: number;
+    /** entries skipped because a prior requeue already recovered them. */
+    alreadyRequeued: number;
+    /** entries skipped because they carried no restorable original event / were not recoverable. */
+    unrecoverable: number;
+    /** entries handed to the pending queue (some may have been dedup-suppressed downstream). */
+    requeued: number;
+    /** of `requeued`, how many the pending-queue dedup collapsed onto a live event. */
+    dedupSuppressed: number;
+    entries: Array<{
+        heldEntryId: string;
+        event: string;
+        nodeId?: string;
+        taskId?: string;
+        reason?: string;
+        outcome: 'requeued' | 'already_requeued' | 'unrecoverable';
+    }>;
+}
+/**
+ * Restore recoverable `event_held` ledger entries back to the pending coordinator
+ * queue for `meshId`. See the block comment above for the no-loss / no-double-requeue
+ * invariants. Returns per-entry outcomes for the caller to surface.
+ */
+export declare function requeueHeldMeshCoordinatorEvents(meshId: string, filter?: MeshHeldEventRequeueFilter): MeshHeldEventRequeueResult;
 /** Explicitly clear all pending coordinator events for a mesh (and coordinator if scoped). */
 export declare function clearPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): void;
 export {};

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

@@ -1,5 +1,5 @@
-export type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
-export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, getMeshV2DrainCounters, isMeshProtocolV2EnforceEnabled, } from './mesh-events-pending.js';
+export type { PendingMeshCoordinatorEvent, MeshHeldEventRequeueFilter, MeshHeldEventRequeueResult, } from './mesh-events-pending.js';
+export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, requeueHeldMeshCoordinatorEvents, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, getMeshV2DrainCounters, isMeshProtocolV2EnforceEnabled, } from './mesh-events-pending.js';
 export { reconcileDirectDispatchCompletionFromTranscript, } from './mesh-events-stale.js';
 export { setupMeshReconcileLoop, runMeshReconcileTick, resolveCoordinatorDrainDeliverability, shouldHoldPendingDrainForBusyLocalCoordinator, getMeshV2BackstopCounters, } from './mesh-reconcile-loop.js';
 export type { MeshQueueTriggerResult } from './mesh-events-coordinator.js';

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

@@ -15,7 +15,7 @@
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { type MeshLedgerOriginatingCoordinatorV2 } from './contracts.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed' | 'coordinator_operating_note' | 'coordinator_operating_note_tombstone' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'event_held_requeued' | 'task_reclaimed' | 'coordinator_operating_note' | 'coordinator_operating_note_tombstone' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;

package/dist/mesh/mesh-reconcile-config.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_RECONCILE_INTERVAL_MS = 4000;
+export declare const DEFAULT_AUTO_PRUNE_MIN_AGE_MS: number;
+export declare function resolveAutoPruneMinAgeMs(): number;
+export declare const DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS = 12000;
+export declare function resolvePendingHeldDrainEscalateMs(): number;
+export declare function resolveReconcileIntervalMs(): number;

package/dist/mesh/mesh-remote-event-pull.d.ts

@@ -0,0 +1,15 @@
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+import type { LocalMeshEntry } from '../repo-mesh-types.js';
+export declare function pullRemoteNodeQueues(components: DaemonComponents, mesh: LocalMeshEntry, localDaemonId: string | undefined, candidateDaemonIds: string[]): Promise<void>;
+export declare function unwrapReadChatPayload(raw: unknown): Record<string, unknown> | null;
+export declare function readChatPayloadStatus(payload: Record<string, unknown> | null): string;
+export declare function realTerminalEmitPendingForTask(meshId: string, taskId: string): boolean;
+export declare function reprobeWorkerStatus(components: DaemonComponents, args: {
+    isLocalNode: boolean;
+    nodeDaemonId: string;
+    readArgs: Record<string, unknown>;
+}): Promise<string | null>;
+export declare function collectLiveNodesWithSessions(components: DaemonComponents, mesh: LocalMeshEntry, selfIds: string[], localDaemonId: string | undefined): Promise<any[]>;
+export declare function extractStatusMetadataSessions(raw: unknown): any[];
+export declare function extractPendingEvents(raw: unknown): any[];
+export declare function buildForwardPayloadFromPending(event: any): Record<string, unknown>;

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

@@ -241,28 +241,6 @@ export declare class MeshRuntimeStore {
     taskHasConfirmedDelivery(meshId: string, taskId: string): boolean;
     expireStaleSessionDeliveries(meshId: string): void;
     deleteSessionDeliveries(meshId: string): void;
-    recordCompletionConflict(entry: {
-        id: string;
-        meshId: string;
-        fingerprint: string;
-        conflictingTaskId?: string;
-        conflictingSessionId?: string;
-        originalTaskId?: string;
-        originalSessionId?: string;
-        event: string;
-        createdAt: string;
-    }): void;
-    getRecentCompletionConflicts(meshId: string, limitMs?: number): Array<{
-        id: string;
-        meshId: string;
-        fingerprint: string;
-        conflictingTaskId: string | null;
-        conflictingSessionId: string | null;
-        originalTaskId: string | null;
-        originalSessionId: string | null;
-        event: string;
-        createdAt: string;
-    }>;
     /**
      * Record a mesh tool call and check whether this mesh+tool combination is
      * being called too rapidly (sliding window rate guard).

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

@@ -4,9 +4,32 @@ export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | '
 export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
 export type MeshHistoricalTaskStatus = Extract<MeshTaskStatus, 'completed' | 'failed' | 'cancelled'>;
 export type MeshTaskMode = 'code_change' | 'validation' | 'live_debug_readonly' | 'launch_app' | 'convergence';
+/** G6: task-level scheduling priority. Ranks which task a node pulls first (created_at tie-break). */
+export type MeshTaskPriority = 'low' | 'normal' | 'high';
 export declare const ACTIVE_MESH_QUEUE_STATUSES: MeshActiveTaskStatus[];
 export declare const HISTORICAL_MESH_QUEUE_STATUSES: MeshHistoricalTaskStatus[];
 export declare const MESH_TASK_MODES: MeshTaskMode[];
+export declare const MESH_TASK_PRIORITIES: MeshTaskPriority[];
+/**
+ * G6: numeric rank of a task priority (higher = pulled first). Absent/unknown → 'normal' (1).
+ * Shared by the claim-candidate ordering and any surface that must sort by task priority.
+ */
+export declare function meshTaskPriorityRank(priority: unknown): number;
+/** G6: coerce an arbitrary input to a valid MeshTaskPriority, or undefined when not one of the three. */
+export declare function normalizeMeshTaskPriority(value: unknown): MeshTaskPriority | undefined;
+/**
+ * G7: resolve a not_before input to a stored ISO string (or undefined when absent/invalid).
+ * Accepts an ISO/date string, an absolute epoch-ms number, or a small relative-ms offset from
+ * `nowMs`. Disambiguation for numbers: a value below {@link NOT_BEFORE_RELATIVE_THRESHOLD_MS}
+ * (~1 year in ms) is treated as a relative offset added to now; a larger value is an absolute
+ * epoch-ms timestamp. A past/negative result is normalized to now (immediately claimable).
+ */
+export declare const NOT_BEFORE_RELATIVE_THRESHOLD_MS: number;
+export declare function resolveNotBefore(value: unknown, nowMs?: number): string | undefined;
+/** G7: is a task claimable now, or is it still held back by its notBefore gate? */
+export declare function meshTaskNotBeforeReady(task: {
+    notBefore?: string;
+} | null | undefined, nowMs?: number): boolean;
 /**
  * QUEUE-NODE-SERIALIZATION: single source of truth for "is this task read-only?".
  *
@@ -57,6 +80,22 @@ export interface MeshWorkQueueEntry {
     targetSessionId?: string;
     /** If specified, a node must expose all tags before it can claim the task. */
     requiredTags?: string[];
+    /**
+     * G6 (task-level scheduling priority): 'low' | 'normal' | 'high'. Orders the
+     * claim candidate list so a high-priority task is pulled ahead of an older
+     * normal/low task within the same claim tier (created_at is the tie-break).
+     * Absent → treated as 'normal'. This is the TASK-level priority, distinct from
+     * the NODE-level schedulingPriority (resolveNodeSchedulingPriority), which ranks
+     * which node a task goes to, not which task a node pulls first.
+     */
+    priority?: MeshTaskPriority;
+    /**
+     * G7 (delayed execution): ISO timestamp before which the task is NOT claimable.
+     * The claim gate holds the task pending while now < notBefore; once the wall
+     * clock passes it the task becomes a normal claim candidate. A pure time gate —
+     * cron/webhook triggers are out of scope. Absent → immediately claimable.
+     */
+    notBefore?: string;
     /**
      * M1: ids of tasks that must reach 'completed' before this task is claimable.
      * Forward references (ids not yet enqueued) are allowed for batch flows and
@@ -190,6 +229,12 @@ export declare function enqueueTask(meshId: string, message: string, opts?: {
     requiredTags?: string[];
     /** M1: tasks that must complete before this one is claimable. */
     dependsOn?: string[];
+    /** G6: task-level scheduling priority ('low' | 'normal' | 'high'). Absent → 'normal'. */
+    priority?: MeshTaskPriority | string;
+    /** G7: hold the task pending until this time. ISO string, absolute epoch-ms, or relative-ms offset from now. */
+    notBefore?: string | number;
+    /** P3: max automatic requeue attempts before the task auto-fails. Absent → policy default (1). */
+    maxRetries?: number;
     /** M1/M3: mission this task belongs to. */
     missionId?: string;
     /** MAGI: consensus group id shared by every replica of a mesh_magi_review fan-out. */

package/dist/providers/cli-provider-effect-format.d.ts

@@ -0,0 +1,30 @@
+export declare function getEffectDedupKey(effect: {
+    id?: string;
+    type: string;
+    message?: {
+        content?: unknown;
+    };
+    toast?: {
+        message?: string;
+    };
+    notification?: {
+        title?: string;
+        body?: string;
+    };
+}): string;
+export declare function getPersistedEffectContent(effect: {
+    type: string;
+    message?: {
+        content?: unknown;
+    };
+    toast?: {
+        message?: string;
+    };
+    notification?: {
+        title?: string;
+        body?: string;
+        bubbleContent?: unknown;
+    };
+}): string | null;
+export declare function formatApprovalRequestMessage(modalMessage?: string, buttons?: string[]): string;
+export declare function formatMarkerTimestamp(timestamp: number): string;

package/dist/providers/cli-provider-instance-types.d.ts

@@ -0,0 +1,45 @@
+export declare const STATUS_HYDRATION_TAIL_LIMIT = 200;
+export type CompletedDebouncePending = {
+    chatTitle: string;
+    duration: number;
+    timestamp: number;
+    firstObservedAt: number;
+    previousStatus: string;
+    loggedBlockReason?: string;
+    loggedTranscriptProbe?: boolean;
+    transcriptProbeHistory?: ExternalTranscriptProbe[];
+    taskId?: string;
+    turnStartedAt?: number;
+    busyEpochAtArm?: number;
+    lastOutputAtArm?: number;
+};
+export type CompletedFinalizationBlock = {
+    reason: string;
+    terminal?: boolean;
+    allowTimeout?: boolean;
+    holdForTranscript?: boolean;
+};
+export type CompletionFinalAssistantEvidence = {
+    present: boolean;
+    messages: unknown[];
+    source: 'parsed' | 'external-native' | 'unavailable';
+};
+export type ExternalTranscriptProbe = {
+    readAt: number;
+    msgCount: number;
+    lastRole: string | null;
+    lastKind: string | null;
+    contentLen: number;
+    sourcePath: string | null;
+    sourceMtimeMs: number | null;
+    mtimeAgeMs: number | null;
+};
+export declare const COMPLETED_FINALIZATION_RETRY_MS = 1000;
+export declare const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30000;
+export declare const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4000;
+export declare const USER_INPUT_ACK_DEDUP_WINDOW_MS = 60000;
+export declare const STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12000;
+/** Events that signal a dispatched mesh task has reached a terminal state.
+ *  Detach the mesh assignment after emitting one of these so the worker's
+ *  next unrelated turn doesn't impersonate another completion. */
+export declare const TERMINAL_MESH_EVENTS: Set<string>;

package/dist/providers/cli-provider-instance.d.ts

@@ -278,7 +278,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private lastExternalCompletionProbe;
     private enforceFreshSessionLaunchIfNeeded;
     private completionHasFinalAssistantMessage;
-    private buildExternalTranscriptProbe;
     private recordPendingTranscriptProbe;
     /**
      * The spawned CLI's env overrides (e.g. the mesh coordinator points hermes
@@ -312,6 +311,18 @@ export declare class CliProviderInstance implements ProviderInstance {
      * genuine resolution frees the gate promptly.
      */
     private autoApproveContinuityWindowMs;
+    /**
+     * The settle-gate identity signature for a raw activeModal, or null when the
+     * modal is NOT a concrete auto-approvable consent prompt (no captured buttons,
+     * a picker/confirm kind, or no reliable affirmative+decline anchor). Mirrors the
+     * gates the auto-approve fire path applies before computing modalSignature, so
+     * the mask-stall nudge can ask the SAME question the settle gate is tracking —
+     * "is THIS frame's modal the identity the settle clock is accruing against?" —
+     * without duplicating the button-pick logic. The signature is message +
+     * normalized affirmative label only (no volatile counters/button set), matching
+     * the fire path exactly (AUTOAPPROVE-SETTLE-FLAP).
+     */
+    private approvableModalSignature;
     private isAutonomousMeshSession;
     /**
      * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
@@ -378,8 +389,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private pushEvent;
     private flushEvents;
     private applyProviderResponse;
-    private getEffectDedupKey;
-    private getPersistedEffectContent;
     getAdapter(): ProviderCliAdapter;
     get cliType(): string;
     get cliName(): string;
@@ -422,13 +431,10 @@ export declare class CliProviderInstance implements ProviderInstance {
     private maybeEmitStalledApprovalNudge;
     private recordAutoApproval;
     recordApprovalSelection(buttonText: string): void;
-    private formatMarkerTimestamp;
     private maybeAppendRuntimeRecoveryMessage;
     private appendRuntimeSystemMessage;
     private appendRuntimeMessage;
     mergeRuntimeChatMessages(parsedMessages: ChatMessage[]): ChatMessage[];
-    private mergeConversationMessages;
-    private formatApprovalRequestMessage;
     private promoteProviderSessionId;
     private shouldHydrateExistingProviderHistory;
     private shouldSuppressFreshLaunchStartupReplay;

package/dist/providers/cli-provider-transcript-merge.d.ts

@@ -0,0 +1,7 @@
+import type { ChatMessage } from '../types.js';
+import type { ExternalTranscriptProbe } from './cli-provider-instance-types.js';
+export declare function mergeConversationMessages(runtimeMessages: Array<{
+    key: string;
+    message: ChatMessage;
+}>, parsedMessages: any[]): ChatMessage[];
+export declare function buildExternalTranscriptProbe(messages: unknown[], sourcePath?: string, sourceMtimeMs?: number): ExternalTranscriptProbe;

package/package.json

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

package/src/index.ts

@@ -219,6 +219,12 @@ export { MAGI_RAW_ANSWER_CAP } from '@adhdev/mesh-shared';
 //    @adhdev/mesh-shared dependency). ──
 export { expandDaemonIdForms, daemonIdsEquivalent, machineCoreFromDaemonId, canonicalDaemonId } from '@adhdev/mesh-shared';
 export { normalizeMeshNodeId, meshNodeIdMatches } from '@adhdev/mesh-shared';
+// Canonical mesh tool-name registry (SSOT for the schema ↔ prompt ↔ barrel-comment
+// consistency the 6-6 test enforces). Re-exported so mcp-server (which depends on
+// daemon-core, not on mesh-shared directly) and the daemon-core prompt test both
+// reference one list.
+export { CANONICAL_MESH_TOOL_NAMES, CANONICAL_MESH_TOOL_COUNT } from '@adhdev/mesh-shared';
+export type { CanonicalMeshToolName } from '@adhdev/mesh-shared';
 
 // ── Mesh Coordinator ──
 export { buildCoordinatorSystemPrompt } from './mesh/coordinator-prompt.js';
@@ -270,8 +276,8 @@ export { buildMeshLedgerReconciliationEvidence, buildMeshLedgerReplicaEvidence }
 export type { AnyLedgerSlice, MeshLedgerReconciliationEvidence, MeshLedgerReplicaEvidence, MeshLedgerReplicaStatus } from './mesh/mesh-ledger-reconciliation.js';
 
 // ── 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 } from './mesh/mesh-work-queue.js';
-export type { MeshWorkQueueEntry, MeshTaskStatus, MeshTaskMode, MeshWorkQueueStats, MeshQueueMutationOptions, MeshTaskModeValidationResult, DirectDispatchRecord, MeshToolCallRateResult } from './mesh/mesh-work-queue.js';
+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 type { StaleDirectPruneClassification, StaleDirectPruneResult, PruneStaleDirectDispatchesOptions } from './mesh/mesh-active-work.js';
 export type { MeshActiveWorkRecord, MeshActiveWorkStatus, MeshActiveWorkSummary, MeshActiveWorkSource, MeshStaleDirectWorkSummary } from './mesh/mesh-active-work.js';
@@ -295,8 +301,8 @@ export { buildMeshHostRequiredFailure, createDefaultMeshHostMetadata, isMeshHost
 // export type { MeshGraph, MeshGraphNode, MeshGraphEdge, MeshGraphNodeType, MeshGraphEdgeType } from './mesh/mesh-visualization.js';
 
 // ── Mesh Events ──
-export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
-export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
+export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, requeueHeldMeshCoordinatorEvents, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
+export type { PendingMeshCoordinatorEvent, MeshHeldEventRequeueFilter, MeshHeldEventRequeueResult } from './mesh/mesh-events.js';
 // The coordinator-side preview surfaced from a worker's completion/status event
 // (finalSummary / workerResult.summary / lastMessagePreview). Same data the mobile
 // inbox is fed; reused by mesh_read_chat's cache fallback when the live P2P read path
@@ -304,7 +310,7 @@ export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
 export { resolveMeshSurfacedSessionPreview, readMeshCompletionSummary, isWeakCompletionEvidence } from './mesh/mesh-events-utils.js';
 
 // ── Mesh Delivery Policy ──
-export { resolveDeliveryDecision, createSessionDelivery, updateSessionDeliveryStatus, getActiveSessionDeliveries, markSessionDeliveriesTerminal, recordCompletionConflict, getRecentCompletionConflicts } from './mesh/mesh-delivery-policy.js';
+export { resolveDeliveryDecision, createSessionDelivery, updateSessionDeliveryStatus, getActiveSessionDeliveries, markSessionDeliveriesTerminal } from './mesh/mesh-delivery-policy.js';
 export type { MeshSessionDeliveryStatus, MeshSessionDeliveryKind, MeshDeliveryDecision, MeshDeliveryPolicyResult, SessionDeliveryRecord } from './mesh/mesh-delivery-policy.js';
 
 // ── Mesh P2P Relay Failure Classification ──

package/src/mesh/coordinator-prompt.ts

@@ -615,24 +615,39 @@ const TOOLS_SECTION = `## Available Tools
 | \`mesh_queue_cancel\` | Cancel a queue task without deleting audit history |
 | \`mesh_queue_requeue\` | Return a task to pending for retry; clears stale session targets |
 | \`mesh_send_task\` | Legacy push: enqueue a task targeted at a specific node |
+| \`mesh_mission_upsert\` | Create/update a persistent mission so a multi-task plan survives coordinator restarts; set status completed/abandoned when the outcome is decided |
+| \`mesh_mission_list\` | List every mission with goal, status, and live task progress — the authority for "what work remains" (never hidden by status) |
 | \`mesh_launch_session\` | Start a new agent session on a node |
 | \`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_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_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) |
 | \`mesh_git_status\` | Check git status on a specific node |
 | \`mesh_read_node_logs\` | Fetch a remote node's daemon log tail directly over P2P (grep/since/byte-bounded, secrets redacted) — no session/PowerShell needed to debug a node's daemon |
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |
+| \`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_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 |
+| \`mesh_refine_plan\` | Dry-run Refinery plan for a worktree node — config source, validation commands, merge/cleanup intent — without executing validation or git merge |
+| \`mesh_refine_config\` | Refinery config helper (read-only) — unified entry for schema/validate/suggest via a required \`mode\` |
+| \`mesh_change_impact_config\` | Change Impact config helper — unified entry for schema/validate/suggest via a required \`mode\` |
 | \`mesh_remove_node\` | Remove a node (cleans up worktree if applicable) |
 | \`mesh_cleanup_sessions\` | Manually clean up delegated session records for a node |
+| \`mesh_prune_stale_direct\` | Prune orphaned staleDirect dispatch records (dry-run by default); live/pending work and audit history preserved |
 | \`mesh_init\` | Guided onboarding for a fresh repo: dry-run scan → suggest \`.adhdev/*\` configs (refine/bootstrap/change-impact) + providerPriority + current-config echo; gated write on approval |
 | \`mesh_reinit\` | Re-onboard an already-configured repo: re-suggest with overwrite semantics + current-vs-suggested diff; dry-run preview first, per-section approval before write |
 | \`mesh_write_mesh_json_config\` | Gated write of \`.adhdev/mesh.json\` (repo coordinator-prompt config) from the mesh entry — dry-run/overwrite like mesh_init |
+| \`mesh_magi_review\` | Cross-verify a read-only investigation across a standing panel of independent mesh agents (different machines/providers) instead of a single worker |
+| \`mesh_magi_collect\` | Collect + synthesize a previously dispatched MAGI fan-out by its consensus group id (async companion to mesh_magi_review wait:false) |
+| \`mesh_magi_panel_set\` | Upsert a named MAGI panel (standing set of independent node×provider members) into machine-local config |
+| \`mesh_magi_panel_list\` | List configured MAGI panels and resolve each member's availability against the current mesh (read-only) |
 | \`mesh_magi_kind_panel_set\` | Bind a task_kind → MAGI kind-panel slots (machine-local, wholesale replacement — approve current-vs-new first) |
 | \`mesh_magi_kind_panel_list\` | List configured task_kind → MAGI kind-panel slot bindings (machine-local, read-only) |`;