opencode-swarm 7.145.0 → 7.145.1

package/dist/observability/catalog.d.ts

@@ -1,7 +1,7 @@
 /**
  * The event catalog (issue #2029).
  *
- * Exactly 44 entries, matching the `TelemetryEvent` union at
+ * Exactly 45 entries, matching the `TelemetryEvent` union at
  * `src/telemetry.ts:15-92`. Thirty-eight predate the #2029 contract; the 39th is
  * `agent_conflict_detected` (previously emitted through a force-cast past the
  * type system), the 40th is `close_archive_result` (issue #2030 — the
@@ -65,7 +65,7 @@ export interface CatalogEntry {
     /**
      * Whether an event of this kind must carry `trace.parentSpanId`.
      *
-     * `false` for all 44 entries today, and that is a truthful statement about
+     * `false` for all 45 entries today, and that is a truthful statement about
      * the current system rather than a placeholder: no producer supplies a
      * parent span, so `createObservation` never sets one. Setting this to `true`
      * for a kind whose producer cannot supply a parent would make every

package/dist/scope/scope-binding.d.ts

@@ -198,6 +198,22 @@ export declare function clearExactScopeBinding(input: {
 }): ScopeBinding | null;
 export declare function installScopeBindingTombstone(binding: ScopeBinding): void;
 export declare function hasScopeBindingDenyOverlay(binding: ScopeBinding): boolean;
+/**
+ * Issue #2271 bug 5: deny check that ignores purely time-based (sweep)
+ * tombstones. `sweepExpired` installs an 'expired'-lifecycle tombstone at
+ * revision+1 for every lapsed generation on ANY scope read — that is not a
+ * deliberate denial, and the durable CAS in the idle-revival path re-verifies
+ * the on-disk generation anyway. Deliberate revocation classes
+ * ('revoked'/'superseded') and any failed-revocation overlay still deny.
+ */
+export declare function hasDeliberateScopeBindingDenyOverlay(binding: ScopeBinding): boolean;
+/**
+ * Issue #2271 bug 5: remove a sweep-signature tombstone so a durable-CAS
+ * revival can be admitted in memory. Only 'expired'-lifecycle tombstones at
+ * or below the revived revision are cleared — deliberate revocations and any
+ * newer overlay are preserved.
+ */
+export declare function clearSweepTombstoneForRevival(binding: ScopeBinding): void;
 /** Fail-closed overlay used only when durable revocation cannot be verified. */
 export declare function installFailedRevocationOverlay(binding: ScopeBinding, reason: Exclude<ScopeBindingLifecycleState, 'live'>): boolean;
 /**

package/dist/services/model-preflight.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Agent model-resolution preflight (issue #2271 bug 4).
+ *
+ * Agent model strings (DEFAULT_MODELS plus user `agents.<role>.model`
+ * overrides) are handed to the OpenCode host unvalidated. When one does not
+ * resolve ("Model not found", "Forbidden"), dispatch-lanes classifies the
+ * failure as permanent, the affected agent never runs, and the plan-critic
+ * gate wedges into manual `approve_plan_critic` overrides because no APPROVED
+ * verdict is ever produced.
+ *
+ * This module validates configured model IDs against the live provider
+ * catalog (`client.provider.list()`). Every check is FAIL-OPEN: if the catalog
+ * is unreachable or malformed, results come back `unknown` and callers must
+ * proceed — the preflight only acts on a POSITIVE confirmation that a model
+ * does not resolve.
+ */
+import type { OpencodeClient } from '@opencode-ai/sdk';
+import type { PluginConfig } from '../config/schema.js';
+/** Tight bound for the catalog HTTP call — it runs on init/doctor paths. */
+export declare const PROVIDER_LIST_TIMEOUT_MS = 2000;
+export interface ConfiguredAgentModel {
+    /** Agent role the model is configured for. */
+    agent: string;
+    /** Full model id in `provider/model` form. */
+    model: string;
+    /** Where the value came from. */
+    source: 'default' | 'override' | 'fallback';
+}
+export type ModelResolutionStatus = 'ok' | 'unresolved' | 'unknown';
+export interface ModelResolution {
+    agent: string;
+    model: string;
+    source: ConfiguredAgentModel['source'];
+    status: ModelResolutionStatus;
+    /** Human-readable explanation for non-ok statuses. */
+    detail?: string;
+}
+export interface ModelPreflightResult {
+    /** False when the catalog could not be fetched — every entry is `unknown`. */
+    catalogAvailable: boolean;
+    resolutions: ModelResolution[];
+}
+/**
+ * Split a model id into its provider and model parts. Returns null for ids
+ * without a provider prefix (e.g. a bare model name) — those cannot be
+ * validated against a provider catalog.
+ */
+export declare function splitModelId(model: string): {
+    provider: string;
+    model: string;
+} | null;
+/**
+ * Collect every model id the swarm could dispatch with: DEFAULT_MODELS
+ * entries, user agent overrides, and declared fallback_models. Overriding one
+ * role replaces its default (mirrors getModelForAgent precedence).
+ */
+export declare function collectConfiguredAgentModels(config?: PluginConfig): ConfiguredAgentModel[];
+/** Provider catalog snapshot: provider id → set of model ids. */
+export type ProviderCatalog = Map<string, Set<string>>;
+/** Test/gate seam: drop the cached catalogs (used after config changes and denials). */
+export declare function invalidateProviderCatalogCache(): void;
+/**
+ * Fetch the provider catalog. Returns null when the catalog cannot be
+ * obtained or parsed — callers fail open on null.
+ */
+export declare function fetchProviderCatalog(client: OpencodeClient | null): Promise<ProviderCatalog | null>;
+/**
+ * Validate collected models against a catalog. A model whose provider is
+ * absent from the catalog, or whose provider exists but does not list the
+ * model, is `unresolved` — but only when the catalog itself was successfully
+ * fetched (callers must treat a null catalog as fail-open, never unresolved).
+ */
+export declare function resolveAgainstCatalog(models: ConfiguredAgentModel[], catalog: ProviderCatalog | null): ModelPreflightResult;
+/**
+ * End-to-end preflight: collect configured models, fetch the catalog, and
+ * resolve. Fail-open on every catalog error.
+ */
+export declare function runModelPreflight(config: PluginConfig | undefined, client: OpencodeClient | null): Promise<ModelPreflightResult>;
+/**
+ * Resolves a single model id against the live catalog for gate preflights.
+ * Returns 'unknown' whenever the catalog cannot be fetched — gates must only
+ * block on 'unresolved'.
+ */
+export declare function checkSingleModelResolution(model: string, client: OpencodeClient | null): Promise<ModelResolutionStatus>;
+export declare const _internals: {
+    /** Injectable seam for the SDK catalog call (tests substitute this). */
+    providerList: (client: OpencodeClient) => Promise<({
+        data: undefined;
+        error: unknown;
+    } | {
+        data: {
+            all: Array<{
+                api?: string;
+                name: string;
+                env: Array<string>;
+                id: string;
+                npm?: string;
+                models: {
+                    [key: string]: {
+                        id: string;
+                        name: string;
+                        release_date: string;
+                        attachment: boolean;
+                        reasoning: boolean;
+                        temperature: boolean;
+                        tool_call: boolean;
+                        cost?: {
+                            input: number;
+                            output: number;
+                            cache_read?: number;
+                            cache_write?: number;
+                            context_over_200k?: {
+                                input: number;
+                                output: number;
+                                cache_read?: number;
+                                cache_write?: number;
+                            };
+                        };
+                        limit: {
+                            context: number;
+                            output: number;
+                        };
+                        modalities?: {
+                            input: Array<"text" | "audio" | "image" | "video" | "pdf">;
+                            output: Array<"text" | "audio" | "image" | "video" | "pdf">;
+                        };
+                        experimental?: boolean;
+                        status?: "alpha" | "beta" | "deprecated" | "active";
+                        options: {
+                            [key: string]: unknown;
+                        };
+                        headers?: {
+                            [key: string]: string;
+                        };
+                        provider?: {
+                            npm: string;
+                        };
+                    };
+                };
+            }>;
+            default: {
+                [key: string]: string;
+            };
+            connected: Array<string>;
+        };
+        error: undefined;
+    }) & {
+        request: Request;
+        response: Response;
+    }>;
+};

