opencode-swarm 7.166.4 → 7.167.0

package/dist/cli/{worktree-isolation-a8f1yahq.js → worktree-isolation-j2ewvha7.js}

@@ -21,44 +21,44 @@ import {
   sanitizeWorktreeTaskId,
   standardWorktreeByCallID,
   standardWorktreeSerializationSessions
-} from "./index-5qws47d4.js";
+} from "./index-wyca2c0w.js";
 import"./index-d5qf7hvh.js";
 import"./index-m3tx1q9v.js";
-import"./index-n189w64j.js";
-import"./index-gccxen4x.js";
-import"./index-kwervbv6.js";
+import"./index-9qceke8g.js";
+import"./index-jhna6xnb.js";
+import"./index-n5bqrkgw.js";
 import"./index-5bd84nxc.js";
 import"./index-txdagbh7.js";
 import"./index-cw912re7.js";
-import"./index-qv4byzwp.js";
-import"./index-n65x6e1y.js";
-import"./index-7g5kdtvw.js";
+import"./index-chdyjg3s.js";
+import"./index-ywa4jvg9.js";
+import"./index-t6hdjtfy.js";
 import"./index-70ha9e09.js";
 import"./index-1aex5zd9.js";
 import"./index-9ss2m4rs.js";
 import"./index-3nm1b3t2.js";
 import"./index-zsrtt42s.js";
-import"./index-z62gdhkd.js";
+import"./index-wkj8m6wh.js";
 import"./index-251vrmge.js";
 import"./index-9wv6a3jx.js";
 import"./index-b43rt5ph.js";
 import"./index-q7sjgr1y.js";
-import"./index-bxrxqwce.js";
-import"./index-8ewgab6z.js";
-import"./index-3ct7fd75.js";
-import"./index-kz44j3qe.js";
+import"./index-qmqn59mw.js";
+import"./index-gw2d37dz.js";
+import"./index-zq0btxga.js";
+import"./index-gbbahxhw.js";
 import"./index-sahf5yz3.js";
 import"./index-p612v1mv.js";
-import"./index-wd86yj53.js";
+import"./index-7yax969v.js";
 import"./index-qww0h314.js";
 import"./index-rtry5xyf.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-st1zw5ps.js";
+} from "./index-d2phtxg2.js";
 import"./index-3qf1vxtb.js";
 import"./index-n832052r.js";
-import"./index-gr5wg0nj.js";
-import"./index-v5wanchr.js";
+import"./index-dczrrnzp.js";
+import"./index-va2m1y35.js";
 import"./index-qd619x3r.js";
 import"./index-75f9jj3h.js";
 import"./index-6d4dc99f.js";
@@ -66,7 +66,7 @@ import"./index-rk10x4zr.js";
 import"./index-ry16d01s.js";
 import"./index-n4fzmqz8.js";
 import"./index-qd726agw.js";
-import"./index-3s194swm.js";
+import"./index-r09mpxtp.js";
 import"./index-vzm6zre7.js";
 import"./index-ae75rja9.js";
 import"./index-t8tw1bhs.js";
@@ -76,10 +76,10 @@ import"./index-f6zgz02s.js";
 import"./index-7qefgq4j.js";
 import"./index-ee6ydtfe.js";
 import"./index-7g4c7s5r.js";
-import"./index-9eswrdp5.js";
+import"./index-kg74hnbc.js";
 import"./index-9e6fdz2h.js";
 import"./index-4rhhvd1a.js";
-import"./index-shqhq68n.js";
+import"./index-mqbgkv5h.js";
 import"./index-0tc0pcmh.js";
 import"./index-bk5tah7q.js";
 import"./index-bpmtbmy9.js";

package/dist/config/schema.d.ts

