@adhdev/daemon-core 0.9.82-rc.41 → 0.9.82-rc.410

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

@@ -0,0 +1,145 @@
+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;
+    enabled?: boolean;
+    runOnClone?: boolean;
+    required?: boolean;
+    commands?: RepoMeshRefineValidationCommandConfig[];
+    staleInputs?: string[];
+}
+export interface WorktreeBootstrapState extends MeshAsyncJobLifecycle {
+    status: WorktreeBootstrapStatus;
+    required: boolean;
+    configSource?: string;
+    configSourceType?: 'repo_file' | 'mesh_policy' | 'unavailable' | 'invalid';
+    lastCommand?: string;
+    exitCode?: number | null;
+    commandsRun?: Array<Record<string, unknown>>;
+    staleInputs?: string[];
+    /**
+     * M2-1: sha256 per staleInputs path recorded when the bootstrap reached
+     * 'ready'. evaluateWorktreeBootstrapState compares current file hashes
+     * against this to detect staleness (e.g. base merge changed a lockfile).
+     * Missing files hash to the literal 'absent'.
+     */
+    staleInputsDigest?: Record<string, string>;
+    /** M2-1: why an evaluated state resolved to stale (digest_mismatch | never_ran). */
+    staleReason?: string;
+}
+export declare const WORKTREE_BOOTSTRAP_STALE_RUNNING_MS: number;
+export declare function isWorktreeBootstrapStaleRunning(node: {
+    worktreeBootstrap?: {
+        status?: string;
+        startedAt?: string;
+        updatedAt?: string;
+        completedAt?: string;
+    };
+    workspace?: string;
+} | undefined, nowMs?: number): boolean;
+export interface WorktreeBootstrapConfigLoadResult {
+    config?: RepoMeshWorktreeBootstrapConfig;
+    source: string;
+    sourceType: 'repo_file' | 'mesh_policy' | 'unavailable' | 'invalid';
+    path?: string;
+    error?: string;
+}
+export declare const MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS: string[];
+export declare const MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "ADHDev Repo Mesh Worktree Bootstrap Config";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["version"];
+    readonly properties: {
+        readonly version: {
+            readonly const: 1;
+        };
+        readonly enabled: {
+            readonly type: "boolean";
+            readonly default: true;
+        };
+        readonly runOnClone: {
+            readonly type: "boolean";
+            readonly default: true;
+        };
+        readonly required: {
+            readonly type: "boolean";
+            readonly default: true;
+        };
+        readonly staleInputs: {
+            readonly type: "array";
+            readonly maxItems: 16;
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+        readonly commands: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly maxItems: 4;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["command"];
+                readonly properties: {
+                    readonly command: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly args: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly category: {
+                        readonly enum: readonly ["typecheck", "test", "lint", "build", "custom"];
+                    };
+                    readonly cwd: {
+                        readonly type: "string";
+                    };
+                    readonly timeoutMs: {
+                        readonly type: "number";
+                        readonly minimum: 1000;
+                        readonly maximum: 600000;
+                    };
+                    readonly outputLimitBytes: {
+                        readonly type: "number";
+                        readonly minimum: 1024;
+                        readonly maximum: 1048576;
+                    };
+                    readonly env: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function validateMeshWorktreeBootstrapConfig(config: unknown, source?: string): {
+    valid: boolean;
+    errors: string[];
+    commands: MeshRefineValidationCommandPlan[];
+    rejectedCommands: Array<Record<string, unknown>>;
+};
+export declare function loadMeshWorktreeBootstrapConfig(mesh: any, workspace: string): WorktreeBootstrapConfigLoadResult;
+/** M2-1: hash staleInputs files so 'ready' can be invalidated when they change. */
+export declare function computeStaleInputsDigest(workspace: string, staleInputs: string[] | undefined): Record<string, string>;
+/**
+ * M2-1: the official bootstrap state contract. Resolves the effective state
+ * for a node workspace from config presence + the persisted last-run state +
+ * a staleInputs digest comparison. Read-only — never runs commands.
+ *
+ *   ready          — last run succeeded and staleInputs are unchanged
+ *   stale          — never ran, or a staleInputs file changed since 'ready'
+ *   running/failed — persisted lifecycle state passes through
+ *   not_configured / disabled / (invalid → failed) — from config resolution
+ */
+export declare function evaluateWorktreeBootstrapState(mesh: any, workspace: string, persisted?: WorktreeBootstrapState | null): WorktreeBootstrapState;
+export declare function runMeshWorktreeBootstrap(mesh: any, workspace: string): Promise<WorktreeBootstrapState>;

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

@@ -44,6 +44,8 @@ export declare class AcpProviderInstance implements ProviderInstance {
     private partialBlocks;
     /** Tool calls collected during current turn */
     private turnToolCalls;
+    /** Guard: prevent concurrent sendPrompt calls from racing on shared state */
+    private _sendPromptInFlight;
     private errorMessage;
     private errorReason;
     private stderrBuffer;
@@ -86,6 +88,9 @@ export declare class AcpProviderInstance implements ProviderInstance {
     sendPrompt(text: string, contentBlocks?: ContentBlock[]): Promise<void>;
     private cancelSession;
     private permissionResolvers;
+    private readonly manualAttendance;
+    /** @see ProviderInstance.noteManualInteraction */
+    noteManualInteraction(now?: number): void;
     resolvePermission(approved: boolean): Promise<void>;
     private handleSessionUpdate;
     /** Handle legacy session/update formats (pre-standardization compat) */

package/dist/providers/approval-utils.d.ts

@@ -1,7 +1,27 @@
 import type { ProviderModule } from './contracts.js';
+/**
+ * True when any of the given button labels reads as a decline/negative option
+ * (No / Deny / Cancel / Skip / …). Used as the second half of an approval-modal
+ * structural anchor: a real approval modal offers BOTH an affirmative and a
+ * decline, which distinguishes it from a generic numbered menu or prose list.
+ */
+export declare function hasNegativeApprovalOption(buttons: string[] | null | undefined): boolean;
 export declare function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[];
 export declare function pickApprovalButton(buttons: string[] | null | undefined, provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): {
     index: number;
     label: string;
 };
+export declare function pickAutoApprovalButton(buttons: string[] | null | undefined): {
+    index: number;
+    label: string;
+};
 export declare function formatAutoApprovalMessage(modalMessage?: string, buttonLabel?: string): string;
+/**
+ * Returns true when the given text (e.g. last assistant message content, or
+ * the tail of the PTY screen) looks like an active approval/input prompt
+ * rather than a completed assistant response. Used to prevent false
+ * idle/completion events when Claude Code surfaces a "Do you want to proceed?"
+ * style prompt that the PTY parser captures as an assistant turn while the
+ * session is still awaiting user input.
+ */
+export declare function looksLikeActiveApprovalPromptText(content: string): boolean;

package/dist/providers/chat-message-normalization.d.ts

@@ -1,6 +1,36 @@
 import type { ChatMessage } from '../types.js';
-export declare const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4000;
+export declare const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16000;
 export declare function extractFinalSummaryFromMessages(messages: ChatMessage[] | null | undefined, maxChars?: number): string;
+/**
+ * Turn-scoped variant of extractFinalSummaryFromMessages. Selects the last
+ * user-facing assistant/model bubble whose own timestamp is at/after the
+ * producing turn's start (`minTimestampMs`). This is the NOTIF Defect-B fix:
+ * a completion event's finalSummary must describe the turn THAT completed, not
+ * the prior task's last bubble. For native-source providers (claude-cli) the
+ * external transcript holds the ENTIRE session history filtered only by session
+ * start, so a completion debounce that fires before the producing turn's final
+ * assistant bubble has landed would otherwise echo the previous task's tail.
+ * A message whose timestamp predates the turn start is skipped; if no in-turn
+ * assistant bubble exists yet, returns '' (weak/empty) — never the stale tail.
+ *
+ * Mirrors the reconcile path's transcriptAfterDispatch guard (mesh-events-stale):
+ * a bubble only counts if its timestamp proves it was produced after the turn began.
+ * When `minTimestampMs` is undefined the behaviour is identical to the unscoped
+ * extractor (no turn boundary known → no filtering).
+ */
+export declare function extractFinalSummaryFromMessagesAfter(messages: ChatMessage[] | null | undefined, minTimestampMs: number | undefined, maxChars?: number): string;
+/**
+ * Like extractFinalSummaryFromMessages but also returns the ISO timestamp of the
+ * selected final assistant/model message. Completion reconciliation needs the
+ * timestamp to prove the transcript was produced AFTER the dispatch — without it
+ * reconcileDirectDispatchCompletionFromTranscript rejects non-JSON summaries as
+ * "transcript_not_proven_after_dispatch". The summary selection is identical so the
+ * timestamp always belongs to the message whose text became the summary.
+ */
+export declare function extractFinalAssistantSummaryEvidence(messages: ChatMessage[] | null | undefined, maxChars?: number): {
+    finalSummary: string;
+    transcriptMessageAt?: string;
+};
 export declare const BUILTIN_CHAT_MESSAGE_KINDS: readonly ["standard", "thought", "tool", "terminal", "system"];
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});

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

@@ -36,24 +36,80 @@ export declare class CliProviderInstance implements ProviderInstance {
     private cliArgs;
     readonly type: string;
     readonly category: "cli";
+    /**
+     * Quiet period an approval modal's signature must be stable before
+     * auto-approve sends the approve key. Guards against firing on a prompt
+     * that is still streaming into the PTY (the "resolves too fast" symptom):
+     * while the modal text/buttons are still changing, every frame yields a
+     * new signature and the settle clock restarts. Once the prompt finishes
+     * rendering the signature holds and the key is sent after this window.
+     * Bounded + small so genuine approvals stay timely. The FSM is already
+     * authoritative over the `waiting_approval` state; this only delays the
+     * keystroke until the modal *content* has settled.
+     */
+    private static readonly AUTO_APPROVE_SETTLE_MS;
+    /**
+     * Busy-side hysteresis for the settle gate. A momentary `generating` flip
+     * while the SAME approval modal's button block is still on screen (its
+     * question line scrolled out of the captured frame, only the buttons + a
+     * residual `esc to interrupt` spinner remain) briefly reports
+     * status!=waiting_approval. Without hysteresis that flip wipes the settle
+     * clock, and the modal→generating→modal flap restarts the 600ms window
+     * every time so auto-approve never fires. We keep the in-progress settle
+     * gate warm across an inactive blip up to this bound; only once the modal
+     * has genuinely stayed gone this long (a real resolution → idle) is the
+     * gate cleared. Bounded so a genuinely new, later approval still re-settles
+     * from scratch rather than firing on a stale timestamp.
+     */
+    private static readonly AUTO_APPROVE_GATE_HYSTERESIS_MS;
+    /**
+     * STATUS-MISMATCH: upper bound on how long the auto-approve→`generating` SURFACE
+     * mask may hide a worker's `waiting_approval` (status + activeModal) before we give
+     * up and surface the real prompt. The mask exists because auto-approve is expected
+     * to resolve the modal momentarily; but if it STALLS without ever calling
+     * resolveModal — the modal signature never settles for AUTO_APPROVE_SETTLE_MS (a
+     * perpetually-flapping/streaming prompt), no concrete modal is ever captured, or the
+     * modal is a picker/non-affirmative we never auto-pick — the mask would persist
+     * forever and read_chat / mesh_status / the dashboard would NEVER see the pending
+     * approval (the coordinator cannot mesh_approve what it cannot see). Once an episode
+     * exceeds this bound we stop masking. Generously larger than
+     * AUTO_APPROVE_SETTLE_MS (600) + AUTO_APPROVE_GATE_HYSTERESIS_MS (1500) so a
+     * legitimately slow-settling / blip-flapping prompt is never unmasked early; a
+     * genuine never-resolving stall surfaces within this window. The settle gate keeps
+     * running underneath, so a prompt that finally stabilises still auto-approves, and
+     * mesh_approve (raw FSM, unmasked) works throughout.
+     */
+    private static readonly AUTO_APPROVE_MASK_STALL_MS;
     private adapter;
     private context;
     private events;
     private lastStatus;
+    private agentReadyEmitted;
     private generatingStartedAt;
+    private fastCollapseSynthesizedTaskId;
+    private startupGraceCollapseAt;
     private settings;
     private monitor;
     private generatingDebounceTimer;
     private generatingDebouncePending;
-    private lastApprovalEventAt;
+    private lastApprovalEventFingerprint;
     private autoApproveBusy;
     private autoApproveBusyTimer;
+    private lastAutoApprovalSignature;
+    private pendingAutoApprovalSignature;
+    private pendingAutoApprovalSince;
+    private autoApproveSettleTimer;
+    private autoApproveInactiveSince;
+    private autoApproveMaskSince;
+    private readonly manualAttendance;
     private controlValues;
     private summaryMetadata;
     private appliedEffectKeys;
     private historyWriter;
     private runtimeMessages;
     private lastPersistedHistoryMessages;
+    private lastAcknowledgedUserInputAt;
+    private recentUserInputAcks;
     private lastNativeSourceCanonicalCheckAt;
     private lastNativeSourceCanonicalCacheKey;
     private cachedSqliteDb;
@@ -63,6 +119,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private suppressIdleHistoryReplay;
     private errorMessage;
     private errorReason;
+    private activeInteractivePrompt;
     private presentationMode;
     private providerSessionId?;
     private launchMode;
@@ -93,20 +150,143 @@ export declare class CliProviderInstance implements ProviderInstance {
     setPresentationMode(mode: 'terminal' | 'chat'): void;
     getPresentationMode(): 'terminal' | 'chat';
     getHotChatSessionState(): HotChatSessionState;
-    getSessionModalState(): SessionModalState;
+    getSessionModalState(sessionId?: string): SessionModalState;
     updateSettings(newSettings: Record<string, any>): void;
+    /**
+     * Stamp a direct-dispatch mesh assignment on this instance.
+     * setupMeshEventForwarding reads settings.meshNodeFor + meshActiveTaskId to
+     * route generating_completed back to the originating coordinator. Without
+     * this stamp, mesh_send_task --direct targets a plain CLI session whose
+     * completion events silently drop because the forwarder has nothing to
+     * match against.
+     */
+    attachMeshAssignment(assignment: {
+        meshId: string;
+        nodeId?: string;
+        taskId?: string;
+        coordinatorDaemonId?: string;
+        coordinatorSessionId?: string;
+    }): void;
+    /**
+     * Clear a previously-attached mesh assignment after the task reaches a
+     * terminal state. Leaving meshNodeFor pinned would route this session's
+     * subsequent unrelated turns (e.g. ad-hoc dashboard chats) to the
+     * coordinator as if they were task completions.
+     *
+     * MESHID-DROP-ON-DETACH (Fix C): a coordinator-LAUNCHED worker session
+     * (launchedByCoordinator) holds its mesh membership (meshNodeFor / meshNodeId /
+     * meshCoordinatorDaemonId) at the SESSION level — set once at launch
+     * (mesh_launch_session / queue auto-launch), independent of any single task.
+     * The original detach wiped meshNodeFor + meshNodeId together with the
+     * task-level meshActiveTaskId, so the FIRST task completion stripped the
+     * membership and EVERY subsequent completion forwarded with meshId absent —
+     * resolveWorkerDelegateRouting fell to mesh_unresolved and the coordinator
+     * rejected the forward "meshId required". For a launched member we therefore
+     * clear ONLY the task-level marker (meshActiveTaskId) and preserve the
+     * session-level membership so its next task's completion still resolves.
+     * A task-less ad-hoc turn on a preserved-membership session is NOT misrouted:
+     * its completion carries no taskId and the session holds no active assignment,
+     * so the forwarder's WARMUPGAP guard skips the dispatch-row flip (it only
+     * injects a benign task-less notification). A NON-launched session (a plain CLI
+     * session adopted by mesh_send_task --direct, launchedByCoordinator falsy)
+     * keeps the original full clear so an ad-hoc session is never left pinned.
+     */
+    detachMeshAssignment(): void;
+    /**
+     * The resolved modal-park status of this session, or null when it is not
+     * parked on a modal awaiting a human answer. Mirrors the overlay logic in
+     * getState(): an active AskUserQuestion interactive prompt resolves to
+     * waiting_choice; otherwise the adapter's waiting_approval (tool consent)
+     * counts — UNLESS auto-approve will dismiss it, in which case the session is
+     * effectively generating and is NOT modal-parked. This is the single signal
+     * the mesh force-inject guard consults, and the same status string the
+     * reconcile loop reads off get_status_metadata. Lowercase literals only —
+     * the SessionStatus enum is forked across modules and waiting_choice is
+     * absent from some of them.
+     */
+    resolveModalParkStatus(): 'waiting_choice' | 'waiting_approval' | null;
+    /** True when this session is parked on a modal awaiting a human answer. */
+    isModalParked(): boolean;
     onEvent(event: string, data?: any): void;
+    recordAcknowledgedUserInput(input: InputEnvelope | string): void;
+    /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
+    private pruneRecentUserInputAcks;
     dispose(): void;
     private completedDebounceTimer;
     private completedDebouncePending;
+    private lastExternalCompletionProbe;
     private enforceFreshSessionLaunchIfNeeded;
     private completionHasFinalAssistantMessage;
+    private buildExternalTranscriptProbe;
+    private recordPendingTranscriptProbe;
+    private readExternalCompletionMessages;
+    private completionFinalAssistantEvidence;
+    private completionFinalSummary;
+    private buildCompletedFinalizationDiagnostic;
     private hasAdapterPendingResponse;
     private shouldSuppressStaleParsedBusyStatus;
-    private getCompletedFinalizationBlockReason;
+    private getCompletedFinalizationBlock;
+    private hasApprovalResolutionEvidence;
+    private approvalResolutionFinalizationBlock;
     private scheduleCompletedDebounceFlush;
+    private isMeshWorkerSession;
+    /**
+     * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
+     * Prefers the per-turn binding (engine.currentTurnTaskId, set when the turn was
+     * submitted and surviving until the next turn starts) over the last-write-wins
+     * session scalar (settings.meshActiveTaskId). The scalar is retained only as a
+     * backward-compat alias for the "current/last assignment" and is the source of the
+     * NOTIF-MISDELIVER / TASK-MSG-MISROUTE race: a second task attaching before this
+     * turn completes overwrites it. Returns undefined for a non-task ad-hoc turn.
+     */
+    private completingTurnTaskId;
+    private meshTraceCtx;
     private flushCompletedDebounceIfFinalized;
     private maybeAutoApproveStatus;
+    /**
+     * Re-drive the auto-approve check after the settle quiet window elapses.
+     * The PTY may have gone silent once the approval prompt finished painting,
+     * so no status-change frame is guaranteed to re-enter maybeAutoApproveStatus
+     * — this timer-driven re-check picks up the now-settled modal and fires.
+     * Deliberately lighter than detectStatusTransition(): it only re-evaluates
+     * the approval decision; the next real PTY frame refreshes visible status.
+     */
+    private recheckAutoApproveSettled;
+    /**
+     * Emit the queue-claim agent:ready event at most once per session. Both the
+     * boot-time starting→idle one-shot and the fsmReadySeen re-arm call this; the
+     * agentReadyEmitted guard ensures the second caller is a no-op so a worker is
+     * never claimed twice and a queued task is never double-dispatched.
+     */
+    private emitAgentReadyOnce;
+    /**
+     * GENERATING-BOUNDARY synthetic emit for a first turn that started AND finished
+     * inside the startup-grace window without the FSM ever observing a 'generating'
+     * frame (an unobservably-fast turn). Synthesizes the agent:generating_started +
+     * agent:generating_completed pair so the mesh coordinator learns the worker went
+     * idle. Returns true iff it synthesized.
+     *
+     * Two callers share this defense line:
+     *  - 'startup_grace_fast_collapse' — the starting→idle transition (the FSM whose
+     *    spec lacks/hadn't-synced the starting→busy edge collapses starting→idle
+     *    directly, with no intervening 'generating' frame).
+     *  - 'startup_grace_idle_turn_collapse' — the idle→idle no-status-change poll
+     *    (the launch settle already drained starting→idle BEFORE the first turn, so
+     *    the turn runs+completes while status stays 'idle' the whole time and
+     *    detectStatusTransition never re-enters its change block — the live rc.403
+     *    Probe1 miss).
+     *
+     * False-positive safety (must NOT fire on a benign boot): currentTurnTaskId is
+     * set ONLY by onTurnStarted (a real turn STARTED this boot) and persists past
+     * completion, so it excludes a true idle boot (null) and a queued-pending first
+     * turn that only runs after grace (onTurnStarted not yet called → null).
+     * !hasAdapterPendingResponse() excludes a turn still mid-flight. generating
+     * never armed (generatingStartedAt===0 && !generatingDebouncePending) means the
+     * whole idle→busy→idle never happened for this turn. The once-per-turn guard
+     * (fastCollapseSynthesizedTaskId) keeps the re-polled idle-stayed caller from
+     * re-emitting every poll.
+     */
+    private maybeSynthesizeStartupGraceCollapse;
     private detectStatusTransition;
     private pushEvent;
     private flushEvents;
@@ -117,6 +297,18 @@ export declare class CliProviderInstance implements ProviderInstance {
     get cliType(): string;
     get cliName(): string;
     private shouldAutoApprove;
+    /** @see ProviderInstance.noteManualInteraction */
+    noteManualInteraction(now?: number): void;
+    /**
+     * Whether auto-approve should be treated as active *right now* for display
+     * and firing decisions: the configured intent AND the user is not currently
+     * attending this session by hand. When a human is attending, auto-approve is
+     * held so the modal stays visible and they can drive it via the controlbar.
+     * Provider-agnostic — the attendance signal is the command set, never any
+     * CLI-specific modal text.
+     */
+    private autoApproveEffectivelyActive;
+    private autoApproveMaskStalled;
     private recordAutoApproval;
     recordApprovalSelection(buttonText: string): void;
     private formatMarkerTimestamp;
@@ -127,6 +319,8 @@ export declare class CliProviderInstance implements ProviderInstance {
     private mergeConversationMessages;
     private formatApprovalRequestMessage;
     private promoteProviderSessionId;
+    private shouldHydrateExistingProviderHistory;
+    private shouldSuppressFreshLaunchStartupReplay;
     private syncCanonicalSavedHistoryIfNeeded;
     private restorePersistedHistoryFromCurrentSession;
     private getProbeDirectories;