opencode-swarm 7.147.0 → 7.148.0

package/dist/failures/action-circuit.d.ts

@@ -0,0 +1,69 @@
+export interface ActionCircuitEntry {
+    sessionID: string;
+    invocationID: number;
+    actionDigest: string;
+    circuitKind: string;
+    count: number;
+    hardStop: boolean;
+    generationToken: number;
+    lastSignalDigest: string | null;
+    firstSeenAt: number;
+    updatedAt: number;
+    expiresAt: number;
+}
+export interface ActionCircuitResetRecord {
+    sessionID: string;
+    invocationID: number;
+    actionDigest: string;
+    reason: 'success' | 'external' | 'invocation' | 'session';
+    actor: string | null;
+    at: number;
+}
+export declare function armActionCircuitAttempt(sessionID: string, invocationID: number, actionDigest: string): number;
+export declare function noteActionCircuitFailure(input: {
+    sessionID: string;
+    invocationID: number;
+    actionDigest: string;
+    circuitKind: string;
+    signal: string;
+    hardStopThreshold: number;
+    now?: number;
+    generationToken?: number;
+}): {
+    entry: ActionCircuitEntry | null;
+    enteredHardStop: boolean;
+    ignoredLateEvent: boolean;
+};
+export declare function clearActionCircuit(sessionID: string, invocationID: number, actionDigest: string, options?: {
+    reason?: 'success' | 'external' | 'invocation' | 'session';
+    actor?: string | null;
+    now?: number;
+}): void;
+export declare function resetActionCircuitExternally(input: {
+    sessionID: string;
+    invocationID: number;
+    actionDigest: string;
+    actor?: string | null;
+    now?: number;
+}): void;
+export declare function clearInvocationActionCircuits(sessionID: string, invocationID: number, now?: number): void;
+export declare function clearSessionActionCircuits(sessionID: string, now?: number): void;
+export declare function getBlockingActionCircuit(sessionID: string, invocationID: number, actionDigest: string): ActionCircuitEntry | null;
+export declare function listBlockingActionCircuitsForInvocation(sessionID: string, invocationID: number): ActionCircuitEntry[];
+export declare function peekActionCircuitCount(sessionID: string, invocationID: number, actionDigest: string, circuitKind: string): number;
+export declare function expireActionCircuit(sessionID: string, invocationID: number, actionDigest: string, circuitKind: string): void;
+export declare function clearAllActionCircuits(): void;
+export declare const _test_exports: {
+    ACTION_CIRCUIT_TTL_MS: number;
+    MAX_TRACKED_ACTION_CIRCUITS: number;
+    size: () => number;
+    getGenerationToken: (sessionID: string, invocationID: number, actionDigest: string) => number;
+    getResetAudit: () => {
+        sessionID: string;
+        invocationID: number;
+        actionDigest: string;
+        reason: "success" | "external" | "invocation" | "session";
+        actor: string | null;
+        at: number;
+    }[];
+};

package/dist/failures/action-identity.d.ts

@@ -0,0 +1,33 @@
+type PresenceMarker = 'missing' | 'empty' | 'value';
+type BackgroundMarker = PresenceMarker | 'invalid';
+export interface ActionIdentityV1 {
+    version: 1;
+    tool: string;
+    role: string;
+    swarm: string | null;
+    taskId: string | null;
+    taskMarker: PresenceMarker;
+    phase: string | null;
+    phaseMarker: PresenceMarker;
+    parentSessionDigest: string | null;
+    parentSessionMarker: PresenceMarker;
+    parentInvocation: string | null;
+    parentInvocationMarker: PresenceMarker;
+    dispatchGeneration: string | null;
+    dispatchGenerationMarker: PresenceMarker;
+    mode: string | null;
+    modeMarker: PresenceMarker;
+    background: boolean | null;
+    backgroundMarker: BackgroundMarker;
+    scopeDigest: string | null;
+    scopeMarker: PresenceMarker;
+    additionalDigest: string;
+    digest: string;
+    pattern: string;
+}
+export interface ActionIdentityInput {
+    tool: string;
+    args?: unknown;
+}
+export declare function createActionIdentity(input: ActionIdentityInput): ActionIdentityV1;
+export {};

package/dist/failures/invocation-failure.d.ts

