opencode-swarm 7.124.0 → 7.125.1

package/dist/cli/index.js

@@ -7,34 +7,34 @@ import {
   getPluginLockFilePaths,
   package_default,
   resolveCommand
-} from "./index-mkkx1a4f.js";
-import"./index-e19mxn9f.js";
-import"./index-v5ecczts.js";
-import"./index-4rzzzjtg.js";
+} from "./index-dsf1yv4s.js";
+import"./index-pbjenws7.js";
+import"./index-z4sc6yxc.js";
+import"./index-fs02c7tz.js";
 import"./index-4905hd2m.js";
 import"./index-134d35c1.js";
 import"./index-6n2jpz7x.js";
-import"./index-tyg0zezw.js";
-import"./index-z0m4angq.js";
-import"./index-eeg04r0x.js";
+import"./index-tn3shyqj.js";
+import"./index-93cq8t5b.js";
+import"./index-kws8zn6y.js";
 import"./index-vxv732ex.js";
 import"./index-c8s9a3zh.js";
 import"./index-s9mj4rb9.js";
 import"./index-23zsx7dm.js";
-import"./index-zjedv2bd.js";
-import"./index-13d2g7k9.js";
+import"./index-ghteqdy1.js";
+import"./index-kvrk3h8p.js";
 import"./index-rtry5xyf.js";
-import"./index-2x4maxte.js";
-import"./index-x2mmnrnx.js";
+import"./index-mwdcvh0e.js";
+import"./index-83rwq7pb.js";
 import"./index-ae75rja9.js";
 import"./index-q27bajqb.js";
-import"./index-3yyr4ynk.js";
+import"./index-3k8pg467.js";
 import"./index-k5jrywpr.js";
 import"./index-n832052r.js";
 import {
   DEFAULT_AGENT_CONFIGS,
   init_constants
-} from "./index-c6crt5rs.js";
+} from "./index-8yvqkbw7.js";
 import"./index-bk5tah7q.js";
 import"./index-8fwhhayc.js";
 import"./index-q1exe2b3.js";
@@ -43,11 +43,12 @@ import"./index-2tn5h2zp.js";
 import"./index-1kz6da87.js";
 import"./index-v2rdhwx8.js";
 import"./index-gacm5s2n.js";
+import"./index-0cz1ws47.js";
 import"./index-2445sx3d.js";
 import"./index-z6xqpmqg.js";
 import"./index-zjygnfay.js";
 import"./index-zgwm4ryv.js";
-import"./index-dqh3zhhc.js";
+import"./index-mg54y5gc.js";
 import"./index-3x761jqv.js";
 import"./index-7mkpsw6g.js";
 import"./index-fsrp8wp3.js";

package/dist/cli/{knowledge-escalator-r1s01m3z.js → knowledge-escalator-jtyykzqc.js}

@@ -8,9 +8,9 @@ import {
   maybeEscalateOnViolation,
   maybeQuarantineOnContradiction,
   readRecentEscalations
-} from "./index-z0m4angq.js";
-import"./index-2x4maxte.js";
-import"./index-x2mmnrnx.js";
+} from "./index-93cq8t5b.js";
+import"./index-mwdcvh0e.js";
+import"./index-83rwq7pb.js";
 import"./index-ae75rja9.js";
 import"./index-q27bajqb.js";
 import"./index-bk5tah7q.js";

package/dist/cli/{knowledge-events-a9hmxvke.js → knowledge-events-qhr97sy9.js}

@@ -26,7 +26,7 @@ import {
   resolveKnowledgeCounterBaselinePath,
   resolveKnowledgeEventsPath,
   resolveLegacyApplicationLogPath
-} from "./index-x2mmnrnx.js";
+} from "./index-83rwq7pb.js";
 import"./index-ae75rja9.js";
 import"./index-q27bajqb.js";
 import"./index-zgwm4ryv.js";

package/dist/cli/{knowledge-store-jt31br5k.js → knowledge-store-332x3pjv.js}

@@ -40,7 +40,7 @@ import {
   transactKnowledge,
   transactKnowledgeWithCas,
   wordBigrams
-} from "./index-2x4maxte.js";
+} from "./index-mwdcvh0e.js";
 import {
   resolveHiveDataDir
 } from "./index-ae75rja9.js";

