opencode-swarm 7.159.0 → 7.159.2

package/dist/observability/catalog.d.ts

@@ -1,7 +1,7 @@
 /**
  * The event catalog (issue #2029).
  *
- * Exactly 51 entries, matching the `TelemetryEvent` union at
+ * Exactly 54 entries, matching the `TelemetryEvent` union at
  * `src/telemetry.ts:15-131`. 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
@@ -22,7 +22,9 @@
  * the bounded `trajectory_health` storage audit for the issue-#2041
  * `.swarm/trajectories/` PRM session store, and the 51st is the bounded
  * `pr_subscription_health` storage audit for the issue-#2042
- * `.swarm/pr-monitor/` PR-monitor subscription checkpoint store. These late
+ * `.swarm/pr-monitor/` subscription checkpoint store. The 52nd is
+ * `delegation_cost_correction`, the 53rd is `delegation_cost_binding`, and the
+ * 54th is `delegation_cost_join`. These late
  * additions are instances
  * of the defect class this contract exists to close: an event kind entering
  * the stream with no registration.
@@ -78,7 +80,7 @@ export interface CatalogEntry {
     /**
      * Whether an event of this kind must carry `trace.parentSpanId`.
      *
-     * `false` for all 51 entries today, and that is a truthful statement about
+     * `false` for all 54 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/review/contracts.d.ts

@@ -1,5 +1,6 @@
 import type { OpencodeClient } from '@opencode-ai/sdk';
 import { type EphemeralAgentDispatchResult } from '../evaluation/ephemeral-agent-dispatcher.js';
+import type { PricingConfig } from '../services/cost-accounting.js';
 import type { ModelOverride } from '../utils/model-dispatch-fallback.js';
 export type ReviewDispatchRequest = {
     directory: string;
@@ -26,4 +27,4 @@ export interface ReviewModelDispatcher {
  * The returned dispatcher is instance-local and safe to inject into hooks and
  * tools; it does not read or mutate module-level client state.
  */
-export declare function createReviewModelDispatcher(client: OpencodeClient): ReviewModelDispatcher;
+export declare function createReviewModelDispatcher(client: OpencodeClient, pricing?: PricingConfig): ReviewModelDispatcher;

package/dist/review/evidence.d.ts

@@ -1,7 +1,10 @@
+import * as fs from 'node:fs';
 import { type FindingValidation, type ReviewFinding } from '../agents/agent-output-schema.js';
 import type { Plan } from '../config/plan-schema.js';
 import type { AutoReviewConfig } from '../config/schema.js';
 import { type ReviewFindingSeverity, type ReviewReceipt } from '../hooks/review-receipt.js';
+import type { CostEvidence, CostEvidenceReason, CostEvidenceStatus } from '../services/cost-accounting.js';
+import { bunWrite } from '../utils/bun-compat.js';
 import type { ReviewDiffCompleteness, ReviewDiffManifest, ReviewDiffSelector } from './diff-source.js';
 export interface AutoReviewEvidenceFinding extends ReviewFinding {
     finding_id: string;
@@ -64,6 +67,10 @@ export interface AutoReviewEvidence {
         tokens_cache: number;
         cost_usd: number | null;
         cost_source: 'reported' | 'estimated' | 'unavailable';
+        /** Bounded per-dispatch provenance; scalar totals remain compatibility projections. */
+        cost_evidence: CostEvidence[];
+        evidence_status: CostEvidenceStatus;
+        evidence_reason?: CostEvidenceReason;
     };
 }
 export declare function computeAutoReviewManifestHash(manifest: Omit<AutoReviewScopeManifest, 'hash'>): string;
@@ -72,6 +79,11 @@ export interface PersistAutoReviewEvidenceOptions {
     /** Rebuild the exact reviewed scope immediately before the atomic rename. */
     verifyCurrent?: () => Promise<boolean>;
 }
+/** Dependency seam for failure-path tests; production defaults stay unchanged. */
+export declare const _internals: {
+    bunWrite: typeof bunWrite;
+    renameSync: typeof fs.renameSync;
+};
 export declare function persistAutoReviewEvidence(directory: string, evidence: AutoReviewEvidence, options?: PersistAutoReviewEvidenceOptions): Promise<string>;
 export declare function readAutoReviewEvidenceForPhase(directory: string, phase: number): AutoReviewEvidence | null;
 export declare function isAutoReviewEvidence(value: unknown): value is AutoReviewEvidence;

