opencode-swarm 7.5.1 → 7.5.2

package/dist/lang/detector.d.ts

@@ -6,6 +6,10 @@
  * No tool logic — pure detection only.
  */
 import { type LanguageProfile } from './profiles.js';
+export declare const _internals: {
+    getProfileForFile: typeof getProfileForFile;
+    detectProjectLanguages: typeof detectProjectLanguages;
+};
 /**
  * Resolve a language profile from a file path based on its extension.
  * Returns undefined for files with no extension or unknown extensions.

package/dist/lang/index.d.ts

@@ -1,4 +1,5 @@
-export * from './detector';
+export { _internals as detectorInternals, detectProjectLanguages, getProfileForFile, } from './detector';
 export * from './profiles';
-export * from './registry';
+export type { LanguageDefinition } from './registry';
+export { _internals as registryInternals, getLanguageForExtension, getParserForFile, isSupportedFile, languageDefinitions, listSupportedLanguages, } from './registry';
 export * from './runtime';

package/dist/lang/registry.d.ts

@@ -1,4 +1,10 @@
 import { type Parser } from './runtime';
+export declare const _internals: {
+    getLanguageForExtension: typeof getLanguageForExtension;
+    listSupportedLanguages: typeof listSupportedLanguages;
+    getParserForFile: typeof getParserForFile;
+    isSupportedFile: typeof isSupportedFile;
+};
 export interface LanguageDefinition {
     id: string;
     extensions: string[];

package/dist/mutation/engine.d.ts

@@ -42,6 +42,11 @@ export interface MutationReport {
     timestamp: string;
 }
 export declare const MAX_MUTATIONS_PER_FUNCTION = 10;
+export declare const _internals: {
+    executeMutation: typeof executeMutation;
+    computeReport: typeof computeReport;
+    executeMutationSuite: typeof executeMutationSuite;
+};
 export declare function executeMutation(patch: MutationPatch, testCommand: string[], _testFiles: string[], workingDir: string): Promise<MutationResult>;
 export declare function computeReport(results: MutationResult[], durationMs: number, budgetMs?: number): MutationReport;
 export declare function executeMutationSuite(patches: MutationPatch[], testCommand: string[], testFiles: string[], workingDir: string, budgetMs?: number, onProgress?: (completed: number, total: number, result: MutationResult) => void, sourceFiles?: Map<string, string>): Promise<MutationReport>;

package/dist/mutation/equivalence.d.ts

@@ -19,6 +19,11 @@ export type LLMJudgeCallback = (original: string, mutated: string, context: stri
  * trailing whitespace, and blank lines. Returns true if the stripped versions are identical.
  */
 export declare function isStaticallyEquivalent(originalCode: string, mutatedCode: string): boolean;
+export declare const _internals: {
+    isStaticallyEquivalent: typeof isStaticallyEquivalent;
+    checkEquivalence: typeof checkEquivalence;
+    batchCheckEquivalence: typeof batchCheckEquivalence;
+};
 /**
  * Check a single mutant for equivalence using two-stage approach.
  * Stage 1: static analysis. Stage 2: LLM judge (if provided and Stage 1 didn't determine equivalence).

package/dist/mutation/gate.d.ts

@@ -15,6 +15,11 @@ export interface MutationGateResult {
     /** Prompt for targeted test improvement (non-empty when verdict is 'warn' or 'fail') */
     testImprovementPrompt: string;
 }
+export declare const _internals: {
+    evaluateMutationGate: typeof evaluateMutationGate;
+    buildTestImprovementPrompt: typeof buildTestImprovementPrompt;
+    buildMessage: typeof buildMessage;
+};
 /** Default thresholds */
 export declare const PASS_THRESHOLD = 0.8;
 export declare const WARN_THRESHOLD = 0.6;
@@ -26,3 +31,6 @@ export declare const WARN_THRESHOLD = 0.6;
  * @returns MutationGateResult with verdict and details
  */
 export declare function evaluateMutationGate(report: MutationReport, passThreshold?: number, warnThreshold?: number): MutationGateResult;
