@adhdev/daemon-core 0.9.82-rc.44 → 0.9.82-rc.440

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

@@ -1,49 +1,6 @@
-import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
-export interface PendingMeshCoordinatorEvent {
-    event: string;
-    meshId: string;
-    nodeLabel: string;
-    nodeId?: string;
-    workspace?: string;
-    metadataEvent: Record<string, unknown>;
-    queuedAt: number;
-}
-export declare function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean;
-/** Drain and return all pending coordinator events for meshId, removing them from disk. */
-export declare function drainPendingMeshCoordinatorEvents(meshId?: string): PendingMeshCoordinatorEvent[];
-/** Peek at pending coordinator events without draining (non-destructive). */
-export declare function getPendingMeshCoordinatorEvents(meshId?: string): readonly PendingMeshCoordinatorEvent[];
-/** Explicitly clear all pending coordinator events for a mesh. */
-export declare function clearPendingMeshCoordinatorEvents(meshId?: string): void;
-export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
-/**
- * Triggers a queue check for all nodes in the mesh.
- * Called when a new task is enqueued, in case nodes are already idle.
- */
-export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): Promise<void>;
-export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
-    success: boolean;
-    forwarded: number;
-    suppressed: boolean;
-    intentionalCleanupStop: boolean;
-    duplicateCompletion?: undefined;
-    error?: undefined;
-} | {
-    success: boolean;
-    forwarded: number;
-    suppressed: boolean;
-    duplicateCompletion: boolean;
-    intentionalCleanupStop?: undefined;
-    error?: undefined;
-} | {
-    success: boolean;
-    forwarded: number;
-    suppressed?: undefined;
-    intentionalCleanupStop?: undefined;
-    duplicateCompletion?: undefined;
-    error?: undefined;
-} | {
-    success: boolean;
-    error: string;
-};
-export declare function setupMeshEventForwarding(components: DaemonComponents): void;
+export type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
+export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, } from './mesh-events-pending.js';
+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, isSessionActivelyGenerating, triggerMeshQueue, handleMeshForwardEvent, setupMeshEventForwarding, isMeshCoordinatorEvent, __resetIdleAutoFastForwardForTests, __resetMeshWorkspaceCacheForTests, } from './mesh-events-coordinator.js';

package/dist/mesh/mesh-fast-forward.d.ts

@@ -0,0 +1,81 @@
+import type { GitRepoStatus } from '../git/git-types.js';
+export interface MeshFastForwardNodeArgs {
+    nodeId?: string;
+    meshId?: string;
+    workspace: string;
+    branch?: string;
+    execute?: boolean;
+    dryRun?: boolean;
+    updateSubmodules?: boolean;
+    submoduleIgnorePaths?: string[];
+    timeoutMs?: number;
+    trigger?: 'manual' | 'idle_auto' | string;
+    /**
+     * Operation mode. 'merge' (default) absorbs upstream commits into the local
+     * branch via git merge --ff-only (requires ahead=0, behind>0). 'push' publishes
+     * local commits to origin via a strict ff-only push (requires HEAD to be a
+     * descendant of origin/<branch>); it never force-pushes, resets, or rebases.
+     */
+    mode?: 'merge' | 'push';
+    /**
+     * When mode='push', also fast-forward push submodule (e.g. oss) HEADs to their
+     * origin main branch. Gated by allowAutoPublishSubmoduleMainCommits — skipped
+     * unless that policy is true. Each submodule must still pass the descendant gate.
+     * Defaults false (root push only).
+     */
+    pushSubmodules?: boolean;
+    /**
+     * Mesh policy flag mirrored from RepoMeshPolicy.allowAutoPublishSubmoduleMainCommits.
+     * Submodule pushes are refused unless this is true.
+     */
+    allowAutoPublishSubmoduleMainCommits?: boolean;
+}
+export interface MeshFastForwardPlannedStep {
+    operation: 'refresh_upstream' | 'verify_clean_worktree' | 'verify_fast_forward' | 'merge_ff_only' | 'submodule_update' | 'verify_post_status' | 'verify_push_descendant' | 'push_ff_only' | 'push_submodules_ff_only';
+    description: string;
+    safe: true;
+    willMutateWorktree: boolean;
+}
+export interface MeshFastForwardSubmodulePushResult {
+    path: string;
+    commit?: string;
+    remote: string;
+    remoteBranch: string;
+    pushed: boolean;
+    skipped: boolean;
+    code: string;
+    refspec?: string;
+    error?: string;
+}
+export interface MeshFastForwardResult {
+    success: boolean;
+    code: string;
+    nodeId?: string;
+    meshId?: string;
+    workspace: string;
+    mode: 'merge' | 'push';
+    allowed: boolean;
+    dryRun: boolean;
+    willRun: boolean;
+    executed: boolean;
+    updateSubmodules: boolean;
+    blockingReasons: string[];
+    plannedSteps: MeshFastForwardPlannedStep[];
+    current?: GitRepoStatus;
+    preStatus?: GitRepoStatus;
+    postStatus?: GitRepoStatus;
+    /** Push target derived from the tracked upstream (mode='push'). */
+    pushTarget?: {
+        remote: string;
+        remoteBranch: string;
+        refspec: string;
+    };
+    /** Submodule ff-only push outcomes (mode='push' with pushSubmodules). */
+    submodulePushes?: MeshFastForwardSubmodulePushResult[];
+    finalBranchConvergenceState?: Record<string, unknown>;
+    operationError?: string;
+    ledgerError?: string;
+    nextStep?: string;
+    trigger?: string;
+}
+export declare function fastForwardMeshNode(args: MeshFastForwardNodeArgs): Promise<MeshFastForwardResult>;