package/dist/services/cost-accounting.d.ts

@@ -1,4 +1,33 @@
 export type CostSource = 'reported' | 'estimated' | 'unavailable';
+export type CostEvidenceKind = 'provider_reported' | 'normalized_estimate';
+export type CostEvidenceStatus = 'complete' | 'inconclusive';
+export type CostCurrency = 'USD' | 'unknown' | (string & {});
+export type CostEvidenceReason = 'authoritative' | 'missing_cost' | 'invalid_number' | 'pricing_missing' | 'unsupported_currency' | 'conflict' | 'unbilled' | 'join_miss' | 'legacy' | 'unreadable' | 'partial';
+/** Fixed, non-provider-controlled paths accepted by the evidence adapter. */
+export type CostEvidenceSourcePath = 'assistant.cost' | 'step-finish.cost' | 'response.info.cost' | 'response.cost' | 'legacy.cost' | 'pricing.model';
+export type CostEvidence = {
+    kind: CostEvidenceKind;
+    amount_usd: number | null;
+    currency: CostCurrency;
+    source_path: CostEvidenceSourcePath;
+    reason: CostEvidenceReason;
+    usage: TokenUsage;
+    model?: string;
+    pricing_version?: string;
+    pricing_effective_at?: string;
+    billing_basis?: string;
+    /** A bounded canonical digest is useful to correction producers. */
+    digest?: string;
+};
+export type CostCandidate = {
+    kind: CostEvidenceKind;
+    amount: number | null;
+    currency: CostCurrency;
+    source_path: CostEvidenceSourcePath;
+    usage: TokenUsage;
+    model?: string;
+    reason?: CostEvidenceReason;
+};
 export type ModelPricing = {
     input_per_million: number;
     output_per_million: number;
@@ -7,6 +36,14 @@ export type ModelPricing = {
 };
 export type PricingConfig = {
     models?: Record<string, ModelPricing>;
+    /** Currency of normalized table rows. Defaults to USD for compatibility. */
+    currency?: string;
+    version?: string;
+    effective_at?: string;
+    billing_basis?: string;
+    /** Explicit provider declarations; reported currency is never inferred. */
+    reported_cost_currency?: Record<string, string>;
+    subscription_unbilled?: boolean;
 };
 export type TokenUsage = {
     tokens_input: number;
@@ -17,6 +54,15 @@ export type TokenUsage = {
 export type DelegationCostFields = TokenUsage & {
     cost_usd: number | null;
     cost_source: CostSource;
+    cost_evidence?: CostEvidence[];
+    evidence_status?: CostEvidenceStatus;
+    evidence_reason?: CostEvidenceReason;
+    record_id?: string;
+    identity_fingerprint?: string;
+    child_session_digest?: string;
+    parent_session_digest?: string;
+    version?: number;
+    currency?: CostCurrency;
     model?: string;
     gate?: string;
     retry_index?: number;
@@ -27,6 +73,7 @@ export type DelegationCostInput = {
     gate?: string;
     retry_index?: number;
     pricing?: PricingConfig;
+    reported_cost_currency?: string;
 };
 export type CostSummary = {
     total_cost_usd: number;
@@ -46,6 +93,16 @@ export type CostSummary = {
         delegations: number;
         cost_usd: number;
     }>;
+    total_legacy_usd: number;
+    conflict_count: number;
+    legacy_count: number;
+    join_miss_count: number;
+    telemetry_error_count: number;
+    accepted_corrections: number;
+    rejected_corrections: number;
+    duplicate_corrections: number;
+    evidence_status: CostEvidenceStatus;
+    currencies: string[];
 };
 export type CostSummaryRow = {
     name: string;
@@ -59,7 +116,50 @@ export type CostSummaryRow = {
 };
 export declare const BUNDLED_MODEL_PRICING: Record<string, ModelPricing>;
 export declare function buildDelegationCostFields(input?: DelegationCostInput): DelegationCostFields;
+/**
+ * Extract only the pinned SDK shapes. The old generic traversal was
+ * intentionally removed: a wrapper's default cost must not shadow a child
+ * AssistantMessage/StepFinishPart report.
+ */
+export declare function extractCostEvidence(raw: unknown, input?: Pick<DelegationCostInput, 'model' | 'pricing' | 'reported_cost_currency'>): CostEvidence[];
+export type CostProjection = {
+    cost_usd: number | null;
+    cost_source: CostSource;
+    evidence_status: CostEvidenceStatus;
+    reason: CostEvidenceReason;
+    currency: CostCurrency;
+};
+/** Project additive evidence to the legacy scalar fields. Unknown is never zero. */
+export declare function projectCostEvidence(evidence: readonly CostEvidence[]): CostProjection;
+export declare function isCostEvidenceComplete(evidence: readonly CostEvidence[] | undefined): boolean;
 export declare function summarizeTelemetryCosts(directory: string): CostSummary;
+export type CostFoldStats = {
+    conflict_count: number;
+    join_miss_count: number;
+    telemetry_error_count: number;
+    accepted_corrections: number;
+    rejected_corrections: number;
+    duplicate_corrections: number;
+};
+export type FoldedCostTelemetry = {
+    events: Record<string, unknown>[];
+    stats: CostFoldStats;
+    versions: Record<string, number>;
+};
+/**
+ * Fold append-only cost corrections into one effective delegation snapshot.
+ * Corrections are buffered and replayed in version order so telemetry arrival
+ * order cannot permanently discard a valid correction. Invalid/orphan
+ * corrections remain diagnostics and can never create a row.
+ */
+export declare function foldTelemetryEvents(events: readonly Record<string, unknown>[]): FoldedCostTelemetry;
+export declare function isCostUpgrade(current: readonly CostEvidence[], next: readonly CostEvidence[]): boolean;
 export declare function readTelemetryEvents(directory: string): Record<string, unknown>[];
+/**
+ * Bounded asynchronous telemetry reader for live recovery paths. The status
+ * service and offline summaries retain the atomic synchronous snapshot above;
+ * recovery must not block event delivery on a full-file synchronous read.
+ */
+export declare function readTelemetryEventsAsync(directory: string): Promise<Record<string, unknown>[]>;
 export declare function estimateCostUsd(usage: TokenUsage, model?: string, pricing?: PricingConfig): number | null;
 export declare function roundUsd(value: number): number;

package/dist/services/status-service.d.ts

@@ -4,6 +4,7 @@ import { loadFullAutoRunState } from '../full-auto/state';
 import { type RecentEscalation } from '../hooks/knowledge-escalator';
 import { getActiveFullAutoSessionID, hasActiveFullAuto, hasActiveLeanTurbo } from '../state';
 import { loadLeanTurboRunState } from '../turbo/lean/state';
+import { summarizeTelemetryCosts } from './cost-accounting.js';
 /**
  * Dependency-injection seam for status-service.
  * Allows tests to intercept Lean Turbo state queries without mock.module leakage.
@@ -14,6 +15,7 @@ export declare const _internals: {
     hasActiveFullAuto: typeof hasActiveFullAuto;
     getActiveFullAutoSessionID: typeof getActiveFullAutoSessionID;
     loadFullAutoRunState: typeof loadFullAutoRunState;
+    summarizeTelemetryCosts: typeof summarizeTelemetryCosts;
 };
 /**
  * Structured status data returned by the status service.
@@ -175,6 +177,16 @@ export interface StatusData {
      * stores surface as typed uncertainty, never partially-trusted counts.
      */
     backgroundWork?: BackgroundWorkStatus;
+    /** Issue #2043: compatibility total plus provenance completeness. */
+    costs?: {
+        totalCostUsd: number;
+        delegations: number;
+        unavailableDelegations: number;
+        evidenceStatus: 'complete' | 'inconclusive';
+        conflictCount: number;
+        joinMissCount: number;
+        telemetryErrorCount: number;
+    };
 }
 /** Issue #2104: opt-in background-work status snapshot for /swarm status. */
 export interface BackgroundWorkStatus {

package/dist/telemetry.d.ts

@@ -1,6 +1,6 @@
 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'
+export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'delegation_cost_correction' | 'delegation_cost_binding' | 'delegation_cost_join' | '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

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

@@ -16,17 +16,44 @@
  *   `${relFile}|${rule_id}|L${line}|UNSTABLE|#${occurrenceIndex}`
  *   Unstable fingerprints are ALWAYS treated as NEW findings (fail-closed).
  *
+ * Reflow identity (schema 1.1.0, issue #2302):
+ *   The 3-line window hash is sensitive to adjacent-line edits and the
+ *   occurrence index shifts when an identical same-rule line is inserted
+ *   above a baselined one — both reclassify an unchanged pre-existing
+ *   finding as NEW. Every stable entry therefore also records a
+ *   position-independent reflow key
+ *   `${relFile}|${rule_id}|${sha256(trimmed flagged line).slice(0,16)}`
+ *   (aligned 1:1 with fingerprints[] in reflow_keys[]). Diff scans match
+ *   current findings against the baseline as a multiset of reflow keys
+ *   BEFORE classifying NEW; matches are reported as `moved` (never gating).
+ *   A 1.0.0 baseline has no reflow keys (they cannot be reconstructed after
+ *   the fact — findings_snapshot stores no line content) and degrades to
+ *   exact matching only until its next capture rewrites it as 1.1.0.
+ *
+ * Absorption triage (schema 1.1.0, issue #2302):
+ *   Merging a finding that matches neither the exact fingerprints nor the
+ *   reflow multiset of the prior baseline is a NOVEL ABSORPTION. EVERY novel
+ *   absorption — in already-indexed OR first-time-indexed files — requires an
+ *   explicit refreshRationale; without it the capture is BLOCKED and the
+ *   baseline is left untouched (fail-closed: a bare failure-response
+ *   recapture can never silently accept a coder-introduced vulnerability).
+ *   With a rationale, every absorbed finding records who/when/rationale in
+ *   triage_log[]. First writes (`status:'written'`) are snapshots, not
+ *   absorptions, and stay free.
+ *
  * Merge semantics:
  *   On every capture for a set of files, ALL prior fingerprints for those files
  *   are removed (full prune, engine-agnostic) before inserting current findings.
  *   This prevents stale cross-engine fingerprints from causing false-pass verdicts.
  */
 import type { SastScanFinding } from './sast-scan';
-export declare const BASELINE_SCHEMA_VERSION: "1.0.0";
+export declare const BASELINE_SCHEMA_VERSION: "1.1.0";
+/** Baselines written before issue #2302 — loaded read-only, exact matching only. */
+export declare const LEGACY_BASELINE_SCHEMA_VERSION: "1.0.0";
 /** Maximum findings to store in baseline (heuristic — open for tuning). */
 export declare const MAX_BASELINE_FINDINGS = 2000;
 export interface SastBaselineFile {
-    schema_version: '1.0.0';
+    schema_version: '1.0.0' | '1.1.0';
     phase: number;
     created_at: string;
     updated_at: string;
@@ -35,14 +62,42 @@ export interface SastBaselineFile {
     files_indexed: string[];
     /** Fingerprint strings for all indexed findings. */
     fingerprints: string[];
+    /**
+     * Position-independent reflow identities aligned 1:1 with fingerprints[]
+     * (`${relFile}|${rule_id}|${sha256(trimmed flagged line).slice(0,16)}`,
+     * '' for unstable entries). Absent in 1.0.0 files — exact matching only.
+     */
+    reflow_keys?: string[];
     /** Full findings snapshot (for auditing / debugging). */
     findings_snapshot: SastScanFinding[];
+    /**
+     * Audit trail for every novel absorption into an existing baseline
+     * (issue #2302). First writes record no entries — a snapshot is not an
+     * acceptance. Entries are dropped when their fingerprint no longer
+     * survives in fingerprints[].
+     */
+    triage_log?: BaselineTriageEntry[];
     /** True if the snapshot was truncated at MAX_BASELINE_FINDINGS. */
     truncated: boolean;
 }
+export interface BaselineTriageEntry {
+    /** Fingerprint of the absorbed finding (post-capture form). */
+    fingerprint: string;
+    /** Canonical relative path of the file containing the absorbed finding. */
+    rel_file: string;
+    rule_id: string;
+    /** Caller-supplied refresh rationale, or the first-time-index auto-rationale. */
+    rationale: string;
+    /** Session id of the capturing caller, or 'unknown-session'. */
+    actor: string;
+    /** ISO timestamp of the absorption. */
+    absorbed_at: string;
+}
 export type LoadBaselineResult = {
     status: 'found';
     fingerprints: Set<string>;
+    /** Reflow keys aligned with the loaded fingerprints (empty for 1.0.0 files). */
+    reflowKeys: string[];
     bundle: SastBaselineFile;
 } | {
     status: 'not_found';
@@ -60,6 +115,18 @@ export interface IndexedFinding {
     index: number;
     stable: boolean;
     fingerprint: string;
+    /** Position-independent reflow identity ('' when unstable — never reflow-matched). */
+    reflowKey: string;
+}
+export interface BaselinePartition {
+    preExisting: SastScanFinding[];
+    moved: SastScanFinding[];
+    newFindings: SastScanFinding[];
+}
+export interface BlockedAbsorptionFinding {
+    fingerprint: string;
+    rel_file: string;
+    rule_id: string;
 }
 export type CaptureResult = {
     status: 'written';
@@ -69,6 +136,14 @@ export type CaptureResult = {
     status: 'merged';
     path: string;
     fingerprint_count: number;
+    /** Novel absorptions recorded in triage_log by this capture. */
+    absorbed_finding_count: number;
+} | {
+    status: 'absorption_blocked';
+    path: string;
+    /** Novel findings in already-indexed files (bounded to MAX_BLOCKED_LIST). */
+    blocked: BlockedAbsorptionFinding[];
+    message: string;
 } | {
     status: 'error';
     message: string;
@@ -89,13 +164,34 @@ export declare function normalizeFindingPath(directory: string, file: string): s
  */
 export declare function fingerprintFinding(finding: SastScanFinding, directory: string, occurrenceIndex: number): FingerprintResult;
 /**
- * Assign occurrence indices to a batch of findings.
+ * Assign occurrence indices and reflow identities to a batch of findings.
  *
  * Two findings that produce the same (relFile, rule_id, contentHash) tuple
  * — e.g., copy-pasted vulnerable lines — receive different indices so they
  * get distinct fingerprints and can be individually classified.
+ *
+ * The reflow key hashes only the flagged line's own (trimmed) content, so it
+ * survives adjacent-line edits, pure line moves, and occurrence-index shifts
+ * — the three fingerprint instabilities fixed by issue #2302. It is '' when
+ * the fingerprint is unstable; unstable findings never reflow-match.
  */
 export declare function assignOccurrenceIndices(findings: SastScanFinding[], directory: string): IndexedFinding[];
+/**
+ * Partition current findings against a loaded baseline (issue #2302).
+ *
+ * 1. Exact: stable fingerprint present in baselineFingerprints → pre-existing.
+ *    Each exact match consumes one count of its reflow key — an exact
+ *    fingerprint match implies the same flagged-line content, so a baseline
+ *    entry can never absorb both an exact and a reflow match.
+ * 2. Reflow: stable finding whose reflow key still has unconsumed baseline
+ *    counts → moved (same finding, new position/window; never gating).
+ * 3. Anything else — including every unstable finding — is NEW (fail-closed).
+ *
+ * Multiset counting keeps duplicate content honest: a baseline with one
+ * `exec(cmd)` line absorbs exactly one current `exec(cmd)` line; a second
+ * identical line stays NEW.
+ */
+export declare function partitionAgainstBaseline(indexed: IndexedFinding[], baselineFingerprints: Set<string>, baselineReflowKeys: readonly string[]): BaselinePartition;
 /**
  * Capture or merge SAST findings into the phase-scoped baseline.
  *
@@ -105,6 +201,15 @@ export declare function assignOccurrenceIndices(findings: SastScanFinding[], dir
  *   This full-prune (engine-agnostic) prevents stale cross-engine entries from
  *   causing false-pass verdicts on later full-engine diff scans.
  *
+ * Absorption triage (issue #2302):
+ *   Current findings that match the prior baseline (exact fingerprint or
+ *   reflow key) are re-fingerprinted mechanically. A finding that matches
+ *   neither is a NOVEL ABSORPTION: the capture is BLOCKED unless
+ *   `refreshRationale` is supplied (the baseline is left untouched —
+ *   fail-closed), for already-indexed AND first-time-indexed files alike.
+ *   With a rationale, every absorbed finding records who (`actor`)/when/
+ *   rationale in `triage_log`.
+ *
  * Severity threshold:
  *   Callers MUST pass ALL findings regardless of severity threshold so the
  *   baseline captures the full pre-existing surface. Threshold filtering is
@@ -117,12 +222,23 @@ export declare function assignOccurrenceIndices(findings: SastScanFinding[], dir
 export declare function captureOrMergeBaseline(directory: string, phase: number, findings: SastScanFinding[], engine: 'tier_a' | 'tier_a+tier_b', scannedFiles: string[], opts?: {
     force?: boolean;
     abortSignal?: AbortSignal;
+    /** Audited rationale required to absorb novel findings in already-indexed files. */
+    refreshRationale?: string;
+    /** Identity recorded in triage_log entries (session id of the caller). */
+    actor?: string;
 }): Promise<CaptureResult>;
 /**
  * Load the SAST baseline for a given phase.
  *
  * Returns 'not_found' when no baseline file exists (first run for phase).
  * Returns 'invalid_schema' when the file is present but unparseable.
+ *
+ * Schema versions: 1.1.0 files carry reflow_keys (reflow matching active);
+ * legacy 1.0.0 files load read-only with an empty reflowKeys array — exact
+ * matching only until the next capture rewrites them as 1.1.0 (reflow keys
+ * cannot be reconstructed retroactively; findings_snapshot stores no line
+ * content). A present-but-misaligned reflow_keys array is corruption and
+ * fails closed to invalid_schema (legacy gating; recoverable by recapture).
  */
 export declare function loadBaseline(directory: string, phase: number): LoadBaselineResult;
 /**
@@ -132,6 +248,7 @@ export declare function loadBaseline(directory: string, phase: number): LoadBase
 export declare const _internals: {
     fingerprintFinding: typeof fingerprintFinding;
     assignOccurrenceIndices: typeof assignOccurrenceIndices;
+    partitionAgainstBaseline: typeof partitionAgainstBaseline;
     captureOrMergeBaseline: typeof captureOrMergeBaseline;
     loadBaseline: typeof loadBaseline;
 };

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

@@ -32,6 +32,16 @@ export interface SastScanInput {
      * baseline diff mode: only findings absent from the phase baseline fail.
      */
     phase?: number;
+    /**
+     * Audited refresh rationale (issue #2302). Required when a capture would
+     * absorb findings that match neither the exact fingerprints nor the
+     * reflow identities of the prior baseline for already-indexed files —
+     * without it that capture is BLOCKED and the baseline is left untouched.
+     * Only meaningful together with capture_baseline: true.
+     */
+    baseline_refresh_rationale?: string;
+    /** Session id of the calling agent, recorded as the triage actor. */
+    session_id?: string;
     /** Host/tool cancellation propagated to optional external scanners. */
     abort_signal?: AbortSignal;
 }
@@ -67,17 +77,31 @@ export interface SastScanResult {
         files_skipped_non_code?: number;
     };
     /** 'baseline_captured' when capture_baseline:true succeeded */
-    status?: 'baseline_captured' | 'baseline_merged';
+    status?: 'baseline_captured' | 'baseline_merged' | 'baseline_absorption_blocked';
     /** Number of findings recorded in the baseline (capture mode only) */
     finding_count?: number;
+    /** Novel findings absorbed into the baseline under a refresh rationale (capture mode only) */
+    absorbed_finding_count?: number;
     /** Findings NOT present in the baseline (diff mode only) */
     new_findings?: SastScanFinding[];
     /** Findings that match the baseline (diff mode only) */
     pre_existing_findings?: SastScanFinding[];
+    /**
+     * Findings that match the baseline via reflow identity — same finding,
+     * new position/window (diff mode only, issue #2302). Reported separately;
+     * never gate the verdict.
+     */
+    moved_findings?: SastScanFinding[];
     /** True when a baseline was loaded and diff mode was active */
     baseline_used?: boolean;
     /** True when pre_existing_findings were truncated to fit result limits */
     truncated_pre_existing?: boolean;
+    /**
+     * True when moved_findings were truncated to fit result limits. Advisory
+     * telemetry only (no in-tree consumer) — kept for parity with
+     * truncated_pre_existing and for future audit consumers.
+     */
+    truncated_moved_findings?: boolean;
 }
 export type SastFailureKind = 'semgrep_process_exit' | 'semgrep_timeout' | 'semgrep_cancelled' | 'semgrep_output_limit' | 'semgrep_spawn_error' | 'semgrep_invalid_output' | 'semgrep_scan_error' | 'semgrep_unexpected' | 'semgrep_unclassified' | 'coverage' | 'cancelled' | 'invalid_input';
 export interface SastScanFinding {

package/opencode-swarm.schema.json

@@ -746,6 +746,46 @@
       "description": "Token/cost estimation fallback table. Provider-reported cost wins when present; entries only estimate from usage tokens when reports omit cost.",
       "type": "object",
       "properties": {
+        "currency": {
+          "default": "USD",
+          "type": "string",
+          "const": "USD"
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 128
+        },
+        "effective_at": {
+          "type": "string",
+          "format": "date-time",
+          "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$"
+        },
+        "billing_basis": {
+          "type": "string",
+          "enum": [
+            "token",
+            "request",
+            "subscription"
+          ]
+        },
+        "reported_cost_currency": {
+          "default": {},
+          "type": "object",
+          "propertyNames": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 128
+          },
+          "additionalProperties": {
+            "type": "string",
+            "const": "USD"
+          }
+        },
+        "subscription_unbilled": {
+          "default": false,
+          "type": "boolean"
+        },
         "models": {
           "default": {},
           "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.159.0",
+	"version": "7.159.2",
 	"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/guardrail-explain-ax2qmsp4.js

@@ -1,67 +0,0 @@
-// @bun
-import {
-  handleGuardrailExplain
-} from "./index-8jnzp5ct.js";
-import"./index-3e8600a7.js";
-import"./index-z54qw70y.js";
-import"./index-04yrxg0z.js";
-import"./index-6e6qxf5q.js";
-import"./index-k4arrwrz.js";
-import"./index-7s1hmrfh.js";
-import"./index-txdagbh7.js";
-import"./index-134d35c1.js";
-import"./index-nj6rmyeh.js";
-import"./index-fcp41snp.js";
-import"./index-k48kgm6z.js";
-import"./index-xmz69g65.js";
-import"./index-70ha9e09.js";
-import"./index-c8s9a3zh.js";
-import"./index-9ss2m4rs.js";
-import"./index-mc9qgkwd.js";
-import"./index-zsrtt42s.js";
-import"./index-1sdb57jv.js";
-import"./index-3f7hqtgg.js";
-import"./index-8fqb0ynp.js";
-import"./index-vywbn766.js";
-import"./index-pfnj5pvs.js";
-import"./index-rtry5xyf.js";
-import"./index-we3nf5as.js";
-import"./index-pvzaryhr.js";
-import"./index-e2s08v0q.js";
-import"./index-ddszzne4.js";
-import"./index-ynjy98vv.js";
-import"./index-b82tq895.js";
-import"./index-nwkr6tvv.js";
-import"./index-556ja8an.js";
-import"./index-4fwbbad3.js";
-import"./index-b43rt5ph.js";
-import"./index-q7sjgr1y.js";
-import"./index-erdsawqz.js";
-import"./index-35grv4jg.js";
-import"./index-hte1e31d.js";
-import"./index-gprxjmm7.js";
-import"./index-n832052r.js";
-import"./index-dtn0pne5.js";
-import"./index-z6xqpmqg.js";
-import"./index-r3mvsbtq.js";
-import"./index-tcbjjppb.js";
-import"./index-b1tenv2s.js";
-import"./index-9e6fdz2h.js";
-import"./index-4rhhvd1a.js";
-import"./index-yt75r1er.js";
-import"./index-zjygnfay.js";
-import"./index-ae75rja9.js";
-import"./index-5zgf140g.js";
-import"./index-h52hs4e9.js";
-import"./index-bk5tah7q.js";
-import"./index-zcmwwp1x.js";
-import"./index-xagq35tf.js";
-import"./index-ed5ykebp.js";
-import"./index-h1g8w4v0.js";
-import"./index-7g4c7s5r.js";
-import"./index-bpmtbmy9.js";
-import"./index-zgwm4ryv.js";
-import"./index-a76rekgs.js";
-export {
-  handleGuardrailExplain
-};