opencode-swarm 7.143.4 → 7.143.6

package/dist/cli/{worktree-isolation-cc3x13ng.js → worktree-isolation-fbfvxw9a.js}

@@ -20,52 +20,52 @@ import {
   sanitizeWorktreeTaskId,
   standardWorktreeByCallID,
   standardWorktreeSerializationSessions
-} from "./index-gz3z9d64.js";
-import"./index-6htwcbxh.js";
-import"./index-ja15rdzd.js";
-import"./index-c9d5y70c.js";
+} from "./index-5d8ydxae.js";
+import"./index-nd1j9wkw.js";
+import"./index-whyrhjsk.js";
+import"./index-w1q9yy1e.js";
 import"./index-134d35c1.js";
 import"./index-b6e016tv.js";
 import"./index-4q9vfav6.js";
 import"./index-k92cagmt.js";
 import"./index-y8552snf.js";
-import"./index-dmtq7tvd.js";
+import"./index-92bm9ys3.js";
 import"./index-xmzmeknp.js";
 import"./index-c8s9a3zh.js";
 import"./index-9ss2m4rs.js";
-import"./index-td2ga37v.js";
+import"./index-bbv64s17.js";
 import"./index-74hpm6sh.js";
-import"./index-19wyta2k.js";
-import"./index-f3xf9dv5.js";
-import"./index-v9qmhrj9.js";
-import"./index-8qmnqd6g.js";
+import"./index-02nm8qhk.js";
+import"./index-scj2asek.js";
+import"./index-z4cv77tq.js";
+import"./index-hjy4txgr.js";
 import"./index-556ja8an.js";
 import"./index-gdd4jt6b.js";
 import"./index-zsrtt42s.js";
 import"./index-k3cxyk66.js";
-import"./index-8aabbfhv.js";
-import"./index-gbr0jbxy.js";
+import"./index-6vmazy9f.js";
+import"./index-s7nb33pc.js";
 import"./index-8fwhhayc.js";
 import"./index-q1exe2b3.js";
 import"./index-7sy3aa9m.js";
 import"./index-4905hd2m.js";
-import"./index-8fq18k02.js";
+import"./index-0adcjpyx.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-9m5gz9ea.js";
+} from "./index-peqmw3wr.js";
 import"./index-gprxjmm7.js";
 import"./index-n832052r.js";
-import"./index-f39n8pbr.js";
-import"./index-z4g05zbr.js";
+import"./index-36vry26a.js";
+import"./index-7bs015gm.js";
 import"./index-rn0eq85g.js";
 import"./index-4rhhvd1a.js";
 import"./index-jqsfsqbx.js";
 import"./index-z6xqpmqg.js";
 import"./index-zjygnfay.js";
-import"./index-z0j133c4.js";
+import"./index-gzxz0s50.js";
 import"./index-tq5s07ta.js";
 import"./index-rtry5xyf.js";
-import"./index-5qqyvwqw.js";
+import"./index-wjk00vwk.js";
 import"./index-ae75rja9.js";
 import"./index-w7x7qxz2.js";
 import"./index-erfnw81g.js";

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

@@ -1,4 +1,5 @@
 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';
