@adhdev/daemon-core 0.9.82-rc.136 → 0.9.82-rc.137

package/dist/mesh/beads-db.d.ts

@@ -2,17 +2,71 @@ import type { MeshTaskStatus, MeshWorkQueueEntry } from './mesh-work-queue.js';
 export declare class BeadsDB {
     private static instance;
     private readonly db;
+    private readonly dbPath;
     private readonly migratedMeshIds;
+    private fingerprintSweepCounter;
+    private walWriteCounter;
+    private static readonly WAL_CHECK_INTERVAL;
+    private static readonly WAL_MAX_BYTES;
     private constructor();
     static getInstance(): BeadsDB;
     static resetForTests(): void;
     close(): void;
     transaction<T>(fn: () => T): T;
     private migrate;
+    hasCompletionFingerprint(fingerprint: string): boolean;
+    recordCompletionFingerprint(fingerprint: string, ttlMs: number): void;
+    sweepExpiredFingerprints(): void;
+    private maybeCheckpointWal;
     private ensureLegacyQueueMigrated;
     getQueueEntries(meshId: string, statuses?: MeshTaskStatus[]): MeshWorkQueueEntry[];
     getQueueRevision(meshId: string): string;
     replaceQueue(meshId: string, queue: MeshWorkQueueEntry[]): void;
     deleteQueue(meshId: string): void;
+    insertQueueEntry(entry: MeshWorkQueueEntry): void;
+    updateQueueEntry(entry: MeshWorkQueueEntry): void;
+    findQueueEntryById(meshId: string, id: string): MeshWorkQueueEntry | null;
+    hasActiveAssignment(meshId: string, sessionId: string, nodeId: string): boolean;
+    claimNextQueueTask(meshId: string, nodeId: string, sessionId: string): MeshWorkQueueEntry | null;
+    getQueueStatsByStatus(meshId: string): {
+        status: string;
+        count: number;
+    }[];
+    getActiveAssignmentDetails(meshId: string): Array<{
+        id: string;
+        nodeId?: string;
+        sessionId?: string;
+        message: string;
+    }>;
+    findAssignedBySession(meshId: string, sessionId: string, occurredAtIso?: string): MeshWorkQueueEntry | null;
     private toRow;
+    insertDirectDispatch(entry: {
+        taskId: string;
+        meshId: string;
+        nodeId?: string;
+        sessionId?: string;
+        providerType?: string;
+        message: string;
+        taskMode?: string;
+        via: string;
+        dispatchedToIdleSession?: boolean;
+        dispatchedAt: string;
+    }): void;
+    getActiveDirectDispatches(meshId: string): Array<{
+        taskId: string;
+        meshId: string;
+        nodeId: string | null;
+        sessionId: string | null;
+        providerType: string | null;
+        message: string;
+        taskMode: string | null;
+        via: string;
+        status: string;
+        dispatchedToIdleSession: boolean;
+        dispatchedAt: string;
+        updatedAt: string;
+    }>;
+    updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale'): void;
+    cleanupTerminalDirectDispatches(olderThanMs: number): void;
+    markStaleDirectDispatches(meshId: string, olderThanMs: number): void;
 }

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

@@ -1,5 +1,5 @@
 import type { MeshLedgerEntry } from './mesh-ledger.js';
