opencode-swarm 7.15.0 → 7.17.0

package/dist/lang/backend.d.ts

@@ -0,0 +1,199 @@
+/**
+ * LanguageBackend — behavior-bearing extension of LanguageProfile.
+ *
+ * `LanguageProfile` (in `./profiles.ts`) is a passive data record: it
+ * declares which build commands, test frameworks, linters etc. exist for a
+ * language, but does not know how to run them. A `LanguageBackend` adds
+ * optional behavior hooks. Every hook has a registry-driven default in
+ * `./default-backend.ts`, so a backend that overrides nothing still works.
+ *
+ * Invariant boundaries (per AGENTS.md):
+ *   - Backends NEVER spawn subprocesses. They return command-arrays only.
+ *     The single spawn site stays in `src/tools/test-runner.ts` (and the
+ *     existing helpers in `src/build/discovery.ts:isCommandAvailable`),
+ *     each of which already satisfies invariant 3 (cwd, stdin: 'ignore',
+ *     timeout, bounded stdio, killable). This rule is enforced by
+ *     `tests/unit/lang/backend-purity.test.ts`.
+ *   - Backends do no top-level `bun:` imports and no direct `Bun.*` calls
+ *     (invariant 2 — runtime portability). Same purity test enforces this.
+ *
+ * Extension model: a new language is a single new file under
+ * `src/lang/backends/<id>.ts` plus one import line in
+ * `src/lang/backends/index.ts`. The default backend handles everything the
+ * new file does not override.
+ */
+import type { LanguageProfile } from './profiles';
+/**
+ * Selected test framework for a project, including the concrete spawn argv
+ * and explicit cwd. Returned by `LanguageBackend.selectTestFramework`.
+ */
+export interface TestFrameworkSelection {
+    /** Framework id matching one of LanguageProfile.test.frameworks[*].name. */
+    name: string;
+    /**
+     * Spawn-arg array. Never includes shell metacharacters or relies on shell
+     * interpretation — passed directly to `bunSpawn(cmd, ...)`. Backends that
+     * cannot avoid a shell-mediated invocation (e.g. PowerShell `-EncodedCommand`)
+     * still produce an array; the array's first element is the binary and the
+     * rest are individual arguments.
+     */
+    cmd: string[];
+    /** Explicit cwd for the spawn (invariant 3). */
+    cwd: string;
+    /** Human-readable note: "package.json scripts.test", "Cargo.toml", etc. */
+    detectedVia: string;
+    /**
+     * When true, the `files` argument to `buildTestCommand` is ignored — the
+     * framework runs all tests in the project by default (e.g. cargo test,
+     * go test ./..., swift test). Per-file selection is the framework's
+     * concern, not the backend's.
+     */
+    filesIgnored?: boolean;
+}
+/**
+ * Structured summary of a test run. The default backend returns only
+ * exit-code-driven `ok` and the raw streams; richer parsing is opt-in per
+ * backend (e.g. the TypeScript backend parses bun:test JSON output).
+ */
+export interface TestRunSummary {
+    ok: boolean;
+    raw: {
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    };
+    passed?: number;
+    failed?: number;
+    skipped?: number;
+    durationMs?: number;
+    /**
+     * Total tests reported by the framework. When undefined the caller may
+     * compute `passed + failed + skipped`.
+     */
+    total?: number;
+    /**
+     * Coverage percentage parsed from the framework's output. Optional —
+     * frameworks without a uniform coverage-line format (mocha, go-test,
+     * etc.) leave this undefined.
+     */
+    coveragePercent?: number;
+}
+/**
+ * Scope strings used by the test-runner tool. Re-exported here so backends
+ * can accept them in `buildTestCommand` without a circular import back to
+ * `src/tools/test-runner.ts`.
+ */
+export type TestScope = 'all' | 'convention' | 'graph' | 'impact';
+/**
+ * Options influencing build-command construction. Backends may ignore
+ * unrecognized opts; the default backend honors all of these.
+ */
+export interface BuildTestCommandOpts {
+    scope?: TestScope;
+    coverage?: boolean;
+}
+/**
+ * Selected web/UI framework for a project (PROJECT_FRAMEWORK template
+ * variable). Best-effort detection — backends return null when no
+ * framework signal is available, and the architect's prompt then ships
+ * with the `unresolved (run /swarm preflight)` sentinel.
+ */
+export interface FrameworkSelection {
+    /** Display name, e.g. "react", "vue", "django", "gin". */
+    name: string;
+    /** Human-readable note describing what evidence supports this. */
+    detectedVia: string;
+}
+/**
+ * Selected build command for a project.
+ */
+export interface BuildCommandSelection {
+    /** Display name matching `LanguageProfile.build.commands[*].name`. */
+    name: string;
+    /** Spawn-arg array. Same constraints as TestFrameworkSelection.cmd. */
+    cmd: string[];
+    /** Explicit cwd. */
+    cwd: string;
+    /** Human-readable note: "Cargo.toml", "package.json#scripts.build", etc. */
+    detectedVia: string;
+}
+/**
+ * The behavior surface for a language. Every method is optional; the
+ * default-backend implementation in `./default-backend.ts` provides
+ * registry-driven fallbacks that work for most languages out of the box.
+ */
+export interface LanguageBackend extends LanguageProfile {
+    /**
+     * Stronger signal than extension matching alone. Default behavior
+     * (provided by the default backend) checks that any of
+     * `profile.build.detectFiles` is present in `dir`. A backend may override
+     * to add language-specific heuristics (e.g. the TypeScript backend reads
+     * `package.json#scripts.test` to confirm a test runner is configured).
+     */
+    detectProject?(dir: string): Promise<boolean>;
+    /**
+     * Pick the highest-priority test framework whose detect file exists in
+     * `dir` AND whose binary is on PATH. Returns `null` if no framework is
+     * configured + available. Default behavior consults
+     * `profile.test.frameworks` sorted by priority and uses
+     * `isCommandAvailable` from `src/build/discovery.ts`.
+     */
+    selectTestFramework?(dir: string): Promise<TestFrameworkSelection | null>;
+    /**
+     * Build the spawn argv for a given framework + file list. Default
+     * behavior implements the full 14-framework legacy switch from
+     * `src/tools/test-runner.ts` (coverage flags, scope-dependent file
+     * inclusion, platform-specific python/python3, pester -EncodedCommand,
+     * gradle wrapper detection, ctest build-dir detection, dart/flutter
+     * selection, bundle/rspec detection, minitest require_relative).
+     * Backends with non-trivial language-specific shape override this.
+     *
+     * Returns `null` when the framework is unknown to this backend; callers
+     * (test-runner dispatch) treat that as "no test command available".
+     */
+    buildTestCommand?(framework: string, files: string[], dir: string, opts?: BuildTestCommandOpts): string[] | null;
+    /**
+     * Parse stdout/stderr into a structured summary. Default behavior
+     * returns only `{ ok: exitCode === 0, raw: { stdout, stderr, exitCode } }`
+     * — no regex, no framework-specific assumptions. Backends that want
+     * pass/fail counts (e.g. the TypeScript backend's bun:test JSON parser)
+     * override this.
+     */
+    parseTestOutput?(framework: string, stdout: string, stderr: string, exitCode: number): TestRunSummary;
+    /**
+     * Map a source file to candidate test files (convention scope). Default
+     * behavior: swap `src/` ↔ `tests/` and the extension to one of the
+     * profile's test-file conventions. Returns the candidate paths sorted by
+     * likelihood.
+     */
+    testFilesFor?(sourceFile: string, dir: string): Promise<string[]>;
+    /**
+     * Extract import paths from a source file (graph/impact scope). Default
+     * behavior: returns `[]` — the analyzer falls back to convention scope
+     * with an explicit "graph scope unavailable for {lang}" notice. Backends
+     * with import-graph support (TypeScript, Python, Go in this phase set)
+     * override this.
+     */
+    extractImports?(sourceFile: string, source: string): string[];
+    /**
+     * Pick the build command for this project. Default behavior consults
+     * `profile.build.commands` sorted by priority + binary-on-PATH check.
+     */
+    selectBuildCommand?(dir: string): Promise<BuildCommandSelection | null>;
+    /**
+     * Detect the dominant web/UI framework in this project (React, Django,
+     * Gin, etc.) for the architect's PROJECT_FRAMEWORK template variable.
+     * Returns null when no framework signal is present — the default
+     * backend's implementation looks for common framework manifest fields
+     * (package.json deps, requirements.txt entries, go.mod requires).
+     */
+    selectFramework?(dir: string): Promise<FrameworkSelection | null>;
+    /**
+     * Identify primary entry-point files for this project (ENTRY_POINTS
+     * template variable). Default behavior: read profile-specific manifests
+     * (package.json `main`/`bin`, pyproject `[project.scripts]`, go.mod
+     * + main.go, etc.). Returns absolute or repo-relative paths sorted by
+     * confidence. Empty list maps to the sentinel.
+     */
+    selectEntryPoints?(dir: string): Promise<string[]>;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Go backend.
+ *
+ * Phase 5 of language-agnostic plugin work. Overrides `extractImports`
+ * with Go-specific import regexes — both single-line `import "x"` and
+ * grouped `import (\n "a"\n "b"\n)` forms — so the test-impact analyzer
+ * can build a graph for Go projects.
+ *
+ * Invariants identical to other backends — see `python.ts` and
+ * `typescript.ts` for the rationale; backend-purity test enforces.
+ */
+import type { LanguageBackend } from '../backend';
+declare function extractImports(_sourceFile: string, source: string): string[];
+/**
+ * Build the Go backend from the registered profile.
+ */
+export declare function buildGoBackend(): LanguageBackend;
+export declare const _internals: {
+    extractImports: typeof extractImports;
+};
+export {};

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

@@ -0,0 +1,27 @@
+/**
+ * Backend registration surface.
+ *
+ * Adding a new language with first-class behavior is a single new file
+ * under this directory plus one `import` line + one `register(...)` call
+ * here. Importing this module triggers all registrations.
+ *
+ * Phase 2 ships only the TypeScript backend. Phase 5 will add Python and
+ * Go backends with import-graph extractors.
+ */
+/**
+ * Register all known backends. Idempotent via the module-level `registered`
+ * flag.
+ *
+ * The flag is load-bearing, not redundant with the registry's own duplicate
+ * guard: `buildTypescriptBackend()` constructs a fresh object every call, so
+ * a second call without the flag would produce a different reference and
+ * trip `LanguageBackendRegistry.register`'s `existing !== backend` throw.
+ * The flag prevents that by short-circuiting before constructing.
+ */
+export declare function registerAllBackends(): void;
+/**
+ * Test-only: reset the registration flag and unregister all known
+ * backends. Allows tests to verify the registration logic itself without
+ * cross-file singleton pollution.
+ */
+export declare function _resetForTesting(): void;

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

@@ -0,0 +1,25 @@
+/**
+ * Python backend.
+ *
+ * Phase 5 of language-agnostic plugin work. Overrides `extractImports`
+ * with Python-specific import regexes (`import x`, `from x import y`)
+ * so the test-impact analyzer can build a graph for Python projects.
+ * Other hooks (selectTestFramework, selectBuildCommand, parseTestOutput,
+ * testFilesFor) inherit the registry-driven defaults.
+ *
+ * Invariants (same as typescript.ts):
+ *   - No subprocess calls; defers binary checks to `isCommandAvailable`.
+ *   - No `bun:` imports, no `Bun.*` calls.
+ *   - Backend-purity test in `tests/unit/lang/backend-purity.test.ts`
+ *     enforces both at PR time.
+ */
+import type { LanguageBackend } from '../backend';
+declare function extractImports(_sourceFile: string, source: string): string[];
+/**
+ * Build the Python backend from the registered profile.
+ */
+export declare function buildPythonBackend(): LanguageBackend;
+export declare const _internals: {
+    extractImports: typeof extractImports;
+};
+export {};

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

@@ -0,0 +1,56 @@
+/**
+ * TypeScript / JavaScript backend.
+ *
+ * Overrides the default backend's `selectTestFramework` to honor
+ * `package.json#scripts.test` (the canonical signal in the JS ecosystem)
+ * and `extractImports` to parse ES6 + CommonJS imports for the
+ * graph/impact analyzer.
+ *
+ * Phase 2 deliverable: this backend exists and registers itself, but
+ * `src/tools/test-runner.ts` and `src/test-impact/analyzer.ts` do not yet
+ * call into it — they still use their existing switch-statement helpers.
+ * Phase 3 wires the test-runner dispatch through this backend.
+ *
+ * Invariants:
+ *   - No subprocess calls (defers to `isCommandAvailable` from
+ *     `../../build/discovery` for binary checks; that helper already
+ *     satisfies invariant 3).
+ *   - No `bun:` imports, no `Bun.*` calls (invariant 2).
+ *   - No mutation of LANGUAGE_REGISTRY at import time — only registers a
+ *     backend in LANGUAGE_BACKEND_REGISTRY via `backends/index.ts`.
+ */
+import type { LanguageBackend } from '../backend';
+interface PackageJsonShape {
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}
+/**
+ * Read package.json. Returns null when missing or malformed. Bounded by a
+ * single sync `fs.readFileSync` — no subprocess.
+ *
+ * Routed through `_internals.readPackageJsonRaw` so tests can substitute a
+ * different reader without touching the filesystem. The adversarial review
+ * (PR #825) flagged that this seam was advertised but unused.
+ */
+declare function readPackageJsonRaw(dir: string): PackageJsonShape | null;
+/** Convenience: read just `scripts.test` (used by tests). */
+declare function readPackageJsonTestScript(dir: string): string | null;
+/**
+ * Map a `package.json#scripts.test` invocation to a framework name. The
+ * mapping mirrors `detectTestFramework` in `src/tools/test-runner.ts:286–326`.
+ */
+declare function frameworkFromScriptsTest(script: string): string | null;
+/**
+ * Build the TypeScript backend from the registered profile. Backend
+ * registration happens in `./index.ts` (the single import-and-register
+ * surface) — this module just exports the factory so the registration
+ * site is explicit.
+ */
+export declare function buildTypescriptBackend(): LanguageBackend;
+export declare const _internals: {
+    readPackageJsonRaw: typeof readPackageJsonRaw;
+    readPackageJsonTestScript: typeof readPackageJsonTestScript;
+    frameworkFromScriptsTest: typeof frameworkFromScriptsTest;
+};
+export {};

package/dist/lang/default-backend.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Default backend — registry-driven implementations of every optional hook
+ * on `LanguageBackend`. A backend that overrides nothing still works for
+ * common cases: any profile with build.commands + test.frameworks +
+ * lint.linters declared correctly will get a working `selectTestFramework`,
+ * `selectBuildCommand`, etc. without writing any backend code.
+ *
+ * No subprocess calls happen here — `isCommandAvailable` is the only seam
+ * to the environment, and it lives in `src/build/discovery.ts` with full
+ * invariant-3 properties (cwd, stdin: 'ignore', timeout, bounded stdio).
+ */
+import type { BuildCommandSelection, BuildTestCommandOpts, FrameworkSelection, LanguageBackend, TestFrameworkSelection, TestRunSummary } from './backend';
+import type { LanguageProfile } from './profiles';
+/**
+ * Tokenize a string command into an array. Splits on whitespace; respects
+ * single and double quotes for argument grouping. Used to convert profile
+ * `cmd` strings (which today are written as "npx tsc --noEmit" etc.) into
+ * the array form `bunSpawn` expects.
+ *
+ * This deliberately does NOT support shell metacharacters (`;`, `&`, `|`,
+ * `>`, `<`, backticks, `$()`) — backends with non-trivial commands must
+ * override `buildTestCommand`/`selectBuildCommand` to return a custom
+ * `cmd: string[]`. Splitting a profile string into words is a 90% case;
+ * the 10% override their backend.
+ */
+export declare function tokenizeCommand(cmd: string): string[];
+/**
+ * Default selectTestFramework: highest-priority framework whose detect
+ * file exists AND whose binary is on PATH. Returns null if none.
+ */
+export declare function defaultSelectTestFramework(profile: LanguageProfile, dir: string): Promise<TestFrameworkSelection | null>;
+/**
+ * Default buildTestCommand: full 14-framework switch ported verbatim from
+ * the legacy logic that lived in `src/tools/test-runner.ts:buildTestCommand`
+ * (pre-Phase-3b). Handles per-framework coverage flags, scope-dependent
+ * file inclusion, platform-specific python/python3, pester
+ * `-EncodedCommand` for safe path passing, gradlew detection, ctest build-
+ * directory probing, flutter-vs-dart selection, bundle/rspec detection,
+ * and the minitest `require_relative` trick for multi-file runs.
+ *
+ * Backends are free to override individual framework cases via their own
+ * `buildTestCommand` — this default is a single source of truth so adding
+ * a 15th framework only requires one switch arm.
+ *
+ * `dir` is the base directory used for gradlew/ctest manifest probing.
+ * `opts.scope` defaults to `'all'`; `opts.coverage` defaults to `false`.
+ * Returns null when the framework name is not in the supported set.
+ */
+export declare function defaultBuildTestCommand(profile: LanguageProfile, framework: string, files: string[], dir?: string, opts?: BuildTestCommandOpts): string[] | null;
+/**
+ * Default parseTestOutput: full 14-framework switch ported verbatim from
+ * `src/tools/test-runner.ts:parseTestOutput`. Returns a TestRunSummary
+ * with `passed`/`failed`/`skipped`/`total`/`coveragePercent` populated
+ * for every supported framework. Unknown frameworks return an
+ * exit-code-only summary.
+ *
+ * `framework` is the union-name string (e.g. 'bun', 'vitest', 'pytest').
+ * Callers pass the combined stdout+stderr as `stdout` and an empty
+ * string for `stderr` per the legacy convention — the legacy parser
+ * always concatenated streams before parsing.
+ */
+export declare function defaultParseTestOutput(framework: string, stdout: string, stderr: string, exitCode: number): TestRunSummary;
+/**
+ * Default detectProject: any of `profile.build.detectFiles` is present in
+ * `dir`. Honors simple glob patterns the same way `detectFileExists` does.
+ */
+export declare function defaultDetectProject(profile: LanguageProfile, dir: string): Promise<boolean>;
+/**
+ * Default selectBuildCommand: highest-priority command whose detectFile
+ * (if specified) exists AND whose binary is on PATH. Returns null if none.
+ */
+export declare function defaultSelectBuildCommand(profile: LanguageProfile, dir: string): Promise<BuildCommandSelection | null>;
+/**
+ * Default testFilesFor: convention swap `src/<x>.<ext>` ↔ `tests/<x>.<ext>`
+ * (and `tests/<x>_test.<ext>`, `tests/<x>.test.<ext>`). Returns candidates
+ * sorted by likelihood. Best-effort — backends with established patterns
+ * (e.g. Python's `tests/test_<x>.py`) override.
+ */
+export declare function defaultTestFilesFor(profile: LanguageProfile, sourceFile: string, dir: string): Promise<string[]>;
+/**
+ * Default extractImports: returns []. The analyzer treats this as
+ * "graph scope unavailable for {lang}" and falls back to convention scope
+ * with an explicit notice. Backends with parser-driven extraction
+ * (TypeScript, Python, Go in the language-agnostic plan's Phase 5) override.
+ */
+export declare function defaultExtractImports(): string[];
+/**
+ * Default selectFramework: returns null. Frameworks (React, Django, Gin)
+ * are not detectable from a profile alone — a concrete backend must read
+ * its language-specific manifest. Returning null causes the architect's
+ * PROJECT_FRAMEWORK placeholder to resolve to the `unresolved` sentinel.
+ */
+export declare function defaultSelectFramework(): Promise<FrameworkSelection | null>;
+/**
+ * Default selectEntryPoints: returns []. Concrete backends override per
+ * language. Empty list maps to the `unresolved` sentinel.
+ */
+export declare function defaultSelectEntryPoints(): Promise<string[]>;
+/**
+ * Build a backend object that delegates every hook to the registry-driven
+ * defaults. Used by `pickBackend` when no language-specific override has
+ * been registered. The returned object is a structural `LanguageBackend`
+ * (it spreads the profile, then attaches default method bindings).
+ */
+export declare function defaultBackendFor(profile: LanguageProfile): LanguageBackend;

package/dist/lang/dispatch.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Dispatch: pick the right `LanguageBackend` for a directory.
+ *
+ * `pickBackend(dir)` walks up from `dir` to find the nearest project
+ * manifest, runs language detection on that root, and returns the
+ * registered (or defaulted) backend for the dominant language. Caches
+ * results in a bounded LRU keyed by (dir, manifest-hash) so repeated calls
+ * during a session do not re-walk the filesystem.
+ *
+ * Per the language-agnostic plan, hot-path callers (hooks, tools) wrap
+ * this in `withTimeout(200ms)` and fail open on the cache miss; session-
+ * start callers use `withTimeout(2000ms)`. Both budgets are caller-set —
+ * the dispatch function itself does not impose timeouts.
+ *
+ * Invariant 4: this module never writes to `.swarm/`. All caching is
+ * in-process. `dir` is treated as caller-supplied and not validated as a
+ * project root — callers are responsible for passing the right directory.
+ */
+import type { LanguageBackend } from './backend';
+import './backends';
+import { detectProjectLanguages } from './detector';
+declare const _internals: {
+    detectProjectLanguages: typeof detectProjectLanguages;
+    cacheCapacity: number;
+};
+export { _internals };
+/**
+ * Pick the most appropriate `LanguageBackend` for `dir`. Walks up to find
+ * the manifest root, detects languages there, returns the highest-tier
+ * backend (with the default backend synthesized for ids that have no
+ * registered override). Returns null if no language is detected.
+ *
+ * The dispatch is cached by `(manifestRoot, manifestHash)`; cache entries
+ * are invalidated automatically when any manifest's size or mtime changes.
+ */
+export declare function pickBackend(dir: string): Promise<LanguageBackend | null>;
+/**
+ * Return the ranked language profile list `pickBackend` last detected for
+ * `dir`. Used by `buildProjectContext` to populate
+ * `PROJECT_CONTEXT_SECONDARY_LANGUAGES` without re-running
+ * `detectProjectLanguages`. Returns an empty array when no cached entry
+ * matches (caller should invoke `pickBackend(dir)` first to warm the
+ * cache).
+ */
+export declare function pickedProfiles(dir: string): ReadonlyArray<{
+    id: string;
+}>;
+/**
+ * Test-only: clear the dispatch cache. Production code should never call
+ * this — the cache is invalidated automatically by manifest hashes.
+ */
+export declare function clearDispatchCache(): void;

package/dist/lang/profiles.d.ts

@@ -27,9 +27,29 @@ export interface LanguageProfile {
     displayName: string;
     tier: 1 | 2 | 3;
     extensions: string[];
+    /**
+     * Reserved for future "parser-only" entries (e.g. css, bash, ini, regex,
+     * and the tsx parser-grammar split) that should register a tree-sitter
+     * parser but never participate in test/build/lint dispatch. Currently
+     * unused — populated in a later phase.
+     */
+    parserOnly?: boolean;
     treeSitter: {
         grammarId: string;
         wasmFile: string;
+        /**
+         * Tree-sitter node names that represent comments for this language.
+         * Used by tools that strip comments (e.g. ast-diff, syntax-check).
+         *
+         * Optional in the type because tests construct ad-hoc profiles for
+         * fixtures that don't exercise comment-stripping. Production profiles
+         * MUST populate this — enforced by
+         * `tests/unit/lang/profile-registry-parity.test.ts` against every
+         * profile in `LANGUAGE_REGISTRY`. Source of truth lives here;
+         * `src/lang/registry.ts` exposes a parity subset for the parser-only
+         * registry.
+         */
+        commentNodes?: string[];
     };
     build: {
         detectFiles: string[];
@@ -62,6 +82,14 @@ export declare class LanguageRegistry {
     private profiles;
     private extensionIndex;
     constructor();
+    /**
+     * Remove a previously registered profile and any extensions it claimed.
+     * Primarily used by tests to clean up after registering fixture profiles
+     * into the shared singleton — without this, fixture entries leak across
+     * test files in Bun's per-file-but-shared-process test runner. No-op if
+     * the id is not registered.
+     */
+    unregister(id: string): void;
     register(profile: LanguageProfile): void;
     get(id: string): LanguageProfile | undefined;
     getById(id: string): LanguageProfile | undefined;

package/dist/lang/registry-backend.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Backend registry — maps language id → concrete `LanguageBackend`. Sits
+ * alongside `LANGUAGE_REGISTRY` (the data registry) and `languageDefinitions`
+ * (the parser registry). When a backend is not registered for a language id,
+ * the default backend (registry-driven defaults) is synthesized on demand.
+ *
+ * Adding a new language with first-class behavior is a single new file
+ * under `src/lang/backends/<id>.ts` plus one import line in
+ * `src/lang/backends/index.ts`. The new file calls
+ * `LANGUAGE_BACKEND_REGISTRY.register(myBackend)` at module load.
+ */
+import type { LanguageBackend } from './backend';
+declare class LanguageBackendRegistry {
+    private backends;
+    register(backend: LanguageBackend): void;
+    /**
+     * Get a registered backend by id, or `undefined` if no backend is
+     * registered. Callers usually want `getOrDefault` instead.
+     */
+    get(id: string): LanguageBackend | undefined;
+    /**
+     * Get the registered backend for `id`, or synthesize a default backend
+     * by wrapping the matching `LanguageProfile`. Returns `undefined` only
+     * when no profile exists for the id (i.e. unknown language).
+     */
+    getOrDefault(id: string): LanguageBackend | undefined;
+    /**
+     * Test-only: remove a registered backend. Mirrors
+     * `LANGUAGE_REGISTRY.unregister` for the same singleton-pollution
+     * rationale (see comment there).
+     */
+    unregister(id: string): void;
+}
+export declare const LANGUAGE_BACKEND_REGISTRY: LanguageBackendRegistry;
+export {};

package/dist/services/skill-improver.d.ts

@@ -40,6 +40,7 @@ export interface SkillImproveRequest {
     maxCalls?: number;
     now?: Date;
     sessionId?: string;
+    signal?: AbortSignal;
     /** Test-only seam: inject a delegate. When undefined, the service uses
      *  createSkillImproverLLMDelegate(directory, sessionId) which returns
      *  undefined unless swarmState.opencodeClient is wired. */

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

@@ -7,6 +7,12 @@ export interface TestImpactResult {
 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;
+/**
+ * Test-only: clear the go-module memoization cache. Production code
+ * should never need this — the cache is per-call-graph scoped, but tests
+ * that reuse the same tempDir benefit from a fresh start.
+ */
+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[]>>;
@@ -21,6 +27,7 @@ export declare const _internals: {
     loadImpactMap: typeof loadImpactMap;
     saveImpactMap: typeof saveImpactMap;
     analyzeImpact: typeof analyzeImpact;
+    _clearGoModuleCache: typeof _clearGoModuleCache;
 };
 export declare function buildImpactMap(cwd: string): Promise<Record<string, string[]>>;
 export declare function loadImpactMap(cwd: string): Promise<Record<string, string[]>>;

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

@@ -49,6 +49,28 @@ export interface TestErrorResult {
     attempted_scope?: 'graph';
 }
 export type TestResult = TestSuccessResult | TestErrorResult;
+export declare function detectTestFrameworkViaDispatch(cwd: string): Promise<TestFramework>;
+/**
+ * Build a test command via the LanguageBackend dispatch path. Reverse-maps
+ * the union TestFramework string back to the profile name and asks the
+ * matching backend to produce a command. Falls back to the legacy switch
+ * (via `defaultBuildTestCommand` import) when no backend is registered or
+ * the backend has no `buildTestCommand` hook.
+ *
+ * Returns null on framework=`none` or when dispatch fails — callers (the
+ * test-runner) then surface "no test command available".
+ */
+export declare function buildTestCommandViaDispatch(framework: TestFramework, scope: 'all' | 'convention' | 'graph' | 'impact', files: string[], coverage: boolean, baseDir: string): Promise<string[] | null>;
+/**
+ * Parse test output via the LanguageBackend dispatch path. Calls
+ * `backend.parseTestOutput` for the directory's resolved backend and
+ * returns the legacy-shaped `{ totals, coveragePercent? }` for the
+ * test-runner. Returns null when dispatch fails.
+ */
+export declare function parseTestOutputViaDispatch(framework: TestFramework, output: string, baseDir: string): Promise<{
+    totals: TestTotals;
+    coveragePercent?: number;
+} | null>;
 export declare function detectTestFramework(cwd: string): Promise<TestFramework>;
 /**
  * Returns true when `basename` matches a language-specific test file naming

package/package.json

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