opencode-swarm 7.132.2 → 7.134.0

package/dist/memory/schema.d.ts

@@ -238,8 +238,8 @@ export declare const MemoryProposalSchema: z.ZodObject<{
     status: z.ZodEnum<{
         pending: "pending";
         applied: "applied";
-        rejected: "rejected";
         approved: "approved";
+        rejected: "rejected";
         superseded: "superseded";
     }>;
     reviewer: z.ZodOptional<z.ZodEnum<{

package/dist/review/contracts.d.ts

@@ -0,0 +1,29 @@
+import type { OpencodeClient } from '@opencode-ai/sdk';
+import { type EphemeralAgentDispatchResult } from '../evaluation/ephemeral-agent-dispatcher.js';
+import type { ModelOverride } from '../utils/model-dispatch-fallback.js';
+export type ReviewDispatchRequest = {
+    directory: string;
+    parentSessionId?: string;
+    /** Already-resolved reviewer or validator agent name. */
+    agentName: string;
+    model?: ModelOverride;
+    /** Complete replacement system prompt for the isolated review session. */
+    system: string;
+    prompt: string;
+    title?: string;
+    timeoutMs?: number;
+    promptByteLimit?: number;
+    responseByteLimit?: number;
+    abortSignal?: AbortSignal;
+};
+export type ReviewDispatchResult = EphemeralAgentDispatchResult;
+export interface ReviewModelDispatcher {
+    dispatch(request: ReviewDispatchRequest): Promise<ReviewDispatchResult>;
+}
+/**
+ * Bind an OpenCode client to the shared ephemeral-session primitive.
+ *
+ * The returned dispatcher is instance-local and safe to inject into hooks and
+ * tools; it does not read or mutate module-level client state.
+ */
+export declare function createReviewModelDispatcher(client: OpencodeClient): ReviewModelDispatcher;

package/dist/review/diff-source.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Canonical, bounded Git diff collection for review-model consumers.
+ *
+ * This module is intentionally independent from hooks and command dispatch so
+ * automatic review, phase review, Lean review, and `/swarm review` can bind to
+ * one identical scope. Every Git child is array-spawned with an explicit cwd,
+ * ignored stdin, bounded streams, a timeout, and best-effort cleanup.
+ */
+import * as fs from 'node:fs';
+import { bunSpawn } from '../utils/bun-compat.js';
+export interface InclusiveLineRange {
+    start: number;
+    end: number;
+}
+export type ReviewDiffSelector = {
+    kind: 'default';
+} | {
+    kind: 'base';
+    ref: string;
+} | {
+    kind: 'range';
+    from: string;
+    to: string;
+    operator: '..' | '...';
+} | {
+    kind: 'working-tree';
+};
+export type ReviewDiffSelectorParseResult = {
+    ok: true;
+    selector: ReviewDiffSelector;
+    json: boolean;
+} | {
+    ok: false;
+    code: 'INVALID_ARGUMENT' | 'INVALID_REF' | 'AMBIGUOUS_SELECTOR';
+    reason: string;
+};
+export type ReviewDiffSkipCode = 'UNSAFE_PATH' | 'PATH_OUTSIDE_ROOT' | 'MISSING_FILE' | 'SYMLINK_OR_REPARSE' | 'NON_REGULAR_FILE' | 'BINARY_FILE' | 'UNREADABLE_FILE' | 'UNTRACKED_FILE_TRUNCATED' | 'TOTAL_SCOPE_TRUNCATED' | 'UNPARSEABLE_DIFF_PATH' | 'TRACKED_BINARY' | 'CONCURRENT_PATH_MUTATION' | 'FILE_LIST_FALLBACK_TRUNCATED' | 'FILE_LIST_FALLBACK_INCOMPLETE' | 'FILE_LIST_FALLBACK_UNAVAILABLE';
+export interface ReviewDiffSkipReason {
+    code: ReviewDiffSkipCode;
+    path?: string;
+    detail: string;
+}
+export interface ReviewDiffCompleteness {
+    complete: boolean;
+    truncated: boolean;
+    skipReasons: ReviewDiffSkipReason[];
+    fileListFallback?: {
+        files: string[];
+        complete: boolean;
+        truncated: boolean;
+    };
+}
+export interface ReviewDiffFileScope {
+    kind: 'added' | 'modified' | 'deleted' | 'renamed';
+    oldPath?: string;
+    newPath?: string;
+}
+export interface ParsedUnifiedDiffScope {
+    changedLines: Map<string, InclusiveLineRange[]>;
+    deletedLines: Map<string, InclusiveLineRange[]>;
+    files: Map<string, ReviewDiffFileScope>;
+    warnings: ReviewDiffSkipReason[];
+}
+export interface ReviewDiffStalenessMetadata {
+    collectedAt: string;
+    headSha: string;
+    selectorKey: string;
+    includesWorkingTree: boolean;
+    scopeHash: string;
+}
+interface ReviewDiffScopeFields {
+    selector: ReviewDiffSelector;
+    canonicalText: string;
+    reviewTextBytes: number;
+    scopeHash: string;
+    headSha: string;
+    baseRef?: string;
+    baseSha?: string;
+    mergeBase?: string;
+    rangeToSha?: string;
+    changedLines: Map<string, InclusiveLineRange[]>;
+    deletedLines: Map<string, InclusiveLineRange[]>;
+    files: Map<string, ReviewDiffFileScope>;
+    completeness: ReviewDiffCompleteness;
+    staleness: ReviewDiffStalenessMetadata;
+}
+export type ReviewDiffResult = ({
+    status: 'ok';
+} & ReviewDiffScopeFields) | ({
+    status: 'clean';
+} & ReviewDiffScopeFields) | {
+    status: 'error';
+    code: 'INVALID_DIRECTORY' | 'NOT_REPOSITORY_ROOT' | 'HEAD_UNAVAILABLE' | 'BASE_UNAVAILABLE' | 'MERGE_BASE_UNAVAILABLE' | 'GIT_FAILED' | 'GIT_TIMEOUT' | 'GIT_OUTPUT_LIMIT';
+    reason: string;
+};
+export interface CollectReviewDiffOptions {
+    directory: string;
+    selector?: ReviewDiffSelector;
+    timeoutMs?: number;
+    maxBytes?: number;
+    maxUntrackedFileBytes?: number;
+}
+/**
+ * Parse `/swarm review` argv. Exactly one selector is accepted; `--json` is
+ * orthogonal and may appear before or after it.
+ */
+export declare function parseReviewDiffSelector(argv: readonly string[]): ReviewDiffSelectorParseResult;
+/**
+ * Parse actual +/- lines, rather than trusting hunk counts. A line is eligible
+ * for anchoring only when its content was present in the exact text sent to the
+ * reviewer; a line-boundary-truncated hunk therefore cannot overclaim scope.
+ */
+export declare function parseUnifiedDiffScope(text: string): ParsedUnifiedDiffScope;
+/**
+ * Collect one canonical review scope. Default/base scopes are merge-base
+ * through the current tracked working tree plus safe untracked text. Exact
+ * ranges are committed-only. Working-tree scopes compare HEAD to tracked and
+ * safe untracked content.
+ */
+export declare function collectReviewDiff(options: CollectReviewDiffOptions): Promise<ReviewDiffResult>;
+/**
+ * File-scoped injection seam. Production reads through this object at each
+ * call site so tests can replace one boundary without process-global mocks.
+ */
+export declare const _internals: {
+    bunSpawn: typeof bunSpawn;
+    realpathSync: typeof fs.realpathSync;
+    lstatBigIntSync: (path: fs.PathLike) => fs.BigIntStats;
+    openSync: typeof fs.openSync;
+    fstatBigIntSync: (fd: number) => fs.BigIntStats;
+    readSync: typeof fs.readSync;
+    closeSync: typeof fs.closeSync;
+};
+export {};

package/dist/review/engine.d.ts

@@ -0,0 +1,60 @@
+import type { AutoReviewConfig } from '../config/schema.js';
+import { persistReviewReceipt } from '../hooks/review-receipt.js';
+import type { ModelOverride } from '../utils/model-dispatch-fallback.js';
+import type { ReviewModelDispatcher } from './contracts.js';
+import { collectReviewDiff, type ReviewDiffResult, type ReviewDiffSelector } from './diff-source.js';
+import { type AutoReviewEvidenceFinding, persistAutoReviewEvidence, readAutoReviewEvidenceForPhase } from './evidence.js';
+export type ReviewEngineTrigger = 'task_completion' | 'phase_completion' | 'plan_completion' | 'manual';
+export interface RunReviewEngineInput {
+    directory: string;
+    sessionID: string;
+    trigger: ReviewEngineTrigger;
+    phase?: number;
+    selector?: ReviewDiffSelector;
+    config: AutoReviewConfig;
+    dispatcher: ReviewModelDispatcher;
+    reviewerAgent: string;
+    validatorAgent: string;
+    reviewerModel?: ModelOverride;
+    reviewerFallbackModels?: ModelOverride[];
+    validatorModel?: ModelOverride;
+    validatorFallbackModels?: readonly ModelOverride[];
+    injectAdvisory?: (sessionID: string, message: string) => void;
+}
+export interface ReviewEngineResult {
+    status: 'completed' | 'clean' | 'error';
+    /** Parsed reviewer verdict when a model response completed successfully. */
+    reviewVerdict?: 'approved' | 'rejected';
+    blocked: boolean;
+    blockReason?: 'DIFF_COLLECTION_FAILED' | 'REVIEW_DISPATCH_FAILED' | 'INCOMPLETE_REVIEW_EVIDENCE' | 'INCOMPLETE_SCOPE' | 'INCOMPLETE_VALIDATION' | 'REVIEW_SCOPE_STALE' | 'EVIDENCE_PERSISTENCE_FAILED' | 'CONFIRMED_FINDINGS';
+    message: string;
+    findings: AutoReviewEvidenceFinding[];
+    blockingFindings: AutoReviewEvidenceFinding[];
+    validationComplete: boolean;
+    receiptPath?: string;
+    evidencePath?: string;
+    scopeHash?: string;
+    scopeComplete?: boolean;
+    scopeWarnings?: string[];
+    scopeFileList?: string[];
+    scopeFileListComplete?: boolean;
+    reviewModel?: string;
+    modelCalls: number;
+}
+export declare const REVIEW_SYSTEM_PROMPT: string;
+interface BuildReviewPromptInput {
+    trigger: ReviewEngineTrigger;
+    diff: Extract<ReviewDiffResult, {
+        status: 'ok';
+    }>;
+    phase?: number;
+}
+export declare function buildReviewPrompt(input: BuildReviewPromptInput): string;
+export declare function runReviewEngine(input: RunReviewEngineInput): Promise<ReviewEngineResult>;
+export declare const _internals: {
+    collectReviewDiff: typeof collectReviewDiff;
+    persistEvidence: typeof persistAutoReviewEvidence;
+    persistReceipt: typeof persistReviewReceipt;
+    readPhaseEvidence: typeof readAutoReviewEvidenceForPhase;
+};
+export {};

package/dist/review/evidence.d.ts

@@ -0,0 +1,88 @@
+import { type FindingValidation, type ReviewFinding } from '../agents/agent-output-schema.js';
+import { type ReviewFindingSeverity, type ReviewReceipt } from '../hooks/review-receipt.js';
+import type { ReviewDiffCompleteness, ReviewDiffSelector } from './diff-source.js';
+export interface AutoReviewEvidenceFinding extends ReviewFinding {
+    finding_id: string;
+    duplicate_count: number;
+    anchored: boolean;
+    anchor_rejection?: string;
+    effective_severity: ReviewFindingSeverity;
+    validation?: FindingValidation;
+}
+export interface AutoReviewEvidence {
+    schema_version: 1;
+    timestamp: string;
+    trigger: 'task_completion' | 'phase_completion' | 'plan_completion' | 'manual';
+    session_id: string;
+    phase?: number;
+    scope: {
+        hash: string;
+        selector: ReviewDiffSelector;
+        head_sha: string;
+        base_ref?: string;
+        base_sha?: string;
+        merge_base?: string;
+        range_to_sha?: string;
+        review_text_bytes: number;
+        completeness: ReviewDiffCompleteness;
+    };
+    policy: {
+        mode: 'advisory' | 'gate';
+        min_confidence: number;
+        structured_findings: boolean;
+        validate_findings: boolean;
+    };
+    review: {
+        status: 'completed' | 'clean' | 'error';
+        output_mode?: 'structured' | 'legacy';
+        overall_confidence?: number;
+        error?: string;
+        model?: string;
+        duration_ms?: number;
+    };
+    findings: AutoReviewEvidenceFinding[];
+    validation_complete: boolean;
+    validation_error?: string;
+    blocking_finding_ids: string[];
+    receipt_path?: string;
+    cost: {
+        model_calls: number;
+        diff_bytes: number;
+        prompt_bytes: number;
+        tokens_input: number;
+        tokens_output: number;
+        tokens_reasoning: number;
+        tokens_cache: number;
+        cost_usd: number | null;
+        cost_source: 'reported' | 'estimated' | 'unavailable';
+    };
+}
+export declare function autoReviewEvidenceRelativePath(trigger: AutoReviewEvidence['trigger'], scopeHash: string, phase?: number): string;
+export interface PersistAutoReviewEvidenceOptions {
+    /** Rebuild the exact reviewed scope immediately before the atomic rename. */
+    verifyCurrent?: () => Promise<boolean>;
+}
+export declare function persistAutoReviewEvidence(directory: string, evidence: AutoReviewEvidence, options?: PersistAutoReviewEvidenceOptions): Promise<string>;
+export declare function readAutoReviewEvidenceForPhase(directory: string, phase: number): AutoReviewEvidence | null;
+export declare function isAutoReviewEvidence(value: unknown): value is AutoReviewEvidence;
+export interface AutoReviewEvidenceExpectation {
+    scopeHash: string;
+    phase: number;
+    trigger: 'phase_completion' | 'plan_completion';
+    policy: AutoReviewEvidence['policy'];
+    /** Canonical diff text used to bind the independent receipt to this scope. */
+    scopeContent?: string;
+}
+export type AutoReviewEvidenceIntegrityResult = {
+    ok: true;
+    receipt?: ReviewReceipt;
+} | {
+    ok: false;
+    code: 'evidence' | 'receipt_missing' | 'receipt';
+    reason: string;
+};
+/**
+ * Cross-validates phase evidence against its independently persisted receipt.
+ * Callers must fail closed on any non-ok result; this function never dispatches.
+ */
+export declare function validateAutoReviewEvidenceIntegrity(directory: string, evidence: AutoReviewEvidence, expected: AutoReviewEvidenceExpectation): AutoReviewEvidenceIntegrityResult;

package/dist/review/finding-validator.d.ts

@@ -0,0 +1,77 @@
+import { type FindingValidation, type ReviewFinding } from '../agents/agent-output-schema.js';
+import type { ModelOverride } from '../utils/model-dispatch-fallback.js';
+import type { ReviewDispatchResult, ReviewModelDispatcher } from './contracts.js';
+import type { ReviewDiffCompleteness, ReviewDiffSelector } from './diff-source.js';
+export interface ValidationCandidate extends ReviewFinding {
+    finding_id: string;
+    duplicate_count: number;
+}
+export interface FindingValidationResult {
+    complete: boolean;
+    candidates: ValidationCandidate[];
+    validations: FindingValidation[];
+    /**
+     * Every model dispatch attempted, in configured order.
+     *
+     * Callers own telemetry and aggregate cost accounting from this list. The
+     * validator deliberately emits no telemetry so synchronous engine review and
+     * asynchronous receipt validation cannot double-count the same attempt.
+     */
+    attempts: readonly ReviewDispatchResult[];
+    error?: string;
+    /** Terminal completed or failed attempt retained for compatibility. */
+    dispatch?: ReviewDispatchResult;
+}
+export interface FindingValidationScopeContext {
+    selector: ReviewDiffSelector;
+    canonicalText: string;
+    scopeHash: string;
+    headSha: string;
+    baseRef?: string;
+    baseSha?: string;
+    mergeBase?: string;
+    rangeToSha?: string;
+    completeness: ReviewDiffCompleteness;
+    /** Optional Stage-B manifest description when canonicalText is not a diff. */
+    scopeDescription?: string;
+    /** Exact files represented by a Stage-B reviewer manifest. */
+    files?: string[];
+}
+export interface RunFindingValidationInput {
+    dispatcher: ReviewModelDispatcher;
+    directory: string;
+    parentSessionId?: string;
+    agentName: string;
+    model?: ModelOverride;
+    /** Plugin-instance-local configured fallback chain, in declared order. */
+    fallbackModels?: readonly ModelOverride[];
+    timeoutMs: number;
+    findings: Array<ReviewFinding | ValidationCandidate>;
+    /**
+     * Exact bounded scope reviewed by the originating reviewer.
+     *
+     * Receipt-only callers may omit this when they do not own canonical diff
+     * evidence. The shared review engine always supplies it so arbitrary ranges
+     * remain bound to their resolved target even when that target is not checked
+     * out in the validator's working directory.
+     */
+    scopeContext?: FindingValidationScopeContext;
+    abortSignal?: AbortSignal;
+}
+export declare const MAX_VALIDATOR_FALLBACK_MODELS = 3;
+export declare function canonicalizeValidationCandidates(findings: Array<ReviewFinding | ValidationCandidate>): ValidationCandidate[];
+export declare function runFindingValidation(input: RunFindingValidationInput): Promise<FindingValidationResult>;
+export declare const MAX_TRACKED_VALIDATION_SESSIONS = 256;
+export interface FindingValidationScheduler {
+    schedule: (validationIdentity: string, run: () => Promise<FindingValidationResult>, onComplete: (result: FindingValidationResult) => void | Promise<void>, onError?: (error: unknown) => void | Promise<void>) => boolean;
+    /** Instance-local test/lifecycle seam. */
+    reset: () => void;
+    readonly pendingCount: number;
+}
+/**
+ * Creates one bounded finding-validation scheduler for one plugin instance.
+ *
+ * Keeping the pending map in this closure is load-bearing: a saturated plugin
+ * instance must not consume another instance's 256 live validation slots.
+ */
+export declare function createFindingValidationScheduler(): FindingValidationScheduler;

package/dist/review/phase-runner.d.ts

@@ -0,0 +1,37 @@
+import type { AutoReviewConfig } from '../config/schema.js';
+import type { ReviewModelDispatcher } from './contracts.js';
+import { type ReviewEngineResult, runReviewEngine } from './engine.js';
+import { type ReviewAgentModelRegistry } from './runtime.js';
+export interface RunPhaseAutoReviewInput {
+    directory: string;
+    sessionID: string;
+    phase: number;
+    isFinalPlanPhase: boolean;
+    activeLeanTurbo: boolean;
+    config: AutoReviewConfig;
+    dispatcher?: ReviewModelDispatcher;
+    generatedAgentNames: Iterable<string>;
+    activeAgentName?: string;
+    agentModelRegistry?: ReviewAgentModelRegistry;
+    injectAdvisory: (sessionID: string, message: string) => void;
+}
+export interface PhaseAutoReviewResult {
+    trigger?: 'phase_completion' | 'plan_completion';
+    scopeHash?: string;
+    scopeComplete?: boolean;
+    blocked?: boolean;
+    blockReason?: ReviewEngineResult['blockReason'];
+    warnings: string[];
+}
+/**
+ * Return whether phase completion needs plan context to select a phase or
+ * final-plan review trigger.
+ *
+ * Keep this preflight free of I/O so the phase_complete path does not replay
+ * the plan ledger when auto-review is disabled or task-only.
+ */
+export declare function mayRunPhaseAutoReview(config: AutoReviewConfig): boolean;
+export declare function runPhaseAutoReview(input: RunPhaseAutoReviewInput): Promise<PhaseAutoReviewResult>;
+export declare const _internals: {
+    runReviewEngine: typeof runReviewEngine;
+};

package/dist/review/runtime.d.ts

@@ -0,0 +1,32 @@
+import { type PluginConfig } from '../config/schema.js';
+import { type ModelOverride } from '../utils/model-dispatch-fallback.js';
+export interface ReviewAgentModelConfig {
+    readonly primaryModel?: string;
+    readonly fallbackModels: readonly string[];
+}
+/**
+ * Immutable, plugin-instance-local model configuration keyed by generated
+ * agent name. Runtime review paths must consume this snapshot instead of the
+ * process-global agent map, which can be overwritten by another plugin
+ * instance in the same host process.
+ */
+export type ReviewAgentModelRegistry = Readonly<Record<string, ReviewAgentModelConfig>>;
+export interface ReviewAgentNames {
+    reviewer: string;
+    validator: string;
+}
+/**
+ * Resolve a generated role from the active agent's exact swarm prefix.
+ *
+ * When no active identity is available, only unambiguous registries are
+ * accepted: a single candidate or an explicit default-swarm (bare) role.
+ * Multiple named swarms without either signal fail closed instead of routing
+ * work to an unrelated longest/alphabetical prefix.
+ */
+export declare function resolveAgentForActiveSwarm(generatedAgentNames: Iterable<string>, role: string, activeAgentName?: string): string;
+export declare function resolveReviewAgentNames(generatedAgentNames: Iterable<string>, activeAgentName?: string): ReviewAgentNames;
+export declare function captureReviewAgentModelRegistry(config: PluginConfig | undefined, generatedAgentNames: Iterable<string>): ReviewAgentModelRegistry;
+export declare function reviewFallbackModelStrings(agentName: string, registry: ReviewAgentModelRegistry | undefined): readonly string[];
+export declare function reviewPrimaryModel(agentName: string, registry: ReviewAgentModelRegistry | undefined): string | undefined;
+export declare function resolveReviewFallbackModels(agentName: string, registry: ReviewAgentModelRegistry | undefined): ModelOverride[];
+export declare function optionalModelOverride(model: string | null | undefined): ModelOverride | undefined;

package/dist/scope/scope-binding.d.ts

@@ -37,6 +37,15 @@ export declare function createScopeBinding(input: {
     ttlMs?: number;
 }): ScopeBinding | null;
 export declare function registerScopeBinding(binding: ScopeBinding): void;
+/**
+ * Resolve the binding created for one fully-approved parent Task dispatch.
+ * An already-claimed child binding wins over its pending parent precursor;
+ * multiple candidates at either specificity fail closed.
+ */
+export declare function getScopeBindingForParentDispatch(input: {
+    parentSessionId: string;
+    dispatchCallId: string;
+}): ScopeBinding | null;
 export declare function getScopeBinding(input: {
     directory: string;
     plan: Plan;

package/dist/services/config-doctor.d.ts

@@ -63,6 +63,18 @@ export interface ConfigDoctorResult {
     timestamp: number;
     /** The config that was analyzed */
     configSource: string;
+    /**
+     * Migration availability metadata. Present when the loaded config's
+     * config_format_version predates the deprecatedIn version of any
+     * DEPRECATED_FIELDS entry.
+     */
+    availableMigrations?: Array<{
+        field: string;
+        replacement: string;
+        deprecatedIn: number;
+        sinceVersion: number;
+        currentFormatVersion: number;
+    }>;
 }
 /** Backup artifact for rollback */
 export interface ConfigBackup {

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

@@ -43,6 +43,8 @@ export interface SerializedAgentSession {
     qaSkipTaskIds: string[];
     pendingAdvisoryMessages: string[];
     taskWorkflowStates?: Record<string, string>;
+    /** Task-keyed coder file attribution. Optional for backward compatibility. */
+    modifiedFilesByTask?: Record<string, string[]>;
     /** Flag for one-shot scope violation warning injection (omitted when undefined for additive-only schema) */
     scopeViolationDetected?: boolean;
     /** Current index into the fallback_models array (v6.33) */