@adhdev/daemon-core 0.9.82-rc.415 → 0.9.82-rc.417

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/package.json

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

package/src/config/mesh-config.ts

@@ -604,7 +604,7 @@ function normalizeReplicaCount(value: unknown): number | undefined {
  * structurally invalid input so the calling tool returns a clear error rather than
  * writing a malformed panel.
  */
-function normalizeMagiPanel(config: unknown): MagiPanel {
+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');
     }

package/src/index.ts

@@ -192,7 +192,7 @@ export type { SavedProviderSessionEntry } from './config/saved-sessions.js';
 export {
   listMeshes, getMesh, getMeshByRepo, createMesh, updateMesh, deleteMesh,
   addNode, removeNode, updateNode, normalizeRepoIdentity,
-  listMagiPanels, getMagiPanel, upsertMagiPanel, removeMagiPanel,
+  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
@@ -201,7 +201,7 @@ export type { CreateMeshOptions, UpdateMeshOptions, AddNodeOptions } from './con
 export type {
   MagiPanel, MagiPanelMember, MagiPanelMap, MagiMode,
   MagiClaim, MagiClaimStance, MagiAgentResponse,
-  MagiResponseSource, MagiSynthesizedResponse,
+  MagiResponseSource, MagiReplicaGitRef, MagiGitSkew, MagiSynthesizedResponse,
   MagiClusterCategory, MagiClusterMember, MagiClaimCluster, MagiSynthesis,
 } from '@adhdev/mesh-shared';
 
@@ -269,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-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 {

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/providers/spec/fsm-driver.ts

@@ -1041,15 +1041,36 @@ export class FsmDriver implements ISpecDriver {
         if (this.win32SubmitTimer) { clearTimeout(this.win32SubmitTimer); this.win32SubmitTimer = null; }
         const startedAt = Date.now();
 
-        // Distinctive whitespace-collapsed TAIL of the body — what we look for in the
-        // composer to confirm the body landed. The tail (not the head) because a long
-        // multiline body scrolls its leading lines out of the composer viewport while
-        // the cursor — and therefore the body's end — stays visible. Empty body →
-        // nothing to confirm.
-        const probe = normalizeForEcho(body).slice(-WIN32_ECHO_PROBE_CHARS);
+        // FULL-BODY echo confirmation. A tail-only probe (slice(-N)) was insufficient
+        // for multi-line prompts: a multiline body echoes line-by-line, so its TAIL can
+        // appear in the composer (and the screen settle) while the HEAD / middle is still
+        // arriving. Releasing the first CR on the tail alone then submits a PARTIAL body:
+        // the early CR commits whatever has accumulated and the remainder is lost, so only
+        // the trailing segment survives (the cross-machine MAGI replica receiving only the
+        // prompt's boilerplate suffix). We now require BOTH the head probe AND the tail
+        // probe to be present in the echo before releasing the CR.
+        //
+        // Crucially, the head check runs against snapshotWithScrollback(), NOT the visible
+        // viewport: a tall body scrolls its leading lines off-screen (the very reason the
+        // original gate used the tail), so the head is only ever observable in the
+        // scrollback-inclusive buffer. The tail check stays on the visible snapshot (the
+        // cursor / body end is always on screen). Both present ⇒ the whole body, head
+        // through tail, has echoed — not just its end with a still-streaming middle.
+        // Single-line / short bodies have overlapping head and tail probes and the
+        // scrollback buffer is a superset of the viewport, so behaviour is unchanged. The
+        // WIN32_ECHO_MAX_WAIT_MS blind-fire backstop below still bounds the wait so a body
+        // that never fully confirms cannot hang.
+        const normBody = normalizeForEcho(body);
+        const headProbe = normBody.slice(0, WIN32_ECHO_PROBE_CHARS);
+        const tailProbe = normBody.slice(-WIN32_ECHO_PROBE_CHARS);
         const bodyEchoed = (): boolean => {
-            if (!probe) return true;
-            return normalizeForEcho(this.adapter.snapshot()).includes(probe);
+            if (!normBody) return true;
+            // Tail on the visible viewport (cursor end is always on screen); head on the
+            // scrollback-inclusive buffer (leading lines of a tall body scroll off-screen).
+            const visible = normalizeForEcho(this.adapter.snapshot());
+            if (!visible.includes(tailProbe)) return false;
+            const full = normalizeForEcho(this.adapter.snapshotWithScrollback());
+            return full.includes(headProbe);
         };
 
         const fire = (attempt: number): void => {