opencode-swarm 7.126.2 → 7.126.4

package/dist/tools/repo-graph/builder.d.ts

@@ -16,12 +16,13 @@ import { extractFileOntology } from './ontology';
 import { safeRealpathSync } from './safe-realpath';
 import type { BuildWorkspaceGraphOptions, GraphEdge, GraphNode, RepoGraph, RepoGraphDiagnostics, SymbolEdge } from './types';
 /**
- * _internals DI seam for safeRealpathSync.
- * Defaults to the real implementation. Tests can override this to inject
- * mock behavior without calling mock.module(...) which leaks across test files
- * in Bun's shared test-runner process.
+ * _internals DI seam for the walk clock and graph helpers.
+ * Defaults to the real implementations. Tests can override these to inject
+ * deterministic behavior without calling mock.module(...) which leaks across
+ * test files in Bun's shared test-runner process.
  */
 export declare const _internals: {
+    now: () => number;
     safeRealpathSync: typeof safeRealpathSync;
     extractTSSymbols: typeof extractTSSymbols;
     extractPythonSymbols: typeof extractPythonSymbols;

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

@@ -1,4 +1,7 @@
+import * as fs from 'node:fs';
 import type { tool } from '@opencode-ai/plugin';
+import { isCommandAvailable } from '../build/discovery';
+import { analyzeImpact, loadImpactMap } from '../test-impact/analyzer.js';
 import { getAllHistory, type TestRunRecord } from '../test-impact/history-store.js';
 export declare const MAX_OUTPUT_BYTES = 512000;
 export declare const MAX_COMMAND_LENGTH = 500;
@@ -41,6 +44,7 @@ export interface ParsedTestCaseResult {
     errorMessage?: string;
     stackPrefix?: string;
 }
+declare const AGGREGATE_TEST_NAME = "(aggregate)";
 export interface TestSuccessResult {
     success: true;
     framework: TestFramework;
@@ -147,7 +151,13 @@ export declare function runTests(framework: TestFramework, scope: 'all' | 'conve
 declare function selectHistoryForAnalysis(history: ReturnType<typeof getAllHistory>): TestRunRecord[];
 export declare const test_runner: ReturnType<typeof tool>;
 export declare const _internals: {
-    readonly selectHistoryForAnalysis: typeof selectHistoryForAnalysis;
-    readonly AGGREGATE_TEST_NAME: "(aggregate)";
+    analyzeImpact: typeof analyzeImpact;
+    loadImpactMap: typeof loadImpactMap;
+    isCommandAvailable: typeof isCommandAvailable;
+    existsSync: typeof fs.existsSync;
+    readdirSync: typeof fs.readdirSync;
+    readFileSync: typeof fs.readFileSync;
+    selectHistoryForAnalysis: typeof selectHistoryForAnalysis;
+    AGGREGATE_TEST_NAME: typeof AGGREGATE_TEST_NAME;
 };
 export {};

package/dist/utils/path-security.d.ts

@@ -1,3 +1,4 @@
+import * as fs from 'node:fs';
 /**
  * Canonical path security utilities.
  * Consolidated from 6+ local implementations across the codebase.
@@ -78,6 +79,7 @@ export declare function validateTargetWithinRoot(filePath: string, root: string)
  * Internal calls should use _internals.fn() instead of fn() directly.
  */
 export declare const _internals: {
+    realpathSync: typeof fs.realpathSync;
     containsPathTraversal: typeof containsPathTraversal;
     containsControlChars: typeof containsControlChars;
     validateDirectory: typeof validateDirectory;

package/dist/utils/timeout.d.ts

@@ -1,9 +1,10 @@
 /**
  * Timeout primitives used by the plugin init path.
  *
- * Hard rule: every timer scheduled here must call `unref()` so it never holds
- * the process open, and every Promise.race must clear the timer in `finally`
- * so it does not leak the timer reference after the racer settles.
+ * Deadline timers must call `unref()` and every Promise.race must clear its
+ * timer in `finally`, so timeouts never pin or leak a process handle. Awaited
+ * cooperative-yield timers are deliberately ref'ed: unref'ing the only handle
+ * can strand their caller before the awaited promise resolves.
  */
 /**
  * Race a promise against a timeout. The timer is cleared in `finally` so the
@@ -18,6 +19,9 @@
 export declare function withTimeout<T>(promise: Promise<T>, ms: number, timeoutError: Error): Promise<T>;
 /**
  * Yield to the macrotask queue. Works under both Node and Bun runtimes,
- * unlike `setImmediate` which is Node-only.
+ * unlike `setImmediate` which is Node-only. The timer intentionally remains
+ * ref'ed: callers await this promise, so unref'ing its only handle can strand a
+ * direct async caller when no unrelated host handle is active. Detached startup
+ * work is made non-pinning at its outer scheduling boundary instead.
  */
 export declare function yieldToEventLoop(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.126.2",
+	"version": "7.126.4",
 	"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",