+declare function buildTestImprovementPrompt(report: MutationReport, passThreshold: number, verdict: MutationGateVerdict): string;
+declare function buildMessage(verdict: MutationGateVerdict, adjustedKillRate: number, killed: number, totalMutants: number, equivalent: number, warnThreshold: number): string;
+export {};

package/dist/parallel/file-locks.d.ts

@@ -1,3 +1,18 @@
+/**
+ * Test-only dependency-injection seam. Tests replace the function on this
+ * object so they can inject mock behaviour without touching the real
+ * `proper-lockfile` module — `mock.module` from `bun:test` leaks across
+ * files in Bun's shared test-runner process, which would corrupt
+ * unrelated suites. Mutating this local object is file-scoped and
+ * trivially restorable via `afterEach`.
+ *
+ * NOTE: Production code does NOT call through this seam internally.
+ * `_internals` exists solely to allow test code to intercept lock
+ * acquisition without patching the real implementation.
+ */
+export declare const _internals: {
+    tryAcquireLock: typeof tryAcquireLock;
+};
 export interface FileLock {
     filePath: string;
     agent: string;

package/dist/plan/checkpoint.d.ts

@@ -23,3 +23,7 @@ export interface ImportCheckpointResult {
  * @returns ImportCheckpointResult indicating success or failure with error message
  */
 export declare function importCheckpoint(directory: string, source?: string): Promise<ImportCheckpointResult>;
+export declare const _internals: {
+    writeCheckpoint: typeof writeCheckpoint;
+    importCheckpoint: typeof importCheckpoint;
+};

package/dist/plan/ledger.d.ts

@@ -65,6 +65,14 @@ export interface SnapshotEventPayload {
 export declare class LedgerStaleWriterError extends Error {
     constructor(message: string);
 }
+/**
+ * Get the path to the ledger file
+ */
+declare function getLedgerPath(directory: string): string;
+/**
+ * Get the path to plan.json
+ */
+declare function getPlanJsonPath(directory: string): string;
 /**
  * Compute a SHA-256 hash of the plan state.
  * Uses deterministic JSON serialization for consistent hashing.
@@ -207,6 +215,15 @@ interface ReplayOptions {
  * @returns Reconstructed Plan from ledger events, or null if plan.json doesn't exist or ledger is empty
  */
 export declare function replayFromLedger(directory: string, _options?: ReplayOptions): Promise<Plan | null>;
+/**
+ * Apply a single ledger event to the plan state.
+ * Returns null if the event indicates a full reset (plan_reset).
+ *
+ * @param plan - Current plan state
+ * @param event - Event to apply
+ * @returns Updated plan state, or null if plan should be reset
+ */
+declare function applyEventToPlan(plan: Plan, event: LedgerEvent): Plan | null;
 /**
  * Result type for readLedgerEventsWithIntegrity
  */
@@ -283,4 +300,23 @@ export interface ApprovedSnapshotInfo {
  * @returns The most recent approved snapshot info, or null if none exists
  */
 export declare function loadLastApprovedPlan(directory: string, expectedPlanId?: string): Promise<ApprovedSnapshotInfo | null>;
+export declare const _internals: {
+    computePlanHash: typeof computePlanHash;
+    computeCurrentPlanHash: typeof computeCurrentPlanHash;
+    ledgerExists: typeof ledgerExists;
+    getLatestLedgerSeq: typeof getLatestLedgerSeq;
+    readLedgerEvents: typeof readLedgerEvents;
+    initLedger: typeof initLedger;
+    appendLedgerEvent: typeof appendLedgerEvent;
+    appendLedgerEventWithRetry: typeof appendLedgerEventWithRetry;
+    takeSnapshotEvent: typeof takeSnapshotEvent;
+    replayFromLedger: typeof replayFromLedger;
+    applyEventToPlan: typeof applyEventToPlan;
+    readLedgerEventsWithIntegrity: typeof readLedgerEventsWithIntegrity;
+    quarantineLedgerSuffix: typeof quarantineLedgerSuffix;
+    replayWithIntegrity: typeof replayWithIntegrity;
+    loadLastApprovedPlan: typeof loadLastApprovedPlan;
+    getLedgerPath: typeof getLedgerPath;
+    getPlanJsonPath: typeof getPlanJsonPath;
+};
 export {};

package/dist/plan/manager.d.ts

@@ -10,6 +10,19 @@ import { type Plan, type RuntimePlan, type TaskStatus } from '../config/plan-sch
 import { type LedgerEvent, type LedgerEventInput } from './ledger';
 /** Reset the startup ledger check flag. For testing only. */
 export declare function resetStartupLedgerCheck(): void;
+/**
+ * Test-only dependency-injection seam. Production code calls
+ * `_internals.loadPlan(...)`, `_internals.loadPlanJsonOnly(...)`, etc. so tests
+ * can replace the functions on this object without touching the real module —
+ * `mock.module` from `bun:test` leaks across files in Bun's shared test-runner
+ * process, which would corrupt unrelated suites. Mutating this local object is
+ * file-scoped and trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    loadPlan: typeof loadPlan;
+    loadPlanJsonOnly: typeof loadPlanJsonOnly;
+    regeneratePlanMarkdown: typeof regeneratePlanMarkdown;
+};
 /**
  * Append a ledger event with exponential-backoff retry on stale-writer conflicts.
  *

package/dist/sast/rules/index.d.ts

@@ -40,6 +40,15 @@ export interface SastFinding {
     remediation?: string;
     excerpt?: string;
 }
+export declare const _internals: {
+    getAllRules: typeof getAllRules;
+    getRulesForLanguage: typeof getRulesForLanguage;
+    getRuleById: typeof getRuleById;
+    findPatternMatches: typeof findPatternMatches;
+    executeRulesSync: typeof executeRulesSync;
+    executeRules: typeof executeRules;
+    getRuleStats: typeof getRuleStats;
+};
 /**
  * Get all registered rules
  */
@@ -52,6 +61,10 @@ export declare function getRulesForLanguage(language: string): SastRule[];
  * Get rule by ID
  */
 export declare function getRuleById(id: string): SastRule | undefined;
+/**
+ * Parse source code and extract matches for a given pattern
+ */
+declare function findPatternMatches(content: string, pattern: RegExp): SastMatch[];
 /**
  * Execute rules synchronously (pattern matching only)
  * This is the primary execution method for offline SAST
@@ -70,3 +83,4 @@ export declare function getRuleStats(): {
     bySeverity: Record<string, number>;
     byLanguage: Record<string, number>;
 };
+export {};

package/dist/sast/semgrep.d.ts

@@ -33,6 +33,14 @@ export interface SemgrepResult {
     /** Engine label for the findings */
     engine: 'tier_a' | 'tier_a+tier_b';
 }
+export declare const _internals: {
+    isSemgrepAvailable: typeof isSemgrepAvailable;
+    checkSemgrepAvailable: typeof checkSemgrepAvailable;
+    resetSemgrepCache: typeof resetSemgrepCache;
+    runSemgrep: typeof runSemgrep;
+    getRulesDirectory: typeof getRulesDirectory;
+    hasBundledRules: typeof hasBundledRules;
+};
 /**
  * Check if Semgrep CLI is available on the system
  * Uses caching to avoid shelling out on every check

package/dist/services/evidence-summary-service.d.ts

@@ -4,7 +4,14 @@
  * Provides deterministic evidence aggregation per task and phase.
  * Produces machine-readable and human-readable summary artifacts.
  */
-import type { PhaseStatus, TaskStatus } from '../config/plan-schema';
+import type { Evidence, EvidenceBundle } from '../config/evidence-schema';
+import type { Phase, PhaseStatus, Task, TaskStatus } from '../config/plan-schema';
+/**
+ * Safely normalize evidence bundle entries to a valid array.
+ * Handles null, undefined, non-array, and invalid entry objects.
+ * Returns only valid entries with required fields.
+ */
+declare function normalizeBundleEntries(bundle: EvidenceBundle | null | undefined): Evidence[];
 /** Evidence types required for task completion */
 export declare const REQUIRED_EVIDENCE_TYPES: readonly ["review", "test"];
 export type RequiredEvidenceType = (typeof REQUIRED_EVIDENCE_TYPES)[number];
@@ -56,6 +63,33 @@ export interface EvidenceSummaryArtifact {
     overallBlockers: PhaseBlocker[];
     summaryText: string;
 }
+/**
+ * Get task status from plan or infer from evidence
+ */
+declare function getTaskStatus(task: Task | undefined, bundle: EvidenceBundle | null): TaskStatus;
+/**
+ * Check if evidence meets completion criteria for a task
+ */
+declare function isEvidenceComplete(bundle: EvidenceBundle | null): {
+    isComplete: boolean;
+    missingEvidence: string[];
+};
+/**
+ * Generate blockers for a task based on evidence and status
+ */
+declare function getTaskBlockers(task: Task | undefined, summary: ReturnType<typeof isEvidenceComplete>, status: TaskStatus): string[];
+/**
+ * Build evidence summary for a single task
+ */
+declare function buildTaskSummary(directory: string, task: Task | undefined, taskId: string): Promise<TaskEvidenceSummary>;
+/**
+ * Build evidence summary for a single phase
+ */
+declare function buildPhaseSummary(directory: string, phase: Phase): Promise<PhaseEvidenceSummary>;
+/**
+ * Generate human-readable summary text
+ */
+declare function generateSummaryText(artifact: EvidenceSummaryArtifact): string;
 /**
  * Build complete evidence summary artifact
  *
@@ -73,3 +107,19 @@ export declare function isAutoSummaryEnabled(automationConfig?: {
     };
     mode?: string;
 }): boolean;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    buildEvidenceSummary: typeof buildEvidenceSummary;
+    isAutoSummaryEnabled: typeof isAutoSummaryEnabled;
+    normalizeBundleEntries: typeof normalizeBundleEntries;
+    getTaskStatus: typeof getTaskStatus;
+    isEvidenceComplete: typeof isEvidenceComplete;
+    getTaskBlockers: typeof getTaskBlockers;
+    buildTaskSummary: typeof buildTaskSummary;
+    buildPhaseSummary: typeof buildPhaseSummary;
+    generateSummaryText: typeof generateSummaryText;
+};
+export {};

package/dist/services/handoff-service.d.ts

@@ -4,6 +4,33 @@
  * Provides structured handoff data for agent transitions between swarm sessions.
  * Reads from .swarm files to gather current state for context-efficient handoffs.
  */
+import { loadPlanJsonOnly } from '../plan/manager';
+/**
+ * Escape HTML special characters to prevent XSS attacks
+ */
+declare function escapeHtml(str: string): string;
+/**
+ * Sanitize string by removing RTL override characters and truncating to max length
+ */
+declare function sanitizeString(str: string | null | undefined, maxLength: number): string;
+/**
+ * Validated plan type
+ */
+interface ValidPlan {
+    phases: Array<{
+        id: number;
+        name: string;
+        tasks: Array<{
+            id: string;
+            status: string;
+        }>;
+    }>;
+    current_phase: number | null;
+}
+/**
+ * Validate that plan.phases is a proper array with valid phase objects
+ */
+declare function validatePlanPhases(plan: unknown): plan is ValidPlan;
 /**
  * Pending QA state from agent sessions
  */
@@ -56,6 +83,30 @@ export interface HandoffData {
         locked: boolean;
     } | null;
 }
+/**
+ * Extract current phase and task from plan
+ */
+declare function extractCurrentPhaseFromPlan(plan: Awaited<ReturnType<typeof loadPlanJsonOnly>>): {
+    currentPhase: string | null;
+    currentTask: string | null;
+    incompleteTasks: string[];
+};
+/**
+ * Parse session state JSON
+ */
+declare function parseSessionState(content: string | null): {
+    activeAgent: string | null;
+    delegationState: DelegationState | null;
+    pendingQA: PendingQA | null;
+} | null;
+/**
+ * Extract decisions from context.md content
+ */
+declare function extractDecisions(content: string | null): string[];
+/**
+ * Extract last 5 lines of Phase Metrics section from context.md
+ */
+declare function extractPhaseMetrics(content: string | null): string;
 /**
  * Get handoff data from the swarm directory.
  * Reads session state, plan, and context to build comprehensive handoff info.
@@ -72,3 +123,20 @@ export declare function formatHandoffMarkdown(data: HandoffData): string;
  * resumption instructions. Designed to be copy-pasted into a new session.
  */
 export declare function formatContinuationPrompt(data: HandoffData): string;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    getHandoffData: typeof getHandoffData;
+    formatHandoffMarkdown: typeof formatHandoffMarkdown;
+    formatContinuationPrompt: typeof formatContinuationPrompt;
+    escapeHtml: typeof escapeHtml;
+    sanitizeString: typeof sanitizeString;
+    validatePlanPhases: typeof validatePlanPhases;
+    extractCurrentPhaseFromPlan: typeof extractCurrentPhaseFromPlan;
+    parseSessionState: typeof parseSessionState;
+    extractDecisions: typeof extractDecisions;
+    extractPhaseMetrics: typeof extractPhaseMetrics;
+};
+export {};

package/dist/services/preflight-service.d.ts

@@ -48,6 +48,52 @@ export interface PreflightConfig {
     /** Linter to use (default 'biome') */
     linter?: 'biome' | 'eslint';
 }
+/**
+ * Validate directory path to prevent path traversal attacks.
+ * Returns the normalized absolute path if valid, or throws an error.
+ */
+declare function validateDirectoryPath(dir: string): string;
+/**
+ * Validate and sanitize timeout value.
+ * Returns a valid timeout within bounds, or throws an error for invalid values.
+ */
+declare function validateTimeout(timeoutMs: number | undefined, defaultValue: number): number;
+/**
+ * Get package.json version from directory
+ */
+declare function getPackageVersion(dir: string): string | null;
+/**
+ * Get version from CHANGELOG.md (latest version header)
+ */
+declare function getChangelogVersion(dir: string): string | null;
+/**
+ * Get version from version file (e.g., VERSION.txt, version.txt)
+ */
+declare function getVersionFileVersion(dir: string): string | null;
+/**
+ * Run version consistency check
+ */
+declare function runVersionCheck(dir: string, _timeoutMs: number): Promise<PreflightCheckResult>;
+/**
+ * Run lint check
+ */
+declare function runLintCheck(dir: string, linter: 'biome' | 'eslint', timeoutMs: number): Promise<PreflightCheckResult>;
+/**
+ * Run tests check
+ */
+declare function runTestsCheck(_dir: string, scope: 'all' | 'convention' | 'graph', timeoutMs: number): Promise<PreflightCheckResult>;
+/**
+ * Run secrets check
+ */
+declare function runSecretsCheck(dir: string, timeoutMs: number): Promise<PreflightCheckResult>;
+/**
+ * Run evidence completeness check
+ */
+declare function runEvidenceCheck(dir: string): Promise<PreflightCheckResult>;
+/**
+ * Run requirement coverage check
+ */
+declare function runRequirementCoverageCheck(dir: string, currentPhase: number): Promise<PreflightCheckResult>;
 /**
  * Run all preflight checks
  */
@@ -60,3 +106,24 @@ export declare function formatPreflightMarkdown(report: PreflightReport): string
  * Handle preflight command - thin adapter for CLI
  */
 export declare function handlePreflightCommand(directory: string, _args: string[]): Promise<string>;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    runPreflight: typeof runPreflight;
+    formatPreflightMarkdown: typeof formatPreflightMarkdown;
+    handlePreflightCommand: typeof handlePreflightCommand;
+    validateDirectoryPath: typeof validateDirectoryPath;
+    validateTimeout: typeof validateTimeout;
+    getPackageVersion: typeof getPackageVersion;
+    getChangelogVersion: typeof getChangelogVersion;
+    getVersionFileVersion: typeof getVersionFileVersion;
+    runVersionCheck: typeof runVersionCheck;
+    runLintCheck: typeof runLintCheck;
+    runTestsCheck: typeof runTestsCheck;
+    runSecretsCheck: typeof runSecretsCheck;
+    runEvidenceCheck: typeof runEvidenceCheck;
+    runRequirementCoverageCheck: typeof runRequirementCoverageCheck;
+};
+export {};

