opencode-swarm 7.145.1 → 7.145.2

package/dist/plan/manager.d.ts

@@ -155,6 +155,14 @@ export declare function savePlan(directory: string, plan: Plan, options?: {
         expectedSeq: number;
         expectedLedgerHash: string;
     };
+    /**
+     * Optional synchronous CAS guard for a caller whose authoritative write is
+     * conditioned on external evidence. It is invoked immediately before every
+     * ledger/projection mutation and must throw when the captured identity is
+     * stale. Keep it synchronous so no writer can interleave in this process
+     * between the final check and the atomic filesystem operation.
+     */
+    preCommitCheck?: () => void;
 }): Promise<void>;
 /**
  * Rebuild plan from ledger events.

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

@@ -69,6 +69,34 @@ export interface ReviewDiffStalenessMetadata {
     includesWorkingTree: boolean;
     scopeHash: string;
 }
+export interface ReviewManifestIdentity {
+    algorithm: 'sha256' | 'git-blob';
+    sha256?: string;
+    byte_length?: number;
+    git_blob_oid?: string;
+    git_object_format?: string;
+}
+export interface ReviewManifestPathRecord {
+    kind: ReviewDiffFileScope['kind'];
+    old_path?: string;
+    new_path?: string;
+    old_identity?: ReviewManifestIdentity;
+    new_identity?: ReviewManifestIdentity;
+}
+export interface ReviewDiffManifest {
+    schema_version: 2;
+    hash: string;
+    content_hash: string;
+    selector: ReviewDiffSelector;
+    selector_key: string;
+    review_target_kind: 'checkout-history-index-working-tree' | 'checkout-index-working-tree' | 'exact-committed-range';
+    completeness: {
+        complete: boolean;
+        truncated: boolean;
+        skip_reason_codes: ReviewDiffSkipCode[];
+    };
+    path_records: ReviewManifestPathRecord[];
+}
 interface ReviewDiffScopeFields {
     selector: ReviewDiffSelector;
     canonicalText: string;
@@ -84,6 +112,7 @@ interface ReviewDiffScopeFields {
     files: Map<string, ReviewDiffFileScope>;
     completeness: ReviewDiffCompleteness;
     staleness: ReviewDiffStalenessMetadata;
+    manifest: ReviewDiffManifest;
 }
 export type ReviewDiffResult = ({
     status: 'ok';
@@ -132,5 +161,6 @@ export declare const _internals: {
     readSync: typeof fs.readSync;
     closeSync: typeof fs.closeSync;
     resolveGitExecutable: typeof resolveGitExecutableAsync;
+    now: () => number;
 };
 export {};

package/dist/review/engine.d.ts

@@ -34,6 +34,7 @@ export interface ReviewEngineResult {
     receiptPath?: string;
     evidencePath?: string;
     scopeHash?: string;
+    manifestHash?: string;
     scopeComplete?: boolean;
     scopeWarnings?: string[];
     scopeFileList?: string[];

package/dist/review/evidence.d.ts

@@ -1,6 +1,8 @@
 import { type FindingValidation, type ReviewFinding } from '../agents/agent-output-schema.js';
+import type { Plan } from '../config/plan-schema.js';
+import type { AutoReviewConfig } from '../config/schema.js';
 import { type ReviewFindingSeverity, type ReviewReceipt } from '../hooks/review-receipt.js';
-import type { ReviewDiffCompleteness, ReviewDiffSelector } from './diff-source.js';
+import type { ReviewDiffCompleteness, ReviewDiffManifest, ReviewDiffSelector } from './diff-source.js';
 export interface AutoReviewEvidenceFinding extends ReviewFinding {
     finding_id: string;
     duplicate_count: number;
@@ -9,8 +11,13 @@ export interface AutoReviewEvidenceFinding extends ReviewFinding {
     effective_severity: ReviewFindingSeverity;
     validation?: FindingValidation;
 }
+export interface AutoReviewScopeManifest extends ReviewDiffManifest {
+    plan_requirements_hash: string;
+    review_policy_digest: string;
+    hash: string;
+}
 export interface AutoReviewEvidence {
-    schema_version: 1;
+    schema_version: 1 | 2;
     timestamp: string;
     trigger: 'task_completion' | 'phase_completion' | 'plan_completion' | 'manual';
     session_id: string;
@@ -25,12 +32,14 @@ export interface AutoReviewEvidence {
         range_to_sha?: string;
         review_text_bytes: number;
         completeness: ReviewDiffCompleteness;
+        manifest?: AutoReviewScopeManifest;
     };
     policy: {
         mode: 'advisory' | 'gate';
         min_confidence: number;
         structured_findings: boolean;
         validate_findings: boolean;
+        digest?: string;
     };
     review: {
         status: 'completed' | 'clean' | 'error';
@@ -57,6 +66,7 @@ export interface AutoReviewEvidence {
         cost_source: 'reported' | 'estimated' | 'unavailable';
     };
 }
+export declare function computeAutoReviewManifestHash(manifest: Omit<AutoReviewScopeManifest, 'hash'>): string;
 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. */
