opencode-swarm 7.125.3 → 7.125.5

package/dist/session/snapshot-writer.d.ts

@@ -76,6 +76,15 @@ export interface SerializedAgentSession {
      * so older snapshots deserialize cleanly; the reader defaults to undefined.
      */
     cachedCohortId?: string;
+    /**
+     * Last observed `provider/model` for this (architect) session (#1896). Omitted
+     * when undefined for additive-only schema. MUST survive rehydration (it is NOT
+     * a transient-reset field) so a silent cross-interrupt model switch is
+     * detectable on resume.
+     */
+    lastObservedModel?: string;
+    /** Provider id paired with lastObservedModel (#1896). Omitted when undefined. */
+    lastObservedProviderID?: string;
 }
 /**
  * Minimal interface for serialized InvocationWindow

package/dist/state.d.ts

@@ -271,6 +271,21 @@ export interface AgentSessionState {
      * failed); callers must handle the miss with a bounded fallback.
      */
     cachedCohortId?: string;
+    /**
+     * The `provider/model` most recently OBSERVED on this (architect/primary)
+     * session's assistant turns (e.g. "anthropic/claude"). Persisted through
+     * snapshots and deliberately NOT reset on rehydration, so a silent model
+     * switch across an interrupt can be detected on resume by comparing the
+     * pre-interrupt observation with the first post-resume one. `undefined` until
+     * first observed.
+     */
+    lastObservedModel?: string;
+    /** Provider id paired with `lastObservedModel` (#1896). */
+    lastObservedProviderID?: string;
+    /** One-shot guard: the resume model-change advisory has fired for this rehydration (#1896). */
+    resumeModelAdvisoryDone?: boolean;
+    /** One-shot guard: the config-vs-UI model advisory has fired for this session (#1896). */
+    configModelAdvisoryDone?: boolean;
 }
 export type NonTransientErrorCategory = 'shell_parse_error' | 'command_not_found' | 'sandbox_wrapper_failure' | 'general_permanent';
 export interface NonTransientCircuitState {

package/dist/tools/abort-pr-workflow.d.ts

@@ -0,0 +1,5 @@
+import { createSwarmTool } from './create-tool.js';
+export declare function executeAbortPrWorkflow(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
+export declare const abort_pr_workflow: ReturnType<typeof createSwarmTool>;

package/dist/tools/index.d.ts

@@ -86,6 +86,7 @@ export type { ClassifiedFailure, FailureClassification, FailureCluster, } from '
 export { classifyAndCluster, classifyFailure, clusterFailures, } from '../test-impact/failure-classifier.js';
 export type { FlakyTestEntry } from '../test-impact/flaky-detector.js';
 export { computeFlakyScore, detectFlakyTests, isTestQuarantined, } from '../test-impact/flaky-detector.js';
+export { abort_pr_workflow, executeAbortPrWorkflow, } from './abort-pr-workflow';
 export { complete_pr_workflow, executeCompletePrWorkflow, } from './complete-pr-workflow';
 export { epic_plan_waves } from './epic-plan-waves';
 export { epic_record_divergence } from './epic-record-divergence';

package/dist/tools/manifest.d.ts

@@ -43,6 +43,7 @@ export declare const TOOL_MANIFEST: {
     check_gate_status: () => ToolDefinition;
     completion_verify: () => ToolDefinition;
     complete_pr_workflow: () => ToolDefinition;
+    abort_pr_workflow: () => ToolDefinition;
     run_pr_feedback_stage_a: () => ToolDefinition;
     submit_council_verdicts: () => ToolDefinition;
     submit_phase_council_verdicts: () => ToolDefinition;

package/dist/tools/tool-metadata.d.ts

@@ -103,6 +103,10 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: "architect"[];
     };
+    abort_pr_workflow: {
+        description: string;
+        agents: "architect"[];
+    };
     run_pr_feedback_stage_a: {
         description: string;
         agents: "architect"[];

package/dist/turbo/lean/reviewer.d.ts

@@ -1,3 +1,4 @@
+import { type ModelOverride } from '../../utils/model-dispatch-fallback';
 import { type LaneEvidence, listLaneEvidence, readPhaseEvidence, type ValidationArtifact } from './evidence';
 import { readPersisted } from './state';
 /**
@@ -102,7 +103,7 @@ export declare const _internals: {
     compileReviewPackage: typeof compileReviewPackage;
     parseReviewerVerdict: typeof parseReviewerVerdict;
     writeReviewerEvidence: typeof writeReviewerEvidence;
-    dispatchReviewerAgent: (directory: string, pkg: ReviewPackage, agentName: string, timeoutMs: number, parentSessionId?: string) => Promise<string>;
+    dispatchReviewerAgent: (directory: string, pkg: ReviewPackage, agentName: string, timeoutMs: number, parentSessionId?: string, model?: ModelOverride) => Promise<string>;
     resolveDefaultReviewerAgent: typeof resolveDefaultReviewerAgent;
     listLaneEvidence: typeof listLaneEvidence;
     readPhaseEvidence: typeof readPhaseEvidence;

package/dist/turbo/lean/runner.d.ts

@@ -21,6 +21,7 @@ import { loadFullAutoRunState } from '../../full-auto/state';
 import { acquireLaneLocks, releaseLaneLocks } from '../../parallel/file-locks';
 import { loadPlanJsonOnly } from '../../plan/manager';
 import { ensureAgentSession, hasActiveFullAuto } from '../../state';
+import { type ModelOverride } from '../../utils/model-dispatch-fallback';
 import { writeLaneEvidence, writePhaseEvidence } from './evidence';
 import { attemptMergeBackFromDirty, getMergeStrategy, mergeLaneBranch, postMergeCleanup, startupOrphanRecovery } from './merge-back';
 import { planLeanTurboLanes } from './planner';
@@ -263,7 +264,7 @@ export declare class LeanTurboRunner {
      * @param lane - Lane to dispatch
      * @param agentName - Agent name to dispatch to
      */
-    dispatchLane(lane: LeanTurboLane, agentName: string, worktreeDirectory?: string): Promise<LaneDispatchResult>;
+    dispatchLane(lane: LeanTurboLane, agentName: string, worktreeDirectory?: string, model?: ModelOverride): Promise<LaneDispatchResult>;
     /**
      * Internal dispatch implementation (separated for timeout wrapping).
      */

package/dist/utils/model-dispatch-fallback.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Issue #1896 (sub-issue 3): shared model-fallback dispatch helper.
+ *
+ * Before this, the ONLY place a role failed over to its configured
+ * `fallback_models` was the guardrails `toolAfter` hook (which fires on
+ * tool-result payloads). Every direct model-dispatch stage — critic oversight,
+ * lean-turbo reviewer, lane runner — called the provider directly and never
+ * failed over, so a role that hit its quota mid-run failed the stage outright.
+ *
+ * All those stages dispatch via `client.session.prompt({ body: { agent, model }})`,
+ * which accepts a per-call `model: {providerID, modelID}` override. This helper
+ * wraps such a dispatch with (a) bounded, per-model transient retry and (b)
+ * model-fallback advance — kept INDEPENDENT per AGENTS.md invariant #9. The
+ * fallback index is owned LOCALLY here: every stage dispatches into an ephemeral
+ * child session, so the only reachable `session.model_fallback_index` belongs to
+ * the parent orchestrator (a different agent) and must not be reused.
+ *
+ * The helper does NOT import `src/agents/index.ts` (avoids a heavy import cycle);
+ * the caller injects a `resolveFallback(index)` closure that wraps
+ * `resolveFallbackModel(baseRole, index, getSwarmAgents(swarmId))`.
+ */
+/** Per-call model override shape accepted by `client.session.prompt` body. */
+export interface ModelOverride {
+    providerID: string;
+    modelID: string;
+}
+/**
+ * Parse a `provider/model` string into the per-call override shape. Returns
+ * undefined for empty/blank input. Throws on a value with no provider or no
+ * model segment.
+ */
+export declare function parseModelString(model: string): ModelOverride | undefined;
+export interface ModelFallbackResult<T> {
+    result: T;
+    /** undefined = the agent's registered/primary model; otherwise the `provider/model` string used. */
+    modelUsed?: string;
+    /** 0 = primary; 1.. = which configured fallback landed. */
+    fallbackIndex: number;
+    /** total dispatch attempts made (across models + same-model retries). */
+    attempts: number;
+}
+export interface DispatchWithModelFallbackOptions<T> {
+    /** Dispatch using `model` (undefined = the agent's registered/primary model). */
+    dispatch: (model: ModelOverride | undefined) => Promise<T>;
+    /**
+     * Resolve the 1-based fallback model as a `provider/model` string, or null
+     * when the fallback chain is exhausted. Typically wraps
+     * `resolveFallbackModel(baseRole, index, getSwarmAgents(swarmId))`.
+     */
+    resolveFallback: (fallbackIndex: number) => string | null;
+    /** Classify a dispatch error: 'transient' → retry/failover; 'permanent' → throw immediately. */
+    classify: (error: unknown) => 'transient' | 'permanent';
+    /** Bounded transient retries on the SAME model before advancing (invariant #9 — independent of fallback). Default 1. */
+    maxTransientRetriesPerModel?: number;
+    /** Backoff before a same-model retry (NOT before a fallback advance). Default 2**(n-1)*1000 ms. */
+    backoffMs?: (retryAttempt: number) => number;
+    /** Notified when advancing to a fallback model (for advisory/telemetry). */
+    onFallback?: (info: {
+        toModel: string;
+        fallbackIndex: number;
+    }) => void;
+    /** DI for tests (avoid real waits). */
+    sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * Try the primary model, then each configured fallback, retrying transient
+ * failures a bounded number of times per model. A permanent failure throws
+ * immediately (no retry, no advance). When every model is exhausted transiently,
+ * the last error is rethrown.
+ */
+export declare function dispatchWithModelFallback<T>(opts: DispatchWithModelFallbackOptions<T>): Promise<ModelFallbackResult<T>>;

package/dist/utils/provider-error-classification.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Issue #1896 (sub-issue 3): single source of truth for provider/model
+ * transient-error classification.
+ *
+ * Previously the same `TRANSIENT_MODEL_ERROR_PATTERN` + transient-status-code set
+ * was duplicated across `src/hooks/guardrails/index.ts`,
+ * `src/hooks/guardrails/messages-transform.ts`, and `src/full-auto/oversight.ts`,
+ * and NONE recognized provider quota / usage-limit exhaustion — so a role whose
+ * model hit its quota mid-run failed the stage outright instead of failing over
+ * to a configured fallback model.
+ *
+ * Design (see the plan critic's M1): QUOTA is a SEPARATE pattern and is combined
+ * ONLY inside {@link isTransientProviderError}, which is consumed exclusively by
+ * the model-DISPATCH classifiers (the failover helper + oversight/reviewer/runner
+ * dispatch paths). The narrow {@link TRANSIENT_MODEL_ERROR_PATTERN} (no quota) is
+ * what the guardrails tool-OUTPUT classifier keeps using, so a bash
+ * `Disk quota exceeded` (EDQUOT) in tool stdout can never be misread as a
+ * transient provider error and trigger a bogus model fallback.
+ */
+/** v6.33: Known HTTP status codes that indicate transient provider errors. */
+export declare const TRANSIENT_STATUS_CODES: Set<number>;
+/** Extracts a transient HTTP status code from an error message string. */
+export declare function extractStatusCode(errorMsg: string): number | null;
+/**
+ * v6.33: Regex for transient model/provider errors that should trigger bounded
+ * retry (and, in the dispatch paths, model fallback). Content is UNCHANGED from
+ * the historical duplicated definition — quota is intentionally NOT here (see the
+ * module doc + {@link QUOTA_ERROR_PATTERN}), so tool-output classifiers that
+ * import this keep byte-identical behavior.
+ */
+export declare const TRANSIENT_MODEL_ERROR_PATTERN: RegExp;
+/**
+ * Issue #1896: provider quota / usage-limit / billing exhaustion — a class
+ * distinct from a transient blip. It is retryable after a wait AND fallback-
+ * eligible (a different configured model may have its own quota). Used ONLY on
+ * model-DISPATCH error strings via {@link isTransientProviderError}, never on
+ * tool stdout, so `Disk quota exceeded` shell output cannot false-trigger it.
+ */
+export declare const QUOTA_ERROR_PATTERN: RegExp;
+/**
+ * True when a model-DISPATCH error is a transient provider failure OR a
+ * quota/rate-limit exhaustion — both are retry + model-fallback eligible.
+ * Do NOT use this on arbitrary tool output; use `TRANSIENT_MODEL_ERROR_PATTERN`
+ * directly there (quota tokens would false-positive on shell stdout).
+ */
+export declare function isTransientProviderError(signal: string): boolean;
+/**
+ * True when the dispatch error specifically indicates quota/usage-limit
+ * exhaustion. Used to tag the fallback advisory / telemetry reason as `'quota'`
+ * vs a generic transient failure.
+ */
+export declare function isQuotaError(signal: string): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.125.3",
+	"version": "7.125.5",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",