package/dist/cli/{knowledge-validator-9vrwxr3z.js → knowledge-validator-3t8tgzsz.js}

@@ -23,11 +23,11 @@ import {
   validateLesson,
   validateSkillCandidatePath,
   validateSkillPath
-} from "./index-zjedv2bd.js";
-import"./index-13d2g7k9.js";
+} from "./index-ghteqdy1.js";
+import"./index-kvrk3h8p.js";
 import"./index-rtry5xyf.js";
-import"./index-2x4maxte.js";
-import"./index-x2mmnrnx.js";
+import"./index-mwdcvh0e.js";
+import"./index-83rwq7pb.js";
 import"./index-ae75rja9.js";
 import"./index-q27bajqb.js";
 import"./index-bk5tah7q.js";

package/dist/cli/pending-delegations-7j8xqg5f.js

@@ -0,0 +1,34 @@
+// @bun
+import {
+  BACKGROUND_DELEGATIONS_FILE,
+  appendDelegationTransition,
+  buildPromptSnapshot,
+  findByBatchId,
+  findByCorrelationId,
+  findOpenAsyncLaneBatches,
+  readDelegations,
+  recordPendingDelegation,
+  sweepStaleDelegations
+} from "./index-0cz1ws47.js";
+import"./index-2445sx3d.js";
+import"./index-z6xqpmqg.js";
+import"./index-zjygnfay.js";
+import"./index-zgwm4ryv.js";
+import"./index-fsrp8wp3.js";
+import"./index-76kvm9z5.js";
+import"./index-q2rrv0cy.js";
+import"./index-bpmtbmy9.js";
+import"./index-7g4c7s5r.js";
+import"./index-qe3v54nb.js";
+import"./index-a76rekgs.js";
+export {
+  sweepStaleDelegations,
+  recordPendingDelegation,
+  readDelegations,
+  findOpenAsyncLaneBatches,
+  findByCorrelationId,
+  findByBatchId,
+  buildPromptSnapshot,
+  appendDelegationTransition,
+  BACKGROUND_DELEGATIONS_FILE
+};

package/dist/cli/{scan-cursor-bkjtsawg.js → scan-cursor-q21c9k9q.js}

@@ -4,8 +4,8 @@ import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   getScanStatus
-} from "./index-eeg04r0x.js";
-import"./index-2x4maxte.js";
+} from "./index-kws8zn6y.js";
+import"./index-mwdcvh0e.js";
 import"./index-ae75rja9.js";
 import"./index-q27bajqb.js";
 import"./index-bk5tah7q.js";

package/dist/cli/{schema-y3z416z7.js → schema-y2d7j2jk.js}

@@ -88,7 +88,7 @@ import {
   resolveGeneratedAgentRole,
   resolveGuardrailsConfig,
   stripKnownSwarmPrefix
-} from "./index-c6crt5rs.js";
+} from "./index-8yvqkbw7.js";
 import"./index-bk5tah7q.js";
 import"./index-zjygnfay.js";
 import"./index-bpmtbmy9.js";

package/dist/cli/{skill-generator-794hyndw.js → skill-generator-3gkxx98d.js}

@@ -33,12 +33,12 @@ import {
   sanitizeSlug,
   selectCandidateEntries,
   writeEvalStub
-} from "./index-tyg0zezw.js";
-import"./index-zjedv2bd.js";
-import"./index-13d2g7k9.js";
+} from "./index-tn3shyqj.js";
+import"./index-ghteqdy1.js";
+import"./index-kvrk3h8p.js";
 import"./index-rtry5xyf.js";
-import"./index-2x4maxte.js";
-import"./index-x2mmnrnx.js";
+import"./index-mwdcvh0e.js";
+import"./index-83rwq7pb.js";
 import"./index-ae75rja9.js";
 import"./index-q27bajqb.js";
 import"./index-bk5tah7q.js";

package/dist/cli/workspace-snapshot-c9pxxt9a.js

