opencode-swarm 7.136.5 → 7.137.1

package/dist/config/plan-schema.d.ts

@@ -9,9 +9,9 @@ export declare const ExecutionProfileSchema: z.ZodObject<{
 export type ExecutionProfile = z.infer<typeof ExecutionProfileSchema>;
 export declare const TaskStatusSchema: z.ZodEnum<{
     blocked: "blocked";
+    completed: "completed";
     pending: "pending";
     in_progress: "in_progress";
-    completed: "completed";
     closed: "closed";
 }>;
 export type TaskStatus = z.infer<typeof TaskStatusSchema>;
@@ -23,11 +23,11 @@ export declare const TaskSizeSchema: z.ZodEnum<{
 export type TaskSize = z.infer<typeof TaskSizeSchema>;
 export declare const PhaseStatusSchema: z.ZodEnum<{
     blocked: "blocked";
+    complete: "complete";
+    completed: "completed";
     pending: "pending";
     in_progress: "in_progress";
-    completed: "completed";
     closed: "closed";
-    complete: "complete";
 }>;
 export type PhaseStatus = z.infer<typeof PhaseStatusSchema>;
 /**
@@ -53,9 +53,9 @@ export declare const TaskSchema: z.ZodObject<{
     phase: z.ZodNumber;
     status: z.ZodDefault<z.ZodEnum<{
         blocked: "blocked";
+        completed: "completed";
         pending: "pending";
         in_progress: "in_progress";
-        completed: "completed";
         closed: "closed";
     }>>;
     size: z.ZodDefault<z.ZodEnum<{
@@ -77,20 +77,20 @@ export declare const PhaseSchema: z.ZodObject<{
     name: z.ZodString;
     status: z.ZodDefault<z.ZodEnum<{
         blocked: "blocked";
+        complete: "complete";
+        completed: "completed";
         pending: "pending";
         in_progress: "in_progress";
-        completed: "completed";
         closed: "closed";
-        complete: "complete";
     }>>;
     tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         phase: z.ZodNumber;
         status: z.ZodDefault<z.ZodEnum<{
             blocked: "blocked";
+            completed: "completed";
             pending: "pending";
             in_progress: "in_progress";
-            completed: "completed";
             closed: "closed";
         }>>;
         size: z.ZodDefault<z.ZodEnum<{
@@ -123,20 +123,20 @@ export declare const PlanSchema: z.ZodObject<{
         name: z.ZodString;
         status: z.ZodDefault<z.ZodEnum<{
             blocked: "blocked";
+            complete: "complete";
+            completed: "completed";
             pending: "pending";
             in_progress: "in_progress";
-            completed: "completed";
             closed: "closed";
-            complete: "complete";
         }>>;
         tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             phase: z.ZodNumber;
             status: z.ZodDefault<z.ZodEnum<{
                 blocked: "blocked";
+                completed: "completed";
                 pending: "pending";
                 in_progress: "in_progress";
-                completed: "completed";
                 closed: "closed";
             }>>;
             size: z.ZodDefault<z.ZodEnum<{

package/dist/config/schema.d.ts

@@ -670,9 +670,9 @@ export declare const KnowledgeConfigSchema: z.ZodObject<{
     todo_max_phases: z.ZodDefault<z.ZodNumber>;
     sweep_enabled: z.ZodDefault<z.ZodBoolean>;
     confidence_floor_action: z.ZodDefault<z.ZodEnum<{
+        none: "none";
         quarantine: "quarantine";
         demote: "demote";
-        none: "none";
     }>>;
     confidence_floor_min_outcomes: z.ZodDefault<z.ZodNumber>;
     confidence_floor_signal_threshold: z.ZodDefault<z.ZodNumber>;
@@ -962,10 +962,10 @@ export declare const SkillImproverConfigSchema: z.ZodObject<{
     consolidation_interval_hours: z.ZodDefault<z.ZodNumber>;
     consolidation_max_calls_per_run: z.ZodDefault<z.ZodNumber>;
     targets: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        knowledge: "knowledge";
         skills: "skills";
         spec: "spec";
         architect_prompt: "architect_prompt";
-        knowledge: "knowledge";
     }>>>;
     write_mode: z.ZodDefault<z.ZodEnum<{
         proposal: "proposal";
@@ -1543,11 +1543,11 @@ export declare const ExternalSkillCandidateSourceTypeSchema: z.ZodEnum<{
 export type ExternalSkillCandidateSourceType = z.infer<typeof ExternalSkillCandidateSourceTypeSchema>;
 /** Evaluation verdict for an external skill candidate. */
 export declare const ExternalSkillCandidateEvaluationVerdictSchema: z.ZodEnum<{
+    passed: "passed";
     pending: "pending";
     promoted: "promoted";
     quarantined: "quarantined";
     in_review: "in_review";
-    passed: "passed";
     rejected: "rejected";
     revoked: "revoked";
 }>;
@@ -1590,21 +1590,21 @@ export declare const ExternalSkillCandidateSchema: z.ZodObject<{
     skill_body: z.ZodString;
     risk_flags: z.ZodDefault<z.ZodArray<z.ZodString>>;
     evaluation_verdict: z.ZodDefault<z.ZodEnum<{
+        passed: "passed";
         pending: "pending";
         promoted: "promoted";
         quarantined: "quarantined";
         in_review: "in_review";
-        passed: "passed";
         rejected: "rejected";
         revoked: "revoked";
     }>>;
     evaluation_history: z.ZodDefault<z.ZodArray<z.ZodObject<{
         verdict: z.ZodEnum<{
+            passed: "passed";
             pending: "pending";
             promoted: "promoted";
             quarantined: "quarantined";
             in_review: "in_review";
-            passed: "passed";
             rejected: "rejected";
             revoked: "revoked";
         }>;
@@ -1613,11 +1613,11 @@ export declare const ExternalSkillCandidateSchema: z.ZodObject<{
         reason: z.ZodOptional<z.ZodString>;
         candidate_id: z.ZodOptional<z.ZodString>;
         original_verdict: z.ZodOptional<z.ZodEnum<{
+            passed: "passed";
             pending: "pending";
             promoted: "promoted";
             quarantined: "quarantined";
             in_review: "in_review";
-            passed: "passed";
             rejected: "rejected";
             revoked: "revoked";
         }>>;
@@ -2115,9 +2115,9 @@ export declare const PluginConfigSchema: z.ZodObject<{
         todo_max_phases: z.ZodDefault<z.ZodNumber>;
         sweep_enabled: z.ZodDefault<z.ZodBoolean>;
         confidence_floor_action: z.ZodDefault<z.ZodEnum<{
+            none: "none";
             quarantine: "quarantine";
             demote: "demote";
-            none: "none";
         }>>;
         confidence_floor_min_outcomes: z.ZodDefault<z.ZodNumber>;
         confidence_floor_signal_threshold: z.ZodDefault<z.ZodNumber>;
@@ -2368,10 +2368,10 @@ export declare const PluginConfigSchema: z.ZodObject<{
         consolidation_interval_hours: z.ZodDefault<z.ZodNumber>;
         consolidation_max_calls_per_run: z.ZodDefault<z.ZodNumber>;
         targets: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            knowledge: "knowledge";
             skills: "skills";
             spec: "spec";
             architect_prompt: "architect_prompt";
-            knowledge: "knowledge";
         }>>>;
         write_mode: z.ZodDefault<z.ZodEnum<{
             proposal: "proposal";

package/dist/consensus/contracts.d.ts

@@ -66,8 +66,8 @@ export declare const ConsensusMineRequestSchema: z.ZodObject<{
 }, z.core.$strict>;
 /** Where a mined attribute would be actioned, if it qualifies as a proposal. */
 declare const ConsensusProposedTargetSchema: z.ZodEnum<{
-    tooling: "tooling";
     none: "none";
+    tooling: "tooling";
     orchestration: "orchestration";
     prompt: "prompt";
     skill: "skill";
@@ -149,8 +149,8 @@ export declare const ConsensusAttributeV1Schema: z.ZodObject<{
     counterexampleRefs: z.ZodArray<z.ZodString>;
     confidence: z.ZodNumber;
     proposedTarget: z.ZodEnum<{
-        tooling: "tooling";
         none: "none";
+        tooling: "tooling";
         orchestration: "orchestration";
         prompt: "prompt";
         skill: "skill";
@@ -388,8 +388,8 @@ export declare const ConsensusReportV1Schema: z.ZodObject<{
         counterexampleRefs: z.ZodArray<z.ZodString>;
         confidence: z.ZodNumber;
         proposedTarget: z.ZodEnum<{
-            tooling: "tooling";
             none: "none";
+            tooling: "tooling";
             orchestration: "orchestration";
             prompt: "prompt";
             skill: "skill";

package/dist/evaluation/index.d.ts

@@ -9,6 +9,7 @@ export type { TaskInputHashLimits } from './hashing.js';
 export { canonicalHash, canonicalJson, computeCandidateInputContentHash, computeManifestContentHash, computeRunIntegrityHash, computeTaskContentHash, computeTaskInputContentHash, computeTaskLineageInputHash, computeTaskSetContentHash, contentHashWithout, resolveContainedExistingPath, sha256, } from './hashing.js';
 export type { EvaluationModelDispatcher, EvaluationModelDispatchRequest, EvaluationModelDispatchResult, } from './model-dispatcher.js';
 export { createEvaluationModelDispatcher, resolveEvaluationAgentName, } from './model-dispatcher.js';
+export * from './pr-review-recovery.js';
 export * from './public-api.js';
 export * from './retention.js';
 export type { EvaluationExecutor, EvaluationExecutorResult, RunEvaluationOptions, } from './runner.js';

package/dist/evaluation/model-dispatcher.d.ts

@@ -2,7 +2,25 @@ import type { Agent, OpencodeClient } from '@opencode-ai/sdk';
 import type { DelegationCostFields } from '../services/cost-accounting.js';
 import { _internals as ephemeralDispatcherInternals } from './ephemeral-agent-dispatcher.js';
 export type EvaluationModelDispatchRequest = {
-    directory: string;
+    /**
+     * The directory the ephemeral session is created against.
+     *
+     * This is the directory OpenCode uses to key permission state
+     * (`Permission.state`, `Agent.state`, `ToolRegistry.state` are all built
+     * through the directory-keyed `InstanceState` cache) AND to resolve
+     * registered agents. It MUST be the invoking instance's directory (the
+     * project root) so the session lands in the SAME permission partition as
+     * the user's session — a foreign directory gets a fresh, empty `approved`
+     * list and a private pending map that the user's TUI cannot reach, so an
+     * `external_directory` prompt raised there hangs forever.
+     *
+     * The SDK's `session.create` has no separate working-directory field, so
+     * this is also the agent's CWD. When the fixture the agent must inspect is
+     * NOT under this directory, the caller conveys the fixture path via the
+     * prompt (see gate-audit.ts `modelPrompt` and runner.ts
+     * `createModelEvaluationExecutor`).
+     */
+    sessionDirectory: string;
     agentName: string;
     modelId: string;
     prompt: string;

package/dist/evaluation/pr-review-recovery.d.ts

@@ -0,0 +1,41 @@
+import type { EvaluationRunV1 } from './contracts.js';
+import type { EvaluationModelDispatcher } from './model-dispatcher.js';
+export declare const PR_REVIEW_RECOVERY_BASE_SHA: "3811fe5981072c7fa541523e9f08430f18594590";
+type RecoveryBudgets = {
+    maxTasks: number;
+    maxRepetitions: number;
+    maxConcurrency: number;
+    maxTaskTimeMs: number;
+    maxRetries: number;
+    maxOutputBytes: number;
+    maxSpendUsd?: number;
+};
+export type EvaluatePrReviewRecoveryV1Options = {
+    projectRoot: string;
+    packageRoot?: string;
+    dispatcher: EvaluationModelDispatcher;
+    parentSessionId?: string;
+    model?: string;
+    seed?: string;
+    baselineSourceSha?: string;
+    budgets?: Partial<RecoveryBudgets>;
+    abortSignal?: AbortSignal;
+};
+type BaselineManifest = {
+    v: 1;
+    sourceSha: string;
+    payloadPath: string;
+    sha256: string;
+};
+declare function parseBaselineManifest(value: unknown): BaselineManifest;
+declare function verifyBaseline(packageRoot: string, requestedSourceSha: string): Promise<void>;
+/**
+ * Runs the packaged issue-2075 recovery scenario against the exact canonical
+ * PR-review skill and its content-addressed pre-hardening baseline.
+ */
+export declare function evaluatePrReviewRecoveryV1(options: EvaluatePrReviewRecoveryV1Options): Promise<EvaluationRunV1>;
+export declare const _internals: {
+    parseBaselineManifest: typeof parseBaselineManifest;
+    verifyBaseline: typeof verifyBaseline;
+};
+export {};

package/dist/evaluation/public-api.d.ts

@@ -1,6 +1,7 @@
 import type { EvaluationRunV1, PromotionDecisionV1, PromotionPolicyV1 } from './contracts.js';
 import { recordTestImpactGateGroundTruth } from './gate-ground-truth.js';
 import { computeCandidateInputContentHash, computeTaskInputContentHash } from './hashing.js';
+import { evaluatePrReviewRecoveryV1 } from './pr-review-recovery.js';
 import { type RunEvaluationOptions, runEvaluation } from './runner.js';
 import { type DecidePromotionInput } from './statistics.js';
 export type EvaluateCandidateV1Options = RunEvaluationOptions & {
@@ -25,6 +26,7 @@ export declare function evaluateCandidateV1(options: EvaluateCandidateV1Options)
  */
 export declare const evaluationV1: ((options: EvaluateCandidateV1Options) => Promise<EvaluateCandidateV1Result>) & {
     evaluateCandidate: typeof evaluateCandidateV1;
+    evaluatePrReviewRecovery: typeof evaluatePrReviewRecoveryV1;
     runEvaluation: typeof runEvaluation;
     decidePromotion: (input: DecidePromotionInput) => {
         v: 1;

package/dist/evaluation/runner.d.ts

@@ -19,6 +19,15 @@ export type EvaluationExecutor = (args: {
     payload: string;
     seed: string;
     abortSignal: AbortSignal;
+    /**
+     * The invoking instance's directory (the project root). An executor that
+     * creates an OpenCode session MUST bind it here — NOT to `isolatedRoot` —
+     * so the session lands in the same permission partition as the user's
+     * session (#2009). OpenCode keys permission state per directory; a foreign
+     * directory gets an empty approved list and a private pending map the TUI
+     * cannot reach, so a prompt raised there hangs forever.
+     */
+    projectRoot: string;
 }) => Promise<EvaluationExecutorResult>;
 export type RunEvaluationOptions = {
     projectRoot: string;

package/dist/hooks/hive-promoter.d.ts

@@ -116,7 +116,7 @@ export declare const _internals: {
         default_max_phases: number;
         todo_max_phases: number;
         sweep_enabled: boolean;
-        confidence_floor_action: "quarantine" | "demote" | "none";
+        confidence_floor_action: "none" | "quarantine" | "demote";
         confidence_floor_min_outcomes: number;
         confidence_floor_signal_threshold: number;
         contradiction_threshold_action: "quarantine" | "tag_only";

package/dist/hooks/pr-workflow-gate.d.ts

@@ -1,4 +1,6 @@
 import * as fsp from 'node:fs/promises';
+import { type LaneOutputArtifact } from '../background/lane-output-store.js';
+import { type BackgroundDelegationRecord, type BackgroundDelegationResult, findByBatchId } from '../background/pending-delegations.js';
 import { type PrReviewInlineTriggerRow } from '../background/pr-review-trigger-contract.js';
 import { type RevisionDigestResult, resolveCommitCountSince, resolveCommitCountSinceAsync, resolveCurrentGitHead, resolveCurrentGitHeadAsync, resolveCurrentUpstreamPushTarget, resolveCurrentUpstreamPushTargetAsync, resolveCurrentUpstreamRemoteRef, resolveExactRemoteBranchHead, resolveExactRemoteBranchHeadAsync, resolveIsExactSingleChildCommit, resolveIsExactSingleChildCommitAsync, resolveIsWorkingTreeClean, resolveIsWorkingTreeCleanAsync, resolvePrReviewDiffStats, resolvePrReviewDiffStatsAsync, resolvePrWorkflowRevisionDigest, resolvePrWorkflowRevisionDigestDetailed, resolveRemoteRefsContainingHead, resolveRemoteRefsContainingHeadAsync } from '../background/workspace-snapshot.js';
 import { type PrWorkflowGitState } from '../git/pr-workflow-state.js';
@@ -6,6 +8,33 @@ export declare const PR_REVIEW_BASE_DIMENSION_IDS: readonly ["intent-architectur
 export declare const PR_REVIEW_REQUIRED_MICRO_LANE_IDS: ("auth-identity-secrets" | "untrusted-input-boundaries" | "subprocess-platform" | "concurrency-state" | "dependencies-build-release" | "api-schema-migrations" | "test-infrastructure" | "ui-accessibility-i18n" | "privacy-observability" | "generated-provenance" | "unclassified-risk")[];
 export type PrReviewBaseDimensionId = (typeof PR_REVIEW_BASE_DIMENSION_IDS)[number];
 export type PrWorkflowMode = 'PR_REVIEW' | 'PR_FEEDBACK';
+export type PrReviewLaneValidationPredicate = 'batch.validated_at' | 'batch.expected_lane_unique' | 'record.missing' | 'record.duplicate_lane' | 'record.subagent_session_id' | 'record.duplicate_subagent_session_id' | 'record.forbidden_subagent_session_id' | 'record.created_at' | 'record.workflow_lane' | 'record.owned_workflow_lanes' | 'record.mode' | 'record.pr_head_sha' | 'record.git_head' | 'record.status' | 'result.output_degraded' | 'result.transcript_incomplete' | 'result.truncated' | 'result.chars' | 'result.digest' | 'result.output_ref' | 'artifact.readable' | 'artifact.ref' | 'artifact.batch_id' | 'artifact.lane_id' | 'artifact.mode' | 'artifact.session_id' | 'artifact.parent_session_id' | 'artifact.agent' | 'artifact.role' | 'artifact.source' | 'artifact.workflow_lane_record' | 'artifact.workflow_lane_expected' | 'artifact.pr_head_sha' | 'artifact.git_head' | 'artifact.revision_digest' | 'record.scope' | 'artifact.scope' | 'artifact.digest' | 'artifact.chars' | 'discovery.header' | 'discovery.row' | 'discovery.coverage' | 'discovery.duplicate_evidence';
+export interface PrReviewLaneValidationFailure {
+    predicate: PrReviewLaneValidationPredicate;
+    expected: string;
+    actual: string;
+}
+export type PrReviewLaneValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    failure: PrReviewLaneValidationFailure;
+};
+export interface PrReviewDiscoveryLaneValidationInput {
+    record: BackgroundDelegationRecord;
+    result: BackgroundDelegationResult;
+    artifact: LaneOutputArtifact | null;
+    expected: {
+        mode: 'swarm-pr-review:base' | 'swarm-pr-review:micro';
+        workflowLane: string;
+        ownedWorkflowLanes?: readonly string[];
+        prHeadSha: string;
+        gitHead: string;
+        revisionDigest: string;
+        reviewScope?: string;
+        checkWorkflowLane?: boolean;
+    };
+}
 export interface PrWorkflowCheckoutRecoveryRecord {
     code: 'UNMERGED_INDEX' | 'GIT_OPERATION_IN_PROGRESS' | 'DIRTY_SUBMODULE' | 'SWARM_STATE_TRACKING_ERROR' | 'GIT_STATE_INDETERMINATE';
     retryable: false;
@@ -460,6 +489,7 @@ export declare function enforcePrWorkflowToolBefore(directory: string, sessionID
 export declare function completePrWorkflow(directory: string, sessionID: string, expectedMode: PrWorkflowMode, prHeadSha: string): Promise<PrWorkflowCompletionStatus>;
 export declare const _test_exports: {
     minimumConsolidatedLaneCover: typeof minimumConsolidatedLaneCover;
+    analyzePrReviewBatchRecordIntegrity: typeof analyzePrReviewBatchRecordIntegrity;
     MAX_COVER_UNIVERSE_BITS: number;
     workflowGateStateRelativePath: typeof workflowGateStateRelativePath;
     workflowGateStateLockRelativePath: typeof workflowGateStateLockRelativePath;
@@ -678,6 +708,45 @@ interface PrReviewPhaseComposition {
  * already computed: no digest resolution, no artifact reads, no subprocess work.
  */
 declare function assertSettledPhaseHasAuthoritativeVerdicts(phase: PrReviewComposablePhase, composed: Pick<PrReviewPhaseComposition, 'requiredInventory' | 'unclaimed'>, authoritative: ReadonlyMap<string, unknown>, origin: string): void;
+interface ExpectedWorkflowLane {
+    laneId: string;
+    workflowLane: string;
+    reviewItemIds?: string[];
+    ownedWorkflowLanes?: string[];
+}
+interface QualifiedBatchRecord {
+    record: ReturnType<typeof findByBatchId>[number];
+    expectedLane: ExpectedWorkflowLane;
+    expectedWorkflowLane: string;
+    expectedOwnedLanes: string[];
+}
+type BatchRecordIntegrityAnalysis = ({
+    ok: true;
+} & QualifiedBatchRecord) | {
+    ok: false;
+    expectedLane: ExpectedWorkflowLane;
+    expectedWorkflowLane: string;
+    expectedOwnedLanes: string[];
+    failure: PrReviewLaneValidationFailure;
+};
+export declare function formatPrReviewLaneValidationFailure(failure: PrReviewLaneValidationFailure): string;
+declare function analyzePrReviewBatchRecordIntegrity(args: {
+    batchId: string;
+    expectedLanes: ReadonlyArray<ExpectedWorkflowLane>;
+    expectedMode: string;
+    validatedAt: string;
+    checkWorkflowLane: boolean;
+    forbiddenSubagentSessionIds: ReadonlySet<string>;
+    records: readonly BackgroundDelegationRecord[];
+    expectedPrHeadSha?: string;
+}): BatchRecordIntegrityAnalysis[];
+/**
+ * Validate a just-collected base/micro discovery result before the delegation
+ * ledger publishes it as completed. The caller supplies the prospective result
+ * and the exact stored artifact, so this pure validator cannot accidentally
+ * accept stale terminal state or a different output reference.
+ */
+export declare function validatePrReviewDiscoveryLaneCompletion(input: PrReviewDiscoveryLaneValidationInput): PrReviewLaneValidationResult;
 /** Require at least one semantically valid discovery row or CLEAN attestation. */
 export declare function prReviewDiscoveryArtifactCoversLane(text: string, expectedWorkflowLane: string, ownedWorkflowLanes?: readonly string[]): boolean;
 declare function parseCriticVerdict(text: string, itemId: string, reviewerSeverity?: string): {

package/dist/index.d.ts

@@ -50,5 +50,7 @@ export type { AgentDefinition } from './agents';
 export type { AgentName, AutomationCapabilities, AutomationConfig, AutomationMode, PipelineAgentName, PluginConfig, QAAgentName, } from './config';
 export { loadTier1EvaluationTasks } from './evaluation/fixtures.js';
 export { recordTestImpactGateGroundTruth } from './evaluation/gate-ground-truth.js';
+export type { EvaluatePrReviewRecoveryV1Options } from './evaluation/pr-review-recovery.js';
+export { evaluatePrReviewRecoveryV1 } from './evaluation/pr-review-recovery.js';
 export type { EvaluateCandidateV1Options, EvaluateCandidateV1Result, } from './evaluation/public-api.js';
 export { evaluateCandidateV1, evaluationV1, } from './evaluation/public-api.js';