opencode-swarm 7.144.1 → 7.144.3

package/dist/cli/{worktree-isolation-cqxgdk2p.js → worktree-isolation-y2p93438.js}

@@ -20,60 +20,60 @@ import {
   sanitizeWorktreeTaskId,
   standardWorktreeByCallID,
   standardWorktreeSerializationSessions
-} from "./index-e9w1tfmm.js";
-import"./index-j2eb0x44.js";
-import"./index-mz1zwz96.js";
-import"./index-1faydhv8.js";
+} from "./index-247wf23m.js";
+import"./index-7554tecy.js";
+import"./index-2en8s72h.js";
+import"./index-satc0vs6.js";
 import"./index-134d35c1.js";
 import"./index-b6e016tv.js";
-import"./index-4q9vfav6.js";
-import"./index-k92cagmt.js";
+import"./index-zwrqe065.js";
+import"./index-8214dd7j.js";
 import"./index-y8552snf.js";
-import"./index-2pmaxbvj.js";
-import"./index-xmzmeknp.js";
+import"./index-wck434f8.js";
+import"./index-70ha9e09.js";
 import"./index-c8s9a3zh.js";
 import"./index-9ss2m4rs.js";
-import"./index-sqp6349j.js";
 import"./index-74hpm6sh.js";
-import"./index-dq26vbfp.js";
-import"./index-g0vr2a4m.js";
-import"./index-f79hf8dr.js";
-import"./index-bgdr1ww3.js";
-import"./index-556ja8an.js";
-import"./index-gdd4jt6b.js";
+import"./index-584grrwn.js";
+import"./index-pag8nsb1.js";
+import"./index-eya357bk.js";
+import"./index-b227mpnk.js";
+import"./index-0fgwdtvp.js";
+import"./index-rtry5xyf.js";
 import"./index-zsrtt42s.js";
+import"./index-krxcxkdq.js";
 import"./index-k3cxyk66.js";
-import"./index-4fda8kkw.js";
-import"./index-2ht8c7ew.js";
+import"./index-x68tw7v3.js";
+import"./index-6s2q144w.js";
+import"./index-p7hbphaq.js";
+import"./index-j6mfyy0a.js";
+import"./index-556ja8an.js";
+import"./index-7sy3aa9m.js";
+import"./index-wx8zdh4a.js";
 import"./index-8fwhhayc.js";
 import"./index-q1exe2b3.js";
-import"./index-7sy3aa9m.js";
-import"./index-4905hd2m.js";
-import"./index-rr2fjfsd.js";
+import"./index-xwpmxpb7.js";
+import"./index-pr8vhj6j.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-8jrn4rwp.js";
+} from "./index-qj22wyw2.js";
 import"./index-gprxjmm7.js";
 import"./index-n832052r.js";
-import"./index-rdb3nr6d.js";
-import"./index-j3byg0a9.js";
 import"./index-rn0eq85g.js";
-import"./index-4rhhvd1a.js";
-import"./index-jqsfsqbx.js";
 import"./index-z6xqpmqg.js";
+import"./index-8hkjk37c.js";
+import"./index-1brb14xc.js";
+import"./index-4rhhvd1a.js";
+import"./index-whezv7vc.js";
 import"./index-zjygnfay.js";
-import"./index-315tnsve.js";
-import"./index-tq5s07ta.js";
-import"./index-rtry5xyf.js";
-import"./index-c3zag2cw.js";
 import"./index-ae75rja9.js";
-import"./index-w7x7qxz2.js";
-import"./index-erfnw81g.js";
-import"./index-bk5tah7q.js";
+import"./index-dpfphnmy.js";
+import"./index-zswmbm15.js";
 import"./index-ed5ykebp.js";
-import"./index-k31en0ja.js";
-import"./index-7g4c7s5r.js";
+import"./index-bk5tah7q.js";
+import"./index-wd24zn2e.js";
 import"./index-s2rcz51a.js";