package/dist/services/run-memory.d.ts

@@ -57,6 +57,14 @@ export declare function getTaskHistory(directory: string, taskId: string): Promi
  * @returns Array of fail/retry entries
  */
 export declare function getFailures(directory: string): Promise<RunMemoryEntry[]>;
+/**
+ * Group entries by taskId
+ */
+declare function groupByTaskId(entries: RunMemoryEntry[]): Map<string, RunMemoryEntry[]>;
+/**
+ * Build a summary line for a single task
+ */
+declare function summarizeTask(taskId: string, entries: RunMemoryEntry[]): string | null;
 /**
  * Generate a compact summary of task failures for context injection
  *
@@ -64,3 +72,17 @@ export declare function getFailures(directory: string): Promise<RunMemoryEntry[]
  * @returns Formatted summary string (≤500 tokens) or null if no failures
  */
 export declare function getRunMemorySummary(directory: string): Promise<string | null>;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    generateTaskFingerprint: typeof generateTaskFingerprint;
+    recordOutcome: typeof recordOutcome;
+    getTaskHistory: typeof getTaskHistory;
+    getFailures: typeof getFailures;
+    getRunMemorySummary: typeof getRunMemorySummary;
+    groupByTaskId: typeof groupByTaskId;
+    summarizeTask: typeof summarizeTask;
+};
+export {};

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

