@adhdev/daemon-core 0.9.82-rc.4 → 0.9.82-rc.400

package/dist/commands/upgrade-helper.d.ts

@@ -39,6 +39,46 @@ export declare function buildPinnedGlobalInstallCommand(options: {
 }): PinnedGlobalInstallCommand;
 export declare function getNpmExecOptions(platform?: NodeJS.Platform): NpmExecOptions;
 export declare function execNpmCommandSync(args: string[], options?: ExecFileSyncOptions, surface?: Pick<CurrentGlobalInstallSurface, 'npmExecutable' | 'npmArgsPrefix' | 'execOptions'>): Buffer | string;
-export declare function stopSessionHostProcesses(appName: string): void;
+export declare function stopSessionHostProcesses(appName: string): Promise<void>;
+/**
+ * Enumerate processes that have a locked native addon (conpty.node /
+ * ghostty-vt.dll) of *this* install memory-mapped.
+ *
+ * `stopSessionHostProcesses()` only knows the single managed session-host pid, so
+ * any *foreign* holder — e.g. an orphaned `pty_*probe*.cjs` left in `%TEMP%` — is
+ * invisible to it and keeps the addon locked through every install retry, dooming
+ * the upgrade with EBUSY. This scans by the module's full path so we only ever
+ * target a holder of the exact `packageRoot` being replaced (never an unrelated
+ * install's copy). Windows-only — these locks don't exist on POSIX.
+ */
+export declare function listForeignNativeAddonHolders(packageRoot: string | null | undefined): Array<{
+    pid: number;
+    commandLine: string | null;
+}>;
+/**
+ * Terminate every foreign process holding this install's native addon mapped,
+ * then wait for each to actually exit so the mapping is released before npm
+ * copies the file into its staging dir. Returns what it found/killed so the
+ * caller can surface an actionable recovery message on failure.
+ */
+export declare function stopForeignNativeAddonHolders(packageRoot: string | null | undefined, options?: {
+    parentPid?: number;
+}): Promise<Array<{
+    pid: number;
+    commandLine: string | null;
+    killed: boolean;
+}>>;
+/**
+ * Best-effort removal of a leftover npm staging entry.
+ *
+ * A stale staging dir can hold a locked native binary — e.g. `ghostty-vt.dll`
+ * from `@adhdev/ghostty-vt-node` still mapped by a lingering session-host
+ * process — which makes `rmSync` throw `EPERM` on Windows. Staging cleanup is
+ * only housekeeping: the leftover is inert and npm creates its own fresh
+ * staging dir for the real install, so a lock on an old leftover must NOT abort
+ * the upgrade. Log and continue instead of letting the error propagate.
+ */
+export declare function safeRemoveStaleEntry(target: string, label: string): void;
+export declare function cleanupStaleGlobalInstallDirs(pkgName: string, surface: CurrentGlobalInstallSurface): void;
 export declare function spawnDetachedDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): void;
 export declare function maybeRunDaemonUpgradeHelperFromEnv(): Promise<boolean>;

package/dist/config/chat-history.d.ts