@@ -65,6 +75,10 @@ export interface PersistAutoReviewEvidenceOptions {
 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 declare function computePlanRequirementsHash(directory: string): Promise<string>;
+export declare function computeAutoReviewPolicyDigest(config: AutoReviewConfig): string;
+export declare function materializeAutoReviewManifest(directory: string, manifest: ReviewDiffManifest, config: AutoReviewConfig): Promise<AutoReviewScopeManifest>;
+export declare function computeReviewPlanRequirementsHash(plan: Plan): string;
 export interface AutoReviewEvidenceExpectation {
     scopeHash: string;
     phase: number;

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

@@ -18,6 +18,7 @@ export interface RunPhaseAutoReviewInput {
 export interface PhaseAutoReviewResult {
     trigger?: 'phase_completion' | 'plan_completion';
     scopeHash?: string;
+    manifestHash?: string;
     scopeComplete?: boolean;
     blocked?: boolean;
     blockReason?: ReviewEngineResult['blockReason'];

package/dist/tools/completion-verify.d.ts

@@ -14,6 +14,8 @@ export interface CompletionVerifyArgs {
     sessionID?: string;
     /** Explicit project root directory override */
     working_directory?: string;
+    /** Internal observational mode used by aggregate phase preflight. */
+    writeEvidence?: boolean;
 }
 /**
  * Execute the completion verification check

package/dist/tools/convene-council.d.ts

@@ -8,9 +8,9 @@ export declare const ArgsSchema: z.ZodObject<{
     verdicts: z.ZodArray<z.ZodObject<{
         agent: z.ZodEnum<{
             reviewer: "reviewer";
+            test_engineer: "test_engineer";
             critic: "critic";
             explorer: "explorer";
-            test_engineer: "test_engineer";
             sme: "sme";
         }>;
         verdict: z.ZodEnum<{

package/dist/tools/index.d.ts

@@ -54,11 +54,15 @@ export { pr_workflow_status } from './pr-workflow-status';
 export { type PreCheckBatchInput, type PreCheckBatchResult, pre_check_batch, runPreCheckBatch, type ToolResult, } from './pre-check-batch';
 export { executePreparePrFeedbackScope, prepare_pr_feedback_scope, } from './prepare-pr-feedback-scope';
 export { type QualityBudgetInput, type QualityBudgetResult, quality_budget, qualityBudget, } from './quality-budget';
+export { executeRecordDirectiveOverride, record_directive_override, } from './record-directive-override';
+export { executeRepairGateEvidence, repair_gate_evidence, } from './repair-gate-evidence';
+export { executeRepairKnowledgeReceiptLedger, repair_knowledge_receipt_ledger, } from './repair-knowledge-receipt-ledger';
 export { buildWorkspaceGraph, type GraphEdge, type GraphNode, loadGraph, loadOrCreateGraph, type RepoGraph, resolveModuleSpecifier, saveGraph, updateGraphForFiles, } from './repo-graph';
 export { repo_map } from './repo-map';
 export { req_coverage } from './req-coverage';
 export { retrieve_lane_output } from './retrieve-lane-output';
 export { retrieve_summary } from './retrieve-summary';
+export { createRunPhaseReviewTool, executeRunPhaseReview, run_phase_review, } from './run-phase-review';
 export { type SastScanFinding, type SastScanInput, type SastScanResult, sast_scan, sastScan, } from './sast-scan';
 export type { SavePlanArgs, SavePlanResult } from './save-plan';
 export { save_plan } from './save-plan';

package/dist/tools/manifest.d.ts

@@ -74,6 +74,10 @@ export declare const TOOL_MANIFEST: {
     retrieve_lane_output: () => ToolDefinition;
     extract_code_blocks: () => ToolDefinition;
     phase_complete: () => ToolDefinition;
+    run_phase_review: () => ToolDefinition;
+    repair_gate_evidence: () => ToolDefinition;
+    repair_knowledge_receipt_ledger: () => ToolDefinition;
+    record_directive_override: () => ToolDefinition;
     save_plan: () => ToolDefinition;
     update_task_status: () => ToolDefinition;
     lint_spec: () => ToolDefinition;

package/dist/tools/phase-complete/gates/final-review-gate.d.ts

@@ -3,10 +3,10 @@ import type { GateContext, GateResult } from './types.js';
 /**
  * Evidence-only final review gate.
  *
- * The model dispatch belongs to the phase_complete tool body. This gate performs
+ * Model dispatch belongs to the explicit run_phase_review recovery tool. This gate performs
  * one bounded, model-free scope collection at the terminal decision point, then
- * verifies that the persisted artifact and in-memory result both describe that
- * current scope and that the configured blocking policy is satisfied.
+ * verifies that the persisted artifact describes that current scope and that
+ * the configured blocking policy is satisfied.
  */
 export declare function runFinalReviewGate(ctx: GateContext): Promise<GateResult>;
 /**

package/dist/tools/phase-complete/gates/types.d.ts

@@ -40,13 +40,13 @@ export interface GateContext {
     loadedRetroBundle?: import('../../../config/evidence-schema').EvidenceBundle | null;
     /** Task id for the accepted retrospective bundle, if one was loaded */
     loadedRetroTaskId?: string | null;
-    /** Exact scope produced by the model-dispatching phase_complete body. */
+    /** Legacy compatibility field; current final review derives persisted scope. */
     autoReviewScopeHash?: string;
     /** Completeness of the freshly collected in-memory review scope. */
     autoReviewScopeComplete?: boolean;
     /** Distinguishes ordinary phase review from the final durable plan phase. */
     autoReviewTrigger?: 'phase_completion' | 'plan_completion';
-    /** Fresh in-memory disposition from the review run owned by phase_complete. */
+    /** Legacy compatibility field for callers carrying a fresh disposition. */
     autoReviewBlocked?: boolean;
     /** Machine-readable reason from the current review run, when blocked. */
     autoReviewBlockReason?: import('../../../review/engine').ReviewEngineResult['blockReason'];

package/dist/tools/phase-complete/preflight-report.d.ts

@@ -0,0 +1,66 @@
+import type { GateResult } from './gates/types.js';
+export type PhaseGateOutcome = 'pass' | 'block' | 'error' | 'not_applicable';
+export interface PhaseGateRecovery {
+    kind: 'tool' | 'command' | 'retry' | 'user_action';
+    action: string;
+    args?: Record<string, unknown>;
+}
+export interface PhaseGateEntry {
+    id: string;
+    code: string;
+    outcome: PhaseGateOutcome;
+    detail?: string;
+    evidenceRefs: string[];
+    responsibleActor: string;
+    recovery?: PhaseGateRecovery;
+    requiredRecoveryKind?: PhaseGateRecovery['kind'];
+    agentsDispatched: string[];
+    agentsMissing: string[];
+    warnings: string[];
+    recoveryGuidance?: string;
+    phase_council_required?: boolean;
+    final_council_required?: boolean;
+    retrospective_gate?: {
+        schema_valid: boolean;
+        gate_pass: boolean;
+        verdict?: 'pass' | 'fail';
+    };
+}
+export interface PhaseGateReport {
+    schemaVersion: 1;
+    phase: number;
+    outcome: 'pass' | 'block';
+    reportHash: string;
+    entries: PhaseGateEntry[];
+}
+export interface PhaseGateCheck {
+    id: string;
+    responsibleActor: string;
+    applicable?: boolean;
+    notApplicableDetail?: string;
+    run: () => Promise<GateResult>;
+    timeoutMs?: number;
+}
+export declare function collectPhaseGateReport(input: {
+    phase: number;
+    checks: readonly PhaseGateCheck[];
+}): Promise<PhaseGateReport>;
+export declare function formatPhaseGateCompatibility(report: PhaseGateReport): {
+    success: boolean;
+    phase: number;
+    status: 'success' | 'blocked' | 'incomplete';
+    reason?: string;
+    message?: string;
+    agentsDispatched: string[];
+    agentsMissing: string[];
+    warnings: string[];
+    gate_report: PhaseGateReport;
+    retrospective_gate?: {
+        schema_valid: boolean;
+        gate_pass: boolean;
+        verdict?: 'pass' | 'fail';
+    };
+    recovery_guidance?: string;
+    phase_council_required?: boolean;
+    final_council_required?: boolean;
+};

package/dist/tools/phase-complete/snapshot-identity.d.ts

@@ -0,0 +1 @@
+export declare function computePhaseEvidenceSnapshot(directory: string): string;

package/dist/tools/phase-complete.d.ts

@@ -3,6 +3,10 @@
  * Core implementation - gathers data, enforces policy, writes event, resets state.
  */
 import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import { savePlan } from '../plan/manager';
+import type { ReviewModelDispatcher } from '../review/contracts.js';
+import type { ReviewAgentModelRegistry } from '../review/runtime.js';
+import { runArchitectureSupervisorGate, runCompletionVerifyGate, runDriftGate, runFinalCouncilGate, runFinalReviewGate, runHallucinationGate, runMutationGate, runPhaseCouncilGate } from './phase-complete/gates/index.js';
 /** Narrow seam for receipt/plan ordering tests. */
 export declare const phaseCompleteReceiptInternals: {
     recordPhaseCloseIntent: (directory: string, phase: string, sessionId?: string, taskId?: string) => Promise<import("../hooks/knowledge-receipt-ledger.js").ReceiptLedgerResult<{
@@ -12,8 +16,67 @@ export declare const phaseCompleteReceiptInternals: {
         event_id: string;
     }>>;
 };
-import type { ReviewModelDispatcher } from '../review/contracts.js';
-import type { ReviewAgentModelRegistry } from '../review/runtime.js';
+/** Narrow seam for guarded-plan commit tests. */
+export declare const phaseCompleteCommitInternals: {
+    savePlan: (directory: string, plan: {
+        schema_version: "1.0.0";
+        title: string;
+        swarm: string;
+        phases: {
+            id: number;
+            name: string;
+            status: "blocked" | "complete" | "completed" | "pending" | "in_progress" | "closed";
+            tasks: {
+                id: string;
+                phase: number;
+                status: "blocked" | "completed" | "pending" | "in_progress" | "closed";
+                size: "small" | "medium" | "large";
+                description: string;
+                depends: string[];
+                files_touched: string[];
+                acceptance?: string | undefined;
+                evidence_path?: string | undefined;
+                blocked_reason?: string | undefined;
+                fr_refs?: string[] | undefined;
+            }[];
+            type?: "code" | "non-code" | undefined;
+            required_agents?: string[] | undefined;
+        }[];
+        current_phase?: number | undefined;
+        migration_status?: "migrated" | "native" | "migration_failed" | undefined;
+        specMtime?: string | undefined;
+        specHash?: string | undefined;
+        execution_profile?: {
+            parallelization_enabled: boolean;
+            max_concurrent_tasks: number;
+            council_parallel: boolean;
+            locked: boolean;
+            auto_proceed: boolean;
+            commit_after_each_completed_task: boolean;
+            planning_profile?: "balanced" | "strict" | undefined;
+        } | undefined;
+    }, options?: {
+        preserveCompletedStatuses?: boolean;
+        acknowledged_removals?: import("../plan/manager").AcknowledgedRemovals;
+        planLockAlreadyHeld?: boolean;
+        staleProjectionReconcile?: {
+            expectedSeq: number;
+            expectedLedgerHash: string;
+        };
+        preCommitCheck?: () => void;
+    } | undefined) => Promise<void>;
+};
+/** Injectable observational gates for aggregate-preflight regression tests. */
+export declare const phaseCompletePreflightInternals: {
+    runCompletionVerifyGate: typeof runCompletionVerifyGate;
+    runDriftGate: typeof runDriftGate;
+    runHallucinationGate: typeof runHallucinationGate;
+    runMutationGate: typeof runMutationGate;
+    runPhaseCouncilGate: typeof runPhaseCouncilGate;
+    runArchitectureSupervisorGate: typeof runArchitectureSupervisorGate;
+    runFinalReviewGate: typeof runFinalReviewGate;
+    runFinalCouncilGate: typeof runFinalCouncilGate;
+};
 /**
  * Arguments for the phase_complete tool
  */
@@ -52,7 +115,7 @@ declare function allCompletedTasksHavePassedGateEvidence(directory: string, task
  * Execute the phase_complete tool
  * Gathers data, enforces policy, writes event, resets state
  */
-export declare function executePhaseComplete(args: PhaseCompleteArgs, workingDirectory?: string, directory?: string, runtime?: PhaseCompleteRuntime): Promise<string>;
+export declare function executePhaseComplete(args: PhaseCompleteArgs, workingDirectory?: string, directory?: string, _runtime?: PhaseCompleteRuntime): Promise<string>;
 /** @internal exported for testing only */
 export declare function _buildOutputJson(outputData: {
     phase: number;

package/dist/tools/record-directive-override.d.ts

@@ -0,0 +1,14 @@
+import type { ToolContext, ToolDefinition } from '@opencode-ai/plugin/tool';
+import { recordDirectiveOverrides } from '../hooks/phase-complete-directive-gate.js';
+import { loadPlan } from '../plan/manager.js';
+export interface RecordDirectiveOverrideArgs {
+    directive_ids: string[];
+    justification: string;
+    phase: number;
+}
+export declare const recordDirectiveOverrideInternals: {
+    loadPlan: typeof loadPlan;
+    recordDirectiveOverrides: typeof recordDirectiveOverrides;
+};
+export declare function executeRecordDirectiveOverride(args: RecordDirectiveOverrideArgs, directory: string, ctx?: Pick<ToolContext, 'sessionID' | 'agent'>): Promise<Record<string, unknown>>;
+export declare const record_directive_override: ToolDefinition;

package/dist/tools/repair-gate-evidence.d.ts

@@ -0,0 +1,6 @@
+import type { ToolContext, ToolDefinition } from '@opencode-ai/plugin/tool';
+import { type RepairGateEvidenceArgs } from '../evidence/task-gate-repair.js';
+export declare function executeRepairGateEvidence(args: RepairGateEvidenceArgs & {
+    working_directory?: string;
+}, directory: string, _ctx?: ToolContext): Promise<import("../evidence/task-gate-repair.js").RepairGateEvidenceResult>;
+export declare const repair_gate_evidence: ToolDefinition;

package/dist/tools/repair-knowledge-receipt-ledger.d.ts

@@ -0,0 +1,27 @@
+import type { ToolContext, ToolDefinition } from '@opencode-ai/plugin/tool';
+import { type RepairKnowledgeReceiptLedgerInput } from '../hooks/knowledge-receipt-ledger.js';
+export declare function executeRepairKnowledgeReceiptLedger(args: RepairKnowledgeReceiptLedgerInput & {
+    working_directory?: string;
+}, directory: string, _ctx?: ToolContext): Promise<{
+    success: boolean;
+    message: string;
+    errors: string[];
+    code?: undefined;
+} | {
+    success: boolean;
+    message: string;
+    errors: string[];
+    code: import("../hooks/knowledge-receipt-ledger-storage.js").ReceiptStoreErrorCode | "legacy_unverifiable";
+} | {
+    ok: true;
+    status: "validated_projection" | "repaired_authority" | "pending_re_evaluation";
+    pending_re_evaluation: boolean;
+    repair_id?: string;
+    salvage_through_seq: number;
+    salvage_through_hash: string;
+    success: boolean;
+    message: string;
+    errors?: undefined;
+    code?: undefined;
+}>;
+export declare const repair_knowledge_receipt_ledger: ToolDefinition;

package/dist/tools/run-phase-review.d.ts

@@ -0,0 +1,37 @@
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import { loadPluginConfigWithMeta as loadPluginConfigWithMeta_import } from '../config/index.js';
+import type { ReviewModelDispatcher } from '../review/contracts.js';
+import { type ReviewAgentModelRegistry } from '../review/runtime.js';
+export interface RunPhaseReviewArgs {
+    phase: number;
+    sessionID: string;
+    is_final_plan_phase?: boolean;
+}
+export interface RunPhaseReviewResult {
+    success: boolean;
+    trigger?: 'phase_completion' | 'plan_completion';
+    status?: 'completed' | 'clean' | 'error';
+    blocked?: boolean;
+    blockReason?: string;
+    scopeHash?: string;
+    manifestHash?: string;
+    scopeComplete?: boolean;
+    evidencePath?: string;
+    receiptPath?: string;
+    message: string;
+}
+/**
+ * Test-only dependency-injection seam.
+ * @tool-opt-out Test-only dependency-injection seam; not a public tool.
+ */
+export declare const _internals: {
+    loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta_import;
+};
+export declare function executeRunPhaseReview(directory: string, args: RunPhaseReviewArgs, options?: {
+    dispatcher?: ReviewModelDispatcher;
+    generatedAgentNames?: readonly string[];
+    agentModelRegistry?: ReviewAgentModelRegistry;
+    activeAgentName?: string;
+}): Promise<RunPhaseReviewResult>;
+export declare function createRunPhaseReviewTool(dispatcher?: ReviewModelDispatcher, generatedAgentNames?: readonly string[], agentModelRegistry?: ReviewAgentModelRegistry, getActiveAgentName?: (sessionID: string) => string | undefined): ToolDefinition;
+export declare const run_phase_review: ToolDefinition;

package/dist/tools/submit-phase-council-verdicts.d.ts

@@ -8,9 +8,9 @@ export declare const ArgsSchema: z.ZodObject<{
     verdicts: z.ZodArray<z.ZodObject<{
         agent: z.ZodEnum<{
             reviewer: "reviewer";
+            test_engineer: "test_engineer";
             critic: "critic";
             explorer: "explorer";
-            test_engineer: "test_engineer";
             sme: "sme";
         }>;
         verdict: z.ZodEnum<{