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

package/src/mesh/mesh-magi-status.ts

@@ -0,0 +1,223 @@
+// MAGI (Multi-Agent Ground-truth Insight) activity reconstruction for mesh_status.
+//
+// MAGI cross-verification runs are persisted in the mesh ledger as `magi_dispatched`
+// (fan-out enqueued) and `magi_synthesis` (collected + synthesized) entries, keyed by
+// consensusGroupId. This module reconstructs the latest per-group activity from a
+// ledger window and folds it into a BOUNDED mesh_status section so a coordinator (and
+// the web dashboard's extractMagiActivity) can read the synthesis fields — the
+// needs_verification counts, independence banner, and git skew — without re-running
+// collection. Mirrors mesh-refine-status.ts (buildMeshAsyncRefineJobs / summarize…).
+//
+// Pure: operates on a ledger-entry array. No I/O, no Node/DOM APIs.
+
+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;
+}
+
+function readString(value: unknown): string | undefined {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function readRecord(value: unknown): Record<string, unknown> | undefined {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value as Record<string, unknown>
+        : undefined;
+}
+
+function readNumber(value: unknown): number | undefined {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+/** Cap on inlined needs_verification preview items per group (keeps the payload bounded). */
+export const MAGI_NEEDS_VERIFICATION_PREVIEW_CAP = 8;
+
+function summarizeNeedsVerification(synthesis: Record<string, unknown> | undefined): MeshMagiNeedsVerificationItem[] | undefined {
+    const list = Array.isArray(synthesis?.needsVerification) ? synthesis!.needsVerification : undefined;
+    if (!list) return undefined;
+    const items: MeshMagiNeedsVerificationItem[] = [];
+    for (const raw of list.slice(0, MAGI_NEEDS_VERIFICATION_PREVIEW_CAP)) {
+        const r = readRecord(raw);
+        const claim = readString(r?.claim);
+        if (!claim) continue;
+        items.push({ claim, category: readString(r?.category) || 'needs_verification' });
+    }
+    return items;
+}
+
+function mergeGroup(
+    groups: Map<string, MeshMagiActivitySummary>,
+    patch: Partial<MeshMagiActivitySummary> & { consensusGroupId?: string },
+): void {
+    const consensusGroupId = readString(patch.consensusGroupId);
+    if (!consensusGroupId) return;
+    const previous = groups.get(consensusGroupId);
+    // synthesized is terminal-ish and must not be downgraded back to running by an
+    // out-of-order dispatch entry.
+    const status: MeshMagiActivityStatus = patch.status === 'synthesized' || previous?.status === 'synthesized'
+        ? 'synthesized'
+        : 'running';
+    const definedPatch = Object.fromEntries(
+        Object.entries(patch).filter(([, v]) => v !== undefined),
+    ) as Partial<MeshMagiActivitySummary>;
+    groups.set(consensusGroupId, { ...previous, ...definedPatch, consensusGroupId, status });
+}
+
+/**
+ * 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 function buildMeshMagiActivity(args: {
+    meshId?: string;
+    ledgerEntries?: MeshLedgerEntry[];
+}): MeshMagiActivitySummary[] {
+    const groups = new Map<string, MeshMagiActivitySummary>();
+
+    for (const entry of args.ledgerEntries || []) {
+        const payload = readRecord(entry.payload);
+        if (payload?.source !== 'magi') continue;
+        const consensusGroupId = readString(payload.consensusGroupId);
+        if (!consensusGroupId) continue;
+
+        if (entry.kind === 'magi_synthesis') {
+            const synthesis = readRecord(payload.synthesis);
+            mergeGroup(groups, {
+                consensusGroupId,
+                status: 'synthesized',
+                missionId: readString(payload.missionId),
+                panel: readString(payload.panel),
+                question: readString(payload.question),
+                replicaCount: readNumber(synthesis?.replicasExpected) ?? readNumber(payload.replicaCount),
+                answered: readNumber(synthesis?.replicasAnswered),
+                missing: readNumber(synthesis?.replicasMissing),
+                staleReplicas: readNumber(payload.staleReplicas) ?? readNumber(synthesis?.staleReplicas),
+                needsVerificationCount: Array.isArray(synthesis?.needsVerification) ? synthesis!.needsVerification.length : undefined,
+                agreedCount: Array.isArray(synthesis?.agreed) ? synthesis!.agreed.length : undefined,
+                independenceBanner: synthesis && 'independenceBanner' in synthesis ? (synthesis.independenceBanner as string | null) : undefined,
+                gitSkew: readRecord(synthesis?.gitSkew) as unknown as MagiGitSkew | undefined,
+                needsVerification: summarizeNeedsVerification(synthesis),
+                openQuestions: Array.isArray(synthesis?.openQuestions) ? (synthesis!.openQuestions as string[]).slice(0, 10) : undefined,
+                lastLedgerKind: entry.kind,
+                lastUpdatedAt: entry.timestamp,
+            });
+        } else if (entry.kind === 'magi_dispatched') {
+            mergeGroup(groups, {
+                consensusGroupId,
+                status: 'running',
+                missionId: readString(payload.missionId),
+                panel: readString(payload.panel),
+                question: readString(payload.question),
+                replicaCount: readNumber(payload.replicaCount),
+                lastLedgerKind: entry.kind,
+                lastUpdatedAt: entry.timestamp,
+            });
+        }
+    }
+
+    return Array.from(groups.values()).sort((a, b) => {
+        const at = new Date(a.lastUpdatedAt || '').getTime();
+        const bt = new Date(b.lastUpdatedAt || '').getTime();
+        return (Number.isFinite(bt) ? bt : 0) - (Number.isFinite(at) ? at : 0);
+    });
+}
+
+/** 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 const STALE_MAGI_WINDOW_MS = 6 * 60 * 60 * 1000;
+
+/** Cap on recent synthesized groups kept in the active list even if all are fresh. */
+export 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[];
+}
+
+function activityTime(g: MeshMagiActivitySummary): number {
+    const t = new Date(g.lastUpdatedAt || '').getTime();
+    return Number.isFinite(t) ? t : 0;
+}
+
+/**
+ * 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 function summarizeMeshMagiActivity(
+    activity: MeshMagiActivitySummary[],
+): MeshMagiActivitySummaryFold {
+    const running: MeshMagiActivitySummary[] = [];
+    const synthesized: MeshMagiActivitySummary[] = [];
+    for (const g of activity) {
+        if (g.status === 'synthesized') synthesized.push(g);
+        else running.push(g);
+    }
+
+    let newest = 0;
+    for (const g of activity) newest = Math.max(newest, activityTime(g));
+    const cutoff = newest - STALE_MAGI_WINDOW_MS;
+
+    const synthesizedByRecency = [...synthesized].sort((a, b) => activityTime(b) - activityTime(a));
+    const freshSynthesized = synthesizedByRecency
+        .filter(g => activityTime(g) >= cutoff)
+        .slice(0, RECENT_MAGI_CAP);
+
+    const byStatus: Record<string, number> = {};
+    for (const g of [...running, ...freshSynthesized]) {
+        byStatus[g.status] = (byStatus[g.status] ?? 0) + 1;
+    }
+
+    // Running first (most actionable), then recent synthesized — both newest-first.
+    const runningByRecency = [...running].sort((a, b) => activityTime(b) - activityTime(a));
+    return {
+        total: running.length + freshSynthesized.length,
+        byStatus,
+        staleSynthesized: synthesized.length - freshSynthesized.length,
+        groups: [...runningByRecency, ...freshSynthesized],
+    };
+}
+
+/** Latest persisted synthesis activity for one consensusGroupId, or undefined. */
+export function getMeshMagiActivityByGroup(
+    ledgerEntries: MeshLedgerEntry[],
+    consensusGroupId: string,
+): MeshMagiActivitySummary | undefined {
+    const key = readString(consensusGroupId);
+    if (!key) return undefined;
+    return buildMeshMagiActivity({ ledgerEntries }).find(g => g.consensusGroupId === key);
+}

package/src/mesh/mesh-queue-assignment.ts

@@ -987,6 +987,30 @@ export function sessionHasActiveAssignment(meshId: string, sessionId: string): b
     return false;
 }
 