package/dist/mesh/mesh-host-ownership.d.ts

@@ -0,0 +1,29 @@
+import type { RepoMeshDaemonRole, RepoMeshHostMetadata, RepoMeshHostStatus } from '../repo-mesh-types.js';
+export declare function normalizeMeshDaemonRole(value: unknown): RepoMeshDaemonRole | undefined;
+/**
+ * Options for resolveMeshHostStatus's read-side host-pin default.
+ *
+ * `localDaemonId` is the id of the daemon evaluating the mesh (typically
+ * `deps.statusInstanceId`). When the persisted `meshHost` declares `role:'host'`
+ * but carries NO `hostDaemonId` (the first-setup miss — a host mesh whose pin was
+ * never written to config), the host daemon IS this local daemon by definition, so
+ * we synthesize `hostDaemonId = localDaemonId` (and, when the mesh has a node
+ * representing this daemon, `hostNodeId`). This is the read-side default — the SSOT
+ * is computed from the role + the evaluating daemon's identity rather than requiring
+ * a config migration to backfill every already-created mesh.
+ *
+ * HARD guard: the synthesis fires ONLY for `role:'host'`. A `role:'member'` daemon
+ * must NEVER fill itself in as host — that would make a member falsely claim
+ * coordinator/queue ownership.
+ */
+export interface ResolveMeshHostOptions {
+    /** Id of the daemon evaluating this mesh (e.g. deps.statusInstanceId). */
+    localDaemonId?: string;
+}
+export declare function resolveMeshHostStatus(mesh: unknown, opts?: ResolveMeshHostOptions): RepoMeshHostStatus;
+export declare function isMeshHostOwner(mesh: unknown): boolean;
+export declare function buildMeshHostRequiredFailure(mesh: unknown, operation: string): Record<string, unknown>;
+export declare function requireMeshHostQueueOwner(opts?: {
+    ownerRole?: RepoMeshDaemonRole;
+}): void;
+export declare function createDefaultMeshHostMetadata(): RepoMeshHostMetadata;

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

