opencode-swarm 7.178.1 → 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,8 +95,15 @@ 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;
+/**
+ * Apply a unified diff's hunks to the original file text, producing the full
+ * mutated file. Returns null when the diff does not parse or does not apply
+ * cleanly to the original (context mismatch), so callers can fall back.
+ */
+export declare function applyUnifiedDiff(originalCode: string, patchText: string): string | null;
 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>, options?: MutationExecutionOptions): Promise<MutationReport>;
 export {};

package/dist/mutation/equivalence.d.ts

@@ -18,7 +18,17 @@ export type LLMJudgeCallback = (original: string, mutated: string, context: stri
  * Strips comments (single-line // and multi-line /* *\/), console.log/debugger statements,
  * trailing whitespace, and blank lines. Returns true if the stripped versions are identical.
  */
-export declare function isStaticallyEquivalent(originalCode: string, mutatedCode: string): boolean;
+/**
+ * Comment syntax family for a language hint (a file path or language id).
+ * The default family preserves the historical 2-argument behavior exactly:
+ * // line comments plus slash-star block comments (TS/JS/Go/PHP/Java/Kotlin/C/C++/Rust).
+ */
+interface CommentSyntaxFamily {
+    lineTokens: string[];
+    blockComments: boolean;
+}
+export declare function commentFamilyForLanguage(languageHint?: string): CommentSyntaxFamily;
+export declare function isStaticallyEquivalent(originalCode: string, mutatedCode: string, languageHint?: string): boolean;
 export declare const _internals: {
     isStaticallyEquivalent: typeof isStaticallyEquivalent;
     checkEquivalence: typeof checkEquivalence;
@@ -38,3 +48,4 @@ export declare function batchCheckEquivalence(patches: Array<{
     originalCode: string;
     mutatedCode: string;
 }>, llmJudge?: LLMJudgeCallback): Promise<EquivalenceResult[]>;
+export {};

package/dist/pr-review/circuit.d.ts

@@ -22,9 +22,9 @@
  * Issue #2385 additionally makes this module the ONLY authority that may
  * construct or transition circuit records: policy snapshot resolution, the
  * re-enable reset, and the rolled-back-probe transition live here (previously
- * inline record constructions in the gate). The parallel-rule guardrail
- * (`src/pr-review/guardrails.ts`) enforces that no circuit record is built
- * outside `src/pr-review/`.
+ * inline record constructions in the gate). The source-tree regression tests
+ * enforce that no circuit record is built outside `src/pr-review/`; this pure
+ * state-machine module remains the production construction authority.
  */
 import { z } from 'zod';
 import type { BackgroundDelegationRecord } from '../background/pending-delegations.js';

package/dist/pr-review/legacy-transcript-adapter.d.ts

@@ -4,12 +4,10 @@
  *
  * This is the ONLY module allowed to convert raw transcript / artifact text
  * into canonical PR-review data (verdict rows, per-item verdicts, feedback
- * classifications). The locality contract is enforced mechanically by
- * `scanTranscriptParsingOutsideAdapter` in `src/pr-review/guardrails.ts`:
- * every identifier in `TRANSCRIPT_CONVERSION_SYMBOLS` may appear only in this
- * file across `src/`. The gate therefore consumes this boundary through the
- * `legacy*`-prefixed aliases and the test surface exported below — never
- * through the conversion identifiers themselves.
+ * classifications). This module is the sole owner of the transcript
+ * conversion identifiers across `src/`; the gate therefore consumes this
+ * boundary through the `legacy*`-prefixed aliases and the test surface
+ * exported below — never through the conversion identifiers themselves.
  *
  * Compat gating: the settlement path that accepts legacy (pre-structured-
  * receipt) transcript text is governed by the delegation record's
@@ -252,10 +250,9 @@ export declare function feedbackArtifactTextCoversItems(text: string, itemIds: r
  */
 export declare function readSettledFeedbackClassifications(directory: string, state: PrReviewTranscriptState): Map<string, string>;
 /**
- * Issue #2385 guardrail aliases: the transcript-conversion identifiers may
- * appear only in this module (`scanTranscriptParsingOutsideAdapter` in
- * `src/pr-review/guardrails.ts`), so the owning gate imports these aliases
- * instead of the canonical names.
+ * Issue #2385 guardrail aliases: transcript-conversion identifiers are owned
+ * only by this module, so the owning gate imports these aliases instead of
+ * the canonical names.
  */
 export declare const analyzeLegacyVerdictRowContract: typeof analyzePrReviewVerdictRowContract;
 export declare const legacyArtifactHasExactPositiveVerdictRow: typeof artifactHasExactPositiveVerdictRow;

package/dist/pr-review/persistence.d.ts

@@ -55,6 +55,10 @@ export interface PrReviewPersistenceHooks {
     beforeSafeDirectoryCreate?: (parentPath: string, nextPath: string) => Promise<void>;
     beforeAtomicTempWrite?: () => Promise<void>;
     beforeAtomicRename?: () => Promise<void>;
+    /** Test-only interleave point immediately before terminal CAS deletion. */
+    beforeTerminalizationDelete?: () => Promise<void>;
+    /** Test-only unlink seam for partial-shadow cleanup recovery tests. */
+    removeShadowProjection?: (filePath: string) => Promise<void>;
 }
 export declare const defaultPersistenceHooks: PrReviewPersistenceHooks;
 /**
@@ -94,6 +98,28 @@ export declare function readPrWorkflowGateStateFromDisk<S extends PrWorkflowPers
 export declare function readPrWorkflowGateStateFileRawFromDisk<S extends PrWorkflowPersistedStateBase>(filePath: string, stateLabel: string): Promise<S | null>;
 export declare function readPrWorkflowGateStateFileFromDisk<S extends PrWorkflowPersistedStateBase>(filePath: string, stateLabel: string): Promise<S | null>;
 export declare function readPrWorkflowGateStateFromCoordination<S extends PrWorkflowPersistedStateBase>(directory: string, sessionID: string): Promise<S | null>;
+export type PrWorkflowGateCoordinationRecovery<S extends PrWorkflowPersistedStateBase> = {
+    kind: 'absent';
+} | {
+    kind: 'valid';
+    rowRevision: number;
+    generation: number;
+    state: S;
+} | {
+    kind: 'corrupt';
+    rowRevision: number;
+    generation: number;
+    reason: string;
+} | {
+    kind: 'invalid';
+    reason: string;
+};
+/**
+ * Inspect one workflow coordination row for recovery without trusting payload
+ * bytes. Only payload JSON/codec/generation failures are recoverable with a
+ * matching shadow projection. Database open/query errors intentionally escape.
+ */
+export declare function readPrWorkflowGateStateCoordinationForRecovery<S extends PrWorkflowPersistedStateBase>(directory: string, sessionID: string): PrWorkflowGateCoordinationRecovery<S>;
 /** Persist one CAS-checked state replacement while the session lock is held. */
 export declare function writeStateWhileLocked<S extends PrWorkflowPersistedStateBase>(directory: string, state: S, options?: {
     replaceWorkflowInstanceId?: string;
@@ -103,6 +129,16 @@ export declare function deleteStateWhileLocked(directory: string, sessionID: str
     expectedStateRevision?: number;
     allowSalvagedRead?: boolean;
 }): Promise<void>;
+/**
+ * Terminalize one session's gate on exact owner lifecycle deletion.
+ *
+ * This is deliberately independent of abort policy: it serializes the exact
+ * normalized session, removes that session's shadow projection before its
+ * CAS-delete, then forgets the cache entry. A missing row/projection is an
+ * idempotent successful terminal; retaining the row across partial cleanup
+ * prevents a legacy shadow from being imported as resurrected state.
+ */
+export declare function terminalizePrWorkflowGateForSession(directory: string, sessionID: string): Promise<void>;
 /** A bounded checkout-mutation refusal that never permits unsafe late overlap. */
 export declare class PrWorkflowCheckoutMutationTimeoutError extends Error {
     readonly phase: 'queue' | 'action';

package/dist/retention/sweep.d.ts

@@ -23,6 +23,10 @@
  *  - authoritative streams (plan ledger, knowledge store, council, evidence,
  *    scopes, swarm.db, telemetry) are NOT in any family and are never
  *    touched (negative test).
+ *  - checkout-preparation receipts remain recovery material: the checkout
+ *    family only removes old, strictly validated applied+verified receipts
+ *    (and abandoned atomic-write temporary files), never a pending receipt or
+ *    its stash.
  */
 /** Default age horizon for keyspace families (30 days). */
 export declare const DEFAULT_FAMILY_AGE_DAYS = 30;

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,2 +1,14 @@
+import * as path from 'node:path';
 import { createSwarmTool } from './create-tool';
+declare function normalizeWorkspaceFile(value: unknown, cwd: string, requireExisting: boolean): {
+    value: string;
+    absolute: string;
+} | {
+    error: string;
+};
+export declare const _internals: {
+    pathRelative: typeof path.relative;
+    normalizeWorkspaceFile: typeof normalizeWorkspaceFile;
+};
 export declare const mutation_test: ReturnType<typeof createSwarmTool>;
+export {};

package/dist/tools/prepare-pr-workflow-checkout.d.ts

@@ -1,9 +1,26 @@
+import { appendCoreEventSync } from '../events/core-events.js';
 import { classifyPrWorkflowGitState } from '../git/pr-workflow-state.js';
 import { createSwarmTool } from './create-tool.js';
 export interface PrWorkflowCheckoutRestoreInventoryItem {
     stash_oid: string;
     stash_present: boolean | null;
 }
+export interface PrWorkflowCheckoutReconciliationSummary {
+    /** The exact owner session whose receipt directory was inspected. */
+    sessionID: string;
+    /** Number of validated receipt files considered in this bounded pass. */
+    inspectedReceiptCount: number;
+    /** Verified receipt OIDs whose marked stash was collected and verified absent. */
+    collectedStashOids: string[];
+    /** Missing-stash receipt OIDs with bounded core-event evidence and receipt retirement. */
+    retiredMissingStashOids: string[];
+    /** Receipt/stash OIDs deliberately preserved (pending, unknown, or failed cleanup). */
+    preservedStashOids: string[];
+    /** Cleanup failures; no corresponding receipt is retired when this is non-empty. */
+    failures: string[];
+    /** True when all inspected inventory stayed within the hard bounds. */
+    bounded: boolean;
+}
 /**
  * Preserve explicit dirty tracked files before the unbound PR checkout.
  *
@@ -27,6 +44,7 @@ declare function runGit(directory: string, args: string[], options?: {
 declare function readBoundedGitStdout(stream: {
     getReader(): ReadableStreamDefaultReader<Uint8Array>;
 }, onOverflow: () => void): Promise<string>;
+export declare function reconcilePrWorkflowCheckoutReceipts(directory: string, rawSessionID: string): Promise<PrWorkflowCheckoutReconciliationSummary>;
 declare function removeCheckoutRestoreReceipt(receiptPath: string): Promise<void>;
 export declare function listPendingPrWorkflowCheckoutRestores(directory: string, sessionID: string): Promise<PrWorkflowCheckoutRestoreInventoryItem[]>;
 /**
@@ -40,6 +58,7 @@ export declare const _internals: {
     readBoundedGitStdout: typeof readBoundedGitStdout;
     classifyGitState: typeof classifyPrWorkflowGitState;
     removeCheckoutRestoreReceipt: typeof removeCheckoutRestoreReceipt;
+    appendCoreEventSync: typeof appendCoreEventSync;
 };
 export declare const prepare_pr_workflow_checkout: ReturnType<typeof createSwarmTool>;
 export {};

package/dist/tools/repo-map-action-dispositions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Disposition registry for repo_map actions audited as unreferenced (issue #2540).
+ *
+ * Every entry in VALID_ACTIONS must be reachable from a real workflow surface
+ * (agent prompt, skill, or command) or be deliberately retired. This registry
+ * records the per-action disposition for the six audit actions from
+ * REPOGRAPH-11 (docs/audits/swarm-plugin-review-2026-09.md): each is retained
+ * and wired to the listed consumers. The controls wired by #2516
+ * (route_trace, test_pack) and the two additional contextually-unreferenced
+ * entries the ratchet surfaced (callers, retrieve) are intentionally NOT
+ * subjects here — they already had, or gained independently, their own
+ * consumers and are enforced by the VALID_ACTIONS↔consumer ratchet test
+ * (tests/unit/config/repo-map-action-consumer-ratchet.test.ts).
+ */
+export interface RepoMapActionDisposition {
+    /** retained = wired to real consumers; retired = removed from the advertised surface */
+    disposition: 'retained' | 'retired';
+    /** repo-relative workflow-surface files containing a repo_map-contextual reference (required when retained) */
+    consumers?: string[];
+    /** surfaces scrubbed of the action (required when retired: schema, help, prompts, inventory) */
+    removedFrom?: string[];
+}
+export declare const REPO_MAP_ACTION_DISPOSITIONS: Record<string, RepoMapActionDisposition>;

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;
@@ -13,6 +13,9 @@ 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.
@@ -23,6 +26,7 @@ export declare const MAX_SAFE_SOURCE_FILES = 1;
  */
 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,7 +39,13 @@ export interface TestRunnerArgs {
     timeout_ms?: number;
     bail?: boolean;
 }
-export type RegressionOutcome = 'pass' | 'skip' | 'regression' | 'scope_exceeded' | 'error';
+export type RegressionOutcome = 'pass' | 'skip' | 'no_impacted_tests' | 'regression' | 'scope_exceeded' | 'error';
+/** Binding cap decision reported on every discovery-scope response. */
+export interface CapDecision {
+    decision: 'within_cap' | 'cap_exceeded';
+    resolved_test_count: number;
+    limit: number;
+}
 export interface TestTotals {
     passed: number;
     failed: number;
@@ -64,6 +74,10 @@ export interface TestSuccessResult {
     testCases?: ParsedTestCaseResult[];
     message?: string;
     outcome?: RegressionOutcome;
+    resolution?: TestResolution;
+    resolved_test_files?: string[];
+    cap_decision?: CapDecision;
+    fallback_reason?: string;
 }
 export interface TestErrorResult {
     success: false;
@@ -80,8 +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
@@ -160,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.178.1",
+	"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",

package/dist/pr-review/guardrails.d.ts

@@ -1,67 +0,0 @@
-/**
- * PR-review recurrence guardrails (issue #2385).
- *
- * Exported source scanners implementing the mechanical guardrails the issue
- * requires. Each scanner is a PURE function over `{ path, content }` source
- * maps; unit tests prove each scanner flags a synthetic violating snippet
- * (the guardrail "biting") and then apply it over the real `src/` tree.
- *
- * 1. `scanObserverTerminalization` — (a) the historical wait-deadline/no-client
- *    terminalizer may never reappear by name; (b) in
- *    `src/tools/dispatch-lanes.ts`, durable delegation-transition writes are
- *    allowed only inside the sanctioned settlement functions.
- * 2. `scanParallelCircuitRuleConstruction` — circuit-record construction may
- *    exist only under `src/pr-review/` (the inline-construction recurrence
- *    class G-1).
- *
- * Issue #2385 originally specified a third scanner for transcript-parsing
- * locality (the 13 conversion symbols restricted to the legacy adapter),
- * but its only test consumer was a synthetic-input bite demo with no
- * production caller. The boundary is already enforced structurally
- * (the legacy-transcript-adapter is the sole module that owns those symbols,
- * and the two retained scanners cover the real recurrence classes). A
- * scanner with no caller would create the appearance of a guardrail where
- * there is none — per the issue's "no unwired functionality" bar, it was
- * removed instead.
- */
-export interface GuardrailSource {
-    path: string;
-    content: string;
-}
-export interface GuardrailHit {
-    path: string;
-    line: number;
-    rule: string;
-    excerpt: string;
-}
-/**
- * The historical PR-review wait-deadline terminalizer (issue #2381 deleted
- * it). Any reappearance of these names in `src/` is the exact recurrence
- * class the issue forbids: a collection wait budget or an unavailable host
- * messages client must never write a terminal delegation transition.
- */
-export declare const FORBIDDEN_OBSERVER_TERMINALIZER_SYMBOLS: readonly string[];
-/**
- * Enclosing functions in `src/tools/dispatch-lanes.ts` that are allowed to
- * write delegation transitions. Every entry is child-evidence-driven
- * settlement (typed terminal error, explicit caller cancellation, or the
- * age+liveness presumed-stale backstop) — never observer-deadline evidence:
- * - `startAsyncLanePrompt`: `running` transition after a successful launch.
- * - `appendAsyncLaneLaunchError`: typed `error` for a failed child launch.
- * - `collectOnce`: explicit caller `cancelled` transition.
- * - `settleCollectedLane`: `completed`/`error` settlement from child evidence.
- * - `sweepStaleAsyncLaneRecords`: the presumed-stale `stale` backstop.
- * Additions must document their evidence source here.
- */
-export declare const DELEGATION_WRITE_ALLOWED_FUNCTIONS: ReadonlySet<string>;
-/**
- * Guardrail 2. (a) flags any forbidden historical-terminalizer symbol;
- * (b) for `src/tools/dispatch-lanes.ts`, flags delegation-transition writes
- * inside any enclosing function outside the sanctioned allowlist. This
- * module itself is exempt from rule (a): it DEFINES the forbidden names
- * (the definition site is not a recurrence, same reasoning as the adapter
- * allowlist in guardrail 1).
- */
-export declare function scanObserverTerminalization(sources: readonly GuardrailSource[]): GuardrailHit[];
-/** Guardrail 3 (issue #2385 recurrence class G-1). */
-export declare function scanParallelCircuitRuleConstruction(sources: readonly GuardrailSource[]): GuardrailHit[];