@adhdev/daemon-core 0.9.82-rc.414 → 0.9.82-rc.416

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

@@ -1,4 +1,4 @@
 export { isMeshCoordinatorEvent, MESH_FORCE_INJECT_EVENTS, shouldForceInjectMeshEvent, } from './mesh-event-classify.js';
-export { __orderEligibleNodesForTests, __resolveSchedulingStrategyForTests, __resetIdleAutoFastForwardForTests, activeReadonlyAssignedCount, activeWriteAssignedCount, triggerMeshQueue, tryAssignQueueTask, } from './mesh-queue-assignment.js';
+export { __orderEligibleNodesForTests, __resolveSchedulingStrategyForTests, __resetIdleAutoFastForwardForTests, activeReadonlyAssignedCount, activeWriteAssignedCount, isSessionActivelyGenerating, triggerMeshQueue, tryAssignQueueTask, } from './mesh-queue-assignment.js';
 export type { MeshQueueTriggerResult } from './mesh-queue-assignment.js';
 export { __resetMeshWorkspaceCacheForTests, buildRelayMetadataEvent, handleMeshForwardEvent, resolveForwardEventMeshId, setupMeshEventForwarding, } from './mesh-event-forwarding.js';

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

@@ -3,4 +3,4 @@ export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, ge
 export { reconcileDirectDispatchCompletionFromTranscript, } from './mesh-events-stale.js';
 export { setupMeshReconcileLoop, runMeshReconcileTick, resolveCoordinatorDrainDeliverability, shouldHoldPendingDrainForBusyLocalCoordinator, } from './mesh-reconcile-loop.js';
 export type { MeshQueueTriggerResult } from './mesh-events-coordinator.js';
-export { tryAssignQueueTask, triggerMeshQueue, handleMeshForwardEvent, setupMeshEventForwarding, isMeshCoordinatorEvent, __resetIdleAutoFastForwardForTests, __resetMeshWorkspaceCacheForTests, } from './mesh-events-coordinator.js';
+export { tryAssignQueueTask, isSessionActivelyGenerating, triggerMeshQueue, handleMeshForwardEvent, setupMeshEventForwarding, isMeshCoordinatorEvent, __resetIdleAutoFastForwardForTests, __resetMeshWorkspaceCacheForTests, } from './mesh-events-coordinator.js';

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

@@ -14,7 +14,7 @@
  */
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.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' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated';
+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' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;

package/dist/mesh/mesh-magi-status.d.ts