+import"./index-7g4c7s5r.js";
 import"./index-bpmtbmy9.js";
 import"./index-4nt52yr9.js";
 import"./index-zgwm4ryv.js";

package/dist/commands/registry.d.ts

@@ -619,7 +619,7 @@ export declare const COMMAND_REGISTRY: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Clear a stuck PR_REVIEW/PR_FEEDBACK mechanical gate and stop the auto-resume loop [mode] [reason]";
         readonly args: "[PR_REVIEW|PR_FEEDBACK] [reason...]";
-        readonly details: "Human-only escape hatch for an unrecoverable PR_REVIEW or PR_FEEDBACK mechanical gate. When the architect cannot reach complete_pr_workflow — for example a compound `git fetch && git checkout` was rejected as read-only shell syntax, the PR head cannot be fetched, or the working tree is on the wrong branch — running this clears the durable gate state for the current session and stops the auto-resume loop without depending on the trapped model. The agent itself cannot run this command; it must call the abort_pr_workflow tool (or ask you to run this command). Both paths funnel into the same fail-closed abortPrWorkflow hook, which refuses while the workflow is armed for publication or while PR workflow lanes are still in flight. When checkout preparation preserved a stash, the result instructs the caller to run prepare_pr_workflow_checkout operation=restore after the clear. An audit event is appended to .swarm/events.jsonl.";
+        readonly details: "Human-only escape hatch for an unrecoverable PR_REVIEW or PR_FEEDBACK mechanical gate. When the architect cannot reach complete_pr_workflow — for example a compound `git fetch && git checkout` was rejected as read-only shell syntax, the PR head cannot be fetched, or the working tree is on the wrong branch — running this clears the durable gate state for the current session and stops the auto-resume loop without depending on the trapped model. The agent itself cannot run this command; it must call the abort_pr_workflow tool (or ask you to run this command). Both paths funnel into the same fail-closed abortPrWorkflow hook, which refuses while the workflow is armed for publication or while PR workflow lanes are still in flight. This human-only force path has exactly one exception to that second refusal (issue #2251): when the ONLY lanes still blocking are ones past the 30-minute staleness horizon that the liveness probe reports as still running — a lane nothing will ever settle on a schedule — it clears the gate anyway, names exactly which lanes it overrode, and finalizes their delegation records so the session can start a new PR workflow. Those sessions are NOT stopped and their output is NOT collected. A lane with a fresh updatedAt still blocks even under force, and any delegation record that still keeps the session blocked is named in the warning. When checkout preparation preserved a stash, the result instructs the caller to run prepare_pr_workflow_checkout operation=restore after the clear. An audit event is appended to .swarm/events.jsonl.";
         readonly category: "utility";
         readonly toolPolicy: "restricted";
     };

package/dist/config/constants.d.ts

@@ -5,7 +5,7 @@ export type { AgentName, PipelineAgentName, QAAgentName } from './agent-names';
 export { ALL_AGENT_NAMES, ALL_SUBAGENT_NAMES, ORCHESTRATOR_NAME, PIPELINE_AGENTS, QA_AGENTS, } from './agent-names';
 export declare const OPENCODE_NATIVE_AGENTS: Set<"plan" | "summary" | "compaction" | "title" | "build" | "general" | "explore">;
 export declare const CLAUDE_CODE_NATIVE_COMMANDS: ReadonlySet<string>;
-export declare const MEMORY_TOOL_NAMES: readonly ["swarm_memory_recall", "swarm_memory_propose"];
+export declare const MEMORY_TOOL_NAMES: readonly ["swarm_memory_recall", "swarm_memory_propose", "swarm_memory_outcome"];
 export declare const MEMORY_AGENT_TOOL_MAP: Partial<Record<AgentName, ToolName[]>>;
 export declare const EXTERNAL_SKILL_TOOL_NAMES: readonly ["external_skill_discover", "external_skill_list", "external_skill_inspect", "external_skill_promote", "external_skill_reject", "external_skill_delete", "external_skill_revoke"];
 export declare const EXTERNAL_SKILL_AGENT_TOOL_MAP: Partial<Record<AgentName, ToolName[]>>;