@@ -0,0 +1,48 @@
+// @bun
+import {
+  _internals,
+  captureWorkspaceSnapshot,
+  changedFilesSinceSnapshot,
+  compareWorkspaceSnapshot,
+  compareWorkspaceSnapshots,
+  digest,
+  parsePorcelainPaths,
+  readGitTextAtRevision,
+  resolveCommitCountSince,
+  resolveCurrentGitHead,
+  resolveCurrentUpstreamPushTarget,
+  resolveCurrentUpstreamRemoteRef,
+  resolveExactMergeBase,
+  resolveExactRemoteBranchHead,
+  resolveGitControlStateDigest,
+  resolveIsExactSingleChildCommit,
+  resolveIsWorkingTreeClean,
+  resolvePrWorkflowRevisionDigest,
+  resolvePrWorkflowRevisionDigestAsync,
+  resolveRemoteRefsContainingHead,
+  workspaceSnapshotMatches
+} from "./index-mg54y5gc.js";
+import"./index-a76rekgs.js";
+export {
+  workspaceSnapshotMatches,
+  resolveRemoteRefsContainingHead,
+  resolvePrWorkflowRevisionDigestAsync,
+  resolvePrWorkflowRevisionDigest,
+  resolveIsWorkingTreeClean,
+  resolveIsExactSingleChildCommit,
+  resolveGitControlStateDigest,
+  resolveExactRemoteBranchHead,
+  resolveExactMergeBase,
+  resolveCurrentUpstreamRemoteRef,
+  resolveCurrentUpstreamPushTarget,
+  resolveCurrentGitHead,
+  resolveCommitCountSince,
+  readGitTextAtRevision,
+  parsePorcelainPaths,
+  digest,
+  compareWorkspaceSnapshots,
+  compareWorkspaceSnapshot,
+  changedFilesSinceSnapshot,
+  captureWorkspaceSnapshot,
+  _internals
+};

package/dist/commands/close.d.ts