@@ -0,0 +1,77 @@
+import type { ActionIdentityInput, ActionIdentityV1 } from './action-identity.js';
+export type InvocationFailureSource = 'provider' | 'shell' | 'filesystem' | 'git' | 'policy' | 'validation' | 'cancellation' | 'deadline';
+export type InvocationFailureRetryClass = 'retry_same' | 'retry_fallback' | 'repair_then_retry' | 'operator_action' | 'do_not_retry';
+export type InvocationFailureRisk = 'low' | 'medium' | 'high';
+export interface InvocationFailureEvidence {
+    display: string;
+    statusCode?: number;
+    exitCode?: number;
+    code?: string;
+    signal?: string;
+}
+export interface InvocationFailureRecordV1 {
+    version: 1;
+    source: InvocationFailureSource;
+    category: string;
+    retryClass: InvocationFailureRetryClass;
+    risk: InvocationFailureRisk;
+    action: ActionIdentityV1 | null;
+    evidence: InvocationFailureEvidence;
+    occurredAt: string;
+}
+export interface ToolFailureClassificationInput {
+    tool: string;
+    args?: unknown;
+    output: string;
+    error?: unknown;
+    metadata?: unknown;
+    correlation?: {
+        sandboxWrapped?: boolean;
+        originalCommand?: string;
+    };
+}
+export declare function sanitizeFailureEvidenceDisplay(value: string): string;
+declare function isNeutralExitOne(command: string): boolean;
+export declare function classifyProviderFailure(error: unknown, action?: ActionIdentityInput): InvocationFailureRecordV1;
+export declare function isRetryableProviderFailure(record: InvocationFailureRecordV1): boolean;
+export declare function classifyToolInvocationFailure(input: ToolFailureClassificationInput): InvocationFailureRecordV1 | null;
+export declare function createFilesystemFailure(input: {
+    reason: 'busy_lock' | 'permission' | 'read_only' | 'no_space' | 'path_containment' | 'not_found' | 'unknown';
+    display: string;
+    code?: string;
+    idempotent?: boolean;
+    action?: ActionIdentityInput;
+}): InvocationFailureRecordV1;
+export declare function createGitFailure(input: {
+    reason: 'conflict' | 'rebase' | 'dirty_primary' | 'lock_busy' | 'timeout' | 'command_unavailable' | 'corrupt_repository';
+    display: string;
+    code?: string;
+    idempotent?: boolean;
+    action?: ActionIdentityInput;
+}): InvocationFailureRecordV1;
+export declare function createPolicyFailure(input: {
+    reason: 'gate_denial' | 'containment' | 'destructive';
+    display: string;
+    code?: string;
+    action?: ActionIdentityInput;
+}): InvocationFailureRecordV1;
+export declare function createValidationFailure(input: {
+    display: string;
+    code?: string;
+    action?: ActionIdentityInput;
+}): InvocationFailureRecordV1;
+export declare function createCancellationFailure(input: {
+    display: string;
+    action?: ActionIdentityInput;
+}): InvocationFailureRecordV1;
+export declare function createDeadlineFailure(input: {
+    display: string;
+    code?: string;
+    idempotent?: boolean;
+    action?: ActionIdentityInput;
+}): InvocationFailureRecordV1;
+export declare const _test_exports: {
+    isNeutralExitOne: typeof isNeutralExitOne;
+    sanitizeFailureEvidenceDisplay: typeof sanitizeFailureEvidenceDisplay;
+};
+export {};

package/dist/full-auto/oversight.d.ts

@@ -1,3 +1,5 @@
+import { sleep } from '../utils/bun-compat';
+import { teardownEphemeralSession } from '../utils/ephemeral-session-teardown';
 import { type ParsedCriticResponse } from './critic-response-parser';
 export interface FullAutoCriticResult extends ParsedCriticResponse {
 }
@@ -48,6 +50,10 @@ export interface DispatchFullAutoOversightInput {
         max_dispatch_retries?: number;
         /** Override for max consecutive dispatch failures (default from schema: 3). */
         max_consecutive_dispatch_failures?: number;
+        /** Total wall-clock deadline across create, prompt, backoff, parse, and cleanup. */
+        total_timeout_ms?: number;
+        /** Cleanup sub-budget for ephemeral-session teardown. */
+        cleanup_timeout_ms?: number;
     };
 }
 export declare function parseFullAutoCriticResponse(rawResponse: string): FullAutoCriticResult;