+/**
+ * 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 function isSessionActivelyGenerating(components: DaemonComponents, sessionId: string): boolean {
+    if (!sessionId) return false;
+    const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+    if (!state) return false;
+    return sessionStateLooksActive(state);
+}
+
 function liveSessionCountForNode(components: DaemonComponents, meshId: string, nodeId: string): number {
     return components.instanceManager.getByCategory('cli').filter((inst: any) => {
         const state = inst.getState();

package/src/mesh/mesh-refine-gates.ts

@@ -21,7 +21,7 @@ import type { WorktreeBootstrapState } from '../mesh/worktree-bootstrap-config.j
 import { basename as pathBasename, join as pathJoin, resolve as pathResolve } from 'path';
 import * as fs from 'fs';
 import { execFileSync } from 'node:child_process';
-import { resolveWin32Executable } from '../cli-adapters/resolve-executable.js';
+import { resolveWin32Executable, buildWin32ExecFileSpawn } from '../cli-adapters/resolve-executable.js';
 import type { CommandRouterResult } from '../commands/router.js';
 
 // Fix (4): resolve the git executable to an absolute path once on win32. A bare `git` handed to
@@ -1573,13 +1573,18 @@ export async function runMeshRefineValidationGate(
             // Resolve to an absolute path via the same helper the PTY path uses
             // (no-op on non-win32 and when the command is already absolute).
             const resolvedCommand = resolveWin32Executable(candidate.command);
+            // A win32 .cmd/.bat shim cannot be exec'd directly — wrap it in
+            // cmd.exe /c (no-op off win32 / for a real .exe). Keep
+            // resolvedCommand for diagnostics.
+            const spawn = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
             try {
-                const result = await execFileAsync(resolvedCommand, candidate.args, {
+                const result = await execFileAsync(spawn.file, spawn.args, {
                     cwd,
                     encoding: 'utf8',
                     timeout,
                     maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
                     env: { ...process.env, CI: process.env.CI || '1', ...(candidate.env || {}) },
+                    ...(spawn.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
                 });
                 summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
             } catch (error: any) {
@@ -1592,7 +1597,7 @@ export async function runMeshRefineValidationGate(
                         ? { failureKind: 'spawn_resolution_failed', resolvedCommand }
                         : { failureKind: 'dependency_bootstrap_failed' }),
                 }));
-                summary.bootstrap = { stage: 'failed', error: describeSpawnError(error, candidate.command, spawnResolutionFailed) };
+                summary.bootstrap = { stage: 'failed', error: describeSpawnError(error, resolvedCommand, spawnResolutionFailed) };
                 summary.status = 'failed';
                 summary.failureKind = spawnResolutionFailed ? 'spawn_resolution_failed' : 'dependency_bootstrap_failed';
                 summary.failureCode = spawnResolutionFailed ? 'spawn_resolution_failed' : 'dependency_bootstrap_failed';
@@ -1622,13 +1627,15 @@ export async function runMeshRefineValidationGate(
         // See the bootstrap loop above: resolve the win32 .cmd shim to an
         // absolute path before handing it to the spawn boundary.
         const resolvedCommand = resolveWin32Executable(candidate.command);
+        const spawn = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
         try {
-            const result = await execFileAsync(resolvedCommand, candidate.args, {
+            const result = await execFileAsync(spawn.file, spawn.args, {
                 cwd,
                 encoding: 'utf8',
                 timeout,
                 maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
                 env: { ...process.env, CI: process.env.CI || '1', ...(candidate.env || {}) },
+                ...(spawn.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
             });
             summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
         } catch (error: any) {
@@ -1652,7 +1659,7 @@ export async function runMeshRefineValidationGate(
             if (spawnResolutionFailed) {
                 summary.failureKind = 'spawn_resolution_failed';
                 summary.failureCode = 'spawn_resolution_failed';
-                summary.spawnResolutionError = describeSpawnError(error, candidate.command, true);
+                summary.spawnResolutionError = describeSpawnError(error, resolvedCommand, true);
             } else if (missingDependencyFailure) {
                 summary.failureKind = 'missing_dependencies';
                 summary.failureCode = 'missing_dependencies';

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

@@ -495,6 +495,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;
@@ -763,6 +770,8 @@ export function enqueueTask(
         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). */