@@ -326,6 +327,12 @@ export interface PrWorkflowGateState {
     prFeedbackTargetUrl?: string;
     prFeedbackReviewHandoff?: PrFeedbackReviewHandoffRecord;
     prFeedbackInventory?: string[];
+    /**
+     * Append-only audit ledger of entries added to `prFeedbackInventory` after
+     * its first declaration (issue #2242 R3). Bounded by
+     * {@link MAX_PR_FEEDBACK_INVENTORY_AMENDMENTS}; never pruned.
+     */
+    prFeedbackInventoryAmendments?: PrFeedbackInventoryAmendmentRecord[];
     prFeedbackVerifications?: PrFeedbackVerificationRecord[];
     /**
      * Item -> lane bindings of verification batches the capacity GC dropped
@@ -352,6 +359,28 @@ export interface PrWorkflowGateState {
     prFeedbackRebindCount?: number;
     prFeedbackScopes?: PrFeedbackScopeDeclarationRecord[];
 }
+/**
+ * Bound on the PR_FEEDBACK inventory-amendment audit ledger (issue #2242 R3).
+ *
+ * `declarePrFeedbackInventory` is agent-callable and each call can append, so
+ * this array would otherwise grow without limit on durable state. It is an
+ * integrity ledger, not a reclaimable cache: unlike `prFeedbackVerifications`
+ * (which `prunePrFeedbackVerificationsForCapacity` compacts), pruning it would
+ * destroy the audit trail, so the cap fails closed on further amendments
+ * instead.
+ */
+export declare const MAX_PR_FEEDBACK_INVENTORY_AMENDMENTS = 128;
+/**
+ * One appended PR_FEEDBACK inventory entry (issue #2242 R3). `batch` groups the
+ * entries appended by a single `declarePrFeedbackInventory` call so an auditor
+ * can tell "two items found in one pass" from "two separate late discoveries".
+ */
+declare const PrFeedbackInventoryAmendmentRecordSchema: z.ZodObject<{
+    entry: z.ZodString;
+    amendedAt: z.ZodString;
+    batch: z.ZodNumber;
+}, z.core.$strict>;
+export type PrFeedbackInventoryAmendmentRecord = z.infer<typeof PrFeedbackInventoryAmendmentRecordSchema>;
 export declare function activatePrWorkflow(directory: string, sessionID: string, mode: PrWorkflowMode, options?: {
     prHeadSha?: string;
     requireCheckoutPreflight?: boolean;
@@ -376,7 +405,42 @@ export declare function withPrWorkflowCheckoutPreparationLock<T>(directory: stri
  * activatePrWorkflow/persistState call.
  */
 export declare function withInactivePrWorkflowCheckoutRestoreLock<T>(directory: string, sessionID: string, action: () => Promise<T>): Promise<T>;
-export declare function clearPrWorkflowGateState(directory: string, sessionID: string, expectedRevision?: number): Promise<void>;
+export declare function clearPrWorkflowGateState(directory: string, sessionID: string, expectedRevision?: number, options?: {
+    allowSalvagedRead?: boolean;
+}): Promise<void>;
+export interface PrWorkflowStaleLaneSettlement {
+    /** Lanes still genuinely in flight (fresh `updatedAt`). These still block. */
+    openLaneIds: string[];
+    openLanes: number;
+    /** Lanes stale past the horizon, treated as settled with disclosure. */
+    presumedStaleLaneIds: string[];
+    /** Operator-facing disclosure; `undefined` when nothing was presumed stale. */
+    disclosure?: string;
+}
+/**
+ * Resolve the open-lane predicate shared by `abortPrWorkflow`, the
+ * PR_REVIEW→PR_FEEDBACK transition, and `completePrWorkflow` (issue #2242 R2,
+ * wedge W-4).
+ *
+ * A lane whose delegation record has not advanced its `updatedAt` within
+ * `PR_WORKFLOW_STALE_LANE_TIMEOUT_MS` is **presumed stale** and settles with
+ * disclosure instead of blocking forever. The background process backing a lane
+ * can die without ever writing a terminal snapshot, and these three predicates
+ * are exactly the exits an operator reaches for when nothing else can proceed —
+ * previously the abort escape hatch was refused by the same check it exists to
+ * resolve, leaving the workflow with no exit through any tool.
+ *
+ * Deliberate ordering — this is the reachability invariant, do not "simplify"
+ * it: staleness is decided by the **in-memory filter below**, and
+ * `sweepStaleDelegations` runs only afterwards as a best-effort durability
+ * complement. That sweep swallows lock timeouts and returns 0
+ * (`pending-delegations.ts`), so making reachability depend on it would let a
+ * contended store lock re-create the exact wedge this removes.
+ *
+ * A lane with a RECENT `updatedAt` still blocks: a re-verification that CAN run
+ * and reports "still progressing" contradicts settlement and fails closed.
+ */
+export declare function settlePresumedStalePrWorkflowLanes(directory: string, sessionID: string): Promise<PrWorkflowStaleLaneSettlement>;
 /**
  * Abort an active PR workflow gate without reaching terminal completion.
  *
@@ -414,6 +478,11 @@ export declare function abortPrWorkflow(directory: string, sessionID: string, op
     mode: PrWorkflowMode;
     prHeadSha?: string;
     openLanes: number;
+    presumedStaleLanes?: string[];
+    presumedStaleDisclosure?: string;
+    stateSalvaged?: boolean;
+    stateSalvageDisclosure?: string;
+    casEscapeDisclosure?: string;
 }>;
 /** Bind an active PR workflow to one immutable PR head. */
 export declare function bindPrWorkflowHead(directory: string, sessionID: string, prHeadSha: string): Promise<PrWorkflowGateState>;
@@ -563,6 +632,12 @@ export declare const _test_exports: {
     withPrWorkflowCheckoutMutationLock: typeof withPrWorkflowCheckoutMutationLock;
     resetTrackedStateCache: () => void;
     beforeTerminalClear: (() => Promise<void>) | undefined;
+    /**
+     * Interleave point between the durable `pr_workflow_aborted` append and the
+     * CAS-guarded clear, so a test can simulate the concurrent mutation that
+     * makes the clear throw after the audit record is already on disk (FB-008).
+     */
+    beforeAbortClear: (() => Promise<void>) | undefined;
     beforePrFeedbackTransitionLock: (() => Promise<void>) | undefined;
     beforePrFeedbackTrackingSwitch: (() => Promise<void>) | undefined;
     afterPrFeedbackTrackingSwitch: (() => Promise<void>) | undefined;
@@ -880,6 +955,65 @@ export declare class PrWorkflowCheckoutMutationTimeoutError extends Error {
 /** Serialize project-wide checkout mutations before any session state lock. */
 export declare function withPrWorkflowCheckoutMutationLock<T>(directory: string, action: () => Promise<T>): Promise<T>;
 declare function isProcessAlive(pid: number): boolean;
+/**
+ * Upper bound on the length of ONE quoted schema issue.
+ *
+ * The issue-COUNT cap alone is not a bound on disclosure size: zod folds every
+ * unrecognized key of a single strict object into ONE `unrecognized_keys` issue
+ * whose message inlines all of them, so one oversized key in a nested strict
+ * child (e.g. `checkoutRecovery`) yields a single 80,000-char message that the
+ * count cap does nothing about. The disclosure is written durably to
+ * `.swarm/events.jsonl` and surfaced verbatim in `pr_workflow_status`, so an
+ * attacker-influenced or partially-written state file could otherwise flood the
+ * audit sink and the operator's console. Matches the ellipsis-marker style of
+ * `MAX_LANE_VALIDATION_VALUE_CHARS` — this is operator prose, so the truncation
+ * must be visible rather than silent.
+ */
+export declare const MAX_SALVAGED_SCHEMA_ERROR_CHARS = 240;
+/** Result of one recovery-only gate-state read. */
+export interface PrWorkflowGateRecoveryRead {
+    /** Schema-valid state, or the salvaged projection when `salvaged`. */
+    state: PrWorkflowGateState;
+    /** true when the durable bytes failed schema validation and were salvaged. */
+    salvaged: boolean;
+    /** `path: message` per schema issue; empty unless `salvaged`. */
+    schemaErrors: string[];
+    /** Loud operator-facing disclosure; present only when `salvaged`. */
+    disclosure?: string;
+    /** false when `revision` could not be salvaged — the CAS escape is required. */
+    revisionSalvageable: boolean;
+    /**
+     * true when a `prFeedbackReadyToPublish` key is present in the raw bytes but
+     * is itself unreadable. Callers MUST treat this as armed: silently dropping
+     * an unreadable armed marker would turn "corrupt that one record" into a way
+     * to bypass the armed-abort refusal — a forgery-class relaxation, not an
+     * availability one.
+     */
+    armedShapeUnreadable: boolean;
+}
+/**
+ * Recovery-only gate-state reader (issue #2242 R4, wedge W-5).
+ *
+ * Used by `abortPrWorkflow` and `pr_workflow_status` ONLY. The general reader
+ * (`readPrWorkflowGateStateFromDisk`) is deliberately unchanged, so no write,
+ * completion, or verification path can ever act on a salvaged projection.
+ *
+ * Policy, mirroring the file-wide "unavailability degrades with disclosure;
+ * contradiction fails closed" invariant:
+ *   - **Unparseable bytes fail everywhere**, recovery included. There is nothing
+ *     to salvage and guessing would be fabrication.
+ *   - **Schema-validation failure on parseable JSON** salvages the fields abort
+ *     actually reads — `{sessionID, mode, prHeadSha}` plus `revision`,
+ *     `prFeedbackReadyToPublish` and `checkoutRecovery` when each is
+ *     individually well-formed — with a loud disclosure naming the schema
+ *     errors. Everything else is dropped rather than guessed.
+ *   - **Identity is not salvageable ⇒ nothing is.** Without a readable
+ *     `sessionID` and `mode` there is no provable subject to act on, so the
+ *     original `is invalid` failure stands.
+ *
+ * A salvaged view is never written to the tracked-state cache.
+ */
+export declare function readPrWorkflowGateStateForRecovery(directory: string, sessionID: string): Promise<PrWorkflowGateRecoveryRead | null>;
 declare function workflowGateStateLockRelativePath(sessionID: string): string;
 declare function workflowGateStateRelativePath(sessionID: string): string;
 export declare function prWorkflowSessionFileStem(sessionID: string): string;