@@ -134,8 +134,10 @@ export declare function runFinalizeStage(ctx: CloseStageContext): Promise<void>;
 export declare function runArchiveStage(ctx: CloseStageContext): Promise<void>;
 /**
  * Runs the evidence-retention sub-logic of STAGE 2 (ARCHIVE).
- * Reads max_age_days / max_bundles from config.evidence (FR-016) and
- * calls archiveEvidence. Fail-open: pushes a warning on error but never throws.
+ * Reads max_age_days / max_bundles / cache_max_bytes / cache_max_records from
+ * config.evidence (FR-016, issue #1184) and calls archiveEvidence. The report
+ * overload is used so the documents-cache prune runs when cache caps are set.
+ * Fail-open: pushes a warning on error but never throws.
  */
 export declare function runArchiveEvidenceRetention(ctx: ArchiveStageContext): Promise<void>;
 /**

package/dist/commands/registry.d.ts

@@ -517,7 +517,7 @@ export declare const COMMAND_REGISTRY: {
         readonly handler: (ctx: CommandContext) => CommandResult;
         readonly description: "Launch deep PR review with multi-lane analysis [url] [--council]";
         readonly args: "<pr-url|owner/repo#N|N> [--council]";
-        readonly details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, launches all 6 fixed base explorer lanes through dispatch_lanes_async while the architect keeps doing non-dependent work, polls collect_lane_results incrementally, runs every triggered micro-lane, validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, then synthesizes only after coverage is closed. If lane tools cannot close coverage, Task-tool dispatch is the final verified-equivalent fallback; if equivalence cannot be proven, the review is BLOCKED rather than degraded. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).";
+        readonly details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, launches all 6 fixed base explorer lanes through dispatch_lanes_async while the architect keeps doing non-dependent work, polls collect_lane_results incrementally, runs all 11 mandatory repository-agnostic micro-lanes without applicability waivers, validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, then synthesizes only after coverage is closed. Failed obligations retry through the same structured async mode and exact PR head; blocking or direct-Task dispatch is not provenance-equivalent, so unclosed coverage leaves the review BLOCKED rather than degraded. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).";
         readonly category: "agent";
         readonly toolPolicy: "none";
     };

package/dist/config/schema.d.ts

@@ -262,6 +262,8 @@ export declare const EvidenceConfigSchema: z.ZodObject<{
     max_age_days: z.ZodDefault<z.ZodNumber>;
     max_bundles: z.ZodDefault<z.ZodNumber>;
     auto_archive: z.ZodDefault<z.ZodBoolean>;
+    cache_max_bytes: z.ZodOptional<z.ZodNumber>;
+    cache_max_records: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type EvidenceConfig = z.infer<typeof EvidenceConfigSchema>;
 export declare const GateFeatureSchema: z.ZodObject<{
@@ -1805,6 +1807,8 @@ export declare const PluginConfigSchema: z.ZodObject<{
         max_age_days: z.ZodDefault<z.ZodNumber>;
         max_bundles: z.ZodDefault<z.ZodNumber>;
         auto_archive: z.ZodDefault<z.ZodBoolean>;
+        cache_max_bytes: z.ZodOptional<z.ZodNumber>;
+        cache_max_records: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     summaries: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/evidence/documents-retention.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Retention for the web_search / web_fetch documents cache at
+ * `.swarm/evidence-cache/documents.jsonl`.
+ *
+ * Background (issue #1184): `writeEvidenceDocuments` in `./documents.ts` is
+ * purely append-only. Without this module the cache grows without bound.
+ * This module provides a bounded, project-root-contained, atomic-rewrite
+ * prune that is invoked only via `/swarm archive` and `/swarm finalize`
+ * (never on the plugin init path — AGENTS.md invariant #1).
+ *
+ * Design contract (mirrors `archiveEvaluationArtifacts` in
+ * `../evaluation/retention.ts` where applicable):
+ *   - Optional byte cap and optional record-count cap. When both are unset the
+ *     prune is a no-op (current append-only behavior preserved exactly).
+ *   - Corrupt rows (failed `JSON.parse`) are dropped from the rewrite and
+ *     reported via `corrupt` count. They are NOT relocated to a sidecar —
+ *     matches the "report, don't relocate" precedent in
+ *     `archiveEvaluationArtifacts` (retention.ts:246-254), while still
+ *     preserving the bounded-growth contract (a corrupt row otherwise counts
+ *     toward caps forever).
+ *   - Atomic rewrite via temp file + fsync + rename. NOT under
+ *     `withEvidenceLock`: web_search/web_fetch are hot paths and forcing a
+ *     lockfile round-trip on every capture is an unjustified latency tax
+ *     (issue-tracer critic item #2). The append-vs-rewrite race is a known,
+ *     accepted data-loss window: a concurrent `appendFile` whose write is in
+ *     flight when the prune renames the temp over the target will, on POSIX,
+ *     complete against the now-unlinked old inode (the appended row is
+ *     silently lost from the cache). This is accepted because refs are
+ *     content-addressed (`evd_<sha256[:16]>`) so a lost row's ref
+ *     re-materializes on the next capture of the same content, and because
+ *     the prune runs only via explicit `/swarm archive` / `/swarm finalize`,
+ *     not on every write.
+ *   - Read is streamed line-by-line via `node:readline` with a hard 100 MiB
+ *     cap. On cap breach the prune aborts, writes nothing, and leaves the
+ *     file byte-identical.
+ *   - Windows-safe rename: `EPERM`/`EBUSY`/`ENOTEMPTY`/`EACCES` are retried
+ *     with bounded backoff (5× / 10ms). On final failure the temp file is
+ *     removed and the original is left untouched (fail-safe).
+ *
+ * Memory tradeoff (L6-002): valid rows are parsed into a `ParsedRow[]` and
+ * retained in memory (raw string + parsed object per row) before selection.
+ * The 100 MiB read cap bounds input bytes, but the in-process heap footprint
+ * is higher (V8 string + object overhead). This is an accepted tradeoff: the
+ * prune runs once per explicit `/swarm archive` / `/swarm finalize` (never on
+ * a hot path), the input is bounded, and a streaming rewrite would be a
+ * materially larger refactor. If the cache ever needs to scale beyond the
+ * current cap, switch `readCacheRows` + `selectSurvivors` to a streaming
+ * selection (single pass, write survivors directly to the temp file).
+ */
+import * as fs from 'node:fs';
+export interface DocumentsRetentionResult {
+    /** Total valid (parseable) rows read before pruning. Excludes corrupt rows. */
+    inventory: number;
+    /** Rows marked for deletion by the policy (same as `inventory - surviving`). */
+    selected: number;
+    /** Rows actually removed from the file. Always 0 when `dryRun` or `aborted`. */
+    archived: number;
+    /** Unparseable rows dropped from the rewrite (count only; not preserved). */
+    corrupt: number;
+    /** File size in bytes before the prune (0 if the file did not exist). */
+    bytesBefore: number;
+    /** File size in bytes after the prune. Equal to `bytesBefore` on no-op. */
+    bytesAfter: number;
+    /** True when the prune produced no file mutation. */
+    dryRun: boolean;
+    /**
+     * True when the read cap (`MAX_READ_BYTES`) was exceeded. On abort the file
+     * is left byte-identical — no temp file, no rewrite, no sidecar.
+     */
+    aborted: boolean;
+}
+export interface PruneEvidenceDocumentsArgs {
+    directory: string;
+    /** Optional byte cap. When omitted, no byte-based pruning. */
+    maxBytes?: number;
+    /** Optional record-count cap. When omitted, no count-based pruning. */
+    maxRecords?: number;
+    /** When true, compute the plan but write nothing. */
+    dryRun?: boolean;
+}
+/** Internal DI seam (AGENTS.md invariant #7 — preferred over mock.module). */
+export declare const _internals: {
+    stat: (path: string) => Promise<fs.Stats>;
+    createReadStream: (path: string, options: {
+        encoding: BufferEncoding;
+        highWaterMark: number;
+    }) => fs.ReadStream;
+    openSync: (path: string, flags: fs.OpenMode) => number;
+    writeSync: (fd: number, data: string, position?: number | null) => number;
+    fsyncSync: (fd: number) => void;
+    closeSync: (fd: number) => void;
+    renameWithRetry: (src: string, dst: string) => Promise<void>;
+    unlink: (path: string) => Promise<void>;
+};
+/**
+ * Atomic rename with bounded retry for Windows.
+ *
+ * On Windows, `fs.rename` over an existing file can fail with `EPERM` when
+ * another handle (e.g. a concurrent `appendFile` from web_search) holds the
+ * target. We retry the rename a bounded number of times with a short backoff
+ * (the `readSwarmFileAsync` precedent in `hooks/utils.ts:263` uses the same
+ * 5× / 10ms shape for the macOS rename-visibility race). On final failure we
+ * rethrow — the caller is responsible for cleaning up the temp file.
+ *
+ * The optional `renameFn` is a test seam (defaults to `fsp.rename`) so the
+ * retry loop can be exercised deterministically on non-Windows hosts.
+ */
+export declare function atomicRenameWithRetry(src: string, dst: string, renameFn?: (s: string, d: string) => Promise<void>): Promise<void>;
+/**
+ * Apply the configured byte/count retention policy to the documents cache.
+ *
+ * Safe to call on a missing file (returns an idempotent zeroed result) and
+ * safe to call with both caps unset (no-op). Never throws for routine cases;
+ * surfaces unexpected I/O errors to the caller (archive command fails open).
+ */
+export declare function pruneEvidenceDocuments(args: PruneEvidenceDocumentsArgs): Promise<DocumentsRetentionResult>;