@@ -110,12 +110,21 @@ export declare function readProviderChatHistory(agentType: string, options?: {
     excludeRecentCount?: number;
     historyBehavior?: ProviderHistoryBehavior;
     scripts?: ProviderNativeHistoryScripts;
+    excludeInProgressTurn?: boolean;
+    sessionStartedAtMs?: number;
+    envOverrides?: Record<string, string>;
+    forceRefresh?: boolean;
 }): {
     messages: HistoryMessage[];
     hasMore: boolean;
     source: 'provider-native' | 'adhdev-mirror' | 'native-unavailable';
     sourcePath?: string;
     sourceMtimeMs?: number;
+    providerSessionId?: string;
+    workspace?: string;
+    nativeHistoryCoverage?: string;
+    partialReason?: string;
+    unavailableReason?: string;
 };
 export declare function listProviderHistorySessions(agentType: string, options?: {
     canonicalHistory?: ProviderCanonicalHistoryConfig;

package/dist/config/config.d.ts

@@ -86,6 +86,11 @@ export declare function isStableMachineId(machineId?: string | null): boolean;
  * Get the config directory path
  */
 export declare function getConfigDir(): string;
+/**
+ * Get the daemon runtime data directory (~/.adhdev/daemon/).
+ * Distinct from the user-config dir so runtime state can be cleared independently.
+ */
+export declare function getDaemonDataDir(): string;
 /**
  * Load configuration from disk
  */

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

@@ -5,7 +5,7 @@
  * Cloud mode syncs these to D1 via server routes; standalone mode
  * uses this file as the single source of truth.
  */
-import type { LocalMeshEntry, LocalMeshNodeEntry, RepoMeshPolicy, RepoMeshNodePolicy, RepoMeshNodeCapabilities, RepoMeshCoordinatorConfig } from '../repo-mesh-types.js';
+import type { LocalMeshEntry, LocalMeshNodeEntry, RepoMeshPolicy, RepoMeshNodePolicy, RepoMeshNodeCapabilities, RepoMeshCoordinatorConfig, RepoMeshHostMetadata, RepoMeshDaemonRole } from '../repo-mesh-types.js';
 /**
  * Normalize a Git remote URL into a stable identity string.
  * e.g. "git@github.com:user/repo.git" → "github.com/user/repo"
@@ -22,6 +22,7 @@ export interface CreateMeshOptions {
     defaultBranch?: string;
     policy?: Partial<RepoMeshPolicy>;
     coordinator?: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
 }
 export declare function createMesh(opts: CreateMeshOptions): LocalMeshEntry;
 export interface UpdateMeshOptions {
@@ -29,23 +30,98 @@ export interface UpdateMeshOptions {
     defaultBranch?: string;
     policy?: Partial<RepoMeshPolicy>;
     coordinator?: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
 }
 export declare function updateMesh(meshId: string, opts: UpdateMeshOptions): LocalMeshEntry | undefined;
 export declare function deleteMesh(meshId: string): boolean;
+export declare function tokenIdForManualPairing(token: string): string;
+export interface ConfigureMeshHostPairingOptions {
+    hostAddress: string;
+    token: string;
+    now?: string;
+}
+export declare function configureMeshHostPairing(meshId: string, opts: ConfigureMeshHostPairingOptions): {
+    mesh: LocalMeshEntry;
+    meshHost: RepoMeshHostMetadata;
+    hostAddress: string;
+} | undefined;
+export interface CreateMeshHostPairingTokenOptions {
+    token?: string;
+    expiresAt?: string;
+    now?: string;
+}
+export declare function createMeshHostPairingToken(meshId: string, opts?: CreateMeshHostPairingTokenOptions): {
+    mesh: LocalMeshEntry;
+    meshHost: RepoMeshHostMetadata;
+    token: string;
+    tokenId: string;
+    expiresAt?: string;
+} | undefined;
+export interface MeshHostJoinMemberNodeInput {
+    id?: string;
+    workspace: string;
+    repoRoot?: string;
+    daemonId?: string;
+    machineId?: string;
+    userOverrides?: Partial<RepoMeshNodeCapabilities>;
+    policy?: RepoMeshNodePolicy;
+    role?: RepoMeshDaemonRole;
+}
+export interface ApplyMeshHostJoinOptions {
+    token: string;
+    memberNode: MeshHostJoinMemberNodeInput;
+    memberMeshId?: string;
+    now?: string;
+}
+export declare function applyMeshHostJoinRequest(meshId: string, opts: ApplyMeshHostJoinOptions): {
+    accepted: true;
+    mesh: LocalMeshEntry;
+    meshHost: RepoMeshHostMetadata;
+    node: LocalMeshNodeEntry;
+    tokenId: string;
+} | {
+    accepted: false;
+    mesh?: LocalMeshEntry;
+    meshHost?: RepoMeshHostMetadata;
+    tokenId?: string;
+    reason: string;
+} | undefined;
+export declare function markMeshHostPairingJoined(meshId: string, opts: {
+    hostDaemonId?: string;
+    hostNodeId?: string;
+    joinedAt?: string;
+    token?: string;
+    tokenId?: string;
+}): {
+    mesh: LocalMeshEntry;
+    meshHost: RepoMeshHostMetadata;
+} | undefined;
 export interface AddNodeOptions {
     workspace: string;
     repoRoot?: string;
     daemonId?: string;
     machineId?: string;
+    capabilities?: string[];
     userOverrides?: Partial<RepoMeshNodeCapabilities>;
     policy?: RepoMeshNodePolicy;
     isLocalWorktree?: boolean;
     worktreeBranch?: string;
     clonedFromNodeId?: string;
+    worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
+    role?: RepoMeshDaemonRole;
 }
 export declare function addNode(meshId: string, opts: AddNodeOptions): LocalMeshNodeEntry | undefined;
 export declare function removeNode(meshId: string, nodeId: string): boolean;
 export declare function updateNode(meshId: string, nodeId: string, opts: {
     userOverrides?: Partial<RepoMeshNodeCapabilities>;
     policy?: RepoMeshNodePolicy;
+    worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
+    /** Per-node instruction surfaced in the coordinator prompt. Pass an
+     *  empty string or undefined to clear it. */
+    systemPrompt?: string;
+    /** Live self-reported platform/arch from the owning daemon's git_status
+     *  envelope. Persisted distinctly from userOverrides (auto-detected, not
+     *  operator intent) so capability-tag os=/arch= self-heals across loads. */
+    reportedPlatform?: string;
+    reportedArch?: string;
 }): LocalMeshNodeEntry | undefined;