@@ -0,0 +1,128 @@
+/**
+ * Mesh init / onboarding helper.
+ *
+ * One-shot helper that onboards an existing git project into Repo Mesh:
+ *   1. suggest + write `.adhdev/refine.json`           (Refinery validation config)
+ *   2. suggest + write `.adhdev/worktree_bootstrap.json` (worktree bootstrap config)
+ *   3. suggest + write `.adhdev/change-impact.json`     (change-impact classification)
+ *   4. recommend a node providerPriority from the installed CLI providers
+ *
+ * mesh_init now covers all THREE repo-committed `.adhdev/*` config families that
+ * carry a suggest→validate→write engine (refine + worktree_bootstrap +
+ * change-impact). `.adhdev/mesh.json` (coordinator prompt + operating notes) has
+ * its own dedicated export/write path (export_mesh_json_config / write_mesh_json_config).
+ *
+ * Design contract (matches the rest of the mesh tooling):
+ *   - Heuristics are suggestion/scaffold only. The written files are the
+ *     execution source of truth; Refinery/bootstrap only ever read the saved
+ *     config. The suggestion functions never become the execution path.
+ *   - Writing is opt-in (`write: true`) and never clobbers an existing config
+ *     unless `overwrite: true` is set, so re-running init on an already-onboarded
+ *     repo is safe.
+ *   - The providerPriority recommendation is returned, not auto-applied to the
+ *     node policy — applying it mutates mesh policy, which is the coordinator's
+ *     decision.
+ */
+import { type RepoMeshRefineConfig, type RepoMeshRefineValidationCommandConfig } from './refine-config.js';
+import { type RepoMeshWorktreeBootstrapConfig } from './worktree-bootstrap-config.js';
+import { type ChangeImpactConfig } from '../git/change-impact-config.js';
+import type { MagiKindPanelMap } from '@adhdev/mesh-shared';
+import type { CLIInfo } from '../detection/cli-detector.js';
+/** Canonical write targets — the first/preferred location for each config family. */
+export declare const MESH_INIT_REFINE_CONFIG_PATH: string;
+export declare const MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH: string;
+export declare const MESH_INIT_CHANGE_IMPACT_CONFIG_PATH: string;
+export interface MeshInitConfigFileResult {
+    path: string;
+    relativePath: string;
+    written: boolean;
+    /** Why it was not written (already_exists / not_suggested / no change). */
+    skippedReason?: 'already_exists' | 'no_suggestion';
+    config?: RepoMeshRefineConfig | RepoMeshWorktreeBootstrapConfig | ChangeImpactConfig;
+}
+/**
+ * Build a worktree_bootstrap scaffold from package scripts. Mirrors
+ * suggestMeshRefineConfig's "scaffold only" posture: prefers an `install`/`ci`
+ * style script, else falls back to `npm install`, and records existing
+ * lockfiles as staleInputs so a base merge that changes them re-runs bootstrap.
+ *
+ * Returns undefined when there is nothing meaningful to scaffold.
+ */
+export declare function suggestMeshWorktreeBootstrapConfig(workspace: string): {
+    commands: RepoMeshRefineValidationCommandConfig[];
+    staleInputs: string[];
+    suggestedConfig?: RepoMeshWorktreeBootstrapConfig;
+};
+export declare function suggestNodeProviderPriority(detected: CLIInfo[]): {
+    providerPriority: string[];
+    installedProviders: Array<{
+        id: string;
+        displayName: string;
+        version?: string;
+    }>;
+};
+export interface RunMeshInitOptions {
+    /** When true, persist suggested configs to disk. Defaults to dry-run (false). */
+    write?: boolean;
+    /** When true, overwrite an existing config file. Defaults to false (never clobber). */
+    overwrite?: boolean;
+}
+/**
+ * A snapshot of the currently-saved config for each domain, so the coordinator can
+ * render a current-vs-suggested diff to the user before an init/reinit overwrite.
+ * This is READ-ONLY echo — every field is what is on disk / machine-local right now,
+ * never a suggestion. Absent domains are reported as `undefined` config.
+ */
+export interface MeshInitCurrentConfigEcho {
+    /** Currently-saved `.adhdev/refine.json` (repo-committed) — undefined when absent/invalid. */
+    refine?: RepoMeshRefineConfig;
+    /** Currently-saved `.adhdev/worktree_bootstrap.json` (repo-committed). */
+    worktreeBootstrap?: RepoMeshWorktreeBootstrapConfig;
+    /** Currently-saved `.adhdev/change-impact.json` (repo-committed). */
+    changeImpact?: ChangeImpactConfig;
+    /** Per-domain source type so the coordinator can tell "absent" from "invalid". */
+    sourceTypes: {
+        refine: string;
+        worktreeBootstrap: string;
+        changeImpact: string;
+    };
+    /**
+     * Currently-configured MAGI kind→panel slot bindings (machine-local
+     * ~/.adhdev/meshes.json). Empty object when none configured. This is a
+     * machine-local echo — the coordinator labels it as such vs. the repo files.
+     */
+    magiKindPanels: MagiKindPanelMap;
+}
+export interface RunMeshInitResult {
+    success: true;
+    workspace: string;
+    dryRun: boolean;
+    refine: MeshInitConfigFileResult;
+    worktreeBootstrap: MeshInitConfigFileResult;
+    changeImpact: MeshInitConfigFileResult;
+    providers: {
+        providerPriority: string[];
+        installedProviders: Array<{
+            id: string;
+            displayName: string;
+            version?: string;
+        }>;
+    };
+    /**
+     * Read-only snapshot of the currently-saved config per domain (repo files +
+     * machine-local kind panels). Lets the coordinator present a current-vs-suggested
+     * diff to the user before any overwrite. Always populated (dry-run and write).
+     */
+    currentConfig: MeshInitCurrentConfigEcho;
+    note: string;
+}
+/**
+ * Orchestrate the full onboarding flow for one workspace:
+ *   detect installed CLIs → suggest refine + bootstrap configs → (optionally)
+ *   write them → recommend a node providerPriority.
+ *
+ * `detected` is injected (the caller resolves it via detectCLIs with its
+ * ProviderLoader) so this module stays free of provider-loader wiring and is
+ * trivially unit-testable.
+ */
+export declare function runMeshInit(mesh: any, workspace: string, detected: CLIInfo[], options?: RunMeshInitOptions): RunMeshInitResult;

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