@@ -0,0 +1,63 @@
+import type { MeshLedgerEntry } from './mesh-ledger.js';
+import type { MagiGitSkew } from '@adhdev/mesh-shared';
+export type MeshMagiActivityStatus = 'running' | 'synthesized';
+/** A bounded needs_verification preview item (claim text + category only). */
+export interface MeshMagiNeedsVerificationItem {
+    claim: string;
+    category: string;
+}
+export interface MeshMagiActivitySummary {
+    consensusGroupId: string;
+    status: MeshMagiActivityStatus;
+    missionId?: string;
+    panel?: string;
+    question?: string;
+    replicaCount?: number;
+    answered?: number;
+    missing?: number;
+    staleReplicas?: number;
+    needsVerificationCount?: number;
+    agreedCount?: number;
+    independenceBanner?: string | null;
+    gitSkew?: MagiGitSkew;
+    /** Bounded sample of the needs_verification clusters (claim + category). */
+    needsVerification?: MeshMagiNeedsVerificationItem[];
+    openQuestions?: string[];
+    lastLedgerKind?: string;
+    lastUpdatedAt?: string;
+}
+/** Cap on inlined needs_verification preview items per group (keeps the payload bounded). */
+export declare const MAGI_NEEDS_VERIFICATION_PREVIEW_CAP = 8;
+/**
+ * Reconstruct per-consensusGroup MAGI activity from a ledger window. The newest
+ * `magi_synthesis` for a group supplies the synthesis fields; a `magi_dispatched`
+ * with no later synthesis stays `running`. Deduped by consensusGroupId, newest first.
+ */
+export declare function buildMeshMagiActivity(args: {
+    meshId?: string;
+    ledgerEntries?: MeshLedgerEntry[];
+}): MeshMagiActivitySummary[];
+/** Synthesized groups older than this (relative to the newest activity in the set) are
+ *  folded out of the active list — already-resolved historical runs that should not keep
+ *  inflating mesh_status. 6h covers a long working session. */
+export declare const STALE_MAGI_WINDOW_MS: number;
+/** Cap on recent synthesized groups kept in the active list even if all are fresh. */
+export declare const RECENT_MAGI_CAP = 6;
+export interface MeshMagiActivitySummaryFold {
+    total: number;
+    byStatus: Record<string, number>;
+    /** Synthesized groups dropped from the active list as stale historical residue. */
+    staleSynthesized: number;
+    /** Bounded set of recent/active groups (running first, then recent synthesized). */
+    groups: MeshMagiActivitySummary[];
+}
+/**
+ * Bound the MAGI activity list for mesh_status: running groups are always kept; synthesized
+ * groups are kept only when recent (within STALE_MAGI_WINDOW_MS of the newest activity AND
+ * among the RECENT_MAGI_CAP most-recent). Freshness is measured relative to the newest group
+ * (not wall-clock) so the result is deterministic for a given input. Mirrors
+ * summarizeMeshAsyncRefineJobs.
+ */
+export declare function summarizeMeshMagiActivity(activity: MeshMagiActivitySummary[]): MeshMagiActivitySummaryFold;
+/** Latest persisted synthesis activity for one consensusGroupId, or undefined. */
+export declare function getMeshMagiActivityByGroup(ledgerEntries: MeshLedgerEntry[], consensusGroupId: string): MeshMagiActivitySummary | undefined;

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

@@ -47,6 +47,24 @@ export declare function __orderEligibleNodesForTests(meshId: string, strategy: R
     bumpCursor?: boolean;
 }): RankableNode[];
 export declare function sessionHasActiveAssignment(meshId: string, sessionId: string): boolean;