package/dist/config/mesh-json-config.d.ts

@@ -0,0 +1,299 @@
+/**
+ * Repo-shared declarative mesh config — `.adhdev/mesh.json`
+ *
+ * A repo-committed, machine-independent BASE for mesh declarative settings
+ * (policy + coordinator prompt override/append + operating notes). It is the
+ * lowest layer of a LOCAL-WINS merge chain:
+ *
+ *   DEFAULT_MESH_POLICY  →  .adhdev/mesh.json (repo base)  →  machine-local
+ *   meshes.json / coordinator-prompt files (always win)
+ *
+ * The merge is **in-memory only**. The on-disk machine-local `meshes.json` is
+ * NEVER mutated by this module — local config keeps winning and the merge is
+ * applied transiently on the coordinator launch + display paths. This keeps the
+ * repo file a shared default that a machine can always override without the
+ * override being silently rewritten back to the repo shape.
+ *
+ * Three zones (scope = mesh-global in v1; per-node scope is not introduced):
+ *   - policy            — RepoMeshPolicy fields; local fields that differ from
+ *                         DEFAULT_MESH_POLICY win, otherwise the repo base shows
+ *                         through (true per-field LOCAL-WINS).
+ *   - coordinator       — systemPromptOverride (local wins, else repo) and
+ *                         systemPromptAppend (repo append + local append BOTH
+ *                         stack, repo first).
+ *   - operatingNotes    — repo-declared baseline notes merged with the runtime
+ *                         ledger notes; on duplicate text the ledger note wins.
+ *
+ * Advisory-only fields (`coordinator.maxPromptChars`, `limits.maxNoteChars`,
+ * `limits.maxNotes`) are accepted and preserved in the schema but NOT enforced
+ * in v1 — they document operator intent only.
+ *
+ * SCHEDULING OVERLAY — this same `.adhdev/mesh.json` also carries the in-tree
+ * scheduling product surface (`policy.scheduling`). Instead of the scattered
+ * `schedulingStrategy` / `maxParallelTasks` knobs (each with its own default +
+ * clamp), an operator declares one `policy.scheduling` block checked into the
+ * repo. It layers ON TOP of the stored meshes.json policy with LOCAL-WINS — a
+ * value present in the repo file overrides the persisted mesh policy, so the
+ * repo is the source of truth for how its own work distributes. Absent keys
+ * leave the stored policy untouched (a partial overlay, not a replacement).
+ *
+ *   .adhdev/mesh.json
+ *   { "policy": { "scheduling": {
+ *       "distribution": "spread" | "in_order",   // → schedulingStrategy
+ *       "maxParallel": 1..8,                       // → maxParallelTasks (clamped)
+ *       "readonlyMultiplier": 2                    // read-only cap multiplier (default 2)
+ *   } } }
+ *
+ * The raw 4-union schedulingStrategy escape hatch is preserved elsewhere: a
+ * hand-edited meshes.json may still write any of the four raw strategies and the
+ * scheduler honors it. The scheduling overlay exposes only the 2-mode
+ * `distribution` façade, mapped through distributionToStrategy.
+ *
+ * The declarative-config loader (`loadRepoMeshJsonConfig`) and the scheduling
+ * overlay loader (`loadMeshJsonConfig`) read the SAME file but resolve different
+ * zones; they coexist intentionally — coordinator launch/display consume the
+ * declarative zones, the scheduler consumes the scheduling overlay.
+ *
+ * SECURITY: declarative only. JSON/YAML is parsed; arbitrary JS (.js) is NOT
+ * supported, so loading a config can never execute code.
+ */
+import { type RepoMeshPolicy, type RepoMeshCoordinatorConfig, type LocalMeshEntry, type RepoMeshDistribution, distributionToStrategy } from '../repo-mesh-types.js';
+import type { CoordinatorOperatingNote } from '../mesh/coordinator-prompt.js';
+export interface RepoMeshDeclarativeCoordinatorConfig {
+    /** Full mesh-level system prompt override. Same semantics as
+     *  RepoMeshCoordinatorConfig.systemPromptOverride; LOCAL-WINS. */
+    systemPromptOverride?: string;
+    /** Mesh-level append stacked after the base prompt. Both the repo append
+     *  and the machine-local append apply; the repo append comes first. */
+    systemPromptAppend?: string;
+    /** Advisory only in v1 — recorded but never enforced. */
+    maxPromptChars?: number;
+}
+export interface RepoMeshDeclarativeLimits {
+    /** Advisory only in v1 — recorded but never enforced. */
+    maxNoteChars?: number;
+    /** Advisory only in v1 — recorded but never enforced. */
+    maxNotes?: number;
+}
+/**
+ * Parsed + normalized `.adhdev/mesh.json` shape. Every field is optional except
+ * version so a repo can declare only the zone(s) it cares about.
+ */
+export interface RepoMeshDeclarativeConfig {
+    version: 1;
+    policy?: Partial<RepoMeshPolicy>;
+    coordinator?: RepoMeshDeclarativeCoordinatorConfig;
+    operatingNotes?: CoordinatorOperatingNote[];
+    limits?: RepoMeshDeclarativeLimits;
+}
+export interface RepoMeshJsonConfigLoadResult {
+    config?: RepoMeshDeclarativeConfig;
+    /** Relative location matched, or 'unavailable'/'invalid' marker. */
+    source: string;
+    sourceType: 'repo_file' | 'unavailable' | 'invalid';
+    /** Absolute path of the matched file, when one was read. */
+    path?: string;
+    error?: string;
+}
+export interface MeshJsonSchedulingConfig {
+    /** User-facing distribution mode; mapped to schedulingStrategy on apply. */
+    distribution?: RepoMeshDistribution;
+    /** Global write-task parallel cap (clamped to [1, 8] on apply). */
+    maxParallel?: number;
+    /** Read-only diagnosis cap multiplier. Missing → 2. */
+    readonlyMultiplier?: number;
+}
+export interface MeshJsonConfig {
+    scheduling?: MeshJsonSchedulingConfig;
+}
+export interface MeshJsonConfigLoadResult {
+    config?: MeshJsonConfig;
+    source: string;
+    sourceType: 'repo_file' | 'unavailable' | 'invalid';
+    path?: string;
+    error?: string;
+    /** Cache key: path + mtime, or a sentinel for the missing/invalid case. */
+    sourceKey: string;
+}
+export declare const MESH_JSON_CONFIG_LOCATIONS: string[];
+export declare const MESH_JSON_CONFIG_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "ADHDev Repo Mesh Declarative Config";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["version"];
+    readonly properties: {
+        readonly version: {
+            readonly const: 1;
+        };
+        readonly policy: {
+            readonly type: "object";
+        };
+        readonly coordinator: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly systemPromptOverride: {
+                    readonly type: "string";
+                };
+                readonly systemPromptAppend: {
+                    readonly type: "string";
+                };
+                readonly maxPromptChars: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+            };
+        };
+        readonly operatingNotes: {
+            readonly type: "array";
+            readonly maxItems: 200;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["text"];
+                readonly properties: {
+                    readonly text: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly category: {
+                        readonly enum: readonly ["provider_quirk", "pattern_to_avoid", "recovery_lesson"];
+                    };
+                    readonly createdAt: {
+                        readonly type: "string";
+                    };
+                    readonly sourceCoordinator: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly limits: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly maxNoteChars: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                readonly maxNotes: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+            };
+        };
+    };
+};
+/**
+ * Validate + normalize a parsed `.adhdev/mesh.json` object into a typed
+ * RepoMeshDeclarativeConfig. Returns the config plus any non-fatal warnings;
+ * `valid` is false only when the document is structurally unusable (not an
+ * object / wrong version). Unknown top-level keys are tolerated (dropped) so a
+ * newer repo file authored against a future schema still loads its known zones.
+ */
+export declare function normalizeRepoMeshDeclarativeConfig(parsed: unknown): {
+    valid: boolean;
+    config?: RepoMeshDeclarativeConfig;
+    errors: string[];
+};
+/**
+ * Load the repo-shared declarative mesh config for a coordinator workspace.
+ *
+ * Resolution: the coordinator node workspace is checked first; if it carries no
+ * `.adhdev/mesh.json`, the calling process cwd is tried as a fallback (per the
+ * design: "workspace path = coordinator node workspace's .adhdev/mesh.json,
+ * else calling cwd"). The first existing file across both bases (and the
+ * json/yaml/yml variants) wins.
+ *
+ * Read/parse errors never throw — they resolve to a sourceType:'invalid'
+ * result so a broken repo file degrades to "no repo base" instead of blocking
+ * coordinator launch.
+ */
+export declare function loadRepoMeshJsonConfig(workspace?: string): RepoMeshJsonConfigLoadResult;
+/**
+ * Reduce a (fully-normalized) machine-local policy to ONLY the fields that
+ * genuinely differ from DEFAULT_MESH_POLICY. A meshes.json policy is always
+ * stored fully-defaulted, so a naive merge would let it shadow every repo-base
+ * field — defeating the repo default. By keeping only the truly-overridden
+ * fields, an untouched local field falls through to the repo base while a local
+ * field the operator actually changed still wins. Optional fields absent from
+ * DEFAULT_MESH_POLICY (e.g. allowedProviders, schedulingStrategy) count as an
+ * override whenever present.
+ */
+export declare function diffPolicyFromDefault(local: Partial<RepoMeshPolicy> | undefined): Partial<RepoMeshPolicy>;
+/**
+ * Effective mesh policy = DEFAULT → repo base → local overrides (per-field
+ * LOCAL-WINS). When `local` is all-default the repo base shows through entirely
+ * (case i); when `local` overrides a field that field wins (case ii). Nested
+ * objects (autoFastForward) are still merged per-field by mergeAndNormalizePolicy.
+ */
+export declare function mergeEffectiveMeshPolicy(repoPolicy: Partial<RepoMeshPolicy> | undefined, localPolicy: RepoMeshPolicy | Partial<RepoMeshPolicy> | undefined): RepoMeshPolicy;
+/**
+ * Effective coordinator config. systemPromptOverride: local wins, else repo.
+ * systemPromptAppend: repo append + local append BOTH stack (repo first). Other
+ * coordinator fields (providerType, preferredNodeId, …) are carried from the
+ * machine-local config unchanged.
+ */
+export declare function mergeEffectiveCoordinatorConfig(repoCoord: RepoMeshDeclarativeCoordinatorConfig | undefined, localCoord: RepoMeshCoordinatorConfig | undefined): RepoMeshCoordinatorConfig;
+/**
+ * Effective operating notes = repo-declared baseline ⊕ runtime ledger notes.
+ * Dedup by trimmed text with the LEDGER note winning (repo duplicates dropped),
+ * so a runtime note's freshest wording/category survives. Order: repo baseline
+ * first, then ledger notes. Returns undefined when nothing usable remains so the
+ * prompt's "## Operating Notes" section is omitted exactly as before.
+ */
+export declare function mergeEffectiveOperatingNotes(repoNotes: CoordinatorOperatingNote[] | undefined, ledgerNotes: CoordinatorOperatingNote[] | undefined): CoordinatorOperatingNote[] | undefined;
+/**
+ * Produce an in-memory effective mesh by layering the repo declarative config
+ * UNDER the machine-local mesh entry (policy + coordinator zones). Returns a new
+ * object; the input mesh and on-disk meshes.json are never mutated. operatingNotes
+ * are merged separately at launch (they ride the prompt context, not the mesh).
+ */
+export declare function applyRepoMeshConfig<T extends Pick<LocalMeshEntry, 'policy' | 'coordinator'>>(mesh: T, repoConfig: RepoMeshDeclarativeConfig | null | undefined): T;
+/**
+ * Build a `.adhdev/mesh.json` DRAFT from a machine-local mesh entry. This is a
+ * scaffold for the operator to review and commit — NOT an automatic migration.
+ * It captures the local policy (fully normalized) plus any coordinator prompt
+ * override/append so a repo can adopt the current machine's settings as the
+ * shared base. Operating notes are intentionally NOT exported: those are runtime
+ * ledger lessons, and a repo should declare baseline notes deliberately.
+ */
+export declare function buildMeshJsonConfigScaffold(mesh: Pick<LocalMeshEntry, 'policy' | 'coordinator'>): RepoMeshDeclarativeConfig;
+/** Serialize a scaffold to the canonical 2-space JSON draft text. */
+export declare function serializeMeshJsonConfigScaffold(config: RepoMeshDeclarativeConfig): string;
+/**
+ * Validate a parsed `.adhdev/mesh.*` document into a MeshJsonConfig (scheduling
+ * overlay). Tolerant of an empty/partial file (an empty object is valid and
+ * yields no overlay); strict about malformed values so a typo surfaces as
+ * `invalid` rather than silently no-op'ing.
+ */
+export declare function validateMeshJsonConfig(raw: unknown, source?: string): {
+    valid: boolean;
+    errors: string[];
+    config?: MeshJsonConfig;
+};
+/**
+ * Locate and load the `.adhdev/mesh.json` scheduling overlay for a repo root.
+ * Declarative only — never executes config. Cached by path + mtime so repeated
+ * scheduler reads are cheap.
+ */
+export declare function loadMeshJsonConfig(repoRoot: string): MeshJsonConfigLoadResult;
+/** Test-only: drop the mtime cache so a per-run temp file is re-read. */
+export declare function __resetMeshJsonConfigCacheForTests(): void;
+/**
+ * The effective scheduling knobs after layering the repo-local `.adhdev/mesh.json`
+ * overlay on top of a stored mesh policy (LOCAL-WINS). This is the single resolution
+ * point the scheduler reads, so the strategy/caps it acts on always reflect the
+ * in-tree override when present and fall back to the persisted policy otherwise.
+ */
+export interface EffectiveMeshScheduling {
+    /** Resolved raw strategy (override distribution → strategy, else stored policy). */
+    strategy: ReturnType<typeof distributionToStrategy> | RepoMeshPolicy['schedulingStrategy'];
+    /** Effective, clamped global write cap. */
+    maxParallelTasks: number;
+    /** Read-only cap multiplier (override, else default 2). */
+    readonlyMultiplier?: number;
+    /** True when an `.adhdev/mesh.json` overlay actually contributed a value. */
+    overrideApplied: boolean;
+}