package/dist/evidence/manager.d.ts

@@ -1,5 +1,6 @@
 import { type BuildEvidence, type Evidence, type EvidenceBundle, type PlaceholderEvidence, type QualityBudgetEvidence, type SastEvidence, type SbomEvidence, type SecretscanEvidence, type SyntaxEvidence } from '../config/evidence-schema';
 import { type EvaluationRetentionResult } from '../evaluation/retention.js';
+import { type DocumentsRetentionResult, pruneEvidenceDocuments } from './documents-retention.js';
 /**
  * Discriminated union returned by loadEvidence.
  * - 'found': file exists and passed Zod schema validation
@@ -101,11 +102,26 @@ export type EvidenceArchiveReport = {
     archivedEvidence: string[];
     failedEvidence: string[];
     evaluation: EvaluationRetentionResult;
+    /**
+     * Documents-cache retention result (issue #1184). Always present in the
+     * report shape — a zeroed result ({ inventory: 0, selected: 0, ... })
+     * indicates the cache was not pruned (no caps configured, file missing,
+     * or prune disabled).
+     */
+    documentsCache: DocumentsRetentionResult;
 };
 export type EvidenceArchiveReportOptions = {
     report: true;
     dryRun?: boolean;
     now?: Date;
+    /**
+     * Optional documents-cache retention caps (issue #1184). When either is a
+     * positive number, `archiveEvidence` also prunes
+     * `.swarm/evidence-cache/documents.jsonl` after the bundle/evaluation
+     * sweep. When both are unset, the cache is left untouched (append-only).
+     */
+    cacheMaxBytes?: number;
+    cacheMaxRecords?: number;
 };
 export declare function archiveEvidence(directory: string, maxAgeDays: number, maxBundles?: number): Promise<string[]>;
 export declare function archiveEvidence(directory: string, maxAgeDays: number, maxBundles: number | undefined, options: EvidenceArchiveReportOptions): Promise<EvidenceArchiveReport>;