@@ -89,4 +95,19 @@ export declare function dispatchFullAutoOversight(input: DispatchFullAutoOversig
  */
 export declare const _internals: {
     resetSequence: () => void;
+    now: () => number;
+    sleep: typeof sleep;
+    setTimer: typeof setTimeout;
+    clearTimer: typeof clearTimeout;
+    teardownEphemeralSession: typeof teardownEphemeralSession;
 };
+export declare function probeFullAutoOversightHealth(input: {
+    directory: string;
+    sessionID: string;
+    totalTimeoutMs?: number;
+    cleanupTimeoutMs?: number;
+}): Promise<{
+    healthy: boolean;
+    attempts: number;
+    reason: string;
+}>;

package/dist/full-auto/policy.d.ts

@@ -41,6 +41,7 @@ export interface FullAutoClassifierInput {
     sessionID: string;
     agentName?: string;
     normalizedAgentName?: string;
+    generatedAgentNames?: string[];
     toolName: string;
     args: Record<string, unknown> | undefined;
     directory: string;
@@ -51,6 +52,27 @@ export interface FullAutoClassifierInput {
     planSummary?: string;
     changedFiles?: string[];
     fullAutoConfig: FullAutoPolicyConfig | undefined;
+    pluginConfig?: {
+        memory?: {
+            enabled?: boolean;
+        };
+        external_skills?: {
+            curation_enabled?: boolean;
+        };
+        council?: {
+            enabled?: boolean;
+            general?: {
+                enabled?: boolean;
+            };
+        };
+        turbo?: unknown;
+        skills?: {
+            enabled?: boolean;
+        };
+        tool_filter?: {
+            overrides?: Record<string, string[]>;
+        };
+    };
 }
 export declare function isReadOnlyTool(toolName: string): boolean;
 export declare function isWriteLikeTool(toolName: string): boolean;

package/dist/full-auto/recovery.d.ts

@@ -0,0 +1,43 @@
+import type { FullAutoRunState } from './state';
+declare const VALID_MODES: readonly ["assisted", "supervised", "strict"];
+export type FullAutoMode = (typeof VALID_MODES)[number];
+export type ParsedFullAutoCommand = {
+    kind: 'status';
+} | {
+    kind: 'enable';
+    mode?: FullAutoMode;
+} | {
+    kind: 'disable';
+} | {
+    kind: 'retry_oversight';
+} | {
+    kind: 'resume';
+} | {
+    kind: 'abort';
+} | {
+    kind: 'toggle';
+} | {
+    kind: 'invalid';
+    message: string;
+};
+type RecoveryBlockerEvaluator = (input: {
+    directory: string;
+    sessionID: string;
+}) => string[];
+export declare function isFullAutoMode(value: string): value is FullAutoMode;
+export declare function parseFullAutoCommandArgs(args: string[], options?: {
+    allowToggle?: boolean;
+}): ParsedFullAutoCommand;
+export declare function isInfrastructurePauseReason(reason: string | undefined): boolean;
+export declare function canRetryOversight(state: FullAutoRunState | undefined): state is FullAutoRunState;
+export declare function canResumeFromProbe(state: FullAutoRunState | undefined, now?: number): state is FullAutoRunState;
+export declare function registerFullAutoRecoveryBlockerEvaluator(evaluator: RecoveryBlockerEvaluator): void;
+export declare function getFullAutoRecoveryBlockers(input: {
+    directory: string;
+    sessionID: string;
+}): string[];
+export declare function isAllowedPausedSwarmCommand(command: string, args: string[], status: 'paused' | 'terminated'): boolean;
+export declare const _internals: {
+    resetRecoveryBlockerEvaluator: () => void;
+};
+export {};

package/dist/full-auto/severe-result.d.ts

@@ -0,0 +1,86 @@
+import { getModifiedFilesForTask } from '../state';
+export type FullAutoSevereCategory = 'external_instructions' | 'out_of_scope_files' | 'protected_state_mutation';
+export interface FullAutoSevereEnvelopeV1 {
+    version: 1;
+    kind: 'full_auto_severe';
+    parent_session_id: string;
+    parent_call_id: string;
+    run_generation: number;
+    correlation_nonce: string;
+    category: FullAutoSevereCategory;
+    path_digests?: string[];
+    path_count?: number;
+    evidence_event_ids?: string[];
+}
+export interface RegisteredSevereEvent {
+    id: string;
+    sessionID: string;
+    category: string;
+    callID?: string;
+    generation?: number;
+    pathDigests?: string[];
+    recordedAt: number;
+}
+type PendingCorrelation = {
+    sessionID: string;
+    callID: string;
+    generation: number;
+    subagent: string;
+    createdAt: number;
+    nonce: string;
+};
+type ChildSessionBinding = {
+    childSessionID: string;
+    parentSessionID: string;
+    parentCallID: string;
+    generation: number;
+    createdAt: number;
+};
+declare function digestPath(filePath: string): string;
+export declare function registerFullAutoSevereCorrelation(input: {
+    sessionID: string;
+    callID: string;
+    generation: number;
+    subagent: string;
+}): {
+    nonce: string;
+    instruction: string;
+};
+export declare function clearFullAutoSevereCorrelation(sessionID: string, callID: string): void;
+export declare function clearFullAutoSevereSession(sessionID: string): void;
+export declare function bindFullAutoSevereChildSession(input: {
+    childSessionID: string;
+    parentSessionID: string;
+    parentCallID: string;
+    generation: number;
+}): void;
+export declare function recordFullAutoSevereEvidenceEvent(input: {
+    sessionID: string;
+    category: string;
+    callID?: string;
+    generation?: number;
+    paths?: string[];
+    childSessionID?: string;
+}): string;
+export declare function extractFullAutoSevereEnvelope(text: string): FullAutoSevereEnvelopeV1 | null;
+export declare function validateFullAutoSevereEnvelope(input: {
+    envelope: FullAutoSevereEnvelopeV1 | null;
+    sessionID: string;
+    callID: string;
+    generation: number;
+    declaredScope?: string[] | null;
+    currentTaskID?: string | null;
+    session?: Parameters<typeof getModifiedFilesForTask>[0];
+    projectDirectory: string;
+}): {
+    accepted: boolean;
+    category?: FullAutoSevereCategory;
+    reason: string;
+};
+export declare const _internals: {
+    pendingCorrelations: Map<string, PendingCorrelation>;
+    evidenceEvents: Map<string, RegisteredSevereEvent>;
+    childBindings: Map<string, ChildSessionBinding>;
+    digestPath: typeof digestPath;
+};
+export {};

package/dist/full-auto/state.d.ts

@@ -19,6 +19,8 @@ export interface FullAutoRunState {
     status: FullAutoStatus;
     sessionID: string;
     mode: 'assisted' | 'supervised' | 'strict';
+    runGeneration?: number;
+    pauseGeneration?: number;
     planID?: string;
     currentPhase?: number;
     currentTaskID?: string;
@@ -50,6 +52,14 @@ export interface FullAutoRunState {
         phase?: number;
         escalatedAt: string;
     };
+    lastRecoveryProbe?: {
+        pauseGeneration: number;
+        checkedAt: string;
+        expiresAt: string;
+        attempts: number;
+        outcome: 'healthy' | 'unhealthy';
+        reason: string;
+    };
 }
 export interface FullAutoPersistedState {
     version: 2;
@@ -155,6 +165,14 @@ export declare function recordFullAutoEscalation(directory: string, sessionID: s
     deadlockCount: number;
     phase?: number;
 }): FullAutoRunState | undefined;
+export declare function recordFullAutoRecoveryProbe(directory: string, sessionID: string, probe: {
+    pauseGeneration: number;
+    checkedAt: string;
+    expiresAt: string;
+    attempts: number;
+    outcome: 'healthy' | 'unhealthy';
+    reason: string;
+}): FullAutoRunState | undefined;
 export interface DenialLimitDecision {
     pause: boolean;
     reason?: string;

package/dist/hooks/full-auto-intercept.d.ts

@@ -53,7 +53,7 @@ export declare function injectVerdictIntoMessages(messages: MessageWithParts[],
  * This function encapsulates the critic invocation and event writing flow.
  * The critic response is awaited before writing the event to events.jsonl.
  */
-export declare function dispatchCriticAndWriteEvent(directory: string, architectOutput: string, criticContext: string, criticModel: string, escalationType: 'phase_completion' | 'question', interactionCount: number, deadlockCount: number, oversightAgentName: string, sessionID?: string, maxDispatchRetries?: number, maxConsecutiveDispatchFailures?: number): Promise<CriticDispatchResult>;
+export declare function dispatchCriticAndWriteEvent(directory: string, architectOutput: string, criticContext: string, criticModel: string, escalationType: 'phase_completion' | 'question', interactionCount: number, deadlockCount: number, oversightAgentName: string, sessionID?: string, maxDispatchRetries?: number, maxConsecutiveDispatchFailures?: number, totalTimeoutMs?: number): Promise<CriticDispatchResult>;
 /**
  * Creates the full-auto intercept hook factory.
  *

package/dist/hooks/gate-denial-tracker.d.ts

@@ -163,7 +163,7 @@ export declare function resetGateDenialStreaks(sessionID: string, tool: string,
  */
 export declare function clearGateDenialStreaks(): void;
 export declare const _test_exports: {
-    readonly MAX_TRACKED_DENIAL_STREAKS: 500;
+    readonly MAX_TRACKED_DENIAL_STREAKS: number;
     readonly GATE_DENIAL_TTL_MS: number;
     readonly MAX_CODE_LENGTH: 64;
     readonly MAX_DISCRIMINATOR_LENGTH: 64;

package/dist/hooks/guardrails/nontransient-circuit.d.ts

@@ -29,12 +29,24 @@ type ToolAfterOutput = {
     [key: string]: unknown;
 };
 declare function isNeutralExitOne(command: string): boolean;
-declare function classifyFatalSignal(signal: string, sandboxWrapped: boolean): NonTransientErrorCategory | null;
 export declare function classifyToolOutcome(input: ToolAfterInput, output: ToolAfterOutput, correlation?: PendingToolExecution): ToolOutcome;
-export declare function recordNonTransientFailure(sessionID: string, category: NonTransientErrorCategory, signal: string): NonTransientCircuitState | null;
-export declare function clearNonTransientCircuit(sessionID: string): void;
+type ActionContext = {
+    tool: string;
+    args?: unknown;
+    /**
+     * A synchronous failure can occur after toolBefore armed an attempt but before
+     * the host can return its result. Re-arm that exact attempt only at this
+     * trusted call site; toolAfter results must remain unable to revive a stale
+     * generation.
+     */
+    armAttempt?: boolean;
+};
+declare function isAllowedRecoverySwarmCommand(args: unknown): boolean;
+declare function isRecoveryAllowedTool(tool: string, args: unknown): boolean;
+export declare function recordNonTransientFailure(sessionID: string, category: NonTransientErrorCategory, signal: string, context?: ActionContext): NonTransientCircuitState | null;
+export declare function clearNonTransientCircuit(sessionID: string, context?: ActionContext): void;
 export declare function nonTransientHardStopMessage(circuit: NonTransientCircuitState): string;
-export declare function assertNonTransientCircuitAllowsTool(sessionID: string): void;
+export declare function assertNonTransientCircuitAllowsTool(sessionID: string, context?: ActionContext): void;
 export declare function rememberToolExecution(sessionID: string, callID: string, tool: string, originalCommand: string): void;
 export declare function isToolExecutionCurrent(sessionID: string, execution: PendingToolExecution): boolean;
 export declare function markToolExecutionSandboxWrapped(sessionID: string, callID: string): void;
@@ -42,6 +54,8 @@ export declare function takeToolExecution(sessionID: string, callID: string): Pe
 export declare function forgetToolExecution(sessionID: string, callID: string): void;
 export declare const _test_exports: {
     isNeutralExitOne: typeof isNeutralExitOne;
-    classifyFatalSignal: typeof classifyFatalSignal;
+    classifyFatalSignal: (signal: string, sandboxWrapped: boolean, tool?: string) => NonTransientErrorCategory | null;
+    isAllowedRecoverySwarmCommand: typeof isAllowedRecoverySwarmCommand;
+    isRecoveryAllowedTool: typeof isRecoveryAllowedTool;
 };
 export {};

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

@@ -529,6 +529,59 @@ declare function probeAlivePrWorkflowLaneSessions(directory: string, records: Ba
     alive: Set<string>;
     degradedReason?: PrWorkflowLaneProbeDegradedReason;
 }>;
+/** One still-pending pr-review lane's host liveness reading (issue #2280 Part B). */
+export interface PrWorkflowPendingLaneLiveness {
+    laneId: string;
+    /**
+     * Milliseconds since the lane record last changed — the same aging field
+     * (`updatedAt`) the 30-minute presumed-stale sweep measures age by, so the
+     * advisory and the terminal sweep can never disagree about how old a lane is.
+     */
+    pendingMs: number;
+    /**
+     * Host session status when known: `'busy'`/`'retry'` are live; any other
+     * reported type is an affirmative non-live reading; `'absent'` means the host
+     * enumerated sessions without ours; `'unknown'` means the probe degraded (or
+     * the record has no session id to probe at all).
+     */
+    hostStatus: string;
+    /**
+     * Past threshold AND the host did not affirmatively report the session live
+     * (non-live status, session absent, or probe degraded). DIAGNOSTIC ONLY — a
+     * `true` value never cancels, retries, replaces, or settles the lane.
+     */
+    stalledSuspect: boolean;
+    /**
+     * Why the reading is not a real host status: the probe's own failure reasons,
+     * plus `'advisory-unavailable'` when the advisory's surrounding accounting
+     * failed unexpectedly after the past-threshold set was already known — so an
+     * emitted entry always distinguishes "degraded" from a missing probe, and an
+     * ABSENT `pending_liveness` keeps meaning "no lane was past the threshold".
+     */
+    degradedReason?: PrWorkflowLaneProbeDegradedReason | 'advisory-unavailable';
+}
+/**
+ * Bounded, fail-open liveness advisory for still-pending pr-review lanes
+ * (issue #2280 Part B).
+ *
+ * ALERT-ONLY, by design: this reads host session status and reports it; it
+ * never cancels, retries, replaces, or settles anything. A stalled-suspect
+ * critic may still be thinking — automatic replacement would risk duplicate
+ * long-running critics racing on the same items — and the 30-minute
+ * presumed-stale sweep (issue #2251) remains the only terminal backstop.
+ *
+ * Cost model: below the threshold there is NO host round-trip at all; past it,
+ * exactly ONE session-status call regardless of how many lanes are pending,
+ * deadline-bounded through the same `_test_exports` seams as the #2251 probe
+ * and additionally clamped to the caller's remaining collection budget
+ * (`probeBudgetMs`) — the diagnostic must never add wait beyond the budget the
+ * caller already granted the collection itself. Any failure mode degrades
+ * (`hostStatus: 'unknown'`, `stalledSuspect: true`, reason named) instead of
+ * throwing — collection must never block or fail on this advisory.
+ */
+export declare function collectPrWorkflowPendingLaneLiveness(directory: string, records: readonly BackgroundDelegationRecord[], options?: {
+    probeBudgetMs?: number;
+}): Promise<PrWorkflowPendingLaneLiveness[]>;
 export interface PrWorkflowStaleLaneSettlement {
     /**
      * Every lane that still blocks: lanes with a fresh `updatedAt` PLUS lanes
@@ -595,9 +648,11 @@ export interface PrWorkflowStaleLaneSettlement {
  * 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.
+ * retained instead of discarded. The probe is fail-open — the settlement
+ * consumes it through the alive-set wrapper {@link
+ * probeAlivePrWorkflowLaneSessions}; the fail-open taxonomy itself lives in
+ * {@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>;
 /**
@@ -863,6 +918,12 @@ export declare const _test_exports: {
      * `checkoutMutationActionTimeoutMs` above.
      */
     laneLivenessProbeTimeoutMs: number;
+    /**
+     * Pending-liveness advisory threshold (issue #2280 Part B), seam-read at
+     * call time for the same clock reason — a test drives the boundary by
+     * shortening the threshold, not by waiting minutes.
+     */
+    pendingLaneLivenessThresholdMs: number;
     resolveCurrentGitHead: typeof resolveCurrentGitHead;
     resolveCurrentGitHeadAsync: typeof resolveCurrentGitHeadAsync;
     resolveCurrentUpstreamPushTarget: typeof resolveCurrentUpstreamPushTarget;