opencode-swarm 7.179.0 → 7.179.1

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

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

@@ -4,7 +4,7 @@ import { resolveLocalNodeTool } from '../build/command-resolution';
 import { isCommandAvailable } from '../build/discovery';
 import type { NativeTestTarget, TestScope } from '../lang/backend';
 import { buildNativeTargetCommand } from '../lang/default-backend';
-import { analyzeImpact, loadImpactMap } from '../test-impact/analyzer.js';
+import { analyzeImpact, getImpactCacheStatus, type ImpactCacheStatus, loadImpactMap, loadImpactMapWithStatus } from '../test-impact/analyzer.js';
 import { getAllHistory, type TestRunRecord } from '../test-impact/history-store.js';
 import { bunSpawn } from '../utils/bun-compat';
 export declare const MAX_OUTPUT_BYTES = 512000;
@@ -12,6 +12,10 @@ export declare const MAX_COMMAND_LENGTH = 500;
 export declare const DEFAULT_TIMEOUT_MS = 60000;
 export declare const MAX_TIMEOUT_MS = 300000;
 export declare const MAX_SAFE_TEST_FILES = 50;
+export declare const MAX_SAFE_SOURCE_FILES = 1;
+export declare const MAX_RAW_FILE_ENTRIES = 512;
+export declare const MAX_FILE_PATH_LENGTH = 4096;
+export declare const MAX_GRAPH_FILE_BYTES: number;
 /**
  * Estimate the fan-out (number of unique test files) for given source files
  * by reading the cached impact map without spawning a subprocess.
@@ -22,6 +26,7 @@ export declare const MAX_SAFE_TEST_FILES = 50;
  */
 export declare function estimateFanOut(sourceFiles: string[], cwd: string): Promise<{
     estimatedCount: number;
+    status: 'advisory' | 'unavailable';
 }>;
 export declare const SUPPORTED_FRAMEWORKS: readonly ["bun", "vitest", "jest", "mocha", "pytest", "cargo", "pester", "go-test", "maven", "gradle", "dotnet-test", "ctest", "swift-test", "dart-test", "rspec", "minitest", "pest", "phpunit", "php-artisan"];
 export type TestFramework = (typeof SUPPORTED_FRAMEWORKS)[number] | 'none';
@@ -35,12 +40,11 @@ export interface TestRunnerArgs {
     bail?: boolean;
 }
 export type RegressionOutcome = 'pass' | 'skip' | 'no_impacted_tests' | 'regression' | 'scope_exceeded' | 'error';
-/** Binding cap decision reported on every discovery-scope test_runner response. */
+/** Binding cap decision reported on every discovery-scope response. */
 export interface CapDecision {
     decision: 'within_cap' | 'cap_exceeded';
     resolved_test_count: number;
     limit: number;
-    source_file_count?: number;
 }
 export interface TestTotals {
     passed: number;
@@ -70,11 +74,9 @@ export interface TestSuccessResult {
     testCases?: ParsedTestCaseResult[];
     message?: string;
     outcome?: RegressionOutcome;
-    /** Post-resolution deduplicated test-file set (discovery scopes only). */
+    resolution?: TestResolution;
     resolved_test_files?: string[];
-    /** Binding cap decision — the post-resolution count, never an estimate. */
     cap_decision?: CapDecision;
-    /** Non-empty exactly when resolution fell back to a narrower discovery scope. */
     fallback_reason?: string;
 }
 export interface TestErrorResult {
@@ -92,11 +94,35 @@ export interface TestErrorResult {
     message?: string;
     outcome?: RegressionOutcome;
     attempted_scope?: 'graph';
+    resolution?: TestResolution;
     resolved_test_files?: string[];
     cap_decision?: CapDecision;
     fallback_reason?: string;
 }
 export type TestResult = TestSuccessResult | TestErrorResult;
+export interface TestResolution {
+    requestedScope: TestScope;
+    effectiveScope: TestScope;
+    sourceFiles: string[];
+    /**
+     * Normalized test files. Execute decisions are always capped at `cap`;
+     * scope-exceeded decisions may retain one `cap + 1` sentinel for evidence.
+     */
+    resolvedFiles: string[];
+    cap: number;
+    decision: 'execute' | 'scope_exceeded' | 'skip';
+    /** Structured fan-out estimate; the scalar fields below are compatibility aliases. */
+    estimate: {
+        count: number;
+        status: 'advisory' | 'unavailable' | 'not_run';
+    };
+    /** Backward-compatible aliases for consumers that predate the structured estimate. */
+    estimateCount: number;
+    estimateStatus: 'advisory' | 'unavailable' | 'not_run';
+    cacheStatus?: ImpactCacheStatus;
+    fallbackReason: string | null;
+    evaluable: boolean;
+}
 /**
  * Phase 3 dispatch path: detect the test framework via the
  * `LanguageBackend` registry from `src/lang/dispatch.ts`. Currently
@@ -175,6 +201,8 @@ export declare const test_runner: ReturnType<typeof tool>;
 export declare const _internals: {
     analyzeImpact: typeof analyzeImpact;
     loadImpactMap: typeof loadImpactMap;
+    loadImpactMapWithStatus: typeof loadImpactMapWithStatus;
+    getImpactCacheStatus: typeof getImpactCacheStatus;
     isCommandAvailable: typeof isCommandAvailable;
     existsSync: typeof fs.existsSync;
     readdirSync: typeof fs.readdirSync;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.179.0",
+	"version": "7.179.1",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",