@adhdev/daemon-core 0.9.82-rc.39 → 0.9.82-rc.391

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/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;

package/dist/git/change-impact-config.d.ts

@@ -0,0 +1,159 @@
+/**
+ * "Change Impact" — config-driven classification of which git changes between the
+ * live daemon's build commit and the workspace HEAD actually require a daemon
+ * rebuild/restart (vs. a web-only redeploy, vs. nothing).
+ *
+ * The daemon-core git surface only knows the FACTS (which files / packages changed
+ * between buildCommit..HEAD). The POLICY — which packages are daemon-runtime, which
+ * are web-only, which root files are non-runtime, and what command to recommend —
+ * is declarative config injected from outside. This keeps git-status.ts repo-agnostic
+ * while preserving ADHDev's exact built-in behavior when no config is present.
+ *
+ * SECURITY: config is declarative only. JSON/YAML are parsed; arbitrary JS config
+ * (.js) is intentionally NOT supported, so loading a config can never execute code.
+ */
+/** A change-impact classification bucket. */
+export type ChangeImpactKind = 'daemon' | 'web' | 'none';
+/**
+ * Recommended action for a given impact classification. `recommendedAction` is the
+ * stable classification key (always one of daemon|web|none, NOT config-overridable);
+ * config customizes only the human-facing `recommendedCommand` recipe.
+ */
+export interface ChangeImpactTarget {
+    /** Human-facing command/recipe to act on the impact (e.g. deploy + restart). */
+    recommendedCommand: string;
+}
+export interface ChangeImpactConfig {
+    /**
+     * Package names (the `<name>` in `packages/<name>/`) whose change means the
+     * daemon runtime is stale and must be rebuilt/redeployed + restarted. When
+     * provided, this REPLACES the built-in daemon-runtime set.
+     */
+    daemonRuntimePackages?: string[];
+    /**
+     * Package names that are web-only — a change to one does not require a daemon
+     * restart, only a web redeploy. When provided, this REPLACES the built-in
+     * web-only set.
+     */
+    webOnlyPackages?: string[];
+    /**
+     * Glob patterns for root-level (non-package) files that demonstrably cannot
+     * change what the daemon runtime executes (markers, docs, license text). These
+     * are added on top of the built-in non-runtime root-file detection.
+     */
+    nonRuntimeRootFilePatterns?: string[];
+    /** Recommended action/command per impact classification. Missing keys fall back to built-in defaults. */
+    impactTargets?: Partial<Record<ChangeImpactKind, ChangeImpactTarget>>;
+}
+export interface ChangeImpactConfigLoadResult {
+    config?: ChangeImpactConfig;
+    source: string;
+    sourceType: 'repo_file' | 'unavailable' | 'invalid';
+    path?: string;
+    error?: string;
+    /**
+     * Stable identity of the config SOURCE, used as part of a cache key so a config
+     * edit invalidates any cached impact evaluation. Combines the resolved path and
+     * its mtime (or the path for the unavailable/invalid case).
+     */
+    sourceKey: string;
+}
+export declare const CHANGE_IMPACT_CONFIG_LOCATIONS: string[];
+export declare const CHANGE_IMPACT_CONFIG_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "ADHDev Change Impact Config";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly daemonRuntimePackages: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+        readonly webOnlyPackages: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+        readonly nonRuntimeRootFilePatterns: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+        readonly impactTargets: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly daemon: {
+                    readonly $ref: "#/$defs/target";
+                };
+                readonly web: {
+                    readonly $ref: "#/$defs/target";
+                };
+                readonly none: {
+                    readonly $ref: "#/$defs/target";
+                };
+            };
+        };
+    };
+    readonly $defs: {
+        readonly target: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["recommendedCommand"];
+            readonly properties: {
+                readonly recommendedCommand: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
+    };
+};
+export declare function validateChangeImpactConfig(raw: unknown, source?: string): {
+    valid: boolean;
+    errors: string[];
+    config?: ChangeImpactConfig;
+};
+/**
+ * Locate and load the Change Impact config for a repo root. Declarative only —
+ * never executes config. Returns a sourceKey suitable for cache invalidation:
+ * config path + mtime, or the sentinel for the missing/invalid case.
+ */
+export declare function loadChangeImpactConfig(repoRoot: string): ChangeImpactConfigLoadResult;
+/**
+ * Translate a config glob pattern into a RegExp matched against a forward-slash
+ * file path. Supports `**` (any path segments), `*` (any chars except `/`), and
+ * `?` (single non-slash char). No brace/character-class expansion — declarative,
+ * minimal, predictable. All other characters are matched literally.
+ */
+export declare function globToRegExp(pattern: string): RegExp;
+export interface ChangeImpactConfigSuggestion {
+    /** A non-executable, declarative config draft a human can save verbatim. */
+    suggestedConfig: ChangeImpactConfig;
+    /** Per-field human-facing rationale for the proposed classification. */
+    notes: string[];
+    /** Package directories discovered under `packages/` (and `oss/packages/`). */
+    discoveredPackages: {
+        daemon: string[];
+        web: string[];
+        unclassified: string[];
+    };
+}
+/**
+ * Inspect a repo's package layout and propose a reasonable, declarative Change
+ * Impact config draft. This is heuristic scaffold ONLY — it never executes
+ * anything and the draft must be reviewed/saved by a human before it takes
+ * effect. The heuristic mirrors ADHDev's own conventions:
+ *   - `web-*` / `*-web` packages → web-only (web redeploy, no daemon restart)
+ *   - everything else under packages/ → daemon-runtime (rebuild + restart)
+ *   - docs/license/marker root files → non-runtime
+ * Callers are expected to prune the draft to their actual runtime topology.
+ */
+export declare function suggestChangeImpactConfig(repoRoot: string): ChangeImpactConfigSuggestion;