@@ -113,3 +113,12 @@ export declare function createSnapshotWriterHook(directory: string): (input: unk
  * are persisted before returning.
  */
 export declare function flushPendingSnapshot(directory: string): Promise<void>;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    writeSnapshot: typeof writeSnapshot;
+    createSnapshotWriterHook: typeof createSnapshotWriterHook;
+    flushPendingSnapshot: typeof flushPendingSnapshot;
+};

package/dist/state.d.ts

@@ -506,3 +506,29 @@ export declare function hasActiveFullAuto(sessionID?: string): boolean;
 export declare function setSessionEnvironment(sessionId: string, profile: EnvironmentProfile): void;
 export declare function getSessionEnvironment(sessionId: string): EnvironmentProfile | undefined;
 export declare function ensureSessionEnvironment(sessionId: string): EnvironmentProfile;
+/**
+ * Test-only dependency-injection seam. Production code calls
+ * `_internals.*` for key exported functions and objects so tests can replace
+ * them without using `mock.module` — `mock.module` from `bun:test` leaks
+ * across files in Bun's shared test-runner process, which would corrupt
+ * unrelated test suites. Mutating this local object is file-scoped and
+ * trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    swarmState: typeof swarmState;
+    resetSwarmState: typeof resetSwarmState;
+    ensureAgentSession: typeof ensureAgentSession;
+    startAgentSession: typeof startAgentSession;
+    getAgentSession: typeof getAgentSession;
+    beginInvocation: typeof beginInvocation;
+    getActiveWindow: typeof getActiveWindow;
+    advanceTaskState: typeof advanceTaskState;
+    getTaskState: typeof getTaskState;
+    hasActiveFullAuto: typeof hasActiveFullAuto;
+    hasActiveTurboMode: typeof hasActiveTurboMode;
+    buildRehydrationCache: typeof buildRehydrationCache;
+    applyRehydrationCache: typeof applyRehydrationCache;
+    rehydrateSessionFromDisk: typeof rehydrateSessionFromDisk;
+    isCouncilGateActive: typeof isCouncilGateActive;
+    defaultRunContext: typeof defaultRunContext;
+};

package/dist/telemetry.d.ts

@@ -57,3 +57,15 @@ export declare const telemetry: {
     prmEscalationTriggered(sessionId: string, pattern: string, level: number, occurrenceCount: number): void;
     prmHardStop(sessionId: string, pattern: string, level: number, occurrenceCount: number): void;
 };
+/**
+ * Test-only dependency-injection seam. Production code calls
+ * `_internals.telemetry` and `_internals.emit` so tests can replace the
+ * underlying implementations without using `mock.module` — `mock.module` from
+ * `bun:test` leaks across files in Bun's shared test-runner process, which
+ * would corrupt unrelated test suites. Mutating this local object is
+ * file-scoped and trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    telemetry: typeof telemetry;
+    emit: typeof emit;
+};

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

@@ -4,6 +4,26 @@ export interface TestImpactResult {
     untestedFiles: string[];
     impactMap: Record<string, string[]>;
 }
+declare function normalizePath(p: string): string;
+declare function isCacheStale(impactMap: Record<string, string[]>, generatedAtMs: number): boolean;
+declare function resolveRelativeImport(fromDir: string, importPath: string): string | null;
+declare function findTestFilesSync(cwd: string): string[];
+declare function extractImports(content: string): string[];
+declare function buildImpactMapInternal(cwd: string): Promise<Record<string, string[]>>;
+export declare const _internals: {
+    normalizePath: typeof normalizePath;
+    isCacheStale: typeof isCacheStale;
+    resolveRelativeImport: typeof resolveRelativeImport;
+    findTestFilesSync: typeof findTestFilesSync;
+    extractImports: typeof extractImports;
+    buildImpactMapInternal: typeof buildImpactMapInternal;
+    buildImpactMap: typeof buildImpactMap;
+    loadImpactMap: typeof loadImpactMap;
+    saveImpactMap: typeof saveImpactMap;
+    analyzeImpact: typeof analyzeImpact;
+};
 export declare function buildImpactMap(cwd: string): Promise<Record<string, string[]>>;
 export declare function loadImpactMap(cwd: string): Promise<Record<string, string[]>>;
+declare function saveImpactMap(cwd: string, impactMap: Record<string, string[]>): Promise<void>;
 export declare function analyzeImpact(changedFiles: string[], cwd: string): Promise<TestImpactResult>;
+export {};

package/dist/tools/co-change-analyzer.d.ts

@@ -43,3 +43,15 @@ export declare function darkMatterToKnowledgeEntries(pairs: CoChangeEntry[], pro
  */
 export declare function formatDarkMatterOutput(pairs: CoChangeEntry[]): string;
 export declare const co_change_analyzer: ReturnType<typeof tool>;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    parseGitLog: typeof parseGitLog;