package/dist/config/schema.d.ts

@@ -816,6 +816,10 @@ export declare const MemoryConfigSchema: z.ZodObject<{
             tokenBudget: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    reflection: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        halfLifeDays: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     learning: z.ZodDefault<z.ZodObject<{
         learningRate: z.ZodDefault<z.ZodNumber>;
         propagationFactor: z.ZodDefault<z.ZodNumber>;
@@ -2199,6 +2203,10 @@ export declare const PluginConfigSchema: z.ZodObject<{
                 tokenBudget: z.ZodDefault<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        reflection: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            halfLifeDays: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
         learning: z.ZodDefault<z.ZodObject<{
             learningRate: z.ZodDefault<z.ZodNumber>;
             propagationFactor: z.ZodDefault<z.ZodNumber>;

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

@@ -2,7 +2,7 @@ import * as fsp from 'node:fs/promises';
 import { z } from 'zod';
 import { type CandidateSeverity, type RowFormatFamily } from '../background/candidate-contract.js';
 import { type LaneOutputArtifact } from '../background/lane-output-store.js';
-import { type BackgroundDelegationRecord, type BackgroundDelegationResult, findByBatchId } from '../background/pending-delegations.js';
+import { type BackgroundDelegationRecord, type BackgroundDelegationResult, findByBatchId, sweepStaleDelegations } 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 { classifyPrWorkflowGitState, type PrWorkflowGitState } from '../git/pr-workflow-state.js';
@@ -408,13 +408,99 @@ export declare function withInactivePrWorkflowCheckoutRestoreLock<T>(directory:
 export declare function clearPrWorkflowGateState(directory: string, sessionID: string, expectedRevision?: number, options?: {
     allowSalvagedRead?: boolean;
 }): Promise<void>;
+/**
+ * The single session operation the liveness probe needs.
+ *
+ * Deliberately a narrow LOCAL structural type rather than a type-only import of
+ * `SessionOps` from `src/tools/dispatch-lanes.ts`: that module's
+ * `isLaneReadyForCollection` is the fail-CLOSED counterpart of this probe, and
+ * keeping the two textually independent removes any invitation to "share" the
+ * predicate. A type-only import would be erased either way; this is about
+ * preventing the wrong reuse, not about module graph cost.
+ */
+interface PrWorkflowLaneLivenessSessionOps {
+    status?: (args: {
+        query?: {
+            directory?: string;
+        };
+    }) => Promise<{
+        data?: Record<string, {
+            type?: string;
+        }> | null;
+        error?: unknown;
+    }>;
+}
+/** Why a probe produced no evidence of life. Absent means the probe ran. */
+export type PrWorkflowLaneProbeDegradedReason = 'probe-unavailable' | 'probe-error' | 'probe-timeout' | 'probe-no-data';
+/**
+ * Probe which of `records` have a session the host affirmatively reports as
+ * still running (issue #2251).
+ *
+ * **FAIL-OPEN, by design.** For its ERROR and NO-DATA cases this is the exact
+ * inverse of `isLaneReadyForCollection` (`src/tools/dispatch-lanes.ts`), which
+ * returns `false` on a truthy `error`, on missing `data`, and on a throw —
+ * because a lane it cannot verify must not be collected. The two agree, rather
+ * than invert, on ONE case: a host that exposes no `status` function at all.
+ * There the collector returns `true` (`dispatch-lanes.ts`, the `typeof
+ * session.status !== 'function'` guard) and this probe reports
+ * `probe-unavailable`, so both fall through to proceeding — an unprobeable host
+ * must not wedge either side.
+ *
+ * Here the default outcome must be "settle": an unavailable, erroring,
+ * timing-out or empty probe returns the empty set, so age alone decides and the
+ * reachability floor this whole subsystem exists to preserve is untouched. Only
+ * a probe that RAN and affirmatively named a live session may contradict
+ * staleness.
+ *
+ * The returned set is built only from a fully-read response — a mid-iteration
+ * throw yields the empty set rather than a partial spare list, so a malformed
+ * response can never spare an arbitrary subset of lanes.
+ *
+ * Keys are `subagentSessionId`s. A record without one is unprobeable and is
+ * simply never added (it settles), which is the fail-open direction.
+ */
+declare function probeAlivePrWorkflowLaneSessions(directory: string, records: BackgroundDelegationRecord[]): Promise<{
+    alive: Set<string>;
+    degradedReason?: PrWorkflowLaneProbeDegradedReason;
+}>;
 export interface PrWorkflowStaleLaneSettlement {
-    /** Lanes still genuinely in flight (fresh `updatedAt`). These still block. */
+    /**
+     * Every lane that still blocks: lanes with a fresh `updatedAt` PLUS lanes
+     * past the horizon whose session the liveness probe reported still running.
+     */
     openLaneIds: string[];
     openLanes: number;
+    /**
+     * Open lanes that block on FRESHNESS alone (age below the horizon).
+     *
+     * Separated from `openLanes` because the human-only `force` abort override
+     * (issue #2251 S3) must distinguish "blocked only by probe retention", which
+     * an operator may override, from "blocked by a lane that is genuinely young",
+     * which stays fail-closed. Deriving it by subtraction or by comparing lane
+     * LABELS would be wrong: `prWorkflowLaneLabel` falls back to `'unknown'`, so
+     * labels are not unique.
+     */
+    freshOpenLanes: number;
     /** Lanes stale past the horizon, treated as settled with disclosure. */
     presumedStaleLaneIds: string[];
-    /** Operator-facing disclosure; `undefined` when nothing was presumed stale. */
+    /**
+     * Lanes past the horizon that the probe spared. Present only when non-empty.
+     */
+    probedAliveLaneIds?: string[];
+    /**
+     * The SAME records as {@link probedAliveLaneIds}, in the same order, keyed by
+     * `correlationId` instead of by display label.
+     *
+     * Both are needed and neither substitutes for the other: `prWorkflowLaneLabel`
+     * falls back to `'unknown'` and is not unique, so it cannot address a durable
+     * record — while `correlationId` is the ledger's primary key and is what the
+     * human-only `force` override must name to finalize exactly these records and
+     * nothing else. Present only when non-empty.
+     */
+    probeRetainedCorrelationIds?: string[];
+    /** Set when the probe could not produce evidence; absent when it ran. */
+    probeDegradedReason?: PrWorkflowLaneProbeDegradedReason;
+    /** Operator-facing disclosure; `undefined` when nothing was settled or retained. */
     disclosure?: string;
 }
 /**
@@ -439,6 +525,13 @@ export interface PrWorkflowStaleLaneSettlement {
  *
  * A lane with a RECENT `updatedAt` still blocks: a re-verification that CAN run
  * and reports "still progressing" contradicts settlement and fails closed.
+ *
+ * Issue #2251 adds the second, stronger contradiction: a lane PAST the horizon
+ * whose session the host affirmatively reports as `busy`/`retry` is genuinely
+ * running (nothing heartbeats `updatedAt`, so age alone cannot see this) and is
+ * retained instead of discarded. The probe is fail-open — see
+ * {@link probeAlivePrWorkflowLaneSessions} — so an unavailable, erroring or
+ * empty probe leaves the age-only behaviour exactly as it was.
  */
 export declare function settlePresumedStalePrWorkflowLanes(directory: string, sessionID: string): Promise<PrWorkflowStaleLaneSettlement>;
 /**
@@ -480,6 +573,16 @@ export declare function abortPrWorkflow(directory: string, sessionID: string, op
     openLanes: number;
     presumedStaleLanes?: string[];
     presumedStaleDisclosure?: string;
+    /** Lanes past the horizon the liveness probe reported as still running. */
+    probeRetainedLanes?: string[];
+    /**
+     * Present ONLY when a human `force` abort cleared the gate while those
+     * probe-retained lanes were the sole remaining reason it was blocked
+     * (issue #2251 S3).
+     */
+    probeRetentionOverrideDisclosure?: string;
+    /** Why the liveness probe produced no evidence, when it could not run. */
+    probeDegradedReason?: PrWorkflowLaneProbeDegradedReason;
     stateSalvaged?: boolean;
     stateSalvageDisclosure?: string;
     casEscapeDisclosure?: string;
@@ -652,6 +755,32 @@ export declare const _test_exports: {
     removeCheckoutLock: typeof removeCheckoutLockFile;
     checkoutMutationActionTimeoutMs: number;
     classifyPrWorkflowGitStateAsync: typeof classifyPrWorkflowGitState;
+    /**
+     * The durability sweep, reached through a seam so a test can prove that a
+     * failing sweep cannot un-settle the decision `settlePresumedStalePrWorkflow-
+     * Lanes` already made in memory. It cannot throw today (it catches internally
+     * and returns 0) — the seam is what makes that guarantee testable rather than
+     * merely asserted.
+     */
+    sweepStaleDelegationsAsync: typeof sweepStaleDelegations;
+    /** The fail-open liveness probe (issue #2251). */
+    probeLaneLivenessAsync: typeof probeAlivePrWorkflowLaneSessions;
+    /**
+     * Session handle for the liveness probe.
+     *
+     * A seam rather than a direct `swarmState.opencodeClient` read at the call
+     * site because 20+ test files mutate that field; without this, this suite and
+     * the stale-lane suite would be order-dependent in bun's shared process.
+     * Mirrors `_internals.getSessionOps` in `src/tools/dispatch-lanes.ts`.
+     */
+    getSessionOps: () => PrWorkflowLaneLivenessSessionOps | null;
+    /**
+     * Probe deadline, read through the seam at CALL time. `freezeClock` patches
+     * `Date.now()`, not `setTimeout`, so a test that must reach the timeout branch
+     * has to shorten the real deadline. Same precedent as
+     * `checkoutMutationActionTimeoutMs` above.
+     */
+    laneLivenessProbeTimeoutMs: number;
     resolveCurrentGitHead: typeof resolveCurrentGitHead;
     resolveCurrentGitHeadAsync: typeof resolveCurrentGitHeadAsync;
     resolveCurrentUpstreamPushTarget: typeof resolveCurrentUpstreamPushTarget;

package/dist/hooks/review-receipt-scope.d.ts

@@ -1,25 +1,38 @@
 /**
- * Canonical scope construction for Stage-B reviewer receipts.
+ * Canonical scope construction for Stage-B reviewer receipts (v2, issue #2100).
  *
  * The architect-authored reviewer prompt is not authoritative scope: it can
  * omit files that the coder actually changed. Guardrails records every
- * write-tool target in `modifiedFilesThisCoderTask`, so receipts fingerprint a
- * bounded manifest of repository HEAD, those paths, and their current byte
- * content instead. A base change therefore invalidates the receipt even when
- * the working-file bytes happen to remain identical.
+ * write-tool target on the coder generation, so receipts fingerprint an exact
+ * manifest of repository HEAD, the canonical workspace identity, those paths,
+ * and their complete current bytes (streamed SHA-256 — no byte caps). A base
+ * change therefore invalidates the receipt even when the working-file bytes
+ * happen to remain identical.
  *
- * Any missing session state, unsafe path, symlink/reparse point, concurrent
- * mutation, or size overflow fails toward no receipt. A durable receipt must
- * never claim a scope the harness could not reconstruct exactly.
+ * The inline payload budget (`maxBytes`) selects a per-file DELIVERY MODE only
+ * — it never decides which files enter the manifest and never changes the
+ * manifest digest. Unsafe paths, symlink/reparse points, non-regular files,
+ * and concurrent mutation fail toward typed results; transient classes
+ * (HEAD timeout/race, capture races, capture deadline) are retryable.
  */
 import * as child_process from 'node:child_process';
 import * as fs from 'node:fs';
-export declare const REVIEWER_TASK_SCOPE_DESCRIPTION = "reviewer-task-files-v1";
+export declare const REVIEWER_TASK_SCOPE_DESCRIPTION = "reviewer-task-files-v2";
+export declare const REVIEWER_TASK_SCOPE_HEADER = "opencode-swarm-reviewer-task-scope-v2";
+export interface ReviewerTaskScopeDeliveryEntry {
+    path: string;
+    mode: 'inline' | 'manual';
+}
 export interface ReviewerTaskScope {
     content: string;
-    description: typeof REVIEWER_TASK_SCOPE_DESCRIPTION;
+    /** Manifest version discriminator — `reviewer-task-files-v2` for live builds; legacy v1 values only reach us from persisted data. */
+    description: string;
     files: string[];
     headSha: string;
+    /** Canonical workspace identity the manifest bytes were captured from. */
+    workspaceIdentity: string;
+    /** Per-file delivery mode — advisory prompt metadata, never part of the digest. */
+    delivery: ReviewerTaskScopeDeliveryEntry[];
     taskId?: string;
     coderCallID?: string;
     generation?: number;
@@ -41,6 +54,17 @@ export interface ResolveReviewerTaskScopeOptions {
     /** Injectable clock used only for deterministic expiry tests. */
     now?: number;
 }
+export type ReviewerScopeBuildFailureCode = 'no_files' | 'too_many_files' | 'invalid_budget' | 'invalid_path' | 'workspace_unresolvable' | 'head_timeout' | 'head_changed' | 'outside_workspace' | 'symlink_or_reparse' | 'non_regular' | 'unreadable' | 'file_changed_during_capture' | 'capture_deadline';
+export type ReviewerScopeBuildResult = {
+    ok: true;
+    scope: ReviewerTaskScope;
+} | {
+    ok: false;
+    code: ReviewerScopeBuildFailureCode;
+    retryable: boolean;
+    file?: string;
+    detail?: string;
+};
 /**
  * Resolve the exact known plan task carried by reviewer/coder Task arguments.
  *
@@ -58,14 +82,17 @@ export declare function resolveReviewerScopeTaskId(directory: string, args: unkn
 export declare const _internals: {
     spawn: typeof child_process.spawn;
     realpath: typeof fs.promises.realpath;
-    lstatBigInt: (path: fs.PathLike) => Promise<fs.BigIntStats>;
-    open: typeof fs.promises.open;
-    fileHandleStatBigInt: (handle: fs.promises.FileHandle) => Promise<fs.BigIntStats>;
 };
 /**
- * Build the exact scope fingerprint input for a guardrails-observed file list.
+ * Build the exact reviewer-task manifest for a guardrails-observed file list.
+ *
+ * Every regular file contributes its COMPLETE byte count and SHA-256 (streamed
+ * capture); the payload budget only selects per-file delivery mode. Transient
+ * failures return typed retryable results; the caller owns bounded retry.
  */
-export declare function buildReviewerTaskScope(directory: string, modifiedFiles: readonly string[], maxBytes?: number, provenance?: ReviewerTaskScopeProvenance): Promise<ReviewerTaskScope | null>;
+export declare function buildReviewerTaskScope(directory: string, modifiedFiles: readonly string[], maxBytes?: number, provenance?: ReviewerTaskScopeProvenance, options?: {
+    deadlineAt?: number;
+}): Promise<ReviewerScopeBuildResult>;
 /**
  * Resolve scope only from the architect session's guardrails-owned task state.
  * Receipt collection consumes the completed coder handoff exactly once; direct

package/dist/hooks/reviewer-scope-file-fingerprint.d.ts

@@ -1,6 +1,33 @@
 import * as fs from 'node:fs';
-export declare const MAX_REVIEWER_SCOPE_FINGERPRINT_BYTES = 1048576;
-export declare const MAX_REVIEWER_SCOPE_FINGERPRINT_AGGREGATE_BYTES = 4194304;
+/**
+ * Exact reviewer-scope capture (v2, issue #2100).
+ *
+ * Every regular file is fingerprinted over its COMPLETE bytes with one fixed
+ * chunk buffer — there is no per-file or aggregate byte cap. File identity is
+ * never denied by size: resource pressure surfaces as the typed retryable
+ * `capture_deadline` (or a per-file race code), and only a successful capture
+ * can ever produce a digest. A partial, sampled, or capped digest cannot be
+ * represented by this module by construction.
+ */
+export type ReviewerScopeCaptureFailureCode = 'invalid_request' | 'outside_workspace' | 'symlink_or_reparse' | 'non_regular' | 'unreadable' | 'workspace_mismatch' | 'file_changed_during_capture' | 'capture_deadline';
+/** `binding_mismatch` and invalid generation identity are lifecycle-level typed errors (reviewer-scope-lifecycle), not per-file capture codes. */
+export declare const RETRYABLE_CAPTURE_FAILURE_CODES: ReadonlySet<ReviewerScopeCaptureFailureCode>;
+export type ReviewerScopeCaptureResult = {
+    kind: 'captured_file';
+    file: string;
+    size: number;
+    hash: string;
+} | {
+    kind: 'captured_deleted';
+    file: string;
+} | {
+    kind: 'capture_failed';
+    file: string;
+    code: ReviewerScopeCaptureFailureCode;
+    retryable: boolean;
+    detail?: string;
+};
+/** Stored success record persisted on generations and ownership tombstones. */
 export type ReviewerScopeFileFingerprint = {
     file: string;
     kind: 'file';
@@ -10,12 +37,37 @@ export type ReviewerScopeFileFingerprint = {
     file: string;
     kind: 'deleted';
 };
+/** Fixed streaming chunk — the only buffer a capture ever allocates. */
+export declare const REVIEWER_SCOPE_CAPTURE_CHUNK_BYTES = 262144;
+/** Bounded attempts for typed retryable capture failures at every call site. */
+export declare const REVIEWER_SCOPE_CAPTURE_ATTEMPTS = 3;
+/** Total deadline (ms) for one capture batch (guardrails batch, freshness check, manifest build). */
+export declare const REVIEWER_SCOPE_CAPTURE_BATCH_DEADLINE_MS = 10000;
 export declare const _internals: {
-    readFileSync: typeof fs.readFileSync;
+    open: typeof fs.openSync;
+    fstat: (fd: number, options: {
+        bigint: true;
+    }) => fs.BigIntStats;
+    read: typeof fs.readSync;
+    close: typeof fs.closeSync;
+    lstat: typeof fs.lstatSync;
+    stat: (path: fs.PathLike, options: {
+        bigint: true;
+    }) => fs.BigIntStats;
+    realpathSync: typeof fs.realpathSync;
+    now: () => number;
 };
 /**
- * Capture the exact post-write file state with a bounded read. Oversized,
- * non-regular, path-racing, and unreadable targets fail closed to null.
+ * Capture the exact current file state with a complete, bounded-memory SHA-256.
+ *
+ * Failure surfaces are typed: traversal/root escape, symlinks/reparse points,
+ * non-regular files, and unreadable targets fail closed as non-retryable codes;
+ * open/stat races and capture deadlines are retryable. Deletions under a
+ * contained (possibly removed) directory are `captured_deleted`.
  */
-export declare function captureReviewerScopeFileFingerprint(directory: string, file: string, maxBytes?: number): ReviewerScopeFileFingerprint | null;
+export declare function captureReviewerScopeFileFingerprint(directory: string, file: string, options?: {
+    deadlineAt?: number;
+}): ReviewerScopeCaptureResult;
+/** Convert a successful capture into the stored fingerprint record shape. */
+export declare function reviewerScopeCaptureToFingerprint(result: ReviewerScopeCaptureResult): ReviewerScopeFileFingerprint | null;
 export declare function reviewerScopeFileFingerprintsEqual(left: ReviewerScopeFileFingerprint, right: ReviewerScopeFileFingerprint): boolean;

package/dist/hooks/reviewer-scope-lifecycle.d.ts

@@ -1,4 +1,12 @@
-export type ReviewerScopeLifecycleTransition = 'coder_started' | 'coder_ready' | 'reviewer_claimed';
+import * as child_process from 'node:child_process';
+export type ReviewerScopeLifecycleTransition = 'coder_started' | 'coder_ready' | 'coder_no_change' | 'reviewer_claimed';
+/** Test-only dependency-injection seam for the no-change status probe. */
+export declare const _internals: {
+    spawn: typeof child_process.spawn;
+    backoffMs?: number;
+    /** Test-only deadline override for the bounded retry loop (ms). */
+    retryDeadlineMs?: number;
+};
 /** Run only after the complete blocking before-chain approved this Task call. */
 export declare function beginApprovedReviewerScopeLifecycle(input: {
     directory: string;

package/dist/hooks/reviewer-scope-mergeback.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Merge-back verification for lane-captured reviewer generations (issue #2100
+ * contract D).
+ *
+ * A lane generation is only reviewable from the primary checkout after every
+ * manifest file (including deletions) matches the lane manifest in the primary
+ * root. Verification re-captures each file from the PRIMARY directory with the
+ * shared exact-byte capture and compares against the generation's stored
+ * fingerprints. A conflict, deferred merge, or changed byte produces a typed
+ * retained state (`mergeback_mismatch`) — never a generic reviewer-stale
+ * relabel and never a discard.
+ */
+/**
+ * Best-effort synchronous verification. Never throws: an unexpected error is
+ * recorded as a typed mismatch so the generation stays actionable.
+ */
+export declare function verifyReviewerScopeGenerationMergeBack(input: {
+    parentSessionID: string;
+    taskId: string;
+    coderCallID: string;
+    primaryDirectory: string;
+    now?: number;
+}): void;

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import type { Plugin } from '@opencode-ai/plugin';
 import { loadPluginConfigWithMetaAsync } from './config';
 import { resolveAutoReviewConfig } from './config/schema';
 import { createRepoGraphBuilderHook } from './hooks';
+import type { MemoryConfig as RuntimeMemoryConfig } from './memory/config.js';
 import { loadSnapshot } from './session/snapshot-reader.js';
 import { ensureSwarmGitExcluded } from './utils/gitignore-warning';
 /**
@@ -24,6 +25,7 @@ type PostResolutionTask = () => void | Promise<void>;
  * expensive filesystem work while `server()` remains unresolved (issue #704).
  */
 declare function schedulePostResolutionTasks(tasks: readonly PostResolutionTask[]): void;
+type RegenerateMemoryReflectionForInit = (directory: string, config: Partial<RuntimeMemoryConfig>) => Promise<unknown>;
 export declare function overrideIndexInternalsForTest(overrides: {
     createRepoGraphBuilderHook?: typeof createRepoGraphBuilderHook;
     schedulePostResolutionTasks?: typeof schedulePostResolutionTasks;
@@ -31,6 +33,7 @@ export declare function overrideIndexInternalsForTest(overrides: {
     loadSnapshot?: typeof loadSnapshot;
     ensureSwarmGitExcluded?: typeof ensureSwarmGitExcluded;
     resolveAutoReviewConfig?: typeof resolveAutoReviewConfig;
+    regenerateMemoryReflection?: RegenerateMemoryReflectionForInit;
 }): () => void;
 export declare function schedulePostResolutionTasksForTest(tasks: readonly PostResolutionTask[]): void;
 /**