@@ -806,6 +815,7 @@ export function enqueueTask(
             requiredTags: resolvedRequiredTags,
             ...(dependsOn.length > 0 ? { dependsOn } : {}),
             ...(typeof opts?.missionId === 'string' && opts.missionId.trim() ? { missionId: opts.missionId.trim() } : {}),
+            ...(typeof opts?.consensusGroupId === 'string' && opts.consensusGroupId.trim() ? { consensusGroupId: opts.consensusGroupId.trim() } : {}),
             ...(typeof opts?.sourceCoordinatorSessionId === 'string' && opts.sourceCoordinatorSessionId.trim()
                 ? { sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId.trim() }
                 : {}),
@@ -1086,6 +1096,9 @@ export function requeueTask(
         // STALE assigned row (dead session, dispatch never confirmed) is NOT in-flight
         // — its mark was cleared on the dispatch failure — so it still requeues as
         // before. An explicit operator override (`force`) bypasses this guard.
+        // MAGI-NOTE: the future consensus group fan-out (separate mission) intentionally
+        // re-dispatches a group-tagged task into multiple sessions and must be exempted
+        // from this single-flight guard; the exemption hook (group-id check) belongs here.
         if (!opts?.force && isTaskDispatchInFlight(meshId, taskId)) {
             LOG.warn('MeshQueue', `Refusing to requeue task ${taskId} on mesh ${meshId}: it is actively dispatched/generating (single-flight in-flight). Requeueing now would open a duplicate second dispatch into another session. Pass force to override.`);
             return entry;

package/src/mesh/worktree-bootstrap-config.ts

@@ -4,7 +4,7 @@ import { execFile, execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { promisify } from 'node:util';
 import * as yaml from 'js-yaml';
-import { resolveWin32Executable } from '../cli-adapters/resolve-executable.js';
+import { resolveWin32Executable, buildWin32ExecFileSpawn } from '../cli-adapters/resolve-executable.js';
 import {
     isMeshConfigRecord,
     normalizeMeshCommandConfig,
@@ -311,14 +311,18 @@ export async function runMeshWorktreeBootstrap(mesh: any, workspace: string): Pr
         // (which appends only .com/.exe) cannot resolve → spawn ENOENT. Resolve
         // to an absolute path first (no-op on non-win32 / already-absolute).
         const resolvedCommand = resolveWin32Executable(command.command);
+        // A win32 .cmd/.bat shim (npm/npx/tsc) cannot be exec'd directly — wrap
+        // it in cmd.exe /c (no-op off win32 / for a real .exe).
+        const spawn = buildWin32ExecFileSpawn(resolvedCommand, command.args);
         try {
-            const result = await execFileAsync(resolvedCommand, command.args, {
+            const result = await execFileAsync(spawn.file, spawn.args, {
                 cwd,
                 encoding: 'utf8',
                 timeout: command.timeoutMs || DEFAULT_TIMEOUT_MS,
                 maxBuffer: command.outputLimitBytes || DEFAULT_OUTPUT_LIMIT_BYTES,
                 env: { ...process.env, CI: process.env.CI || '1', ...(command.env || {}) },
                 windowsHide: true,
+                ...(spawn.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
             });
             state.commandsRun?.push({
                 command: command.command,

package/src/repo-mesh-types.ts

@@ -13,6 +13,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';
 
 // ─── Core Mesh Types ────────────────────────────
 
@@ -705,6 +706,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 {