package/dist/services/session-reflection.d.ts

@@ -109,6 +109,14 @@ export interface SessionReflectionData {
     knowledgeDelta?: KnowledgeDelta;
     skillViolations: SkillViolationSignal[];
     contradictionCandidates: ContradictionCandidate[];
+    /**
+     * Issue #2271 bug 6: rejection/circuit-breaker/manual-approval event counts
+     * by type, read from the session ledger (.swarm/events.jsonl). Gate denials
+     * throw in tool.execute.before and never increment ToolAggregate counters
+     * (denied calls do not fire toolAfter), so without this field a session
+     * full of gate rejections reports "0 tool failures or gate rejections".
+     */
+    ledgerRejections?: Record<string, number>;
 }
 export interface SessionReflectionResult {
     data: SessionReflectionData;
@@ -138,6 +146,21 @@ declare function gatherRetroLessonsAndTaxonomy(directory: string): Promise<{
     taxonomy: Record<string, number>;
 }>;
 declare function gatherGateFailures(directory: string): Promise<GateFailureSummary[]>;
+/**
+ * Count rejection-class events in the session ledger. Reads the LIVE
+ * .swarm/events.jsonl first (finalize runs before archive in the close
+ * pipeline), falling back to the newest archived copy for a partially-run
+ * prior close. Fail-open: any read/parse problem yields empty counts.
+ *
+ * When `sessionId` is provided, events carrying a DIFFERENT session id are
+ * ignored so a per-session close summary cannot overcount sibling sessions'
+ * rejections in multi-swarm projects. Events with NO session field are still
+ * counted: several rejection writers emit none (coder_retry_circuit_breaker,
+ * architect_loop_detected), a sessionless event cannot be attributed to a
+ * sibling session, and dropping them would resurrect the bug-6 undercount in
+ * the standard close flow.
+ */
+declare function gatherLedgerRejections(directory: string, sessionId?: string): Promise<Record<string, number>>;
 /**
  * Top skills by violation this session (issue #2077).
  *
@@ -242,6 +265,7 @@ export declare const _internals: {
     gatherAgentDispatches: typeof gatherAgentDispatches;
     gatherRetroLessonsAndTaxonomy: typeof gatherRetroLessonsAndTaxonomy;
     gatherGateFailures: typeof gatherGateFailures;
+    gatherLedgerRejections: typeof gatherLedgerRejections;
     buildReflectionDataSummary: typeof buildReflectionDataSummary;
     buildDeterministicReport: typeof buildDeterministicReport;
     gatherSkillViolations: typeof gatherSkillViolations;

package/dist/telemetry.d.ts

@@ -1,6 +1,12 @@
 import { createObservation, toLegacyTelemetryLine } from './observability/index.js';
 import type { DelegationCostFields } from './services/cost-accounting.js';
-export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'task_state_changed' | 'gate_passed' | 'gate_failed' | 'gate_parse_error' | 'reviewer_gate_decision' | 'phase_changed' | 'budget_updated' | 'context_pruned' | 'model_fallback' | 'hard_limit_hit' | 'revision_limit_hit' | 'loop_detected' | 'no_op_strong_warning' | 'scope_violation' | 'qa_skip_violation' | 'heartbeat' | 'turbo_mode_changed' | 'auto_oversight_escalation' | 'environment_detected' | 'evidence_lock_acquired' | 'evidence_lock_contended' | 'evidence_lock_stale_recovered' | 'plan_ledger_cas_retry' | 'plan_md_write_failed' | 'snapshot_failed' | 'gate_denial_loop'
+export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'task_state_changed' | 'gate_passed' | 'gate_failed' | 'gate_parse_error' | 'reviewer_gate_decision' | 'phase_changed' | 'budget_updated' | 'context_pruned' | 'model_fallback'
+/**
+ * Issue #2271 bug 4 — a configured agent model id was POSITIVELY confirmed
+ * unresolvable against the live provider catalog (distinct from a runtime
+ * model_fallback: this fires at preflight, before any dispatch attempt).
+ */
+ | 'model_unresolved' | 'hard_limit_hit' | 'revision_limit_hit' | 'loop_detected' | 'no_op_strong_warning' | 'scope_violation' | 'qa_skip_violation' | 'heartbeat' | 'turbo_mode_changed' | 'auto_oversight_escalation' | 'environment_detected' | 'evidence_lock_acquired' | 'evidence_lock_contended' | 'evidence_lock_stale_recovered' | 'plan_ledger_cas_retry' | 'plan_md_write_failed' | 'snapshot_failed' | 'gate_denial_loop'
 /**
  * Issue #2063 B5 — an ARMED execution episode reached the advisory rung:
  * `execution_stall_warn_calls` tool calls with no delegation completion, no
@@ -133,6 +139,11 @@ export declare const telemetry: {
         prunedTokensFreed: number;
     }): void;
     modelFallback(sessionId: string, agentName: string, fromModel: string, toModel: string, reason: string): void;
+    /**
+     * Issue #2271 bug 4 — preflight confirmed a configured model id does not
+     * resolve against the provider catalog. Emitted once per detected model.
+     */
+    modelUnresolved(agentName: string, model: string, detail: string): void;
     hardLimitHit(sessionId: string, agentName: string, limitType: string, value: number): void;
     revisionLimitHit(sessionId: string, agentName: string): void;
     loopDetected(sessionId: string, agentName: string, loopType: string): void;

package/dist/tools/placeholder-scan.d.ts

@@ -36,8 +36,72 @@ export interface PlaceholderScanResult {
         files_with_findings: number;
     };
 }