package/dist/git/git-commands.d.ts

@@ -23,8 +23,12 @@ export interface GitLogResult extends GitRepoIdentity {
     lastCheckedAt: number;
 }
 export interface GitCheckpointResult extends GitRepoIdentity {
-    commit: string;
+    commit?: string;
     message: string;
+    status?: 'created' | 'skipped';
+    skipped?: boolean;
+    noop?: boolean;
+    reason?: 'nothing_to_commit';
     lastCheckedAt: number;
 }
 export interface GitStashPushResult extends GitRepoIdentity {
@@ -43,15 +47,19 @@ export interface GitCommandServices {
     getStatus?: (params: {
         workspace: string;
         refreshUpstream?: boolean;
+        includeSubmodules?: boolean;
+        submoduleIgnorePaths?: string[];
     }) => Promise<GitRepoStatus> | GitRepoStatus;
     getDiffSummary?: (params: {
         workspace: string;
         staged?: boolean;
+        base?: string;
     }) => Promise<GitDiffSummary> | GitDiffSummary;
     getDiffFile?: (params: {
         workspace: string;
         path: string;
         staged?: boolean;
+        base?: string;
     }) => Promise<GitFileDiff> | GitFileDiff;
     createSnapshot?: (params: {
         workspace: string;
@@ -113,6 +121,8 @@ type GitCommandFailure = {
 type GitCommandSuccess = {
     success: true;
     status: GitRepoStatus;
+    reporterPlatform?: string;
+    reporterArch?: string;
 } | {
     success: true;
     diffSummary: GitDiffSummary;

package/dist/git/git-diff.d.ts

@@ -3,6 +3,12 @@ export interface GitDiffOptions {
     timeoutMs?: number;
     maxFiles?: number;
     maxBytes?: number;
+    /**
+     * When set, diff `<baseRef>...HEAD` (merge-base range — "what this branch
+     * adds on top of base") instead of the working tree. Staged/untracked
+     * sections do not apply in this mode.
+     */
+    baseRef?: string;
 }
 export interface GitFileDiffResult {
     workspace: string;

package/dist/git/git-executor.d.ts

@@ -1,4 +1,15 @@
 import type { GitFailureReason, GitRepoIdentity } from './git-types.js';
+/**
+ * Timeout for status-collection git commands (status/log/submodule/stash/fetch).
+ * The default 5s is fine for porcelain status, but on Windows the `git` subprocess
+ * spawn itself is pathologically slow (measured: `submodule status` ~3.5s, cold
+ * `log -1` ~4.2s) and overlaps with refreshUpstream fetches — a single command
+ * routinely exceeds 5s, which previously collapsed the whole status to all-null and
+ * dropped the node from the mesh graph. Give the collection path a much larger
+ * budget so a slow-but-healthy repo never reads as "not a git repo". Windows gets a
+ * larger budget than POSIX because the spawn cost is OS-specific, not repo-specific.
+ */
+export declare const GIT_STATUS_TIMEOUT_MS: number;
 export interface GitExecutorOptions {
     timeoutMs?: number;
     maxBuffer?: number;

package/dist/git/git-status.d.ts

@@ -1,4 +1,10 @@
 import type { GitRepoStatus } from './git-types.js';
+import { type DaemonBuildInfo } from '../build-info.js';
+import { type ChangeImpactConfig } from './change-impact-config.js';
+/** Test seam: clear the last-known-good status cache between cases. */
+export declare function __resetGitStatusCacheForTests(): void;
+/** Test-only introspection: number of memoized Change Impact evaluations. */
+export declare function __changeImpactEvalCacheSizeForTests(): number;
 export interface GitStatusOptions {
     timeoutMs?: number;
     /** When true, include submodule status in the result. Defaults to true. */
@@ -10,6 +16,23 @@ export interface GitStatusOptions {
      * Callers should opt into this only for convergence-critical surfaces.
      */
     refreshUpstream?: boolean;
+    /**
+     * Test/override seam for the daemon build stamp used by the stale-build
+     * detector. Production callers omit this so the real baked-in build commit
+     * (getDaemonBuildInfo) is used.
+     */
+    daemonBuildInfo?: DaemonBuildInfo;
+    /**
+     * Change Impact policy override. When provided, the daemonBuildBehind
+     * classifier uses this declarative config instead of auto-loading the repo's
+     * `.adhdev/change-impact.*` file. When omitted, getGitRepoStatus auto-loads the
+     * repo config (cached); when neither is present the built-in ADHDev default
+     * policy applies, preserving the legacy behavior exactly.
+     *
+     * Pass `null` to force the built-in default policy and skip auto-loading (used
+     * to assert legacy parity in tests).
+     */
+    changeImpactConfig?: ChangeImpactConfig | null;
 }
 export declare function getGitRepoStatus(workspace: string, options?: GitStatusOptions): Promise<GitRepoStatus>;
 interface ParsedPorcelainStatus {

package/dist/git/git-types.d.ts

@@ -5,56 +5,8 @@
  * transports, and web-core. Git state is daemon-owned product truth; do not
  * infer these values from agent transcripts in frontend code.
  */
-export type GitFailureReason = 'not_git_repo' | 'git_not_installed' | 'timeout' | 'path_outside_repo' | 'dirty_index_required' | 'conflict' | 'invalid_args' | 'nothing_to_commit' | 'git_command_failed';
-export interface GitRepoIdentity {
-    workspace: string;
-    repoRoot: string | null;
-    isGitRepo: boolean;
-}
-export interface GitSubmoduleStatus {
-    /** Submodule path relative to repo root */
-    path: string;
-    /** Current commit SHA the submodule is at */
-    commit: string;
-    /** Path to the submodule repo (absolute) */
-    repoPath: string;
-    /** Whether the submodule has uncommitted changes */
-    dirty: boolean;
-    /** Whether the submodule commit differs from what the parent repo expects */
-    outOfSync: boolean;
-    /** Last checked timestamp */
-    lastCheckedAt: number;
-    /** Error message if submodule status could not be read */
-    error?: string;
-}
-export type GitUpstreamFreshness = 'fresh' | 'unchecked' | 'stale' | 'no_upstream' | 'unavailable';
-export interface GitRepoStatus extends GitRepoIdentity {
-    branch: string | null;
-    headCommit: string | null;
-    headMessage: string | null;
-    upstream: string | null;
-    /** Whether ahead/behind was verified against a freshly fetched upstream ref. */
-    upstreamStatus: GitUpstreamFreshness;
-    /** Timestamp for the fetch that refreshed upstream refs when upstreamStatus === 'fresh'. */
-    upstreamFetchedAt?: number;
-    /** Error from the last refresh attempt when upstreamStatus === 'stale'. */
-    upstreamFetchError?: string;
-    ahead: number;
-    behind: number;
-    staged: number;
-    modified: number;
-    untracked: number;
-    deleted: number;
-    renamed: number;
-    hasConflicts: boolean;
-    conflictFiles: string[];
-    stashCount: number;
-    lastCheckedAt: number;
-    /** Submodule statuses when auto-discover is enabled */
-    submodules?: GitSubmoduleStatus[];
-    error?: string;
-    reason?: GitFailureReason;
-}
+export type { GitFailureReason, GitRepoIdentity, GitSubmoduleStatus, GitUpstreamFreshness, GitRepoStatus, DaemonBuildBehind, } from '@adhdev/mesh-shared';
+import type { GitRepoIdentity, GitRepoStatus, GitFailureReason, GitUpstreamFreshness } from '@adhdev/mesh-shared';
 export type GitFileChangeStatus = 'added' | 'modified' | 'deleted' | 'renamed' | 'copied' | 'untracked' | 'conflict';
 export interface GitFileChange {
     path: string;

package/dist/git/git-worktree.d.ts

@@ -75,3 +75,25 @@ export declare function listWorktrees(repoRoot: string): Promise<WorktreeEntry[]
  * Parse `git worktree list --porcelain` output into structured entries.
  */
 export declare function parseWorktreeListOutput(output: string): WorktreeEntry[];
+export interface BranchRefDeleteResult {
+    /** True if the branch ref no longer exists after this call. */
+    deleted: boolean;
+    /** Why it was (not) deleted, for surfacing in the cleanup result. */
+    reason: string;
+    /** True when a forced delete (`-D`) was needed (e.g. squash/patch-equivalent merge). */
+    forced?: boolean;
+}
+/**
+ * Delete a local branch ref after its worktree was removed.
+ *
+ * SAFETY: this is only meant to be called once the caller has independently
+ * verified that the branch is fully merged / its content is contained in the
+ * default ref (no work loss). It first tries the safe `git branch -d`, which
+ * refuses to delete a branch git itself does not consider merged. If
+ * `safeDeleteOnly` is false (the caller proved containment by patch-equivalence,
+ * which `-d` cannot see), it falls back to `git branch -D`. When the branch is
+ * already gone, this reports `deleted: true` idempotently.
+ */
+export declare function deleteBranchRef(repoRoot: string, branch: string, opts?: {
+    safeDeleteOnly?: boolean;
+}): Promise<BranchRefDeleteResult>;

package/dist/git/index.d.ts

@@ -3,6 +3,8 @@ export { GitCommandError, isPathInside, normalizeGitOutput, resolveGitRepository
 export type { GitCommandResult as GitExecutorCommandResult, GitExecutorOptions, RunGitOptions } from './git-executor.js';
 export { getGitRepoStatus, parsePorcelainV2Status } from './git-status.js';
 export type { GitStatusOptions } from './git-status.js';
+export { CHANGE_IMPACT_CONFIG_LOCATIONS, CHANGE_IMPACT_CONFIG_SCHEMA, globToRegExp, loadChangeImpactConfig, suggestChangeImpactConfig, validateChangeImpactConfig, } from './change-impact-config.js';
+export type { ChangeImpactConfig, ChangeImpactConfigLoadResult, ChangeImpactConfigSuggestion, ChangeImpactKind, ChangeImpactTarget, } from './change-impact-config.js';
 export { getGitDiffSummary, getGitFileDiff } from './git-diff.js';
 export type { GitDiffOptions, GitFileDiffResult } from './git-diff.js';
 export { createGitCompactSummary, summarizeGitStatus } from './git-summary.js';