-import type { MeshWorkQueueEntry } from './mesh-work-queue.js';
+import type { MeshWorkQueueEntry, DirectDispatchRecord } from './mesh-work-queue.js';
 export type MeshActiveWorkSource = 'queue' | 'direct';
 export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval';
 export interface MeshActiveWorkRecord {
@@ -64,6 +64,12 @@ export interface BuildMeshActiveWorkOptions {
     meshId: string;
     queue?: MeshWorkQueueEntry[];
     ledgerEntries?: MeshLedgerEntry[];
+    /**
+     * Active direct dispatches from BeadsDB. When provided, these are used instead of
+     * scanning ledger entries for direct dispatches — eliminates the O(n_ledger) scan.
+     * Falls back to ledger scanning when not provided.
+     */
+    directDispatches?: DirectDispatchRecord[];
     nodes?: any[];
     now?: number;
     /** Include terminal direct rows (idle/failed) for handoff/recent-work surfaces. Defaults false. */

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

@@ -8,14 +8,20 @@ export interface PendingMeshCoordinatorEvent {
     metadataEvent: Record<string, unknown>;
     coordinatorMessage?: string;
     queuedAt: number;
+    /**
+     * When set, this event is intended for a specific coordinator daemon.
+     * Coordinators on other daemons should ignore it during drain.
+     * Absent on legacy events — treated as broadcast to any coordinator.
+     */
+    targetCoordinatorDaemonId?: string;
 }
 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[];
+export declare function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: 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 getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): readonly PendingMeshCoordinatorEvent[];
+/** Explicitly clear all pending coordinator events for a mesh (and coordinator if scoped). */
+export declare function clearPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: 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.

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

@@ -13,7 +13,7 @@
  * 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_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward';
+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';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;
@@ -151,6 +151,26 @@ 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;
 /**

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

@@ -1,7 +1,8 @@
 import type { MeshLedgerEntry } from './mesh-ledger.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events.js';
+import type { MeshAsyncJobLifecycle } from '../repo-mesh-types.js';
 export type MeshAsyncRefineJobStatus = 'accepted' | 'running' | 'completed' | 'failed';
-export interface MeshAsyncRefineJobSummary {
+export interface MeshAsyncRefineJobSummary extends MeshAsyncJobLifecycle {
     jobId: string;
     interactionId?: string;
     status: MeshAsyncRefineJobStatus;
@@ -12,8 +13,6 @@ export interface MeshAsyncRefineJobSummary {
     workspace?: string;
     branch?: string;
     into?: string;
-    startedAt?: string;
-    completedAt?: string;
     retryOfJobId?: string;
     lastEvent?: string;
     lastLedgerKind?: string;

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

@@ -1,4 +1,5 @@
 import type { RepoMeshDaemonRole } from '../repo-mesh-types.js';
+import { BeadsDB } from './beads-db.js';
 export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
 export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
 export type MeshHistoricalTaskStatus = Extract<MeshTaskStatus, 'completed' | 'failed' | 'cancelled'>;
@@ -127,3 +128,19 @@ export declare function getMeshQueueStats(meshId: string): MeshWorkQueueStats;
 export declare function __replaceMeshQueueForTests(meshId: string, queue: MeshWorkQueueEntry[]): void;
 export declare function __clearMeshQueueForTests(meshId: string): void;
 export declare function __resetBeadsDBForTests(): void;
+export type DirectDispatchRecord = ReturnType<BeadsDB['getActiveDirectDispatches']>[number];
+export declare function insertDirectDispatch(meshId: string, data: {
+    taskId: string;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    message: string;
+    taskMode?: string;
+    via: string;
+    dispatchedToIdleSession?: boolean;
+    dispatchedAt: string;
+}): void;
+export declare function getActiveDirectDispatches(meshId: string): DirectDispatchRecord[];
+export declare function updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale'): void;
+export declare function cleanupTerminalDirectDispatches(olderThanMs?: number): void;
+export declare function markStaleDirectDispatches(meshId: string, olderThanMs?: number): void;

package/dist/mesh/worktree-bootstrap-config.d.ts

@@ -1,4 +1,5 @@
 import { type MeshRefineValidationCommandPlan, type RepoMeshRefineValidationCommandConfig } from './refine-config.js';
+import type { MeshAsyncJobLifecycle } from '../repo-mesh-types.js';
 export type WorktreeBootstrapStatus = 'ready' | 'running' | 'failed' | 'not_configured' | 'disabled' | 'stale';
 export interface RepoMeshWorktreeBootstrapConfig {
     version: 1;
@@ -8,16 +9,13 @@ export interface RepoMeshWorktreeBootstrapConfig {
     commands?: RepoMeshRefineValidationCommandConfig[];
     staleInputs?: string[];
 }
-export interface WorktreeBootstrapState {
+export interface WorktreeBootstrapState extends MeshAsyncJobLifecycle {
     status: WorktreeBootstrapStatus;
     required: boolean;
     configSource?: string;
     configSourceType?: 'repo_file' | 'mesh_policy' | 'unavailable' | 'invalid';
-    startedAt?: string;
-    completedAt?: string;
     lastCommand?: string;
     exitCode?: number | null;
-    error?: string;
     commandsRun?: Array<Record<string, unknown>>;
     staleInputs?: string[];
 }

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

@@ -408,3 +408,8 @@ export interface RepoMeshLedgerStatus {
     entries: RepoMeshLedgerEntryStatus[];
     summary: RepoMeshLedgerSummaryStatus;
 }
+export interface MeshAsyncJobLifecycle {
+    startedAt?: string;
+    completedAt?: string;
+    error?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.136",
+  "version": "0.9.82-rc.137",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli-adapters/cli-script-runner.ts

@@ -0,0 +1,145 @@
+/**
+ * CliScriptRunner — isolated execution of provider CLI scripts
+ *
+ * Responsible solely for invoking provider-supplied JavaScript functions
+ * (detectStatus, parseApproval, parseSession, etc.) and managing the
+ * per-session script state created by createState().
+ *
+ * The runner is stateless with respect to PTY / buffer content — all
+ * input data is passed explicitly by the caller so that the adapter can
+ * remain a pure transport layer without embedding parsing logic.
+ */
+
+import { LOG } from '../logging/logger.js';
+import {
+    listCliScriptNames,
+    type CliApprovalInput,
+    type CliScripts,
+    type CliScriptInput,
+    type CliScreenSnapshot,
+    type CliStatusInput,
+    type ParsedSession,
+} from './provider-cli-shared.js';
+
+export class CliScriptRunner {
+    private scripts: CliScripts = {};
+    private scriptState: unknown = null;
+    private _parseErrorMessage: string | null = null;
+    private readonly cliType: string;
+
+    constructor(cliType: string) {
+        this.cliType = cliType;
+    }
+
+    // ─── Script lifecycle ─────────────────────────────
+
+    setScripts(scripts: CliScripts): void {
+        this.scripts = scripts;
+        this._parseErrorMessage = null;
+        this.scriptState = typeof scripts.createState === 'function'
+            ? (scripts.createState() ?? null)
+            : null;
+    }
+
+    /** Reset per-session state — called when the PTY process exits. */
+    resetSessionState(): void {
+        this.scriptState = null;
+    }
+
+    // ─── Script access (for reflection and test patching) ────────────────────
+
+    /** Returns the live scripts object. Direct property assignment on this object
+     *  patches individual scripts without replacing others (used in tests). */
+    get cliScripts(): CliScripts { return this.scripts; }
+
+    // ─── Capability checks ────────────────────────────
+
+    hasDetectStatus(): boolean {
+        return typeof this.scripts.detectStatus === 'function';
+    }
+
+    hasParseSession(): boolean {
+        return typeof this.scripts.parseSession === 'function';
+    }
+
+    getScriptNames(): string[] {
+        return listCliScriptNames(this.scripts);
+    }
+
+    // ─── Error state ──────────────────────────────────
+
+    get parseErrorMessage(): string | null {
+        return this._parseErrorMessage;
+    }
+
+    clearParseError(): void {
+        this._parseErrorMessage = null;
+    }
+
+    // ─── Script invocation ────────────────────────────
+
+    detectStatus(input: CliStatusInput): string | null {
+        if (!this.scripts.detectStatus) return null;
+        try {
+            return this.invoke<string | null>(this.scripts.detectStatus, input);
+        } catch (e: any) {
+            LOG.warn('CLI', `[${this.cliType}] detectStatus error: ${e?.message || e}`);
+            return null;
+        }
+    }
+
+    parseApproval(
+        input: CliApprovalInput,
+    ): { message: string; buttons: string[] } | null {
+        if (!this.scripts.parseApproval) return null;
+        try {
+            return this.invoke<{ message: string; buttons: string[] } | null>(
+                this.scripts.parseApproval,
+                input,
+            );
+        } catch (e: any) {
+            LOG.warn('CLI', `[${this.cliType}] parseApproval error: ${e?.message || e}`);
+            return null;
+        }
+    }
+
+    parseSession(
+        input: CliScriptInput & { tail?: string; tailScreen?: CliScreenSnapshot },
+    ): ParsedSession | null {
+        if (!this.scripts.parseSession) {
+            this._parseErrorMessage = `${this.cliType} parseSession unavailable`;
+            return null;
+        }
+        try {
+            const result = this.invoke<ParsedSession | null>(this.scripts.parseSession, input);
+            this._parseErrorMessage = null;
+            return result && typeof result === 'object' ? result : null;
+        } catch (e: any) {
+            this._parseErrorMessage = e?.message || String(e);
+            LOG.warn('CLI', `[${this.cliType}] parseSession error: ${this._parseErrorMessage}`);
+            return null;
+        }
+    }
+
+    /**
+     * Invoke an arbitrary named script (e.g. setModel, openModelPicker).
+     * Throws if the script is not available.
+     */
+    invokeByName(name: string, input: any): any {
+        const fn = this.scripts[name];
+        if (typeof fn !== 'function') {
+            throw new Error(`CLI script '${name}' not available`);
+        }
+        return this.invoke(fn, input);
+    }
+
+    // ─── Internal ─────────────────────────────────────
+
+    private invoke<T>(fn: Function, input: any): T {
+        const hasStateFactory = typeof this.scripts.createState === 'function';
+        const expectsState = hasStateFactory || this.scriptState !== null || fn.length >= 2;
+        return expectsState
+            ? (fn as (state: unknown, input: any) => T)(this.scriptState, input)
+            : (fn as (input: any) => T)(input);
+    }
+}