@@ -1872,6 +1872,23 @@ export declare const PrReviewResilienceConfigSchema: z.ZodObject<{
     max_retry_attempts_after_initial: z.ZodDefault<z.ZodNumber>;
     circuit_open_duration_ms: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
+/**
+ * Issue #2506 (G2): the lane-liveness watchdog. Default OFF; each numeric knob
+ * disables its own feature at 0. When enabled, `timeout_ms` becomes the ONE
+ * effective PR-lane settlement horizon (the 30-minute reachability floor
+ * remains the fallback when the watchdog is off or `timeout_ms` is 0), and
+ * stall detection escalates low-output lanes BEFORE that horizon. Parameter
+ * surface adopted with credit from opencode-ensemble (reimplemented per ADR
+ * 0002 — no upstream code is ported).
+ */
+export declare const LaneLivenessWatchdogConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    timeout_ms: z.ZodDefault<z.ZodNumber>;
+    stall_threshold_ms: z.ZodDefault<z.ZodNumber>;
+    stall_min_steps: z.ZodDefault<z.ZodNumber>;
+    stall_token_threshold: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type LaneLivenessWatchdogConfig = z.infer<typeof LaneLivenessWatchdogConfigSchema>;
 /**
  * Issue #2384: deprecated transcript-row settlement for Profile A PR-review
  * base/micro discovery lanes is an explicit compatibility opt-in. Omitted
@@ -1977,6 +1994,13 @@ export declare const PluginConfigSchema: z.ZodObject<{
         max_retry_attempts_after_initial: z.ZodDefault<z.ZodNumber>;
         circuit_open_duration_ms: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
+    lane_liveness_watchdog: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        timeout_ms: z.ZodDefault<z.ZodNumber>;
+        stall_threshold_ms: z.ZodDefault<z.ZodNumber>;
+        stall_min_steps: z.ZodDefault<z.ZodNumber>;
+        stall_token_threshold: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
     pr_review_legacy_transcript_compatibility: z.ZodOptional<z.ZodBoolean>;
     gates: z.ZodOptional<z.ZodObject<{
         syntax_check: z.ZodDefault<z.ZodObject<{

package/dist/hooks/lane-liveness-watchdog.d.ts

@@ -0,0 +1,102 @@
+import type { LaneLivenessWatchdogConfig } from '../config/schema.js';
+/** The five frozen defaults from the #2506 contract (0 disables a feature). */
+export declare const LANE_LIVENESS_WATCHDOG_DEFAULTS: LaneLivenessWatchdogConfig;
+/**
+ * Upper bound on lane ids named in one `pr_workflow_lane_watchdog` event or
+ * disclosure. Defined here (not imported from the gate) so this module never
+ * depends on the gate layer.
+ */
+export declare const MAX_LANE_LIVENESS_DISCLOSED_IDS = 10;
+/**
+ * The typed liveness conditions #2506 requires to be distinguishable. A
+ * temporarily slow provider or an expired observation budget must never be
+ * reported as child failure.
+ *
+ * - `observer_deadline` — the CALLER's collection wait budget expired while
+ *   the session is live or unknown. Says nothing about the child; never a
+ *   terminal transition.
+ * - `provider_retry_in_flight` — the host reports the session in `retry`:
+ *   provider latency with its own bounded retry owner. Retained.
+ * - `completed_failure` — the ledger already holds a terminal error: the
+ *   lane completed, with a real (failed) outcome.
+ * - `idle_failed_child` — an open record whose session is idle or absent
+ *   below the horizon: the child failed without a terminal write.
+ * - `execution_deadline` — the lane exceeded the effective execution
+ *   horizon: aborted best-effort and settled with its real outcome.
+ */
+export type LaneLivenessCondition = 'observer_deadline' | 'provider_retry_in_flight' | 'completed_failure' | 'idle_failed_child' | 'execution_deadline';
+export interface ClassifyLaneLivenessInput {
+    /** Host session status type, when a probe ran. `undefined` = unknown. */
+    sessionStatusType?: string;
+    /** Ledger record status string (e.g. `pending`, `running`, `error`). */
+    recordStatus: string;
+    /** Whether the caller's observation/collection budget expired. */
+    waitBudgetExpired: boolean;
+    /** Whether the lane's age exceeds the EFFECTIVE horizon. */
+    exceededEffectiveHorizon: boolean;
+}
+/**
+ * Classify one lane's liveness with the frozen precedence
+ * `completed_failure > observer_deadline > provider_retry_in_flight >
+ * execution_deadline > idle_failed_child`:
+ * a terminal error is a real outcome and wins over every in-flight signal;
+ * an expired observation budget on a live-or-unknown session is observer
+ * noise, not child failure; a `retry` session is provider latency even past
+ * the horizon; only then may the execution deadline fire; everything else
+ * is an open, low-signal lane below the horizon.
+ */
+export declare function classifyLaneLivenessCondition(input: ClassifyLaneLivenessInput): LaneLivenessCondition;
+export interface EffectivePrLaneHorizon {
+    /** The ONE effective PR-lane settlement horizon, in ms. */
+    horizonMs: number;
+    /** Which configured value won. */
+    source: 'watchdog-timeout' | 'reachability-floor';
+    /**
+     * True when `backgroundPendingTimeoutMs` was provided, is > 0, and
+     * disagrees with the effective horizon. The disagreement is disclosed,
+     * never resolved into a second horizon.
+     */
+    conflictDisclosed: boolean;
+}
+/**
+ * Resolve the single effective PR-lane settlement horizon (#2506 AC2).
+ *
+ * Precedence: an ENABLED watchdog with `timeout_ms > 0` owns the horizon;
+ * everything else (no config, `enabled: false`, or `timeout_ms: 0` — "0
+ * disables the feature") falls back to the 30-minute reachability floor
+ * (`DEFAULT_STALE_DELEGATION_TIMEOUT_MS`), which must never disappear: it is
+ * the guarantee that abort and completion cannot be permanently blocked by a
+ * lane whose backing process died.
+ */
+export declare function resolveEffectivePrLaneHorizonMs(watchdog?: LaneLivenessWatchdogConfig, backgroundPendingTimeoutMs?: number): EffectivePrLaneHorizon;
+/** Per-lane activity within the last `stall_threshold_ms` window. */
+export interface LaneActivity {
+    /** Observable transcript steps in the window. */
+    stepsObserved: number;
+    /**
+     * Token ESTIMATE derived from transcript text length — the host API does
+     * not expose provider-true token counts; every surface that reports this
+     * value must label it an estimate.
+     */
+    estimatedTokens: number;
+    /** Epoch-ms timestamp of the last observed activity, when known. */
+    lastActivityAtMs?: number;
+}
+export declare const ZERO_LANE_ACTIVITY: LaneActivity;
+/** The overridable activity reader the gate seam exposes for tests. */
+export type ReadLaneActivity = (directory: string, subagentSessionId: string) => LaneActivity | null | Promise<LaneActivity | null>;
+/**
+ * Default transcript-derived activity reader. The host API exposes no
+ * per-session token counts and no bounded transcript read on this path (a
+ * per-lane `session.messages` call would violate the frozen one-status-call
+ * budget), so a lane with no stored activity information reads as ZERO
+ * activity — the conservative direction for stall escalation (escalate,
+ * then let the operator inspect). This is the #2506 frozen contract: "an
+ * absent transcript reads as zero activity".
+ */
+export declare const defaultReadLaneActivity: ReadLaneActivity;
+/** Feature activation derived from the config (each knob disables at 0). */
+export declare function laneLivenessWatchdogFeatures(watchdog?: LaneLivenessWatchdogConfig): {
+    deadlineActive: boolean;
+    stallActive: boolean;
+};

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

@@ -6,6 +6,7 @@ import { type BackgroundDelegationRecord, type BackgroundDelegationResult, type
 import { PR_REVIEW_BASE_DIMENSION_IDS, type PrReviewLaneResultEnvelope, type PrReviewRiskImpact, type PrReviewRiskTag } from '../background/pr-review-contract.js';
 import { type PrReviewInlineTriggerRow } from '../background/pr-review-trigger-contract.js';
 import { type RevisionDigestResult, resolveCommitCountSince, resolveCommitCountSinceAsync, resolveCurrentGitHead, resolveCurrentGitHeadAsync, resolveCurrentLocalHeadRefAsync, resolveCurrentUpstreamPushTarget, resolveCurrentUpstreamPushTargetAsync, resolveCurrentUpstreamRemoteRef, resolveExactRemoteBranchHead, resolveExactRemoteBranchHeadAsync, resolveIsExactSingleChildCommit, resolveIsExactSingleChildCommitAsync, resolveIsWorkingTreeClean, resolveIsWorkingTreeCleanAsync, resolvePrReviewDiffStats, resolvePrReviewDiffStatsAsync, resolvePrWorkflowRevisionDigest, resolvePrWorkflowRevisionDigestDetailed, resolveRemoteRefsContainingHead, resolveRemoteRefsContainingHeadAsync, resolveRemoteUrlIdentity, resolveRemoteUrlIdentityAsync } from '../background/workspace-snapshot.js';
+import type { LaneLivenessWatchdogConfig } from '../config/schema.js';
 import { type PrReviewResilienceConfig } from '../config/schema.js';
 import { classifyPrWorkflowGitState, type PrWorkflowGitState } from '../git/pr-workflow-state.js';
 import { type PrReviewReentryAuthorizationRecord, type PrReviewReentryBindingContext, type PrReviewReentryRole } from '../pr-review/authorization.js';
@@ -13,6 +14,7 @@ import { classifyPrReviewCircuitSignal, type PrReviewCircuitLegacyRecord, type P
 import { type PrReviewDimensionCancellationRecord, type PrReviewPartialBaseCoverageRecord, type PrReviewReportVerdict, type PrReviewTerminalCoverageSettlement } from '../pr-review/completion.js';
 import { type PrReviewComposablePhase, type PrReviewPhaseComposition, parseCriticVerdict } from '../pr-review/legacy-transcript-adapter.js';
 import { withPrWorkflowCheckoutMutationLock, workflowCheckoutMutationLockRelativePath, workflowGateStateLockRelativePath, workflowGateStateRelativePath } from '../pr-review/persistence.js';
+import { classifyLaneLivenessCondition, type EffectivePrLaneHorizon, resolveEffectivePrLaneHorizonMs } from './lane-liveness-watchdog.js';
 export type { PrReviewDimensionCancellationRecord, PrReviewDimensionTerminalState, PrReviewPartialBaseCoverageRecord, PrReviewPartialBaseCoverageRecordV1, PrReviewPartialBaseCoverageRecordV2, PrReviewReportVerdict, PrReviewTerminalCoverageKind, PrReviewTerminalCoverageSettlement, PrReviewUnresolvedDimensionRecord, } from '../pr-review/completion.js';
 export { allowedPrReviewReportVerdicts, normalizePrReviewPartialBaseCoverageRecord, PR_REVIEW_REPORT_VERDICTS, readPrReviewTerminalCoverageForReport, rollbackPrReviewPartialBaseCoverageAdmission, } from '../pr-review/completion.js';
 export { ensurePrWorkflowSafeParentDirectory, PrWorkflowCheckoutMutationTimeoutError, prWorkflowSessionFileStem, withPrWorkflowCheckoutMutationLock, writePrWorkflowAtomicJson, } from '../pr-review/persistence.js';
@@ -650,9 +652,29 @@ interface PrWorkflowLaneLivenessSessionOps {
         }> | null;
         error?: unknown;
     }>;
+    /**
+     * Issue #2506: the watchdog's best-effort, one-attempt lane abort. The
+     * host session object exposes it; the seam type keeps it optional so the
+     * probe-only hosts of the #2251 era remain valid.
+     */
+    abort?: (args: unknown) => Promise<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';
+/**
+ * Core session-status probe shared by the fail-open liveness probe below and
+ * the pending-lane liveness advisory (issue #2280 Part B). Same host call,
+ * deadline, and failure taxonomy as the probe; instead of collapsing each
+ * session to allowlist membership it records the status TYPE the host reported
+ * for every record that has one, so a caller can distinguish "live" from
+ * "affirmatively non-live" from "session absent". Failure modes return the
+ * empty map plus a `degradedReason` — a probe that did not fully read its
+ * response never yields a partial map.
+ */
+declare function probePrWorkflowLaneSessionStatusTypes(directory: string, records: readonly BackgroundDelegationRecord[], timeoutMs?: number): Promise<{
+    statuses: Map<string, string>;
+    degradedReason?: PrWorkflowLaneProbeDegradedReason;
+}>;
 /**
  * Probe which of `records` have a session the host affirmatively reports as
  * still running (issue #2251).
@@ -757,6 +779,14 @@ export interface PrWorkflowStaleLaneSettlement {
     freshOpenLanes: number;
     /** Lanes stale past the horizon, treated as settled with disclosure. */
     presumedStaleLaneIds: string[];
+    /**
+     * Present ONLY when the configured `hooks.background_pending_timeout_minutes`
+     * disagrees with the ONE effective horizon this settlement used (issue
+     * #2506 AC2). Fixed template, no second horizon is created — the field
+     * exists so the disagreement is observable on tool responses instead of
+     * being silently absorbed.
+     */
+    horizonConflictNote?: string;
     /**
      * Lanes past the horizon that the probe spared. Present only when non-empty.
      */
@@ -809,7 +839,33 @@ export interface PrWorkflowStaleLaneSettlement {
  * {@link probePrWorkflowLaneSessionStatusTypes} — 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>;
+/**
+ * Issue #2506 (G2): optional lane-liveness watchdog options for the on-demand
+ * settlement entry points. The two-argument call shape every existing caller
+ * uses means "watchdog disabled" (the default-off config contract).
+ */
+export interface PrWorkflowLaneLivenessOptions {
+    laneLivenessWatchdog?: LaneLivenessWatchdogConfig;
+    backgroundPendingTimeoutMs?: number;
+}
+/**
+ * The #2506 stall-escalation evaluation for the lanes a settlement still
+ * considers open or probe-retained: escalate each lane whose session is
+ * busy/retry and whose observed activity in the last `stall_threshold_ms`
+ * missed BOTH the step and the estimated-token thresholds, deduped per lane
+ * against the last escalation event unless activity was observed since.
+ * Advisory by design: an escalated lane is never settled or aborted here —
+ * the operator response (inspect, or the human-only force abort) owns that.
+ */
+declare function evaluateLaneLivenessWatchdogEscalation(args: {
+    directory: string;
+    sessionID: string;
+    lanes: BackgroundDelegationRecord[];
+    sessionTypes: Map<string, string>;
+    watchdog: LaneLivenessWatchdogConfig;
+    horizon: EffectivePrLaneHorizon;
+}): Promise<void>;
+export declare function settlePresumedStalePrWorkflowLanes(directory: string, sessionID: string, options?: PrWorkflowLaneLivenessOptions): Promise<PrWorkflowStaleLaneSettlement>;
 /**
  * Abort an active PR workflow gate without reaching terminal completion.
  *
@@ -853,6 +909,8 @@ export declare function abortPrWorkflow(directory: string, sessionID: string, op
      * `recovery`/`force` aborts remain refused while armed.
      */
     cancelPublication?: boolean;
+    /** Issue #2506: lane-liveness watchdog config for this settlement. */
+    laneLiveness?: PrWorkflowLaneLivenessOptions;
 }): Promise<{
     mode: PrWorkflowMode;
     prHeadSha?: string;
@@ -914,6 +972,8 @@ export declare function recoverArmedPrWorkflow(directory: string, sessionID: str
     generation: number;
     workflowInstanceId?: string;
     reason: string;
+    /** Issue #2506: lane-liveness watchdog config for this settlement. */
+    laneLiveness?: PrWorkflowLaneLivenessOptions;
 }): Promise<{
     mode: PrWorkflowMode;
     prHeadSha: string;
@@ -1250,6 +1310,8 @@ export declare function transitionPrReviewToFeedback(directory: string, sessionI
     prUrl?: string;
     exactCommand?: string;
     confirmedByUser?: boolean;
+    /** Issue #2506 review round 2: watchdog policy for the readiness settle. */
+    laneLiveness?: PrWorkflowLaneLivenessOptions;
 }): Promise<PrWorkflowGateState>;
 export declare function declarePrFeedbackScope(directory: string, sessionID: string, taskId: string, files: string[]): Promise<PrWorkflowGateState>;
 export declare function resolvePrFeedbackScopeDeclaration(directory: string, sessionID: string, taskId: string): Promise<PrFeedbackScopeDeclarationRecord | null>;
@@ -1291,6 +1353,8 @@ export declare function reserveActivePrReviewReentryAuthorization(directory: str
 }): Promise<PrReviewReentryAuthorizationRecord | null>;
 export declare function completePrWorkflow(directory: string, sessionID: string, expectedMode: PrWorkflowMode, prHeadSha: string, options?: {
     reportVerdict?: PrReviewReportVerdict;
+    /** Issue #2506: lane-liveness watchdog config for this settlement. */
+    laneLiveness?: PrWorkflowLaneLivenessOptions;
 }): Promise<PrWorkflowCompletionStatus>;
 export declare const _test_exports: {
     classifyPrReviewCircuitSignal: typeof classifyPrReviewCircuitSignal;
@@ -1339,6 +1403,28 @@ export declare const _test_exports: {
     sweepStaleDelegationsAsync: typeof sweepStaleDelegations;
     /** The fail-open liveness probe (issue #2251). */
     probeLaneLivenessAsync: typeof probeAlivePrWorkflowLaneSessions;
+    /**
+     * The types-carrying variant of the liveness probe (issue #2506): one
+     * shared status call returning per-session status TYPES, so the watchdog
+     * can distinguish `retry` (provider latency) from `busy` (past-deadline
+     * execution) without a second host round-trip. Seam for the same
+     * order-independence reason as `probeLaneLivenessAsync`.
+     */
+    probeLaneSessionStatusTypesAsync: typeof probePrWorkflowLaneSessionStatusTypes;
+    /**
+     * The #2506 lane-liveness watchdog surface: the pure policy functions,
+     * the overridable transcript-activity reader, and the live budget
+     * counters (zeroed by `resetTrackedStateCache`).
+     */
+    laneLivenessWatchdog: {
+        resolveEffectivePrLaneHorizonMs: typeof resolveEffectivePrLaneHorizonMs;
+        classifyLaneLivenessCondition: typeof classifyLaneLivenessCondition;
+        evaluateLaneLivenessWatchdog: typeof evaluateLaneLivenessWatchdogEscalation;
+        readLaneActivity: import("./lane-liveness-watchdog.js").ReadLaneActivity;
+        hostStatusCalls: number;
+        hostAbortCalls: number;
+        evaluations: number;
+    };
     /**
      * Session handle for the liveness probe.
      *