opencode-swarm 7.179.0 → 7.180.0

package/dist/lang/backends/go.d.ts

@@ -10,6 +10,8 @@
  * `typescript.ts` for the rationale; backend-purity test enforces.
  */
 import type { LanguageBackend } from '../backend';
+/** Avoid spending unbounded time parsing an attacker-controlled source file. */
+export declare const MAX_IMPORT_SOURCE_BYTES: number;
 declare function extractImports(_sourceFile: string, source: string): string[];
 /**
  * Build the Go backend from the registered profile.

package/dist/mutation/engine.d.ts

@@ -95,6 +95,7 @@ export declare const _internals: {
      * `args.executable === 'git'`) keeps working for `git`-flavored callers.
      */
     resolveGitExecutable: typeof resolveGitExecutable;
+    beforeRestoreWrite: () => void;
 };
 export declare function executeMutation(patch: MutationPatch, testCommand: string[], testFiles: string[], workingDir: string, options?: MutationExecutionOptions): Promise<MutationResult>;
 export declare function computeReport(results: MutationResult[], durationMs: number, budgetMs?: number): MutationReport;

package/dist/sdd/effective-spec.d.ts

@@ -47,31 +47,36 @@ export interface SpeckitDetection {
     features: SpeckitFeatureEntry[];
 }
 /**
- * Discriminated union returned by {@link resolveSpeckitProjection} (task 1.4).
+ * Discriminated union returned by {@link resolveSpeckitProjection}.
  *
- * Each kind carries exactly the information the command layer (task 2.2) needs to
+ * Each kind carries exactly the information the command layer needs to
  * produce the correct error message per FR-008, FR-012, FR-013 without re-detecting.
  *
+ * Issue #2501 (Spec-Kit v2): the `ambiguous` kind is GONE — with more than one
+ * detected feature and no `options.feature`, the projector now projects ALL
+ * features into one effective spec with feature-scoped requirement ids
+ * (`<featureId>/FR-###`). Selecting a single feature (explicit `options.feature`)
+ * keeps the v1 single-feature, bare-id output byte-for-byte.
+ *
  * - `not_speckit`      — no `.specify/` marker at the repo root (A-001).
  * - `empty`            — marker present but no `specs/NNN/spec.md` feature dirs (FR-012).
- * - `ambiguous`        — more than one feature and no `options.feature` given (FR-008);
- *                        `features` = sorted feature ids for naming in the error message.
  * - `unknown_feature`  — `options.feature` was given but matches no detected feature.
- * - `zero_requirements`— the selected feature's spec.md yielded zero parsable functional
- *                        requirements (covers unreadable/oversized *input* files too) (FR-013).
+ * - `zero_requirements`— a projected feature's spec.md yielded zero parsable functional
+ *                        requirements (covers unreadable/oversized *input* files too)
+ *                        (FR-013). In multi-feature mode the whole projection refuses —
+ *                        a partially-dropped feature must never project silently.
  * - `too_large`        — requirements parsed, but the projected *output* exceeds the byte
  *                        cap and is refused; `bytes` is the projected size. Distinct from
  *                        zero_requirements so the command layer reports the real reason.
- * - `ok`               — a valid projection was built; `spec` is ready for use, `feature`
- *                        identifies the projected feature dir name.
+ * - `ok`               — a valid projection was built; `spec` is ready for use.
+ *                        `features` lists the projected feature dir names and
+ *                        `namespaced` is true when ids are feature-scoped (multi-feature
+ *                        projection; single-feature output stays bare-id v1 form).
  */
 export type SpeckitResolution = {
     kind: 'not_speckit';
 } | {
     kind: 'empty';
-} | {
-    kind: 'ambiguous';
-    features: string[];
 } | {
     kind: 'unknown_feature';
     feature: string;
@@ -86,7 +91,14 @@ export type SpeckitResolution = {
 } | {
     kind: 'ok';
     spec: EffectiveSpec;
-    feature: string;
+    features: string[];
+    namespaced: boolean;
+    /**
+     * Rendered requirement ids per feature, in projection order (parallel to
+     * `features`). Basis for the check-off ledger's story-index mapping
+     * (#2501 Part B: `[US n]` on a task line maps to the n-th requirement).
+     */
+    featureRequirementIds: string[][];
 };
 /**
  * Detect whether `directory` is a GitHub Spec-Kit project (FR-001, A-001).
@@ -113,10 +125,11 @@ export declare function detectSpeckit(directory: string): SpeckitDetection;
  * re-running detection:
  * - `not_speckit`       — no `.specify/` marker (A-001).
  * - `empty`             — marker present but no feature dirs (FR-012).
- * - `ambiguous`         — multiple features, no `options.feature` (FR-008).
  * - `unknown_feature`   — `options.feature` not among detected features.
  * - `zero_requirements` — feature found but yields zero parsable FRs, or spec.md unreadable
- *                         (FR-013; covers oversized files too).
+ *                         (FR-013; covers oversized *input* files too).
+ * - `too_large`         — requirements parsed, but the projected output exceeds the byte
+ *                         cap (FR-013; `bytes` is the projected size).
  * - `ok`                — valid EffectiveSpec built (FR-002, FR-003, FR-004, FR-005).
  *
  * This function is the single source of truth for feature selection logic.
@@ -126,15 +139,16 @@ export declare function resolveSpeckitProjection(directory: string, options?: {
     feature?: string;
 }): SpeckitResolution;
 /**
- * Project a single Spec-Kit feature into an EffectiveSpec (FR-002, FR-003, FR-004, FR-005).
+ * Project Spec-Kit feature(s) into an EffectiveSpec (FR-002, FR-003, FR-004, FR-005;
+ * #2501 multi-feature).
  *
  * Delegates all selection and build logic to {@link resolveSpeckitProjection} — that function
  * is the single source of truth for feature selection.  This wrapper preserves the existing
  * `EffectiveSpec | null` contract so all call sites (task 2.2, tests) are unchanged.
  *
- * Returns null when resolution is anything other than `ok` (not_speckit, empty, ambiguous,
- * unknown_feature, zero_requirements).  Callers that need the failure reason should call
- * {@link resolveSpeckitProjection} directly.
+ * Returns null when resolution is anything other than `ok` (not_speckit, empty,
+ * unknown_feature, zero_requirements, too_large).  Callers that need the failure reason
+ * should call {@link resolveSpeckitProjection} directly.
  */
 export declare function buildSpeckitProjectionSync(directory: string, options?: {
     feature?: string;
@@ -254,10 +268,9 @@ export declare function writeProjectedSpecSync(directory: string, options?: {
  * - Missing required spec.md sections (`SPECKIT_REQUIRED_SECTIONS`).
  * - `tasks.md` task lines that carry no `[US#]` user-story reference (FR-007).
  *
- * For other resolution kinds (`not_speckit`, `empty`, `ambiguous`,
- * `unknown_feature`, `too_large`) the command layer uses
- * {@link formatSpeckitError} on the returned resolution — same messaging path
- * as task 2.2 (plan.md task 2.3 requirement: no second messaging scheme).
+ * For other resolution kinds (`not_speckit`, `empty`, `unknown_feature`,
+ * `too_large`) the command layer uses {@link formatSpeckitError} on the
+ * returned resolution — same messaging path as the project command.
  */
 export declare function validateSpeckit(directory: string, options?: {
     feature?: string;

package/dist/sdd/speckit-checkoff.d.ts

@@ -0,0 +1,113 @@
+export declare const SPECKIT_CHECKOFF_LEDGER_REL: string;
+/** One captured Spec-Kit task line in the ledger. */
+export interface SpeckitCheckoffTaskEntry {
+    taskId: string;
+    /** Canonical requirement refs (namespaced in multi-feature mode, bare otherwise). */
+    frRefs: string[];
+    /** Trimmed snapshot of the task line at projection time (staleness + locate basis). */
+    lineSnapshot: string;
+    initiallyChecked: boolean;
+    /** ISO timestamp when Swarm checked this task off (absent until then). */
+    swarmCheckedAt?: string;
+}
+/** Per-feature ledger record. */
+export interface SpeckitCheckoffFeatureRecord {
+    featureId: string;
+    /** Posix path of tasks.md relative to the project root. */
+    tasksRelPath: string;
+    /** sha256 over the trimmed task lines at projection time (staleness basis). */
+    taskLinesDigest: string;
+    tasks: SpeckitCheckoffTaskEntry[];
+}
+export interface SpeckitCheckoffLedger {
+    version: 1;
+    namespaced: boolean;
+    projectedAt: string;
+    features: SpeckitCheckoffFeatureRecord[];
+}
+/** Per-feature outcome of one propagation run. */
+export interface SpeckitCheckoffFeatureResult {
+    featureId: string;
+    tasksRelPath: string;
+    checked: string[];
+    reopenedSkipped: string[];
+    stale: boolean;
+    refused: string[];
+}
+export interface SpeckitCheckoffResult {
+    ran: boolean;
+    reason?: string;
+    features: SpeckitCheckoffFeatureResult[];
+    /** True when the completed task matched no ledger task anywhere (reported, not guessed). */
+    unmatched?: boolean;
+}
+declare function sha256(text: string): string;
+declare function readBounded(filePath: string): string | null;
+/** Parse the T### checkbox lines of a tasks.md into task entries (no writes). */
+export declare function parseSpeckitTasksContent(content: string, namespaced: boolean, featureId: string): {
+    tasks: SpeckitCheckoffTaskEntry[];
+    taskLinesDigest: string;
+};
+/**
+ * Build and atomically write the check-off ledger for a successful Spec-Kit
+ * projection. Called from `writeProjectedSpecSync` (both write paths); the
+ * projection write stays authoritative — a ledger failure is logged, never
+ * thrown to the caller.
+ *
+ * Task→requirement mapping basis (#2501): Spec-Kit task lines reference user
+ * STORIES (`[US n]`), not necessarily FR ids. The ledger derives each task's
+ * requirement refs from (a) any explicit FR refs on the line, plus (b) the
+ * story-index mapping: `[US n]` maps to the feature's n-th requirement in
+ * projection order (`featureRequirementIds`, captured at projection time).
+ * Out-of-range story indices map to nothing (the task reports unmatched rather
+ * than guessing).
+ */
+export declare function writeSpeckitCheckoffLedger(root: string, resolution: {
+    features: string[];
+    namespaced: boolean;
+    featureRequirementIds: string[][];
+    spec: {
+        sourcePaths: string[];
+    };
+}): void;
+export interface ApplyCheckoffEditOutcome {
+    applied: boolean;
+    content: string;
+    reason: string;
+}
+export declare function applyCheckoffEdit(taskEntry: SpeckitCheckoffTaskEntry, _baselineContent: string, currentContent: string): ApplyCheckoffEditOutcome;
+/**
+ * Propagate one completed plan task's check-off into the source tasks.md files.
+ *
+ * `completed.frRefs` are the task's requirement refs (plan `fr_refs`); refs are
+ * also mined from `completed.text` (descriptions often carry the natural ids).
+ * Never throws for expected refusal paths; structural I/O failures throw only
+ * from the atomic-write core and are caught by {@link
+ * maybePropagateSpeckitCheckoff}.
+ */
+export declare function propagateSpeckitCheckoff(directory: string, completed: {
+    taskId: string;
+    frRefs: string[];
+    text: string;
+}, options: {
+    enabled: boolean;
+}): Promise<SpeckitCheckoffResult>;
+/**
+ * Fail-open wrapper for the plan-manager wiring: loads the plugin config,
+ * no-ops unless `speckit_checkoff.enabled`, and never lets a check-off failure
+ * propagate into the task-status update (AGENTS.md #5/#9 — bookkeeping is
+ * advisory to the durable plan write).
+ */
+export declare function maybePropagateSpeckitCheckoff(directory: string, completed: {
+    taskId: string;
+    frRefs: string[];
+    text: string;
+}): Promise<void>;
+/** DI seam for tests/checks (repo convention: restore in afterEach). */
+export declare const _internals: {
+    applyCheckoffEdit: typeof applyCheckoffEdit;
+    parseSpeckitTasksContent: typeof parseSpeckitTasksContent;
+    readBounded: typeof readBounded;
+    sha256: typeof sha256;
+};
+export {};

package/dist/session/hydration-ownership.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Project-owned, generation-fenced hydration state (issue #2667).
+ *
+ * The live maps on `swarmState` are process-resident and keyed by sessionID;
+ * hydration is a per-PROJECT operation. This module owns the per-project
+ * registries that scope a hydration's blast radius to the project that
+ * initiated it and fence stale generations from publishing over newer state:
+ *
+ * - `projectHydrationGenerations` — monotonic counter per canonical project
+ *   key, bumped ONLY when a hydration is initiated (`beginHydrationScope`).
+ *   Session creation NEVER bumps it; new sessions stamp `current + 1` so a
+ *   session created while generation `g` is latest survives any later apply
+ *   at `g`.
+ * - `rehydrationCaches` — the plan/evidence rehydration cache, keyed per
+ *   project (replaces the former process-singleton `_rehydrationCache`).
+ * - `hydratedAggregateKeys` — the toolAggregates keys each project's last
+ *   hydration published, so a re-hydration replaces only its own keys.
+ *
+ * Fence rule: a hydration whose scope generation `g` satisfies
+ * `projectHydrationGenerations[K] > g` is REJECTED before any mutation —
+ * some newer hydration began for that project. Stamp rule: an accepted
+ * hydration at `g` evicts only sessions owned by `K` with
+ * `hydrationStamp <= g`.
+ *
+ * All maps are bounded (FIFO) with an explicit reset path
+ * (`clearHydrationOwnershipState`, called by `resetSwarmState`) per
+ * AGENTS.md invariant 8.
+ */
+/** Upper bound for tracked per-project registries (matches MAX_READY_ROOTS). */
+export declare const MAX_TRACKED_PROJECTS = 32;
+/** Upper bound for the raw-spelling → canonical-key memo. */
+export declare const MAX_DIRECTORY_KEY_MEMO = 64;
+/** Opaque cache payload owned by state.ts; opaque here by design. */
+export type ProjectRehydrationCache = unknown;
+/** Fence token captured when a hydration is initiated; see beginHydrationScope. */
+export interface HydrationScope {
+    projectKey: string;
+    generation: number;
+}
+/**
+ * Resolve the canonical project key for a directory spelling through a
+ * module-owned bounded memo: exactly ONE realpath-equivalent resolution per
+ * distinct spelling per process; every later call is a pure Map hit.
+ *
+ * The memo is keyed by `canonicalRootKeyLexical` (the shared filesystem-free
+ * lexical alias key, per the path-identity ratchet — raw resolved paths must
+ * not key project maps) so distinct spellings memoize independently while
+ * lexically-identical spellings share one entry — whose canonical resolution
+ * is identical anyway.
+ *
+ * `canonicalProjectKey` itself is intentionally NOT memoized (it calls
+ * `canonicalRootKeyFresh`, bypassing the shared `canonicalRootMemo`), which
+ * is why this memo exists — `beginHydrationScope`/`startAgentSession` sit on
+ * the plugin-init and chat.message hot paths. A symlink retargeted
+ * mid-process yields a second key: fail-safe isolation (separate ownership
+ * buckets), never corruption. `canonicalProjectKey` never throws (lexical
+ * `path.resolve` fallback on realpath failure) — that fallback is accepted.
+ */
+export declare function hydrationProjectKey(directory: string): string;
+/**
+ * Begin a hydration scope: bump the project's generation counter and return
+ * the fence token. The token must be captured when the hydration is
+ * INITIATED (e.g. at `loadSnapshot` entry) and carried into
+ * `rehydrateState`, which refuses to apply it once any newer generation has
+ * begun.
+ */
+export declare function beginHydrationScope(directory: string): HydrationScope;
+/** Latest initiated hydration generation for a project (0 when never). */
+export declare function currentHydrationGeneration(projectKey: string): number;
+/**
+ * Stamp value for a session created NOW under `projectKey`:
+ * `current + 1`, i.e. newer than any already-initiated hydration, so an
+ * in-flight or late apply at the current generation can never evict it.
+ */
+export declare function nextSessionHydrationStamp(projectKey: string): number;
+export declare function getRehydrationCache(projectKey: string): ProjectRehydrationCache | undefined;
+export declare function setRehydrationCache(projectKey: string, cache: ProjectRehydrationCache): void;
+/** Record the aggregate keys a project's hydration published (replace set). */
+export declare function recordHydratedAggregateKeys(projectKey: string, keys: Set<string>): void;
+/** The aggregate keys the project's last hydration published (empty if none). */
+export declare function hydratedAggregateKeysFor(projectKey: string): Set<string>;
+/** Reset every registry (invariant 8: bounded state with an explicit reset). */
+export declare function clearHydrationOwnershipState(): void;

package/dist/session/snapshot-coordination-init.d.ts

@@ -1,4 +1,5 @@
 /** Post-resolution SQLite snapshot import/readiness lifecycle (#2481). */
+import { type HydrationScope } from './hydration-ownership.js';
 import type { SnapshotData } from './snapshot-writer.js';
 type ReadinessState = 'running' | 'succeeded' | 'failed' | 'timed_out' | 'closing';
 interface ReadinessEntry {
@@ -41,7 +42,7 @@ export declare function closeSnapshotCoordinationInitialization(directory: strin
 export declare function markSnapshotCoordinationClosing(directory: string): void;
 export declare const _snapshotCoordinationInternals: {
     entries: Map<string, ReadinessEntry>;
-    initialize: (directory: string) => Promise<void>;
+    initialize: (directory: string, scope?: HydrationScope) => Promise<void>;
     renameLegacySnapshot: (from: string, to: string) => void;
     writeProjection: (directory: string, snapshot: SnapshotData) => Promise<void>;
     timeoutMs: number;

package/dist/session/snapshot-reader.d.ts

@@ -3,6 +3,7 @@
  * Reads .swarm/session/state.json and rehydrates swarmState on plugin init.
  */
 import type { AgentSessionState } from '../state';
+import { type HydrationScope } from './hydration-ownership.js';
 import type { SerializedAgentSession, SnapshotData } from './snapshot-writer';
 /**
  * Transient session fields that must be reset on rehydration.
@@ -33,7 +34,19 @@ export declare function readSnapshot(directory: string): Promise<SnapshotData |
 export declare function readSnapshotFileStrict(directory: string, relativePath: string): Promise<SnapshotData>;
 /**
  * Rehydrate swarmState from a SnapshotData object.
- * Clears existing maps first, then populates from snapshot.
+ *
+ * Issue #2667 — project-owned and generation-fenced:
+ * - With a `directory`, this replaces ONLY the state owned by that project
+ *   (sessions whose `owningProjectKey` matches and whose `hydrationStamp` is
+ *   at or below the applying generation). Other projects' live state — and
+ *   this project's sessions created after the hydration began — survive.
+ * - With an explicit `scope` captured at initiation, the apply is refused
+ *   outright (zero mutation) once any NEWER hydration has begun for the
+ *   project, so a late/timed-out callback cannot publish over newer state.
+ * - WITHOUT a `directory`, the legacy process-global clear-all semantics are
+ *   preserved verbatim (direct-test path only; every production caller passes
+ *   a directory).
+ *
  * Does NOT touch activeToolCalls or pendingEvents (remain at defaults).
  *
  * activeAgent and delegationChains are restored only for session IDs that are
@@ -41,16 +54,21 @@ export declare function readSnapshotFileStrict(directory: string, relativePath:
  * eviction existed can carry far more activeAgent entries than agentSessions
  * (sessions were evicted but their satellite entries never were); restoring
  * those wholesale would resurrect the ghosts into memory and re-serialize them
- * into every subsequent snapshot forever. Rehydration runs at plugin init,
- * before any turn is in flight; a session that resumes afterwards gets its
- * entry re-established by chat.message (delegation-tracker), and until then
- * tool-path readers fall back to ORCHESTRATOR_NAME — the same treatment a
- * fresh process gives an unknown session.
+ * into every subsequent snapshot forever.
  */
-export declare function rehydrateState(snapshot: SnapshotData, directory?: string): Promise<void>;
+export interface RehydrateOutcome {
+    applied: boolean;
+    reason?: 'superseded';
+}
+export declare function rehydrateState(snapshot: SnapshotData, directory?: string, scope?: HydrationScope): Promise<RehydrateOutcome>;
 /**
  * Load snapshot from disk and rehydrate swarmState.
  * Called on plugin init to restore state from previous session.
  * NEVER throws - swallows any errors silently.
+ *
+ * Issue #2667: a hydration scope is captured at entry so the eventual
+ * rehydrateState apply is generation-fenced — a loadSnapshot whose 5 s init
+ * timeout (src/index.ts) abandoned the await is refused once any newer
+ * hydration for the same project has begun.
  */
 export declare function loadSnapshot(directory: string): Promise<void>;

package/dist/state.d.ts

@@ -448,6 +448,30 @@ export interface AgentSessionState {
     lastProviderRecoveryFingerprint?: string;
     /** Timestamp when session was rehydrated from snapshot (0 if never rehydrated) */
     sessionRehydratedAt: number;
+    /**
+     * Canonical project key that owns this session's live state. Written ONLY
+     * by `startAgentSession` (from its `directory` argument) and by
+     * `rehydrateState` (from the HYDRATING directory). A hydration for project
+     * K evicts only sessions whose `owningProjectKey` is K.
+     *
+     * DELIBERATELY NOT SNAPSHOTTED: `serializeAgentSession` is field-explicit
+     * so this never round-trips. Ownership is defined by which project's
+     * plugin instance created/restored the session, never by snapshot bytes —
+     * a snapshot is per-project on disk, so the hydrating directory is the
+     * only trustworthy attribution source. `undefined` = unowned (created
+     * without a directory): such sessions survive every hydration — fail-open
+     * toward preservation.
+     */
+    owningProjectKey?: string;
+    /**
+     * Hydration generation this session was created/restored AT.
+     * `startAgentSession` stamps `currentGeneration + 1` (newer than any
+     * in-flight hydration); `rehydrateState` stamps its applying generation.
+     * A hydration at generation `g` evicts only owned sessions with
+     * `hydrationStamp <= g`, so live sessions created after `g` began always
+     * survive. Also never snapshotted.
+     */
+    hydrationStamp?: number;
     /** Pattern type to detection count mapping */
     prmPatternCounts: Map<string, number>;
     /** Current escalation level (0=none, 1=guidance, 2=strong guidance, 3=hard stop) */
@@ -1357,9 +1381,15 @@ export declare function buildRehydrationCache(directory: string): Promise<void>;
  * Merge rules:
  *   - evidence-derived state: only applied if it advances past existing state
  *   - plan-only derived state: only applied if it advances past existing state
- * No-op when the cache has not been built yet.
+ * No-op when no cache exists for the session's project.
+ *
+ * Issue #2667: the cache is project-owned. `projectKey` wins when given;
+ * otherwise it resolves from `session.owningProjectKey`. New callers must
+ * ensure ownership is stamped on the session (or pass the key explicitly)
+ * BEFORE calling — a session with no project context intentionally gets no
+ * cache application rather than another project's data.
  */
-export declare function applyRehydrationCache(session: AgentSessionState): void;
+export declare function applyRehydrationCache(session: AgentSessionState, projectKey?: string): void;
 /**
  * Rehydrates session workflow state from durable swarm files.
  * Builds (or refreshes) the rehydration cache from disk, then applies it

package/dist/test-impact/analyzer.d.ts

@@ -1,4 +1,20 @@
 import { validateProjectRoot } from '../evidence/manager.js';
+/**
+ * Impact analysis is advisory and must never turn a caller's request into an
+ * unbounded workspace scan. These limits are deliberately larger than the
+ * 50-file execution cap: a normal repository may have more test files than a
+ * single invocation may safely execute, but a pathological repository must
+ * still fail closed before it consumes unbounded memory or CPU.
+ */
+export declare const MAX_IMPACT_TEST_FILES = 4096;
+export declare const MAX_IMPACT_TEST_FILE_BYTES: number;
+export declare const MAX_IMPACT_GO_MOD_BYTES: number;
+export declare const MAX_IMPACT_SCAN_BYTES: number;
+export declare const MAX_IMPACT_WALK_ENTRIES = 100000;
+export declare const MAX_IMPACT_SCAN_DEPTH = 32;
+export declare const MAX_IMPACT_CACHE_BYTES: number;
+export declare const MAX_IMPACT_MAP_SOURCES = 10000;
+export declare const MAX_IMPACT_MAP_REFERENCES = 100000;
 export interface TestImpactResult {
     impactedTests: string[];
     unrelatedTests: string[];
@@ -6,9 +22,24 @@ export interface TestImpactResult {
     impactMap: Record<string, string[]>;
     budgetExceeded?: boolean;
 }
+export type ImpactCacheStatus = 'fresh' | 'missing' | 'corrupt' | 'legacy' | 'stale' | 'rebuilt_missing' | 'rebuilt_corrupt' | 'rebuilt_legacy' | 'rebuilt_stale' | 'overflow' | 'overflow_unverified' | 'missing_unverified' | 'corrupt_unverified' | 'legacy_unverified' | 'fresh_unverified';
+export interface ImpactCacheInspection {
+    status: ImpactCacheStatus;
+    cachePath: string;
+}
+interface TestFileIdentity {
+    path: string;
+    size: number;
+    mtimeMs: number;
+    digest: string;
+}
 declare function normalizePath(p: string): string;
-declare function isCacheStale(impactMap: Record<string, string[]>, generatedAtMs: number): boolean;
+declare function isCacheStale(impactMap: Record<string, string[]>, generatedAtMs: number, testFiles?: TestFileIdentity[], cwd?: string): boolean;
 declare function resolveRelativeImport(fromDir: string, importPath: string): string | null;
+declare function findGoModule(fromDir: string): {
+    moduleRoot: string;
+    modulePath: string;
+} | null;
 /**
  * Test-only: clear the go-module memoization cache. Production code
  * should never need this — the cache is per-call-graph scoped, but tests
@@ -17,7 +48,10 @@ declare function resolveRelativeImport(fromDir: string, importPath: string): str
 declare function _clearGoModuleCache(): void;
 declare function findTestFilesSync(cwd: string): string[];
 declare function extractImports(content: string): string[];
-declare function buildImpactMapInternal(cwd: string): Promise<Record<string, string[]>>;
+declare function buildImpactMapInternal(cwd: string, testFilesOverride?: string[]): Promise<Record<string, string[]>>;
+export declare function getImpactCacheStatus(cwd: string, options?: {
+    verify?: boolean;
+}): ImpactCacheInspection;
 export declare const _internals: {
     validateProjectRoot: typeof validateProjectRoot;
     normalizePath: typeof normalizePath;
@@ -25,11 +59,14 @@ export declare const _internals: {
     resolveRelativeImport: typeof resolveRelativeImport;
     findTestFilesSync: typeof findTestFilesSync;
     extractImports: typeof extractImports;
+    findGoModule: typeof findGoModule;
     buildImpactMapInternal: typeof buildImpactMapInternal;
     buildImpactMap: typeof buildImpactMap;
     loadImpactMap: typeof loadImpactMap;
+    loadImpactMapWithStatus: typeof loadImpactMapWithStatus;
     saveImpactMap: typeof saveImpactMap;
     analyzeImpact: typeof analyzeImpact;
+    getImpactCacheStatus: typeof getImpactCacheStatus;
     _clearGoModuleCache: typeof _clearGoModuleCache;
 };
 export declare function buildImpactMap(cwd: string): Promise<Record<string, string[]>>;
@@ -38,7 +75,12 @@ export interface LoadImpactMapOptions {
      *  Use for estimation-only reads where slight staleness is acceptable. */
     skipRebuild?: boolean;
 }
+export interface ImpactMapLoadResult {
+    map: Record<string, string[]>;
+    status: ImpactCacheStatus;
+}
+export declare function loadImpactMapWithStatus(cwd: string, options?: LoadImpactMapOptions): Promise<ImpactMapLoadResult>;
 export declare function loadImpactMap(cwd: string, options?: LoadImpactMapOptions): Promise<Record<string, string[]>>;
-declare function saveImpactMap(cwd: string, impactMap: Record<string, string[]>): Promise<void>;
-export declare function analyzeImpact(changedFiles: string[], cwd: string, budget?: number): Promise<TestImpactResult>;
+declare function saveImpactMap(cwd: string, impactMap: Record<string, string[]>, testFiles?: string[]): Promise<void>;
+export declare function analyzeImpact(changedFiles: string[], cwd: string, budget?: number, impactMapOverride?: Record<string, string[]>): Promise<TestImpactResult>;
 export {};

package/dist/test-impact/constants.d.ts

@@ -0,0 +1,4 @@
+/** Shared cap for any tool that executes a resolved test-file selection. */
+export declare const MAX_SAFE_TEST_FILES = 50;
+/** Version marker for the rebuildable impact-cache envelope. */
+export declare const IMPACT_CACHE_VERSION = 2;

package/dist/tools/mutation-test.d.ts

@@ -1,8 +1,14 @@
-import { analyzeImpact } from '../test-impact/analyzer.js';
+import * as path from 'node:path';
 import { createSwarmTool } from './create-tool';
-export declare const mutation_test: ReturnType<typeof createSwarmTool>;
+declare function normalizeWorkspaceFile(value: unknown, cwd: string, requireExisting: boolean): {
+    value: string;
+    absolute: string;
+} | {
+    error: string;
+};
 export declare const _internals: {
-    mutationInternals: {
-        analyzeImpact: typeof analyzeImpact;
-    };
+    pathRelative: typeof path.relative;
+    normalizeWorkspaceFile: typeof normalizeWorkspaceFile;
 };
+export declare const mutation_test: ReturnType<typeof createSwarmTool>;
+export {};