@adhdev/daemon-core 0.9.77-rc.5 → 0.9.77-rc.50

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

@@ -8,20 +8,23 @@ export interface PendingMeshCoordinatorEvent {
 }
 /** Drain and return all pending coordinator events, clearing the queue. */
 export declare function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[];
-export declare function tryAssignQueueTask(components: {
-    cliManager: any;
-}, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
+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: {
-    instanceManager: any;
-    cliManager: any;
-}, meshId: string): void;
+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;
+    error?: undefined;
+} | {
+    success: boolean;
+    forwarded: number;
+    suppressed?: undefined;
+    intentionalCleanupStop?: undefined;
     error?: undefined;
 } | {
     success: boolean;

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

@@ -0,0 +1,55 @@
+import type { AppendRemoteLedgerResult, MeshLedgerSlice, MeshLedgerSummary } from './mesh-ledger.js';
+export type MeshLedgerReplicaStatus = 'local' | 'queried' | 'imported' | 'failed';
+export interface MeshLedgerReplicaEvidence {
+    nodeId: string;
+    daemonId?: string;
+    status: MeshLedgerReplicaStatus;
+    transport: 'local' | 'p2p_datachannel';
+    protocol: 'adhdev.mesh.ledger.slice.v1';
+    entriesReceived: number;
+    entriesImported: number;
+    skippedDuplicate: number;
+    rejectedInvalid: number;
+    hasMore: boolean;
+    nextAfterId: string | null;
+    lastTimestamp: string | null;
+    summary?: MeshLedgerSummary;
+    error?: string;
+    noFallbackReason?: string;
+}
+export interface MeshLedgerReconciliationEvidence {
+    protocol: 'adhdev.mesh.ledger.reconciliation.v1';
+    meshId: string;
+    generatedAt: string;
+    sourceOfTruth: {
+        kind: 'coordinator_local_jsonl';
+        p2pOnly: true;
+        cloudD1LedgerSync: false;
+        notes: string;
+    };
+    replicas: MeshLedgerReplicaEvidence[];
+    totals: {
+        replicas: number;
+        queried: number;
+        failed: number;
+        entriesReceived: number;
+        entriesImported: number;
+        skippedDuplicate: number;
+        rejectedInvalid: number;
+    };
+    convergence: {
+        complete: boolean;
+        pendingNodes: string[];
+        failedNodes: string[];
+    };
+}
+export declare function buildMeshLedgerReplicaEvidence(args: {
+    nodeId: string;
+    daemonId?: string;
+    transport: 'local' | 'p2p_datachannel';
+    slice?: MeshLedgerSlice;
+    importResult?: AppendRemoteLedgerResult;
+    status?: MeshLedgerReplicaStatus;
+    error?: string;
+}): MeshLedgerReplicaEvidence;
+export declare function buildMeshLedgerReconciliationEvidence(meshId: string, replicas: MeshLedgerReplicaEvidence[]): MeshLedgerReconciliationEvidence;

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_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_removed' | 'coordinator_started' | 'recovery_attempted';
+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';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;
@@ -24,6 +24,43 @@ export interface MeshLedgerEntry {
     providerType?: string;
     payload: Record<string, unknown>;
 }
+export declare function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind' | 'payload'>): boolean;
+export interface MeshTaskCompletionEvidence {
+    source: 'agent_status_event';
+    event: 'agent:generating_completed' | 'agent:ready';
+    nodeId: string;
+    sessionId: string;
+    providerType?: string;
+    completedAt: string;
+    transcriptHandle: {
+        kind: 'provider_session' | 'runtime_session';
+        sessionId: string;
+        providerSessionId?: string;
+        finalSummaryAvailable: boolean;
+    };
+    git: {
+        status: 'deferred';
+        reason: string;
+    };
+    validation: {
+        status: 'deferred';
+        commandsRun: string[];
+        reason: string;
+    };
+    checkpoint: {
+        attempted: false;
+        reason: 'not_attempted_for_ordinary_completion';
+    };
+}
+export interface BuildTaskCompletionEvidenceOptions {
+    event: MeshTaskCompletionEvidence['event'];
+    nodeId: string;
+    sessionId: string;
+    providerType?: string;
+    providerSessionId?: string;
+    finalSummary?: string;
+    completedAt?: string;
+}
 export interface MeshLedgerSummary {
     meshId: string;
     totalEntries: number;
@@ -41,7 +78,44 @@ export interface ReadLedgerOptions {
     since?: string;
     kind?: MeshLedgerKind[];
 }
+export interface ReadLedgerSliceOptions {
+    /** Return entries strictly after this entry id. If not found, starts from the beginning of the filtered set. */
+    afterId?: string;
+    /** Return entries at or after this timestamp. */
+    since?: string;
+    /** Optional event kind filter. */
+    kind?: MeshLedgerKind[];
+    /** Maximum entries to return. Clamped to a bounded protocol maximum. */
+    limit?: number;
+}
+export interface MeshLedgerCursor {
+    afterId: string | null;
+    nextAfterId: string | null;
+    limit: number;
+    hasMore: boolean;
+}
+export interface MeshLedgerSlice {
+    protocol: 'adhdev.mesh.ledger.slice.v1';
+    meshId: string;
+    entries: MeshLedgerEntry[];
+    cursor: MeshLedgerCursor;
+    summary: MeshLedgerSummary;
+    sourceOfTruth: {
+        kind: 'local_jsonl';
+        path: string;
+        bounded: true;
+        maxLimit: number;
+    };
+}
+export interface AppendRemoteLedgerResult {
+    accepted: number;
+    skippedDuplicate: number;
+    rejectedInvalid: number;
+    entries: MeshLedgerEntry[];
+}
+export declare const MAX_LEDGER_SLICE_LIMIT = 500;
 export declare function getLedgerDir(): string;
+export declare function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOptions): MeshTaskCompletionEvidence;
 /**
  * Append a new entry to the mesh ledger.
  * Handles file creation, rotation on size overflow, and atomic writes.
@@ -49,14 +123,20 @@ export declare function getLedgerDir(): string;
 export declare const meshLedgerEvents: EventEmitter<[never]>;
 export declare function appendLedgerEntry(meshId: string, partial: Omit<MeshLedgerEntry, 'id' | 'meshId' | 'timestamp'>): MeshLedgerEntry;
 /**
- * Append entries received from the cloud to the local ledger.
- * This skips deduplicated entries and just writes new ones.
+ * Append entries received over local-first/P2P ledger replication to the local ledger.
+ * This skips deduplicated entries and rejects malformed/cross-mesh entries.
  */
-export declare function appendRemoteLedgerEntries(meshId: string, entries: MeshLedgerEntry[]): void;
+export declare function appendRemoteLedgerEntries(meshId: string, entries: MeshLedgerEntry[]): AppendRemoteLedgerResult;
 /**
  * Read ledger entries with optional filtering.
  */
 export declare function readLedgerEntries(meshId: string, opts?: ReadLedgerOptions): MeshLedgerEntry[];
+/**
+ * Read a bounded, cursor-addressable ledger slice for local-first/P2P replication.
+ * The result is intentionally small and self-describing so coordinators can query
+ * remote daemons on demand without Cloud/D1 becoming a ledger data-plane.
+ */
+export declare function readLedgerSlice(meshId: string, opts?: ReadLedgerSliceOptions): MeshLedgerSlice;
 /**
  * Get a summary of mesh activity from the ledger.
  */

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

@@ -1,10 +1,12 @@
 /**
- * Mesh Sync — Sync local mesh config to/from cloud D1
+ * Mesh Sync — Sync local mesh metadata to/from cloud D1
  *
  * When cloud is available, this module pushes local mesh config
  * to the server and pulls remote meshes that were created from
  * other machines. The local ~/.adhdev/meshes.json remains the
- * canonical source; cloud is a persistence/relay layer.
+ * canonical source; cloud is a membership/metadata layer only.
+ * Task/chat/ledger evidence remains local-first and must not be
+ * synchronized through Cloud/D1.
  *
  * This is called lazily (not on daemon startup) — only when the
  * user explicitly opens the mesh page or runs `adhdev mesh sync`.
@@ -26,12 +28,6 @@ export interface MeshSyncTransport {
     }>;
     /** DELETE /api/v1/repo-meshes/:id */
     deleteRemoteMesh(meshId: string): Promise<void>;
-    /** POST /api/v1/repo-meshes/:id/ledger/sync */
-    syncMeshLedger?(meshId: string, data: {
-        newEntries: any[];
-    }): Promise<{
-        missingEntries: any[];
-    }>;
 }
 export interface RemoteMeshRecord {
     id: string;
@@ -55,7 +51,3 @@ export interface MeshSyncResult {
  * Pull remote meshes that don't exist locally.
  */
 export declare function syncMeshes(transport: MeshSyncTransport): Promise<MeshSyncResult>;
-/**
- * Sync the task ledger for a specific mesh.
- */
-export declare function syncMeshLedger(meshId: string, transport: MeshSyncTransport): Promise<void>;

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

@@ -1,4 +1,8 @@
-export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed';
+export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
+export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
+export type MeshHistoricalTaskStatus = Extract<MeshTaskStatus, 'completed' | 'failed' | 'cancelled'>;
+export declare const ACTIVE_MESH_QUEUE_STATUSES: MeshActiveTaskStatus[];
+export declare const HISTORICAL_MESH_QUEUE_STATUSES: MeshHistoricalTaskStatus[];
 export interface MeshWorkQueueEntry {
     id: string;
     meshId: string;
@@ -6,10 +10,28 @@ export interface MeshWorkQueueEntry {
     status: MeshTaskStatus;
     /** If specified, only this node can claim the task (used by legacy mesh_send_task) */
     targetNodeId?: string;
+    /** If specified, only this runtime session can claim the task */
+    targetSessionId?: string;
     /** The node that actually claimed and is executing the task */
     assignedNodeId?: string;
     /** The session currently executing the task */
     assignedSessionId?: string;
+    /** Human/operator reason for terminal cancellation. */
+    cancelReason?: string;
+    cancelledAt?: string;
+    /** Human/operator reason for manually requeueing a task. */
+    requeueReason?: string;
+    requeuedAt?: string;
+    requeueCount?: number;
+    /** Last automatic queue session spin-up attempt, for mesh_view_queue/debug visibility. */
+    autoLaunch?: {
+        status: 'skipped' | 'started' | 'failed' | 'completed';
+        reason?: string;
+        nodeId?: string;
+        providerType?: string;
+        sessionId?: string;
+        updatedAt: string;
+    };
     createdAt: string;
     updatedAt: string;
 }
@@ -18,6 +40,7 @@ export interface MeshWorkQueueEntry {
  */
 export declare function enqueueTask(meshId: string, message: string, opts?: {
     targetNodeId?: string;
+    targetSessionId?: string;
 }): MeshWorkQueueEntry;
 /**
  * Get all tasks in the queue, optionally filtered by status.
@@ -34,15 +57,47 @@ export declare function claimNextTask(meshId: string, nodeId: string, sessionId:
  * Used when a session completes, fails, or stalls.
  */
 export declare function updateTaskStatus(meshId: string, taskId: string, status: MeshTaskStatus): MeshWorkQueueEntry | null;
+export declare function recordTaskAutoLaunch(meshId: string, taskId: string, autoLaunch: Omit<NonNullable<MeshWorkQueueEntry['autoLaunch']>, 'updatedAt'>): MeshWorkQueueEntry | null;
+/**
+ * Mark a queue task as manually cancelled without deleting audit history.
+ */
+export declare function cancelTask(meshId: string, taskId: string, opts?: {
+    reason?: string;
+}): MeshWorkQueueEntry | null;
+/**
+ * Return a queue task to pending for retry. By default, dead session targeting
+ * and assigned ownership are cleared so stale assignments do not strand again.
+ */
+export declare function requeueTask(meshId: string, taskId: string, opts?: {
+    reason?: string;
+    targetNodeId?: string;
+    targetSessionId?: string;
+    clearTargetNode?: boolean;
+    clearTargetSession?: boolean;
+}): MeshWorkQueueEntry | null;
 /**
  * Update the status of the task currently assigned to a specific session.
  */
 export declare function updateSessionTaskStatus(meshId: string, sessionId: string, status: MeshTaskStatus): MeshWorkQueueEntry | null;
 export interface MeshWorkQueueStats {
+    total: number;
+    active: number;
+    historical: number;
     pending: number;
     assigned: number;
     completed: number;
     failed: number;
+    cancelled: number;
+    /** Source-of-truth active queue counters; only pending/assigned are live work. */
+    activeCounts: Record<MeshActiveTaskStatus, number>;
+    /** Terminal ledger records kept for audit/history; never count as active work. */
+    historicalCounts: Record<MeshHistoricalTaskStatus, number>;
+    activeAssignments: Array<{
+        id: string;
+        nodeId?: string;
+        sessionId?: string;
+        message: string;
+    }>;
 }
 /**
  * Return aggregate queue statistics for the given mesh.

package/dist/mesh/p2p-relay-failure.d.ts

@@ -0,0 +1,35 @@
+export type P2pRelayFailureCode = 'p2p_unavailable' | 'p2p_timeout' | 'p2p_not_connected' | 'p2p_datachannel_closed' | 'p2p_no_route' | 'p2p_daemon_offline' | 'mesh_logic_or_provider_failure';
+export interface P2pRelayFailureContext {
+    command?: string;
+    targetDaemonId?: string;
+}
+export interface P2pRelayFailureClassification {
+    code: P2pRelayFailureCode;
+    reason: string;
+    transport: 'p2p' | 'unknown';
+    recoverable: boolean;
+    retryRecommended: boolean;
+    nextAction: string;
+    noFallbackReason: string;
+}
+export interface P2pRelayFailurePayload extends P2pRelayFailureClassification {
+    success: false;
+    error: string;
+    command?: string;
+    targetDaemonId?: string;
+}
+export declare function classifyP2pRelayFailure(error: unknown, _context?: P2pRelayFailureContext): P2pRelayFailureClassification;
+export declare function isP2pRelayTransportFailure(error: unknown): boolean;
+export declare function buildP2pRelayFailurePayload(error: unknown, context?: P2pRelayFailureContext): P2pRelayFailurePayload;
+export declare class P2pRelayFailureError extends Error {
+    code: P2pRelayFailureCode;
+    reason: string;
+    transport: 'p2p' | 'unknown';
+    recoverable: boolean;
+    retryRecommended: boolean;
+    nextAction: string;
+    noFallbackReason: string;
+    command?: string;
+    targetDaemonId?: string;
+    constructor(message: string, context?: P2pRelayFailureContext);
+}

package/dist/providers/cli-provider-instance.d.ts

@@ -100,6 +100,12 @@ export declare class CliProviderInstance implements ProviderInstance {
     private completedDebounceTimer;
     private completedDebouncePending;
     private enforceFreshSessionLaunchIfNeeded;
+    private completionHasFinalAssistantMessage;
+    private hasAdapterPendingResponse;
+    private shouldSuppressStaleParsedBusyStatus;
+    private getCompletedFinalizationBlockReason;
+    private scheduleCompletedDebounceFlush;
+    private flushCompletedDebounceIfFinalized;
     private maybeAutoApproveStatus;
     private detectStatusTransition;
     private pushEvent;

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

@@ -179,6 +179,8 @@ export interface LocalMeshNodeEntry {
     workspace: string;
     repoRoot?: string;
     daemonId?: string;
+    /** Machine registry ID that owns this workspace, when known. */
+    machineId?: string;
     userOverrides: Partial<RepoMeshNodeCapabilities>;
     policy: RepoMeshNodePolicy;
     /** For single-machine mesh: same daemon, different worktree */

package/dist/shared-types.d.ts

@@ -293,10 +293,29 @@ export interface SessionEntry {
     surfaceHidden?: boolean;
     settings?: Record<string, any>;
     meshQueueStats?: {
+        total?: number;
+        active?: number;
+        historical?: number;
         pending: number;
         assigned: number;
         completed: number;
         failed: number;
+        cancelled?: number;
+        activeCounts?: {
+            pending: number;
+            assigned: number;
+        };
+        historicalCounts?: {
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
+        activeAssignments?: Array<{
+            id: string;
+            nodeId?: string;
+            sessionId?: string;
+            message: string;
+        }>;
     };
 }
 /**
@@ -337,10 +356,29 @@ export interface CompactSessionEntry {
     summaryMetadata?: ProviderSummaryMetadata;
     settings?: Record<string, any>;
     meshQueueStats?: {
+        total?: number;
+        active?: number;
+        historical?: number;
         pending: number;
         assigned: number;
         completed: number;
         failed: number;
+        cancelled?: number;
+        activeCounts?: {
+            pending: number;
+            assigned: number;
+        };
+        historicalCounts?: {
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
+        activeAssignments?: Array<{
+            id: string;
+            nodeId?: string;
+            sessionId?: string;
+            message: string;
+        }>;
     };
 }
 export type VersionUpdateReason = 'force_update_below' | 'major_minor_mismatch' | 'patch_mismatch' | 'daemon_ahead';

package/package.json

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

package/src/boot/daemon-lifecycle.ts

@@ -83,6 +83,9 @@ export interface DaemonInitConfig {
 
     /** Fired before send_chat is dispatched — used for turn snapshot hooks */
     onBeforeSendChat?: (params: { workspace: string; sessionId: string }) => void;
+
+    /** Relays a command to a remote mesh node daemon */
+    dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
 }
 
 // ─── Result ───
@@ -100,6 +103,7 @@ export interface DaemonComponents {
     sessionRegistry: SessionRegistry;
     detectedIdes: { value: IDEInfo[] };
     refreshProviderAvailability: (providerType?: string) => Promise<void>;
+    dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
 }
 
 export interface DaemonDevSupportOptions {
@@ -331,6 +335,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         sessionRegistry,
         detectedIdes: detectedIdesRef,
         refreshProviderAvailability,
+        dispatchMeshCommand: config.dispatchMeshCommand,
     };
 
     // 11. Setup Mesh Event Forwarding

package/src/cli-adapters/provider-cli-adapter.ts

@@ -195,6 +195,8 @@ export class ProviderCliAdapter implements CliAdapter {
 
     // ─── CLI Scripts (script-based parsing) ───
     private cliScripts: CliScripts;
+    /** Per-session opaque state object created by cliScripts.createState(), reset on stop. */
+    private scriptState: unknown = null;
     private runtimeSettings: Record<string, any> = {};
     /** Full accumulated rendered PTY transcript for parser/readback use */
     private accumulatedBuffer: string = '';
@@ -223,6 +225,7 @@ export class ProviderCliAdapter implements CliAdapter {
         currentTurnScope: TurnParseScope | null;
         recentOutputBuffer: string;
         accumulatedBuffer: string;
+        accumulatedRawBufferKey: string;
         screenText: string;
         currentStatus: CliSessionStatus['status'];
         activeModal: { message: string; buttons: string[] } | null;
@@ -297,14 +300,23 @@ export class ProviderCliAdapter implements CliAdapter {
         this.lastScreenSnapshotReadAt = Number.NEGATIVE_INFINITY;
     }
 
+    private getAccumulatedRawBufferCacheKey(): string {
+        return this.accumulatedRawBuffer
+            .replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, '')
+            .replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, '')
+            .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+    }
+
     private getFreshParsedStatusCache(): any | null {
         const cached = this.parsedStatusCache;
+        const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
         if (
             cached
             && cached.responseBuffer === this.responseBuffer
             && cached.currentTurnScope === this.currentTurnScope
             && cached.recentOutputBuffer === this.recentOutputBuffer
             && cached.accumulatedBuffer === this.accumulatedBuffer
+            && cached.accumulatedRawBufferKey === accumulatedRawBufferKey
             && cached.screenText === this.lastScreenText
             && cached.currentStatus === this.currentStatus
             && cached.activeModal === this.activeModal
@@ -448,6 +460,7 @@ export class ProviderCliAdapter implements CliAdapter {
 
         // Scripts are required — loaded by ProviderLoader via compatibility array
         this.cliScripts = provider.scripts || {};
+        this.scriptState = typeof this.cliScripts.createState === 'function' ? (this.cliScripts.createState() ?? null) : null;
         const scriptNames = listCliScriptNames(this.cliScripts);
         if (scriptNames.length > 0) {
             LOG.info('CLI', `[${this.cliType}] CLI scripts: [${scriptNames.join(', ')}]`);
@@ -477,6 +490,9 @@ export class ProviderCliAdapter implements CliAdapter {
         this.cliScripts = scripts;
         this.parsedStatusCache = null;
         this.parseErrorMessage = null;
+        // Initialize per-session state: createState() is called once here and on script reload.
+        // The returned object lives until the PTY exits (scriptState = null on exit).
+        this.scriptState = typeof scripts.createState === 'function' ? (scripts.createState() ?? null) : null;
         const scriptNames = listCliScriptNames(scripts);
         LOG.info('CLI', `[${this.cliType}] CLI scripts injected: [${scriptNames.join(', ')}]`);
     }
@@ -610,6 +626,7 @@ export class ProviderCliAdapter implements CliAdapter {
             this.ready = false;
             this.startupParseGate = false;
             this.spawnAt = 0;
+            this.scriptState = null;
             this.onStatusChange?.();
         });
 
@@ -1450,6 +1467,14 @@ export class ProviderCliAdapter implements CliAdapter {
 
  // ─── Script Execution ──────────────────────────
 
+    private invokeCliScript<T>(script: Function, input: any): T {
+        const hasStateFactory = typeof this.cliScripts?.createState === 'function';
+        const expectsStateArgument = hasStateFactory || this.scriptState !== null || script.length >= 2;
+        return expectsStateArgument
+            ? script(this.scriptState, input)
+            : script(input);
+    }
+
     private runParseSession(): ParsedSession | null {
         if (typeof this.cliScripts?.parseSession !== 'function') {
             this.parseErrorMessage = `${this.cliType} parseSession unavailable`;
@@ -1470,7 +1495,10 @@ export class ProviderCliAdapter implements CliAdapter {
                 scope: this.currentTurnScope,
                 runtimeSettings: this.runtimeSettings,
             });
-            const session = this.cliScripts.parseSession({ ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
+            const session = this.invokeCliScript<ParsedSession | null>(
+                this.cliScripts.parseSession,
+                { ...input, tail, tailScreen: buildCliScreenSnapshot(tail) },
+            );
             this.parseErrorMessage = null;
             return session && typeof session === 'object' ? session : null;
         } catch (e: any) {
@@ -1485,7 +1513,7 @@ export class ProviderCliAdapter implements CliAdapter {
         if (!this.cliScripts?.detectStatus) return null;
         try {
             const screenText = this.terminalScreen.getText();
-            const status = this.cliScripts.detectStatus({
+            const status = this.invokeCliScript<string | null>(this.cliScripts.detectStatus, {
                 tail: text.slice(-500),
                 screenText,
                 rawBuffer: this.accumulatedRawBuffer,
@@ -1505,7 +1533,7 @@ export class ProviderCliAdapter implements CliAdapter {
         try {
             const screenText = this.terminalScreen.getText();
             const buffer = screenText || this.accumulatedBuffer;
-            return this.cliScripts.parseApproval({
+            return this.invokeCliScript<{ message: string; buttons: string[] } | null>(this.cliScripts.parseApproval, {
                 buffer,
                 screenText,
                 rawBuffer: this.accumulatedRawBuffer,
@@ -1570,12 +1598,14 @@ export class ProviderCliAdapter implements CliAdapter {
         const screenText = this.readTerminalScreenText();
         const parseScreenText = this.getParseScreenText(screenText);
         const cached = this.parsedStatusCache;
+        const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
         if (
             cached
             && cached.responseBuffer === this.responseBuffer
             && cached.currentTurnScope === this.currentTurnScope
             && cached.recentOutputBuffer === this.recentOutputBuffer
             && cached.accumulatedBuffer === this.accumulatedBuffer
+            && cached.accumulatedRawBufferKey === accumulatedRawBufferKey
             && cached.screenText === parseScreenText
             && cached.currentStatus === this.currentStatus
             && cached.activeModal === this.activeModal
@@ -1615,6 +1645,7 @@ export class ProviderCliAdapter implements CliAdapter {
             currentTurnScope: this.currentTurnScope,
             recentOutputBuffer: this.recentOutputBuffer,
             accumulatedBuffer: this.accumulatedBuffer,
+            accumulatedRawBufferKey,
             screenText: parseScreenText,
             currentStatus: this.currentStatus,
             activeModal: this.activeModal,
@@ -1640,7 +1671,7 @@ export class ProviderCliAdapter implements CliAdapter {
             scope: this.currentTurnScope,
             runtimeSettings: this.runtimeSettings,
         });
-        return await Promise.resolve(fn({
+        return await Promise.resolve(this.invokeCliScript(fn, {
             ...input,
             args: args && typeof args === 'object' ? { ...args } : {},
         }));

package/src/cli-adapters/provider-cli-shared.ts

@@ -48,11 +48,21 @@ export interface ParsedSession {
 }
 
 export interface CliScripts {
-    parseSession?: (input: CliScriptInput & { tail?: string; tailScreen?: CliScreenSnapshot }) => ParsedSession | null;
-    detectStatus?: (input: CliStatusInput) => string | null;
-    parseApproval?: (input: CliApprovalInput) => { message: string; buttons: string[] } | null;
+    /**
+     * Optional state factory. Called once per CLI session start (or script reload).
+     * The returned object is passed as the first argument to detectStatus, parseApproval,
+     * and parseSession on every invocation, allowing scripts to maintain per-session state
+     * (e.g. last-seen status, approval fingerprints, stability counters).
+     *
+     * Scripts that don't define createState() receive null as the state argument,
+     * making this change fully backward compatible.
+     */
+    createState?: () => unknown;
+    parseSession?: (state: unknown, input: CliScriptInput & { tail?: string; tailScreen?: CliScreenSnapshot }) => ParsedSession | null;
+    detectStatus?: (state: unknown, input: CliStatusInput) => string | null;
+    parseApproval?: (state: unknown, input: CliApprovalInput) => { message: string; buttons: string[] } | null;
     resolveAction?: (data: any) => string;
-    [name: string]: ((input: any) => any) | undefined;
+    [name: string]: ((state: unknown, input: any) => any) | ((data: any) => any) | (() => unknown) | undefined;
 }
 
 export interface CliScreenLine {

package/src/commands/cli-manager.ts

@@ -177,10 +177,6 @@ export function buildCoordinatorDelegatedCliLaunchOptions(
     const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
     const env: Record<string, string> = { ...(input.env || {}), ...COORDINATOR_DELEGATED_ENV_UNSETS };
 
-    if (cliType === 'hermes-cli' && !hasCliArg(cliArgs, '--ignore-user-config')) {
-        cliArgs.unshift('--ignore-user-config');
-    }
-
     if (cliType === 'claude-cli' && !hasCliArg(cliArgs, '--mcp-config')) {
         cliArgs.unshift('--mcp-config', ensureEmptyDelegatedMcpConfig(input.workspace));
     }