+    buildCoChangeMatrix: typeof buildCoChangeMatrix;
+    getStaticEdges: typeof getStaticEdges;
+    detectDarkMatter: typeof detectDarkMatter;
+    darkMatterToKnowledgeEntries: typeof darkMatterToKnowledgeEntries;
+    formatDarkMatterOutput: typeof formatDarkMatterOutput;
+};

package/dist/tools/knowledge-recall.d.ts

@@ -1,2 +1,9 @@
 import { createSwarmTool } from './create-tool.js';
 export declare const knowledge_recall: ReturnType<typeof createSwarmTool>;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    knowledge_recall: typeof knowledge_recall;
+};

package/dist/tools/lint.d.ts

@@ -61,3 +61,13 @@ export declare function runLint(linter: SupportedLinter, mode: 'fix' | 'check',
  */
 export declare function runAdditionalLint(linter: AdditionalLinter, mode: 'fix' | 'check', cwd: string): Promise<LintResult>;
 export declare const lint: ReturnType<typeof tool>;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    detectAvailableLinter: typeof detectAvailableLinter;
+    runLint: typeof runLint;
+    detectAdditionalLinter: typeof detectAdditionalLinter;
+    runAdditionalLint: typeof runAdditionalLint;
+};

package/dist/tools/quality-budget.d.ts

@@ -24,3 +24,10 @@ export interface QualityBudgetResult {
  */
 export declare function qualityBudget(input: QualityBudgetInput, directory: string): Promise<QualityBudgetResult>;
 export declare const quality_budget: ReturnType<typeof tool>;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    qualityBudget: typeof qualityBudget;
+};

package/dist/tools/sast-baseline.d.ts

@@ -124,3 +124,13 @@ export declare function captureOrMergeBaseline(directory: string, phase: number,
  * Returns 'invalid_schema' when the file is present but unparseable.
  */
 export declare function loadBaseline(directory: string, phase: number): LoadBaselineResult;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    fingerprintFinding: typeof fingerprintFinding;
+    assignOccurrenceIndices: typeof assignOccurrenceIndices;
+    captureOrMergeBaseline: typeof captureOrMergeBaseline;
+    loadBaseline: typeof loadBaseline;
+};