package/dist/daemon/dev-server.d.ts

@@ -103,8 +103,6 @@ export declare class DevServer implements DevServerContext {
     getLatestScriptVersionDir(scriptsDir: string): string | null;
     private resolveAutoImplWritableProviderDir;
     private handleAutoImplement;
-    private buildAutoImplPrompt;
-    private buildCliAutoImplPrompt;
     private handleAutoImplSSE;
     private handleAutoImplCancel;
     sendAutoImplSSE(msg: {

package/dist/detection/ide-detector.d.ts

@@ -32,4 +32,17 @@ export interface IDEDefinition {
     };
 }
 export declare function registerIDEDefinition(def: IDEDefinition): void;
+/**
+ * Resolve an IDE version on demand (NOT at boot).
+ *
+ * Order of preference, all spawn-free where possible:
+ *  1. win32: read the bundled product.json/package.json next to the exe.
+ *  2. Otherwise spawn `<cli> --version` — but ONLY when the binary is not a
+ *     known GUI executable (the #4 guard), so we never boot an IDE window.
+ *
+ * `win32ProcessNames` is provider.json `processNames.win32` (type → exe names),
+ * used to recognise GUI executables. Callers that have a ProviderLoader can
+ * pass `providerLoader.getWinProcessNames()`.
+ */
+export declare function getIdeVersion(cliCommand: string, win32ProcessNames?: Record<string, string[]>): Promise<string | null>;
 export declare function detectIDEs(providerLoader?: ProviderLoader): Promise<IDEInfo[]>;

package/dist/detection/win32-ide-version.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ADHDev — Windows IDE version detection (execution-free)
+ *
+ * On Windows the resolved "CLI" for a VS Code fork (Cursor, Antigravity, …)
+ * frequently resolves to the GUI Electron executable itself, because the
+ * case-insensitive filesystem matches `...\cursor\cursor.exe` against the
+ * real `Cursor.exe`. Running `<that exe> --version` boots the GUI instead of
+ * printing a version (Electron ignores the unknown flag and opens a window).
+ *
+ * To learn the version WITHOUT spawning anything, we read the bundled
+ * `product.json` / `package.json` that ship next to the executable. VS Code
+ * forks embed their version there. This is a pure filesystem read.
+ *
+ * It also exposes a guard so any remaining `--version` exec path can refuse to
+ * spawn a binary that is a known GUI executable for an IDE provider.
+ */
+/**
+ * Read an IDE version from disk (no process spawn).
+ *
+ * @param exePath Absolute path to the GUI executable (or any path inside the
+ *   IDE install dir — we read the manifest relative to its directory).
+ * @returns The version string, or null if it could not be determined.
+ */
+export declare function readWin32IdeVersionFromDisk(exePath: string): string | null;
+/**
+ * True when `binPath` resolves to a known GUI executable for some IDE.
+ *
+ * Used as a safety net: any code path about to run `<bin> --version` must skip
+ * the spawn when the binary is actually the GUI Electron exe, since that would
+ * launch the IDE window. Comparison is case-insensitive on the basename
+ * (Windows filesystem semantics) against every provider's `processNames.win32`.
+ *
+ * @param binPath Resolved binary path that would be exec'd.
+ * @param win32ProcessNames Map of provider type → list of GUI exe names
+ *   (from provider.json `processNames.win32`, e.g. `["Cursor.exe"]`).
+ */
+export declare function isKnownWin32GuiExe(binPath: string | null | undefined, win32ProcessNames: Record<string, string[]>): boolean;