@@ -1,4 +1,24 @@
-import type { AppendRemoteLedgerResult, MeshLedgerSlice, MeshLedgerSummary } from './mesh-ledger.js';
+import type { AppendRemoteLedgerResult, MeshLedgerSummary } from './mesh-ledger.js';
+/** Minimal ledger slice shape accepted by buildMeshLedgerReplicaEvidence. Covers both JSONL and SQLite slices. */
+export interface AnyLedgerSlice {
+    entries: Array<{
+        id: string;
+        meshId: string;
+        timestamp: string;
+        kind: string;
+        nodeId?: string | null;
+        sessionId?: string | null;
+        providerType?: string | null;
+        payload: unknown;
+    }>;
+    cursor: {
+        afterId: string | null;
+        nextAfterId: string | null;
+        limit: number;
+        hasMore: boolean;
+    };
+    summary?: MeshLedgerSummary;
+}
 export type MeshLedgerReplicaStatus = 'local' | 'queried' | 'imported' | 'failed';
 export interface MeshLedgerReplicaEvidence {
     nodeId: string;
@@ -22,9 +42,8 @@ export interface MeshLedgerReconciliationEvidence {
     meshId: string;
     generatedAt: string;
     sourceOfTruth: {
-        kind: 'coordinator_local_jsonl';
+        kind: 'coordinator_local_sqlite';
         p2pOnly: true;
-        cloudD1LedgerSync: false;
         notes: string;
     };
     replicas: MeshLedgerReplicaEvidence[];
@@ -47,7 +66,7 @@ export declare function buildMeshLedgerReplicaEvidence(args: {
     nodeId: string;
     daemonId?: string;
     transport: 'local' | 'p2p_datachannel';
-    slice?: MeshLedgerSlice;
+    slice?: AnyLedgerSlice;
     importResult?: AppendRemoteLedgerResult;
     status?: MeshLedgerReplicaStatus;
     error?: string;

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

@@ -13,7 +13,8 @@
  * Safety:  mode 0o600, atomic append via appendFileSync
  */
 import { EventEmitter } from 'events';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled';
+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' | 'magi_dispatched' | 'magi_synthesis';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;
@@ -25,6 +26,40 @@ export interface MeshLedgerEntry {
     payload: Record<string, unknown>;
 }
 export declare function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind' | 'payload'>): boolean;
+export type MeshWorkerResultStatus = 'completed' | 'failed' | 'blocked' | 'partial' | 'unknown';
+export type MeshProcessArtifactKind = 'process' | 'log' | 'port' | 'window' | 'session' | 'file' | 'url' | 'other';
+export interface MeshValidationResultArtifact {
+    command?: string;
+    status: 'passed' | 'failed' | 'skipped' | 'unknown';
+    durationMs?: number;
+    outputPath?: string;
+    summary?: string;
+}
+export interface MeshProcessArtifact {
+    kind: MeshProcessArtifactKind;
+    id?: string;
+    label?: string;
+    locator?: string;
+    pid?: number;
+    port?: number;
+    url?: string;
+    path?: string;
+    sessionId?: string;
+    keepRunning?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface MeshWorkerResultArtifact {
+    status: MeshWorkerResultStatus;
+    classification?: string;
+    changedFiles: string[];
+    validationResults: MeshValidationResultArtifact[];
+    gitStatus?: Record<string, unknown>;
+    processArtifacts: MeshProcessArtifact[];
+    errors: string[];
+    nextAction?: string;
+    requiresUserAction: boolean;
+    source: 'explicit_metadata' | 'final_summary_json' | 'parseable_answer' | 'default';
+}
 export interface MeshTaskCompletionEvidence {
     source: 'agent_status_event';
     event: 'agent:generating_completed' | 'agent:ready';
@@ -38,6 +73,7 @@ export interface MeshTaskCompletionEvidence {
         providerSessionId?: string;
         finalSummaryAvailable: boolean;
     };
+    workerResult: MeshWorkerResultArtifact;
     git: {
         status: 'deferred';
         reason: string;
@@ -59,6 +95,7 @@ export interface BuildTaskCompletionEvidenceOptions {
     providerType?: string;
     providerSessionId?: string;
     finalSummary?: string;
+    workerResult?: Record<string, unknown>;
     completedAt?: string;
 }
 export interface MeshLedgerSummary {
@@ -115,6 +152,27 @@ export interface AppendRemoteLedgerResult {
 }
 export declare const MAX_LEDGER_SLICE_LIMIT = 500;
 export declare function getLedgerDir(): string;
+/**
+ * Footer to append to worker task messages so workers output structured results
+ * that the daemon parses via extractJsonObjectFromSummary / normalizeMeshWorkerResult.
+ *
+ * Usage: append buildWorkerTaskFooter() to the task message in mesh_send_task /
+ * mesh_enqueue_task. The coordinator prompt rules instruct coordinators to do this.
+ */
+export declare function buildWorkerTaskFooter(): string;
+/**
+ * Compact the active ledger file for a mesh by moving old terminal entries
+ * (task_completed, task_failed, task_stalled, recovery_attempted older than 7 days)
+ * to <meshId>.archive.jsonl, keeping the active file lean.
+ *
+ * Non-terminal entries (dispatch, sessions, node lifecycle) are always retained.
+ * Called automatically from appendLedgerEntry when the file exceeds COMPACT_THRESHOLD_BYTES.
+ */
+export declare function compactLedger(meshId: string): {
+    archivedCount: number;
+    retainedCount: number;
+};
+export declare function normalizeMeshWorkerResult(input?: Record<string, unknown>, source?: MeshWorkerResultArtifact['source']): MeshWorkerResultArtifact;
 export declare function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOptions): MeshTaskCompletionEvidence;
 /**
  * Append a new entry to the mesh ledger.
@@ -127,8 +185,16 @@ export declare function appendLedgerEntry(meshId: string, partial: Omit<MeshLedg
  * This skips deduplicated entries and rejects malformed/cross-mesh entries.
  */
 export declare function appendRemoteLedgerEntries(meshId: string, entries: MeshLedgerEntry[]): AppendRemoteLedgerResult;
+/**
+ * Test helper: clear all runtime ledger state for a mesh — SQLite rows, read
+ * cache, and the one-time import flag. JSONL files are the caller's concern.
+ */
+export declare function __clearMeshLedgerForTests(meshId: string): void;
 /**
  * Read ledger entries with optional filtering.
+ * G2: SQLite (mesh_event_ledger) is the primary read path; legacy JSONL is
+ * imported once per store instance and otherwise retained as an
+ * export/import/debug artifact only.
  */
 export declare function readLedgerEntries(meshId: string, opts?: ReadLedgerOptions): MeshLedgerEntry[];
 /**
@@ -137,6 +203,16 @@ export declare function readLedgerEntries(meshId: string, opts?: ReadLedgerOptio
  * remote daemons on demand without Cloud/D1 becoming a ledger data-plane.
  */
 export declare function readLedgerSlice(meshId: string, opts?: ReadLedgerSliceOptions): MeshLedgerSlice;
+/**
+ * G4: Read a bounded ledger slice from the SQLite mesh_event_ledger table.
+ * This is the preferred P2P reconcile read path; JSONL files are retained as
+ * export/import/debug/legacy artifacts only.
+ *
+ * Returns a shape structurally compatible with MeshLedgerSlice (minus the
+ * JSONL-specific `summary` and `sourceOfTruth.path` fields) so callers can
+ * pass it to buildMeshLedgerReplicaEvidence without modification.
+ */
+export declare function readLedgerSliceFromStore(meshId: string, opts?: ReadLedgerSliceOptions): ReturnType<typeof MeshRuntimeStore.prototype.readLedgerSlice>;
 /**
  * Get a summary of mesh activity from the ledger.
  */

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;