+/**
+ * CANON-IDENTITY single-flight hardening (restart-safe, observation-based).
+ *
+ * The in-memory single-flight Set (mesh-task-inflight) is process-local and is LOST on a
+ * daemon restart — after a restart, a task still being generated by a live local worker is
+ * no longer marked in-flight, so requeueTask's Set check passes and would re-open the task
+ * for a duplicate second dispatch. This recovers the "still generating" signal from
+ * observable runtime state instead of the in-memory mark: a session is actively generating
+ * when its live local CLI instance reports an active (generating/streaming/…) status — the
+ * same predicate the dispatch active-work gate uses (sessionStateLooksActive).
+ *
+ * Local-only by design: it inspects THIS daemon's instanceManager. The primary cross-process
+ * fix (IpcTransport requeue delegating to the mesh-host daemon) keeps begin (dispatch) and
+ * check (requeue guard) co-located so the in-memory mark stays authoritative in the common
+ * path; this is the restart-safety net for sessions hosted on this daemon. A genuinely
+ * dead/stale session is not generating → returns false → the requeue proceeds as before.
+ */
+export declare function isSessionActivelyGenerating(components: DaemonComponents, sessionId: string): boolean;
 export interface MeshQueueTriggerResult {
     success: true;
     meshId: string;

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

@@ -65,6 +65,13 @@ export interface MeshWorkQueueEntry {
     dependsOn?: string[];
     /** M1/M3: mission this task belongs to (joins mesh_missions). */
     missionId?: string;
+    /**
+     * MAGI: consensus group id shared by every replica of one mesh_magi_review
+     * fan-out. Marks the task as part of an INTENTIONAL same-prompt quorum so the
+     * completion-event dedup (mesh-events-pending) never collapses grouped
+     * replicas. Absent on ordinary tasks. Rides in the payload JSON (no column).
+     */
+    consensusGroupId?: string;
     /**
      * M1: why this task is held back (e.g. "dependency_failed:<taskId>").
      * Only set by the system on dependency failure under the 'block' policy;
@@ -177,6 +184,8 @@ export declare function enqueueTask(meshId: string, message: string, opts?: {
     dependsOn?: string[];
     /** M1/M3: mission this task belongs to. */
     missionId?: string;
+    /** MAGI: consensus group id shared by every replica of a mesh_magi_review fan-out. */
+    consensusGroupId?: string;
     /** Explicit task id for batch/template flows (M5). Random UUID when omitted. */
     id?: string;
     /** (3) Originating coordinator session id (for session-anchored completion routing). */

package/dist/repo-mesh-types.d.ts

@@ -12,6 +12,7 @@
  */
 import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
 import type { MeshMissionSummary, MeshMissionSlimSummary } from './mesh/mesh-missions.js';
+import type { MagiPanelMap } from '@adhdev/mesh-shared';
 export interface RepoMesh {
     id: string;
     name: string;
@@ -466,6 +467,13 @@ export interface RepoMeshCoordinatorConfig {
  */
 export interface LocalMeshConfig {
     meshes: LocalMeshEntry[];
+    /**
+     * MAGI cross-verification panels (machine-local). Keyed by panel name; each
+     * binds concrete `(node × provider)` members — machine-dependent facts — so
+     * panels live here in meshes.json, never in the repo-shared .adhdev/mesh.json.
+     * Optional: absent on configs written before MAGI existed.
+     */
+    magiPanels?: MagiPanelMap;
 }
 export interface LocalMeshEntry {
     id: string;

package/package.json

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

package/src/cli-adapters/resolve-executable.ts

@@ -6,6 +6,12 @@ import * as path from 'path';
 // need a cmd.exe wrapper).
 const DIRECT_EXEC_EXT = new Set(['.exe', '.com']);
 
+// Batch-style shims: absolute and launchable by node-pty's ConPTY, but NOT by
+// child_process.execFile/spawn without a cmd.exe wrapper (Node ≥18.20/20.12/22/24
+// refuse to exec a .cmd/.bat directly — CVE-2024-27980 mitigation). Preferred
+// over extensionless Unix wrappers, which are not win32-executable at all.
+const SHIM_EXEC_EXT = new Set(['.cmd', '.bat']);
+
 // Executable extensions to probe when scanning a directory ourselves, ordered
 // most-directly-launchable first. node-pty's ConPTY backend launches an
 // absolute `.cmd`/`.bat` shim fine (verified) — it only fails to *resolve* a
@@ -42,6 +48,29 @@ function resolveWin32GlobalBin(trimmed: string): string | null {
   return null;
 }
 
+/**
+ * Pick the best launch target from `where`'s match list on win32.
+ *
+ * `where npm` on a typical install returns BOTH the extensionless Unix wrapper
+ * (e.g. `C:\Program Files\nodejs\npm`, a bash shell script) AND the `npm.cmd`
+ * shim. The extensionless wrapper is NOT a win32 executable — handing it to a
+ * spawn boundary ENOENTs (errno -4058). So:
+ *   1. Prefer a directly-launchable `.exe`/`.com`.
+ *   2. Otherwise take a `.cmd`/`.bat` shim (absolute → works for ConPTY, and for
+ *      execFile once wrapped via buildWin32ExecFileSpawn).
+ *   3. NEVER fall back to an extensionless match — return null so the caller can
+ *      try other resolution strategies (global-bin scan) rather than emit a
+ *      path that cannot be exec'd.
+ */
+export function selectWin32ExecutableMatch(matches: string[]): string | null {
+  const cleaned = matches.map((m) => m.trim()).filter(Boolean);
+  const direct = cleaned.find((m) => DIRECT_EXEC_EXT.has(path.extname(m).toLowerCase()));
+  if (direct) return direct;
+  const shim = cleaned.find((m) => SHIM_EXEC_EXT.has(path.extname(m).toLowerCase()));
+  if (shim) return shim;
+  return null;
+}
+
 /**
  * Resolve a launch command to an absolute executable path on Windows.
  *
@@ -70,9 +99,12 @@ export function resolveWin32Executable(command: string): string {
     }).trim();
     if (out) {
       const matches = out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
-      // Prefer a directly-launchable executable (.exe/.com) over .cmd/.bat shims.
-      const direct = matches.find((m) => DIRECT_EXEC_EXT.has(path.extname(m).toLowerCase()));
-      return direct || matches[0] || command;
+      // Prefer .exe/.com, then a .cmd/.bat shim; never an extensionless Unix
+      // wrapper (the old `matches[0]` fallback returned exactly that and made
+      // the spawn boundary ENOENT). On no usable match, fall through to the
+      // off-PATH global-bin scan below rather than returning a dead path.
+      const selected = selectWin32ExecutableMatch(matches);
+      if (selected) return selected;
     }
   } catch {
     // `where` not found / non-zero exit — fall through to the global-bin scan.
@@ -88,3 +120,85 @@ export function resolveWin32Executable(command: string): string {
 
   return command;
 }
+
+/**
+ * Quote one argument for a cmd.exe command line using the standard
+ * CommandLineToArgvW rules (the same algorithm Node uses internally): wrap in
+ * double quotes only when needed, double up the backslashes that precede a
+ * quote, and escape embedded quotes. We do per-argument quoting ourselves
+ * (rather than `{ shell: true }`) because Node's shell mode joins argv with bare
+ * spaces and applies NO quoting — any argument containing a space (a path, a
+ * test name) would split. Inputs here are repo-mesh validation/bootstrap command
+ * tokens (trusted config, not network data), so argv-quoting for spaces/quotes
+ * is sufficient; we deliberately do not attempt full cmd.exe metacharacter
+ * (& | < > ^ %) escaping.
+ */
+export function quoteWin32CmdArg(arg: string): string {
+  if (arg.length > 0 && !/[ \t"]/.test(arg)) return arg;
+  let result = '"';
+  let backslashes = 0;
+  for (const ch of arg) {
+    if (ch === '\\') {
+      backslashes += 1;
+      continue;
+    }
+    if (ch === '"') {
+      // Escape every pending backslash (they precede a quote) plus the quote.
+      result += '\\'.repeat(backslashes * 2 + 1) + '"';
+      backslashes = 0;
+      continue;
+    }
+    result += '\\'.repeat(backslashes) + ch;
+    backslashes = 0;
+  }
+  // Trailing backslashes precede the closing quote → must be doubled.
+  result += '\\'.repeat(backslashes * 2) + '"';
+  return result;
+}
+
+export interface Win32ExecFileSpawn {
+  file: string;
+  args: string[];
+  /** Set when the args are pre-quoted for cmd.exe and must not be re-quoted. */
+  windowsVerbatimArguments?: boolean;
+}
+
+/**
+ * Build child_process.execFile/spawn parameters for an already-resolved command.
+ *
+ * On win32 a `.cmd`/`.bat` shim (what `npm`/`npx`/`tsc`/`vitest` resolve to)
+ * cannot be launched by execFile directly — modern Node refuses it (CVE-2024-27980
+ * mitigation) and CreateProcess cannot exec a batch file. So wrap it in
+ * `cmd.exe /d /s /c "<quoted command line>"` with `windowsVerbatimArguments` so
+ * our own per-argument quoting is preserved. `.exe`/`.com` (and every non-win32
+ * platform, and any already-cmd.exe target) pass through unchanged — this is a
+ * strict no-op off win32, guarding against regressions on linux/macOS.
+ */
+export function buildWin32ExecFileSpawn(resolvedCommand: string, args: string[]): Win32ExecFileSpawn {
+  if (process.platform !== 'win32') return { file: resolvedCommand, args };
+  const ext = path.extname(resolvedCommand).toLowerCase();
+  if (!SHIM_EXEC_EXT.has(ext)) return { file: resolvedCommand, args };
+  // cmd.exe /d (skip AutoRun) /s (treat the rest, between the outer quotes, as
+  // the verbatim command) /c (run then exit). Mirrors Node's internal shell
+  // wrapping but with each token individually quoted.
+  const commandLine = [resolvedCommand, ...args].map(quoteWin32CmdArg).join(' ');
+  return {
+    file: process.env.ComSpec || 'cmd.exe',
+    args: ['/d', '/s', '/c', `"${commandLine}"`],
+    windowsVerbatimArguments: true,
+  };
+}
+
+/**
+ * Convenience: resolve a bare command to an absolute win32 path AND build the
+ * execFile spawn parameters (cmd.exe-wrapping a .cmd/.bat shim). Returns the
+ * resolved command alongside the spawn spec so callers can still surface the
+ * resolved path in diagnostics.
+ */
+export function resolveWin32ExecFileSpawn(
+  command: string,
+  args: string[],
+): Win32ExecFileSpawn & { resolvedCommand: string } {
+  const resolvedCommand = resolveWin32Executable(command);
+  return { resolvedCommand, ...buildWin32ExecFileSpawn(resolvedCommand, args) };
+}

package/src/commands/med-family/mesh-queue.ts

@@ -67,7 +67,29 @@ export const meshQueueHandlers: Record<string, MedFamilyHandler> = {
         const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'queue requeue');
         if (ownerFailure) return ownerFailure;
         try {
-            const { requeueTask } = await import('../../mesh/mesh-work-queue.js');
+            const { requeueTask, getQueue } = await import('../../mesh/mesh-work-queue.js');
+            // CANON-IDENTITY single-flight hardening (restart-safe): the in-memory in-flight
+            // mark requeueTask consults is process-local and is lost across a daemon restart.
+            // Independently of that mark, if the row is still 'assigned' to a session this
+            // daemon hosts that is actively generating, requeueing would flip it back to
+            // pending and let a SECOND session claim the SAME task (the duplicate dispatch).
+            // Refuse unless force. A genuinely dead/stale session is not generating, so this
+            // observation passes and a legitimate requeue proceeds. force=true (operator
+            // override) bypasses BOTH this and the in-memory guard.
+            // MAGI-NOTE: a future consensus group fan-out (separate mission) will exempt
+            // group-tagged tasks from this guard; the exemption hook belongs here.
+            if (args?.force !== true) {
+                const { isSessionActivelyGenerating } = await import('../../mesh/mesh-events.js');
+                const existing = getQueue(meshId).find((t: any) => t?.id === taskId) as { status?: string; assignedSessionId?: string } | undefined;
+                if (existing?.status === 'assigned' && existing.assignedSessionId
+                    && isSessionActivelyGenerating(ctx.deps as any, existing.assignedSessionId)) {
+                    return {
+                        success: false,
+                        error: `Task '${taskId}' is actively dispatched/generating (live session ${existing.assignedSessionId}); requeue refused to avoid a duplicate second dispatch. Pass force:true to override, or cancel and re-enqueue.`,
+                        task: existing,
+                    };
+                }
+            }
             const task = requeueTask(meshId, taskId, {
                 reason: typeof args?.reason === 'string' ? args.reason : undefined,
                 targetNodeId: typeof args?.targetNodeId === 'string' ? args.targetNodeId.trim() : undefined,

package/src/config/mesh-config.ts

@@ -22,6 +22,7 @@ import type {
     RepoMeshHostMetadata,
     RepoMeshDaemonRole,
 } from '../repo-mesh-types.js';
+import type { MagiPanel, MagiPanelMember } from '@adhdev/mesh-shared';
 import { mergeAndNormalizePolicy } from '../repo-mesh-types.js';
 import { createDefaultMeshHostMetadata } from '../mesh/mesh-host-ownership.js';
 
@@ -584,3 +585,118 @@ export function updateNode(
     saveMeshConfig(config);
     return node;
 }
+
+// ─── MAGI Panels (machine-local cross-verification quorums) ──
+
+/** Hard cap on members per panel — a sanity bound, not the per-invocation replica cap. */
+const MAX_MAGI_PANEL_MEMBERS = 24;
+
+function normalizeReplicaCount(value: unknown): number | undefined {
+    if (typeof value !== 'number' || !Number.isFinite(value)) return undefined;
+    const n = Math.floor(value);
+    return n >= 1 ? n : undefined;
+}
+
+/**
+ * Validate + normalize a panel config before persisting. Mirrors the node-config
+ * normalization style (mesh-config addNode/updateNode): trims strings, drops
+ * empties, requires a provider per member, clamps replica counts. Throws on
+ * structurally invalid input so the calling tool returns a clear error rather than
+ * writing a malformed panel.
+ */
+export function normalizeMagiPanel(config: unknown): MagiPanel {
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+        throw new Error('invalid_magi_panel: config must be an object');
+    }
+    const raw = config as Record<string, unknown>;
+    const rawMembers = raw.members;
+    if (!Array.isArray(rawMembers) || rawMembers.length === 0) {
+        throw new Error('invalid_magi_panel: members must be a non-empty array');
+    }
+    if (rawMembers.length > MAX_MAGI_PANEL_MEMBERS) {
+        throw new Error(`invalid_magi_panel: too many members (max ${MAX_MAGI_PANEL_MEMBERS})`);
+    }
+    const members: MagiPanelMember[] = rawMembers.map((entry, idx) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            throw new Error(`invalid_magi_panel: member[${idx}] must be an object`);
+        }
+        const m = entry as Record<string, unknown>;
+        const provider = typeof m.provider === 'string' ? m.provider.trim() : '';
+        if (!provider) {
+            throw new Error(`invalid_magi_panel: member[${idx}].provider is required`);
+        }
+        const nodeId = typeof m.nodeId === 'string' && m.nodeId.trim() ? m.nodeId.trim() : undefined;
+        const capabilityTags = normalizeCapabilityTags(m.capabilityTags);
+        const n = normalizeReplicaCount(m.n);
+        return {
+            provider,
+            ...(nodeId ? { nodeId } : {}),
+            ...(capabilityTags ? { capabilityTags } : {}),
+            ...(n !== undefined ? { n } : {}),
+        };
+    });
+    const description = typeof raw.description === 'string' && raw.description.trim()
+        ? raw.description.trim().slice(0, 200)
+        : undefined;
+    const defaultN = normalizeReplicaCount(raw.defaultN);
+    return {
+        ...(description ? { description } : {}),
+        members,
+        ...(defaultN !== undefined ? { defaultN } : {}),
+        // dedupExempt is always meaningful for a MAGI panel (intentional same-prompt
+        // fan-out). Persist it true unless the caller explicitly disables it.
+        dedupExempt: raw.dedupExempt === false ? false : true,
+    };
+}
+
+function normalizePanelName(name: unknown): string {
+    const trimmed = typeof name === 'string' ? name.trim() : '';
+    if (!trimmed) throw new Error('invalid_magi_panel: panel name is required');
+    return trimmed.slice(0, 100);
+}
+
+/** All configured MAGI panels (machine-local), keyed by name. Empty when none. */
+export function listMagiPanels(): Record<string, MagiPanel> {
+    return loadMeshConfig().magiPanels ?? {};
+}
+
+/** A single panel by name, or undefined when not configured. */
+export function getMagiPanel(name: string): MagiPanel | undefined {
+    const key = typeof name === 'string' ? name.trim() : '';
+    if (!key) return undefined;
+    return loadMeshConfig().magiPanels?.[key];
+}
+
+/**
+ * Upsert a named panel into meshes.json. Defaults to refusing to clobber an
+ * existing panel (overwrite=false) — mirrors the mesh_init write/overwrite
+ * precedent. Returns the normalized, persisted panel.
+ */
+export function upsertMagiPanel(
+    name: string,
+    config: unknown,
+    opts: { overwrite?: boolean } = {},
+): MagiPanel {
+    const key = normalizePanelName(name);
+    const panel = normalizeMagiPanel(config);
+    const stored = loadMeshConfig();
+    const panels = stored.magiPanels ?? {};
+    if (panels[key] && opts.overwrite !== true) {
+        throw new Error(`magi_panel_exists: panel '${key}' already exists — pass overwrite=true to replace it`);
+    }
+    panels[key] = panel;
+    stored.magiPanels = panels;
+    saveMeshConfig(stored);
+    return panel;
+}
+
+/** Remove a named panel. Returns true when a panel was removed. */
+export function removeMagiPanel(name: string): boolean {
+    const key = typeof name === 'string' ? name.trim() : '';
+    if (!key) return false;
+    const stored = loadMeshConfig();
+    if (!stored.magiPanels || !stored.magiPanels[key]) return false;
+    delete stored.magiPanels[key];
+    saveMeshConfig(stored);
+    return true;
+}

package/src/index.ts

@@ -192,8 +192,18 @@ export type { SavedProviderSessionEntry } from './config/saved-sessions.js';
 export {
   listMeshes, getMesh, getMeshByRepo, createMesh, updateMesh, deleteMesh,
   addNode, removeNode, updateNode, normalizeRepoIdentity,
+  listMagiPanels, getMagiPanel, upsertMagiPanel, removeMagiPanel, normalizeMagiPanel,
 } from './config/mesh-config.js';
 export type { CreateMeshOptions, UpdateMeshOptions, AddNodeOptions } from './config/mesh-config.js';
+// MAGI panel / common-output / synthesis types (re-exported from the mesh-shared
+// leaf so the mcp-server — which depends only on @adhdev/daemon-core — can consume
+// them without taking a direct @adhdev/mesh-shared dependency).
+export type {
+  MagiPanel, MagiPanelMember, MagiPanelMap, MagiMode,
+  MagiClaim, MagiClaimStance, MagiAgentResponse,
+  MagiResponseSource, MagiReplicaGitRef, MagiGitSkew, MagiSynthesizedResponse,
+  MagiClusterCategory, MagiClusterMember, MagiClaimCluster, MagiSynthesis,
+} from '@adhdev/mesh-shared';
 
 // ── Mesh shared daemon-id / node-id helpers (re-export so external tooling —
 //    e.g. the mcp-server, which depends only on @adhdev/daemon-core — can
@@ -259,6 +269,8 @@ export type { StaleDirectPruneClassification, StaleDirectPruneResult, PruneStale
 export type { MeshActiveWorkRecord, MeshActiveWorkStatus, MeshActiveWorkSummary, MeshActiveWorkSource, MeshStaleDirectWorkSummary } 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';
+export type { MeshMagiActivityStatus, MeshMagiActivitySummary, MeshMagiActivitySummaryFold, MeshMagiNeedsVerificationItem } from './mesh/mesh-magi-status.js';
 
 // ── Mesh Scheduling Runtime (observability projection) ──
 export { buildMeshSchedulingRuntime } from './mesh/mesh-scheduling-runtime.js';

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

@@ -719,13 +719,29 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     // coordinator has no local instance and keeps relying on the relayed fields — unchanged.
     const enrichedMetadataEvent = ((): Record<string, unknown> => {
         const last = sourceSession ? getLastDisplayMessage(sourceSession.getState()) : null;
-        if (!last || !last.preview) return args.metadataEvent;
-        return {
-            ...args.metadataEvent,
-            lastMessagePreview: last.preview,
-            lastMessageRole: last.role,
-            ...(last.receivedAt > 0 ? { lastMessageAt: last.receivedAt } : {}),
-        };
+        const base = (!last || !last.preview)
+            ? args.metadataEvent
+            : {
+                ...args.metadataEvent,
+                lastMessagePreview: last.preview,
+                lastMessageRole: last.role,
+                ...(last.receivedAt > 0 ? { lastMessageAt: last.receivedAt } : {}),
+            };
+        // MAGI: stamp the queue task's consensusGroupId onto the completion metadata
+        // so the intentional-fan-out dedup exemption (buildPendingEventFingerprint)
+        // can see it. The work queue is owned by THIS host/coordinator daemon — where
+        // both the lookup and the dedup run — so the local lookup covers local and
+        // relayed workers alike. Best-effort: never fail the event path on a miss, and
+        // never clobber a consensusGroupId the worker already relayed.
+        if (readNonEmptyString((base as Record<string, unknown>).consensusGroupId)) return base;
+        const eventTaskId = readNonEmptyString(args.metadataEvent.taskId);
+        if (!eventTaskId) return base;
+        try {
+            const entry = MeshRuntimeStore.getInstance().findQueueEntryById(args.meshId, eventTaskId);
+            const consensusGroupId = readNonEmptyString((entry as { consensusGroupId?: unknown } | null)?.consensusGroupId);
+            if (consensusGroupId) return { ...base, consensusGroupId };
+        } catch { /* queue lookup is best-effort; absence just falls back to the generic fingerprint */ }
+        return base;
     })();
 
     // R2: cloud P2P dashboard metadata sync. The cloud daemon used to do this from its own

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

@@ -17,6 +17,7 @@ export {
     __resetIdleAutoFastForwardForTests,
     activeReadonlyAssignedCount,
     activeWriteAssignedCount,
+    isSessionActivelyGenerating,
     triggerMeshQueue,
     tryAssignQueueTask,
 } from './mesh-queue-assignment.js';

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

@@ -121,6 +121,21 @@ export function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent)
             ].join('::');
         }
     }
+    // MAGI consensus-group exemption: a consensusGroupId marks an INTENTIONAL
+    // same-prompt fan-out across N replicas — the exact opposite of the accidental
+    // duplicates this dedup collapses. Anchor the fingerprint on the unique
+    // (taskId, consensusGroupId) so grouped replicas can NEVER be collapsed by any
+    // future prompt-content-based tightening of this builder. Mirrors the
+    // bootstrap-event exemption above and serves as the explicit fan-out marker.
+    // (Today this is belt-and-suspenders: each replica already gets a distinct
+    // taskId, so the generic key below would not collapse them either.)
+    const consensusGroupId = readNonEmptyString(metadata.consensusGroupId)
+        || readNonEmptyString(readRecord(metadata.payload)?.consensusGroupId);
+    if (consensusGroupId) {
+        const groupTaskId = readNonEmptyString(metadata.taskId)
+            || readNonEmptyString(readRecord(metadata.payload)?.taskId);
+        return [event.meshId, event.event, groupTaskId || '', consensusGroupId, 'group'].join('::');
+    }
     const sessionId = resolveEventSessionId(metadata);
     const providerSessionId = readNonEmptyString(metadata.providerSessionId);
     const taskId = readNonEmptyString(metadata.taskId) || readNonEmptyString(readRecord(metadata.payload)?.taskId);

package/src/mesh/mesh-events.ts

@@ -27,6 +27,7 @@ export {
 export type { MeshQueueTriggerResult } from './mesh-events-coordinator.js';
 export {
     tryAssignQueueTask,
+    isSessionActivelyGenerating,
     triggerMeshQueue,
     handleMeshForwardEvent,
     setupMeshEventForwarding,

package/src/mesh/mesh-ledger.ts

@@ -59,6 +59,13 @@ export type MeshLedgerKind =
     | 'mission_created'
     | 'mission_status_changed'
     | 'mission_goal_updated'
+    // MAGI (Multi-Agent Ground-truth Insight) cross-verification activity. Persisted
+    // so a wait=false fan-out and its later synthesis survive coordinator restarts and
+    // are foldable into mesh_status (keyed by consensusGroupId).
+    // magi_dispatched payload: { source:'magi', consensusGroupId, missionId?, panel?, question?, replicaCount }
+    // magi_synthesis  payload: { source:'magi', consensusGroupId, missionId?, panel?, question?, synthesis }
+    | 'magi_dispatched'
+    | 'magi_synthesis'
     ;
 
 export interface MeshLedgerEntry {