opencode-swarm 7.145.0 → 7.145.2

package/dist/observability/catalog.d.ts

@@ -1,7 +1,7 @@
 /**
  * The event catalog (issue #2029).
  *
- * Exactly 44 entries, matching the `TelemetryEvent` union at
+ * Exactly 45 entries, matching the `TelemetryEvent` union at
  * `src/telemetry.ts:15-92`. Thirty-eight predate the #2029 contract; the 39th is
  * `agent_conflict_detected` (previously emitted through a force-cast past the
  * type system), the 40th is `close_archive_result` (issue #2030 — the
@@ -65,7 +65,7 @@ export interface CatalogEntry {
     /**
      * Whether an event of this kind must carry `trace.parentSpanId`.
      *
-     * `false` for all 44 entries today, and that is a truthful statement about
+     * `false` for all 45 entries today, and that is a truthful statement about
      * the current system rather than a placeholder: no producer supplies a
      * parent span, so `createObservation` never sets one. Setting this to `true`
      * for a kind whose producer cannot supply a parent would make every

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/scope/scope-binding.d.ts

@@ -198,6 +198,22 @@ export declare function clearExactScopeBinding(input: {
 }): ScopeBinding | null;
 export declare function installScopeBindingTombstone(binding: ScopeBinding): void;
 export declare function hasScopeBindingDenyOverlay(binding: ScopeBinding): boolean;
+/**
+ * Issue #2271 bug 5: deny check that ignores purely time-based (sweep)
+ * tombstones. `sweepExpired` installs an 'expired'-lifecycle tombstone at
+ * revision+1 for every lapsed generation on ANY scope read — that is not a
+ * deliberate denial, and the durable CAS in the idle-revival path re-verifies
+ * the on-disk generation anyway. Deliberate revocation classes
+ * ('revoked'/'superseded') and any failed-revocation overlay still deny.
+ */
+export declare function hasDeliberateScopeBindingDenyOverlay(binding: ScopeBinding): boolean;
+/**
+ * Issue #2271 bug 5: remove a sweep-signature tombstone so a durable-CAS
+ * revival can be admitted in memory. Only 'expired'-lifecycle tombstones at
+ * or below the revived revision are cleared — deliberate revocations and any
+ * newer overlay are preserved.
+ */
+export declare function clearSweepTombstoneForRevival(binding: ScopeBinding): void;
 /** Fail-closed overlay used only when durable revocation cannot be verified. */
 export declare function installFailedRevocationOverlay(binding: ScopeBinding, reason: Exclude<ScopeBindingLifecycleState, 'live'>): boolean;
 /**

package/dist/services/model-preflight.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Agent model-resolution preflight (issue #2271 bug 4).
+ *
+ * Agent model strings (DEFAULT_MODELS plus user `agents.<role>.model`
+ * overrides) are handed to the OpenCode host unvalidated. When one does not
+ * resolve ("Model not found", "Forbidden"), dispatch-lanes classifies the
+ * failure as permanent, the affected agent never runs, and the plan-critic
+ * gate wedges into manual `approve_plan_critic` overrides because no APPROVED
+ * verdict is ever produced.
+ *
+ * This module validates configured model IDs against the live provider
+ * catalog (`client.provider.list()`). Every check is FAIL-OPEN: if the catalog
+ * is unreachable or malformed, results come back `unknown` and callers must
+ * proceed — the preflight only acts on a POSITIVE confirmation that a model
+ * does not resolve.
+ */
+import type { OpencodeClient } from '@opencode-ai/sdk';
+import type { PluginConfig } from '../config/schema.js';
+/** Tight bound for the catalog HTTP call — it runs on init/doctor paths. */
+export declare const PROVIDER_LIST_TIMEOUT_MS = 2000;
+export interface ConfiguredAgentModel {
+    /** Agent role the model is configured for. */
+    agent: string;
+    /** Full model id in `provider/model` form. */
+    model: string;
+    /** Where the value came from. */
+    source: 'default' | 'override' | 'fallback';
+}
+export type ModelResolutionStatus = 'ok' | 'unresolved' | 'unknown';
+export interface ModelResolution {
+    agent: string;
+    model: string;
+    source: ConfiguredAgentModel['source'];
+    status: ModelResolutionStatus;
+    /** Human-readable explanation for non-ok statuses. */
+    detail?: string;
+}
+export interface ModelPreflightResult {
+    /** False when the catalog could not be fetched — every entry is `unknown`. */
+    catalogAvailable: boolean;
+    resolutions: ModelResolution[];
+}
+/**
+ * Split a model id into its provider and model parts. Returns null for ids
+ * without a provider prefix (e.g. a bare model name) — those cannot be
+ * validated against a provider catalog.
+ */
+export declare function splitModelId(model: string): {
+    provider: string;
+    model: string;
+} | null;
+/**
+ * Collect every model id the swarm could dispatch with: DEFAULT_MODELS
+ * entries, user agent overrides, and declared fallback_models. Overriding one
+ * role replaces its default (mirrors getModelForAgent precedence).
+ */
+export declare function collectConfiguredAgentModels(config?: PluginConfig): ConfiguredAgentModel[];
+/** Provider catalog snapshot: provider id → set of model ids. */
+export type ProviderCatalog = Map<string, Set<string>>;
+/** Test/gate seam: drop the cached catalogs (used after config changes and denials). */
+export declare function invalidateProviderCatalogCache(): void;
+/**
+ * Fetch the provider catalog. Returns null when the catalog cannot be
+ * obtained or parsed — callers fail open on null.
+ */
+export declare function fetchProviderCatalog(client: OpencodeClient | null): Promise<ProviderCatalog | null>;
+/**
+ * Validate collected models against a catalog. A model whose provider is
+ * absent from the catalog, or whose provider exists but does not list the
+ * model, is `unresolved` — but only when the catalog itself was successfully
+ * fetched (callers must treat a null catalog as fail-open, never unresolved).
+ */
+export declare function resolveAgainstCatalog(models: ConfiguredAgentModel[], catalog: ProviderCatalog | null): ModelPreflightResult;
+/**
+ * End-to-end preflight: collect configured models, fetch the catalog, and
+ * resolve. Fail-open on every catalog error.
+ */
+export declare function runModelPreflight(config: PluginConfig | undefined, client: OpencodeClient | null): Promise<ModelPreflightResult>;
+/**
+ * Resolves a single model id against the live catalog for gate preflights.
+ * Returns 'unknown' whenever the catalog cannot be fetched — gates must only
+ * block on 'unresolved'.
+ */
+export declare function checkSingleModelResolution(model: string, client: OpencodeClient | null): Promise<ModelResolutionStatus>;
+export declare const _internals: {
+    /** Injectable seam for the SDK catalog call (tests substitute this). */
+    providerList: (client: OpencodeClient) => Promise<({
+        data: undefined;
+        error: unknown;
+    } | {
+        data: {
+            all: Array<{
+                api?: string;
+                name: string;
+                env: Array<string>;
+                id: string;
+                npm?: string;
+                models: {
+                    [key: string]: {
+                        id: string;
+                        name: string;
+                        release_date: string;
+                        attachment: boolean;
+                        reasoning: boolean;
+                        temperature: boolean;
+                        tool_call: boolean;
+                        cost?: {
+                            input: number;
+                            output: number;
+                            cache_read?: number;
+                            cache_write?: number;
+                            context_over_200k?: {
+                                input: number;
+                                output: number;
+                                cache_read?: number;
+                                cache_write?: number;
+                            };
+                        };
+                        limit: {
+                            context: number;
+                            output: number;
+                        };
+                        modalities?: {
+                            input: Array<"text" | "audio" | "image" | "video" | "pdf">;
+                            output: Array<"text" | "audio" | "image" | "video" | "pdf">;
+                        };
+                        experimental?: boolean;
+                        status?: "alpha" | "beta" | "deprecated" | "active";
+                        options: {
+                            [key: string]: unknown;
+                        };
+                        headers?: {
+                            [key: string]: string;
+                        };
+                        provider?: {
+                            npm: string;
+                        };
+                    };
+                };
+            }>;
+            default: {
+                [key: string]: string;
+            };
+            connected: Array<string>;
+        };
+        error: undefined;
+    }) & {
+        request: Request;
+        response: Response;
+    }>;
+};