+/**
+ * Classify a single expression node as a "constant literal" for stub-skeleton
+ * detection. Returns true for nodes whose source text is one of:
+ *   - `null`, `true`, `false` (JS/TS keywords; Python `none`/`True`/`False` differ)
+ *   - `number` literals (e.g. `0`, `1`)
+ *   - `string` literals (e.g. `""`)
+ *   - `array` literals (e.g. `[]`)
+ *   - `object` literals (e.g. `{}`)
+ *   - `unary_expression` with operator `-` and number operand (e.g. `-1`)
+ *   - `identifier` (a named constant reference, e.g. `CONFIG_DEFAULTS`)
+ *   - `template_string` with NO `template_substitution` children
+ *     (i.e. `\`hello\`` is constant; `\`hello ${world}\`` is not)
+ *
+ * Note: Python's `none`/`True`/`False`/`integer`/`float`/`string`/`list`/
+ * `dictionary`/`tuple` map to tree-sitter-python grammar node types and
+ * follow the same classification rules.
+ */
+declare function isConstantLiteralNode(node: any): boolean;
+/**
+ * Determine whether a function's body (or expression body) is a "stub
+ * skeleton" — exactly one effective statement, and that statement is a
+ * constant return (or, for expression-bodied arrows, the body expression
+ * itself is a constant).
+ *
+ * Returns true when the function IS a stub skeleton.
+ * Returns false when the function has substantive subsequent behavior
+ * (the constant return is a guard clause, not a stub).
+ */
+declare function isStubSkeletonFunction(fnNode: any): boolean;
+/**
+ * Walk a tree-sitter root node and collect the line numbers of all function
+ * bodies whose structure is NOT a pure stub skeleton. These are the lines
+ * where a regex `code-stub-return` finding should be suppressed, because
+ * the function has substantive subsequent behavior and the constant return
+ * is a guard clause.
+ *
+ * For expression-bodied arrows (where the body's range equals the arrow's
+ * own range), we add only the lines that are INSIDE the body expression
+ * itself, NOT the entire arrow's range — otherwise a curried arrow like
+ * `const f = () => () => null;` would suppress the inner stub's finding
+ * (because the outer arrow's range covers the inner arrow too).
+ *
+ * Recognized function-like node types:
+ *   - TS/JS: `function_declaration`, `generator_function_declaration`,
+ *     `method_definition`, `arrow_function`, `function_expression`,
+ *     `generator_function`
+ *   - Python: `function_definition`
+ *
+ * `method_definition` nodes with no body (abstract/declared methods) are
+ * skipped. Getters and setters classify by their body like normal methods.
+ */
+declare function collectNonStubBodyLines(rootNode: any): Set<number>;
 /**
  * Scan files for placeholder content (TODO/FIXME comments, stub implementations, etc.)
  */
 export declare function placeholderScan(input: PlaceholderScanInput, directory: string): Promise<PlaceholderScanResult>;
 export declare const placeholder_scan: ReturnType<typeof tool>;