@@ -125,6 +141,7 @@ export declare const _internals: {
     validateEvidence: typeof validateEvidence;
     saveEvidence: typeof saveEvidence;
     deleteEvidence: typeof deleteEvidence;
+    pruneEvidenceDocuments: typeof pruneEvidenceDocuments;
     now: () => Date;
 };
 export {};

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

@@ -0,0 +1,211 @@
+import { resolveCommitCountSince, resolveCurrentGitHead, resolveCurrentUpstreamPushTarget, resolveCurrentUpstreamRemoteRef, resolveExactRemoteBranchHead, resolveIsExactSingleChildCommit, resolveIsWorkingTreeClean, resolvePrWorkflowRevisionDigest, resolveRemoteRefsContainingHead } from '../background/workspace-snapshot.js';
+export declare const PR_REVIEW_BASE_DIMENSION_IDS: readonly ["intent-architecture", "correctness-state", "tests-falsifiability", "security-trust", "reliability-performance", "compatibility-delivery"];
+export declare const PR_REVIEW_REQUIRED_MICRO_LANE_IDS: readonly ["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 interface PrWorkflowLaneSpec {
+    laneId?: string;
+    workflowLane?: string;
+    reviewItemIds?: string[];
+}
+export interface PrFeedbackLaneOwnership {
+    laneId: string;
+    ownedItemIds: string[];
+}
+interface PrReviewBaseDispatchRecord {
+    batchId: string;
+    lanes: Array<{
+        laneId: string;
+        workflowLane: PrReviewBaseDimensionId;
+    }>;
+    validatedAt: string;
+}
+interface PrFeedbackVerificationRecord {
+    batchId: string;
+    ownership: PrFeedbackLaneOwnership[];
+    validatedAt: string;
+}
+export type PrFeedbackGatePhase = 'stage-b-reviewer' | 'stage-b-test' | 'closeout-reviewer' | 'closeout-critic';
+export type PrFeedbackStageACategory = 'build' | 'typecheck' | 'lint' | 'diff-check' | 'reproduction';
+export interface PrFeedbackStageACheckReceipt {
+    category: PrFeedbackStageACategory;
+    workingDirectory?: string;
+    obligationId?: string;
+    validatorContract?: {
+        path: string;
+        id: string;
+    };
+    command: string[];
+    targets?: string[];
+    feedbackTargets?: Array<{
+        feedbackItemId: string;
+        target: string;
+        expectedBehavior: string;
+    }>;
+    durationMs: number;
+}
+interface PrFeedbackStageARecord {
+    revisionDigest: string;
+    checks: PrFeedbackStageACheckReceipt[];
+    feedbackItemIds?: string[];
+    applicableCategories?: Array<'build' | 'typecheck' | 'lint'>;
+    applicableObligations?: Array<{
+        id: string;
+        category: 'build' | 'typecheck' | 'lint';
+        workingDirectory: string;
+        source: string;
+        validatorContract?: {
+            path: string;
+            id: string;
+        };
+    }>;
+    validatedAt: string;
+}
+interface PrFeedbackGateBatchRecord {
+    batchId: string;
+    phase: PrFeedbackGatePhase;
+    laneId: string;
+    itemIds: string[];
+    revisionDigest: string;
+    validatedAt: string;
+}
+interface PrFeedbackReadyToPublishRecord {
+    revisionDigest: string;
+    localHead: string;
+    remoteName: string;
+    remoteBranchRef: string;
+    remoteRef: string;
+    validatedAt: string;
+}
+export type PrWorkflowCompletionStatus = 'completed' | 'ready-to-publish';
+export type PrReviewValidationPhase = 'council' | 'reviewer' | 'critic';
+interface PrReviewValidationBatchRecord {
+    batchId: string;
+    phase: PrReviewValidationPhase;
+    lanes: Array<{
+        laneId: string;
+        workflowLane: string;
+        reviewItemIds?: string[];
+    }>;
+    validatedAt: string;
+}
+export interface PrWorkflowGateState {
+    schemaVersion: 1;
+    /** Monotonic durable revision used to reject stale same-session transitions. */
+    revision: number;
+    sessionID: string;
+    mode: PrWorkflowMode;
+    activatedAt: string;
+    updatedAt: string;
+    prHeadSha?: string;
+    prReviewBaseRef?: string;
+    prReviewBaseSha?: string;
+    prReviewBaseDispatches?: PrReviewBaseDispatchRecord[];
+    /** @deprecated Compatibility projection of the most recent base dispatch. */
+    prReviewBaseDispatch?: PrReviewBaseDispatchRecord;
+    prReviewTriggerEvalPath?: string;
+    prReviewValidationBatches?: PrReviewValidationBatchRecord[];
+    prFeedbackInventory?: string[];
+    prFeedbackVerifications?: PrFeedbackVerificationRecord[];
+    /** @deprecated Compatibility projection of the most recent verification dispatch. */
+    prFeedbackVerification?: PrFeedbackVerificationRecord;
+    prFeedbackStageA?: PrFeedbackStageARecord;
+    prFeedbackGateBatches?: PrFeedbackGateBatchRecord[];
+    prFeedbackReadyToPublish?: PrFeedbackReadyToPublishRecord;
+}
+export declare function activatePrWorkflow(directory: string, sessionID: string, mode: PrWorkflowMode, options?: {
+    prHeadSha?: string;
+}): Promise<PrWorkflowGateState>;
+export declare function readPrWorkflowGateState(directory: string, sessionID: string): Promise<PrWorkflowGateState | null>;
+export declare function clearPrWorkflowGateState(directory: string, sessionID: string, expectedRevision?: number): Promise<void>;
+/** Bind an active PR workflow to one immutable PR head. */
+export declare function bindPrWorkflowHead(directory: string, sessionID: string, prHeadSha: string): Promise<PrWorkflowGateState>;
+/** Bind an active PR_REVIEW workflow to one immutable merge-base scope. */
+export declare function bindPrReviewBase(directory: string, sessionID: string, options: {
+    prHeadSha: string;
+    baseRef: string;
+    baseSha: string;
+}): Promise<PrWorkflowGateState>;
+/** Prove that caller-provided PR identity equals the actual checked-out commit. */
+export declare function assertCurrentCheckoutHead(directory: string, expectedHead: string): string;
+/** Prove that every PR-review lane reads the immutable checked-out PR tree. */
+export declare function assertPrReviewCleanCheckout(directory: string): void;
+export declare function enforcePrWorkflowDispatchLanesAsync(directory: string, sessionID: string, toolName: string): Promise<PrWorkflowGateState | null>;
+export declare function enforcePrReviewBaseDimensions(directory: string, sessionID: string, lanes: readonly PrWorkflowLaneSpec[], options: {
+    batchId: string;
+    prHeadSha: string;
+}): Promise<PrWorkflowGateState>;
+/** Validate durable exact-six PR review evidence across all base and retry batches. */
+export declare function assertPrReviewBaseCoverageSettled(directory: string, sessionID: string): Promise<PrWorkflowGateState>;
+/** Persist a council/reviewer/critic validation batch before launch. */
+export declare function recordPrReviewValidationBatch(directory: string, sessionID: string, phase: PrReviewValidationPhase, lanes: readonly PrWorkflowLaneSpec[], options: {
+    batchId: string;
+    prHeadSha: string;
+}): Promise<PrWorkflowGateState>;
+/** Validate that every declared council/reviewer/critic obligation has a successful retry. */
+export declare function assertPrReviewValidationSettled(directory: string, sessionID: string, phase?: PrReviewValidationPhase): Promise<PrWorkflowGateState>;
+export declare function declarePrFeedbackInventory(directory: string, sessionID: string, inventoryIds: readonly string[], options: {
+    prHeadSha: string;
+}): Promise<PrWorkflowGateState>;
+export declare function enforcePrFeedbackVerificationOwnership(directory: string, sessionID: string, ownership: readonly PrFeedbackLaneOwnership[], options: {
+    batchId: string;
+    prHeadSha: string;
+}): Promise<PrWorkflowGateState>;
+/** Validate cumulative exact inventory ownership and settled verification artifacts. */
+export declare function assertPrFeedbackVerificationSettled(directory: string, sessionID: string): Promise<PrWorkflowGateState>;
+/** Persist an actually executed Stage A receipt and invalidate later approvals. */
+export declare function recordPrFeedbackStageA(directory: string, sessionID: string, revisionDigest: string, checks: readonly PrFeedbackStageACheckReceipt[], options?: {
+    applicableCategories?: ReadonlyArray<'build' | 'typecheck' | 'lint'>;
+    applicableObligations?: ReadonlyArray<{
+        id: string;
+        category: 'build' | 'typecheck' | 'lint';
+        workingDirectory: string;
+        source: string;
+        validatorContract?: {
+            path: string;
+            id: string;
+        };
+    }>;
+}): Promise<PrWorkflowGateState>;
+/** Record one ordered, single-lane feedback validation phase before launch. */
+export declare function recordPrFeedbackGateBatch(directory: string, sessionID: string, phase: PrFeedbackGatePhase, lane: PrFeedbackLaneOwnership, options: {
+    batchId: string;
+    prHeadSha: string;
+    revisionDigest: string;
+}): Promise<PrWorkflowGateState>;
+/** Require the latest receipt for a feedback gate phase to be positive and fresh. */
+export declare function assertPrFeedbackGatePhaseSettled(directory: string, sessionID: string, phase: PrFeedbackGatePhase): Promise<PrWorkflowGateState>;
+/** Require every ordered feedback gate on one unchanged revision. */
+export declare function assertPrFeedbackReadyToPublish(directory: string, sessionID: string): Promise<PrWorkflowGateState>;
+export declare function markPrReviewTriggerEvaluationComplete(directory: string, sessionID: string, artifactPath: string): Promise<PrWorkflowGateState>;
+export declare function enforcePrWorkflowToolBefore(directory: string, sessionID: string, toolName: string, args: Record<string, unknown> | undefined, generatedAgentNames?: readonly string[]): Promise<void>;
+/** Validate the terminal PR workflow contract before removing its durable gate. */
+export declare function completePrWorkflow(directory: string, sessionID: string, expectedMode: PrWorkflowMode, prHeadSha: string): Promise<PrWorkflowCompletionStatus>;
+export declare const _test_exports: {
+    workflowGateStateRelativePath: typeof workflowGateStateRelativePath;
+    workflowGateStateLockRelativePath: typeof workflowGateStateLockRelativePath;
+    resetTrackedStateCache: () => void;
+    beforeTerminalClear: (() => Promise<void>) | undefined;
+    resolveCurrentGitHead: typeof resolveCurrentGitHead;
+    resolveCurrentUpstreamPushTarget: typeof resolveCurrentUpstreamPushTarget;
+    resolveCurrentUpstreamRemoteRef: typeof resolveCurrentUpstreamRemoteRef;
+    resolveExactRemoteBranchHead: typeof resolveExactRemoteBranchHead;
+    resolveCommitCountSince: typeof resolveCommitCountSince;
+    resolveIsWorkingTreeClean: typeof resolveIsWorkingTreeClean;
+    resolveIsExactSingleChildCommit: typeof resolveIsExactSingleChildCommit;
+    resolvePrWorkflowRevisionDigest: typeof resolvePrWorkflowRevisionDigest;
+    resolveRemoteRefsContainingHead: typeof resolveRemoteRefsContainingHead;
+    parseCriticVerdict: typeof parseCriticVerdict;
+    isProcessAlive: typeof isProcessAlive;
+    nowMs: () => number;
+};
+/** Require at least one real discovery row or a lane-bound CLEAN attestation. */
+export declare function prReviewDiscoveryArtifactCoversLane(text: string, expectedWorkflowLane: string): boolean;
+declare function parseCriticVerdict(text: string, itemId: string, reviewerSeverity?: string): {
+    status: string;
+    severity: string;
+} | null;
+declare function isProcessAlive(pid: number): boolean;
+declare function workflowGateStateLockRelativePath(sessionID: string): string;
+declare function workflowGateStateRelativePath(sessionID: string): string;
+export {};