@adhdev/daemon-core 0.9.82-rc.49 → 0.9.82-rc.490

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

@@ -0,0 +1,219 @@
+import { type MeshRefineValidationCommandPlan, type RepoMeshRefineValidationCommandConfig } from './refine-config.js';
+import type { MeshAsyncJobLifecycle } from '../repo-mesh-types.js';
+export type WorktreeBootstrapStatus = 'ready' | 'complete' | '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;
+/**
+ * Enumerate registered submodule paths for a worktree, generically (no hardcoded
+ * 'oss'/'adhdev-providers'). Reads `.gitmodules` via `git config --file .gitmodules
+ * --get-regexp path`, whose lines are `submodule.<name>.path <relativePath>`. Paths
+ * are returned normalized to forward slashes (git porcelain always emits '/'),
+ * trailing slash stripped. Returns an empty set when there are no submodules or the
+ * lookup fails — callers must then treat any change as dirty (conservative).
+ */
+export declare function getRegisteredSubmodulePaths(workspace: string): Set<string>;
+/**
+ * Read each registered submodule's configured `branch` from `.gitmodules`, keyed
+ * by the submodule's normalized path (matching {@link getRegisteredSubmodulePaths}).
+ *
+ * `.gitmodules` stores `submodule.<name>.path` and (optionally)
+ * `submodule.<name>.branch`; this joins the two on `<name>`. The special branch
+ * value `.` ("track the superproject's branch") is deliberately OMITTED so callers
+ * fall through to remote-HEAD detection instead of treating `.` as a literal branch
+ * name. Returns an empty map when there are no submodules, no `.gitmodules`, or the
+ * lookup fails (conservative — callers then detect or fall back).
+ */
+export declare function getSubmoduleConfiguredBranches(workspace: string): Map<string, string>;
+/** Fallback submodule branch when no configured/detected default can be resolved. */
+export declare const SUBMODULE_DEFAULT_BRANCH_FALLBACK = "main";
+/**
+ * Resolve the default branch a submodule's commits are published to / checked for
+ * reachability against. Generalizes the previously hardcoded `main` so a submodule
+ * whose default branch is `master`/`trunk`/etc. is handled. Priority (each tier
+ * falls through to the next on miss/error):
+ *
+ *   1. `.gitmodules` `submodule.<name>.branch` (via {@link getSubmoduleConfiguredBranches};
+ *      `.` is ignored) — an explicit, local, zero-cost declaration.
+ *   2. the submodule checkout's LOCAL remote HEAD: `git symbolic-ref --short
+ *      refs/remotes/<remote>/HEAD` → strip the `<remote>/` prefix (no network).
+ *   3. the submodule remote's advertised HEAD: `git ls-remote --symref <remote> HEAD`
+ *      → `ref: refs/heads/<branch>` (one network round-trip).
+ *   4. fallback {@link SUBMODULE_DEFAULT_BRANCH_FALLBACK} (`'main'`).
+ *
+ * Because the final fallback is `'main'` and every earlier tier that resolves `'main'`
+ * yields the same string, a repo whose submodules default to `main` (the common case)
+ * produces byte-identical downstream fetch/merge-base/push ref targets — only a
+ * read-only resolution probe is added.
+ */
+export declare function resolveSubmoduleDefaultBranch(opts: {
+    /** The submodule's local checkout — cwd for symbolic-ref / ls-remote. */
+    submoduleRepoPath: string;
+    /** The superproject workspace — for the `.gitmodules` branch lookup (tier 1). */
+    superprojectWorkspace?: string;
+    /** The submodule's path relative to the superproject (key into `.gitmodules`). */
+    submodulePath?: string;
+    /** Remote name (default `origin`). */
+    remote?: string;
+    /** Timeout for the local probe (tier 2); the network probe (tier 3) gets max(this, 30s). */
+    timeoutMs?: number;
+}): Promise<string>;
+export declare function isWorktreeBootstrapStaleRunning(node: {
+    worktreeBootstrap?: {
+        status?: string;
+        startedAt?: string;
+        updatedAt?: string;
+        completedAt?: string;
+    };
+    workspace?: string;
+} | undefined, nowMs?: number): boolean;
+/**
+ * COMPLETION-PROPAGATION F7 (C2): the single shared consume-ready / bootstrap-pending defer
+ * predicate. A task must NOT be injected into a worktree node whose bootstrap is still 'running'
+ * — the provider is not yet ready to consume input, so the inject lands in the input buffer and
+ * is silently swallowed (empty session). Both the remote dispatch guard (the router agent_command
+ * handler) and the local queue-claim gate (tryAssignQueueTask) route through THIS predicate so
+ * they agree on exactly when to defer. Returns true = defer. The stale-'running' backstop
+ * (isWorktreeBootstrapStaleRunning) is honored here too: a 'running' state far older than any real
+ * bootstrap whose worktree is git-clean is treated as silently complete (do NOT defer), so a node
+ * whose terminal stamp never reached this daemon is not stranded forever.
+ */
+export declare function shouldDeferDispatchForBootstrap(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,53 @@
 import type { ProviderModule } from './contracts.js';
+export declare function normalizeApprovalLabel(value: string): string;
+/**
+ * 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;
+/**
+ * True when a button reliably identifies a tool-CONSENT modal on its own — a
+ * scoped permission-grant affirmative such as:
+ *   - "Yes, allow all edits in tmp/ during this session"
+ *   - "Yes, and don't ask again for example.com"
+ *   - "Yes, allow reading from etc/ from this project"
+ *   - "Always allow"
+ *
+ * These options only ever appear in a genuine approval/permission prompt; a
+ * /model or /mode picker ("1. Default  2. Opus  3. Sonnet") never offers a
+ * "grant this scope" choice. They therefore serve as a SECOND reliable
+ * structural anchor alongside {@link hasNegativeApprovalOption}.
+ *
+ * Why this exists (tall-diff fallback, #137): when a Write/Edit diff is tall,
+ * the trailing decline option ("3. No") can scroll off the bottom of the
+ * captured PTY frame, leaving only "1. Yes" + "2. Yes, allow … this session".
+ * hasNegativeApprovalOption then reads false and the auto-approve gate bails —
+ * a delegated worker sits forever on a modal it could safely have approved. The
+ * grant-scope affirmative lets the gate recognize the consent modal WITHOUT
+ * seeing the off-frame decline. The gate still selects the plain "Yes"
+ * (allow-once) via pickApprovalButton, never the broader grant, and the settle
+ * gate still requires a stable modal — so a half-rendered frame never fires.
+ * Kept deliberately narrow so no picker/confirm modal can trip it.
+ */
+export declare function hasReliableApprovalAffirmative(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,63 @@
 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;
+export declare function readChatMessageTimestampMs(message: ChatMessage | null | undefined): number | undefined;
+/**
+ * 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;
+};
+/**
+ * EARLYNOTIFY-GATEBYPASS (a)/(b) — the shared turn-finality selector for the completion
+ * final-assistant judgement, so the ~duplicated "which bubble is the turn's final answer"
+ * logic is decided ONE way (UNIFY A-6).
+ *
+ * Returns the message that qualifies as the turn's FINAL assistant bubble, or null when the
+ * transcript does not (yet) prove a turn end. The rule is a NON-EMPTY LATEST user-facing
+ * assistant/model bubble:
+ *   - Scanning from the end, the FIRST user-facing assistant/model bubble encountered IS the
+ *     turn-end candidate. If it is EMPTY (a streaming placeholder / mid-turn narration whose
+ *     text has not landed), the turn is still in flight → return null. Crucially we do NOT walk
+ *     back past that empty bubble to promote an EARLIER assistant narration to "final" (the
+ *     Defect-B walk-back).
+ *   - Trailing activity/internal bubbles (tool/thought/status) are skipped — they are not the
+ *     assistant's user-facing answer.
+ *   - A trailing user-facing USER message (a freshly dispatched task with no reply yet) means the
+ *     assistant did not have the last word — no earlier bubble is promoted here; callers that must
+ *     still reach a prior turn's tail use the timestamp-scoped extractor instead.
+ *
+ * A bare snapshot-idle with an arbitrary non-empty tail therefore does NOT qualify as a turn end;
+ * only a genuine latest-assistant bubble does. Turn-finality signals that live OUTSIDE the
+ * transcript (a committed generating→idle FSM transition, a self-attributing final_summary_json,
+ * or a continuous-idle streak) are enforced by the callers (the CLI completion gate, the reconcile
+ * grace gate) on top of this structural check.
+ */
+export declare function selectFinalAssistantTurnEndMessage(messages: ChatMessage[] | null | undefined): ChatMessage | null;
 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-effect-format.d.ts

@@ -0,0 +1,30 @@
+export declare function getEffectDedupKey(effect: {
+    id?: string;
+    type: string;
+    message?: {
+        content?: unknown;
+    };
+    toast?: {
+        message?: string;
+    };
+    notification?: {
+        title?: string;
+        body?: string;
+    };
+}): string;
+export declare function getPersistedEffectContent(effect: {
+    type: string;
+    message?: {
+        content?: unknown;
+    };
+    toast?: {
+        message?: string;
+    };
+    notification?: {
+        title?: string;
+        body?: string;
+        bubbleContent?: unknown;
+    };
+}): string | null;
+export declare function formatApprovalRequestMessage(modalMessage?: string, buttons?: string[]): string;
+export declare function formatMarkerTimestamp(timestamp: number): string;

package/dist/providers/cli-provider-history-dedup.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CLI provider persisted-history dedup — incremental append computation.
+ *
+ * Pure move out of cli-provider-instance.ts (no behavior change): the
+ * shared-prefix diff that turns a full parsed transcript into the newly-added
+ * tail to append to the persisted chat history. cli-provider-instance
+ * re-exports buildIncrementalHistoryAppendMessages so existing importers/tests
+ * keep their path.
+ */
+export type PersistableCliHistoryMessage = {
+    role: string;
+    content: string;
+    kind?: string;
+    senderName?: string;
+    receivedAt?: number;
+};
+export declare function buildIncrementalHistoryAppendMessages(previousMessages: PersistableCliHistoryMessage[], currentMessages: PersistableCliHistoryMessage[]): PersistableCliHistoryMessage[];

package/dist/providers/cli-provider-input-prompt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CLI provider structured-input helpers — image materialization + prompt build.
+ *
+ * Pure move out of cli-provider-instance.ts (no behavior change): the input
+ * envelope → CLI prompt string construction and its image-materialization
+ * support. cli-provider-instance re-exports buildCliStructuredInputPrompt so
+ * existing importers/tests keep their path.
+ */
+import { type InputEnvelope } from './contracts.js';
+export declare function buildCliStructuredInputPrompt(input: InputEnvelope, options?: {
+    materializeDir?: string;
+}): string;

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

@@ -0,0 +1,45 @@
+export declare const STATUS_HYDRATION_TAIL_LIMIT = 200;
+export type CompletedDebouncePending = {
+    chatTitle: string;
+    duration: number;
+    timestamp: number;
+    firstObservedAt: number;
+    previousStatus: string;
+    loggedBlockReason?: string;
+    loggedTranscriptProbe?: boolean;
+    transcriptProbeHistory?: ExternalTranscriptProbe[];
+    taskId?: string;
+    turnStartedAt?: number;
+    busyEpochAtArm?: number;
+    lastOutputAtArm?: number;
+};
+export type CompletedFinalizationBlock = {
+    reason: string;
+    terminal?: boolean;
+    allowTimeout?: boolean;
+    holdForTranscript?: boolean;
+};
+export type CompletionFinalAssistantEvidence = {
+    present: boolean;
+    messages: unknown[];
+    source: 'parsed' | 'external-native' | 'unavailable';
+};
+export type ExternalTranscriptProbe = {
+    readAt: number;
+    msgCount: number;
+    lastRole: string | null;
+    lastKind: string | null;
+    contentLen: number;
+    sourcePath: string | null;
+    sourceMtimeMs: number | null;
+    mtimeAgeMs: number | null;
+};
+export declare const COMPLETED_FINALIZATION_RETRY_MS = 1000;
+export declare const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30000;
+export declare const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4000;
+export declare const USER_INPUT_ACK_DEDUP_WINDOW_MS = 60000;
+export declare const STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12000;
+/** Events that signal a dispatched mesh task has reached a terminal state.
+ *  Detach the mesh assignment after emitting one of these so the worker's
+ *  next unrelated turn doesn't impersonate another completion. */
+export declare const TERMINAL_MESH_EVENTS: Set<string>;