+/**
+ * Internal seam for direct testing of the body-shape walker without
+ * exercising the full placeholderScan pipeline. Mirrors the `_internals`
+ * pattern from `src/lang/backends/typescript.ts:343-351` (AGENTS.md
+ * invariant 7 — DI over `mock.module`).
+ */
+export declare const _internals: {
+    readonly collectNonStubBodyLines: typeof collectNonStubBodyLines;
+    readonly isStubSkeletonFunction: typeof isStubSkeletonFunction;
+    readonly isConstantLiteralNode: typeof isConstantLiteralNode;
+};
+export {};

package/dist/tools/sast-scan.d.ts

@@ -59,6 +59,12 @@ export interface SastScanResult {
             medium: number;
             low: number;
         };
+        /**
+         * Issue #2271 bug 3: present when every input was skipped for having no
+         * SAST language profile (non-code diff) — the scan passed because there
+         * was nothing to scan, and this counts the skipped non-code inputs.
+         */
+        files_skipped_non_code?: number;
     };
     /** 'baseline_captured' when capture_baseline:true succeeded */
     status?: 'baseline_captured' | 'baseline_merged';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.145.0",
+	"version": "7.145.1",
 	"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",

package/dist/cli/{curator-drift-yn5d0mvq.js → curator-drift-r50x1rac.js}

@@ -6,13 +6,13 @@ import {
   readEffectiveSpecSync
 } from "./index-9ss2m4rs.js";
 import"./index-n832052r.js";
+import"./index-4rhhvd1a.js";
 import {
   readSwarmFileAsync,
   validateSwarmPath
 } from "./index-w8pgjr75.js";
 import"./index-z6xqpmqg.js";
 import"./index-zj6t9zgx.js";
-import"./index-4rhhvd1a.js";
 import"./index-zjygnfay.js";
 import"./index-bpmtbmy9.js";
 import {