package/dist/services/session-reflection.d.ts

@@ -109,6 +109,14 @@ export interface SessionReflectionData {
     knowledgeDelta?: KnowledgeDelta;
     skillViolations: SkillViolationSignal[];
     contradictionCandidates: ContradictionCandidate[];
+    /**
+     * Issue #2271 bug 6: rejection/circuit-breaker/manual-approval event counts
+     * by type, read from the session ledger (.swarm/events.jsonl). Gate denials
+     * throw in tool.execute.before and never increment ToolAggregate counters
+     * (denied calls do not fire toolAfter), so without this field a session
+     * full of gate rejections reports "0 tool failures or gate rejections".
+     */
+    ledgerRejections?: Record<string, number>;
 }
 export interface SessionReflectionResult {
     data: SessionReflectionData;
@@ -138,6 +146,21 @@ declare function gatherRetroLessonsAndTaxonomy(directory: string): Promise<{
     taxonomy: Record<string, number>;
 }>;
 declare function gatherGateFailures(directory: string): Promise<GateFailureSummary[]>;
+/**
+ * Count rejection-class events in the session ledger. Reads the LIVE
+ * .swarm/events.jsonl first (finalize runs before archive in the close
+ * pipeline), falling back to the newest archived copy for a partially-run
+ * prior close. Fail-open: any read/parse problem yields empty counts.
+ *
+ * When `sessionId` is provided, events carrying a DIFFERENT session id are
+ * ignored so a per-session close summary cannot overcount sibling sessions'
+ * rejections in multi-swarm projects. Events with NO session field are still
+ * counted: several rejection writers emit none (coder_retry_circuit_breaker,
+ * architect_loop_detected), a sessionless event cannot be attributed to a
+ * sibling session, and dropping them would resurrect the bug-6 undercount in
+ * the standard close flow.
+ */
+declare function gatherLedgerRejections(directory: string, sessionId?: string): Promise<Record<string, number>>;
 /**
  * Top skills by violation this session (issue #2077).
  *
@@ -242,6 +265,7 @@ export declare const _internals: {
     gatherAgentDispatches: typeof gatherAgentDispatches;
     gatherRetroLessonsAndTaxonomy: typeof gatherRetroLessonsAndTaxonomy;
     gatherGateFailures: typeof gatherGateFailures;
+    gatherLedgerRejections: typeof gatherLedgerRejections;
     buildReflectionDataSummary: typeof buildReflectionDataSummary;
     buildDeterministicReport: typeof buildDeterministicReport;
     gatherSkillViolations: typeof gatherSkillViolations;

package/dist/telemetry.d.ts

@@ -1,6 +1,12 @@
 import { createObservation, toLegacyTelemetryLine } from './observability/index.js';
 import type { DelegationCostFields } from './services/cost-accounting.js';
-export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'task_state_changed' | 'gate_passed' | 'gate_failed' | 'gate_parse_error' | 'reviewer_gate_decision' | 'phase_changed' | 'budget_updated' | 'context_pruned' | 'model_fallback' | 'hard_limit_hit' | 'revision_limit_hit' | 'loop_detected' | 'no_op_strong_warning' | 'scope_violation' | 'qa_skip_violation' | 'heartbeat' | 'turbo_mode_changed' | 'auto_oversight_escalation' | 'environment_detected' | 'evidence_lock_acquired' | 'evidence_lock_contended' | 'evidence_lock_stale_recovered' | 'plan_ledger_cas_retry' | 'plan_md_write_failed' | 'snapshot_failed' | 'gate_denial_loop'
+export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'task_state_changed' | 'gate_passed' | 'gate_failed' | 'gate_parse_error' | 'reviewer_gate_decision' | 'phase_changed' | 'budget_updated' | 'context_pruned' | 'model_fallback'
+/**
+ * Issue #2271 bug 4 — a configured agent model id was POSITIVELY confirmed
+ * unresolvable against the live provider catalog (distinct from a runtime
+ * model_fallback: this fires at preflight, before any dispatch attempt).
+ */
+ | 'model_unresolved' | 'hard_limit_hit' | 'revision_limit_hit' | 'loop_detected' | 'no_op_strong_warning' | 'scope_violation' | 'qa_skip_violation' | 'heartbeat' | 'turbo_mode_changed' | 'auto_oversight_escalation' | 'environment_detected' | 'evidence_lock_acquired' | 'evidence_lock_contended' | 'evidence_lock_stale_recovered' | 'plan_ledger_cas_retry' | 'plan_md_write_failed' | 'snapshot_failed' | 'gate_denial_loop'
 /**
  * Issue #2063 B5 — an ARMED execution episode reached the advisory rung:
  * `execution_stall_warn_calls` tool calls with no delegation completion, no
@@ -133,6 +139,11 @@ export declare const telemetry: {
         prunedTokensFreed: number;
     }): void;
     modelFallback(sessionId: string, agentName: string, fromModel: string, toModel: string, reason: string): void;
+    /**
+     * Issue #2271 bug 4 — preflight confirmed a configured model id does not
+     * resolve against the provider catalog. Emitted once per detected model.
+     */
+    modelUnresolved(agentName: string, model: string, detail: string): void;
     hardLimitHit(sessionId: string, agentName: string, limitType: string, value: number): void;
     revisionLimitHit(sessionId: string, agentName: string): void;
     loopDetected(sessionId: string, agentName: string, loopType: string): void;

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;