opencode-swarm 7.144.8 → 7.145.1

package/dist/memory/schema.d.ts

@@ -48,8 +48,8 @@ export declare const MemoryKindSchema: z.ZodEnum<{
 }>;
 export declare const MemorySourceSchema: z.ZodObject<{
     type: z.ZodEnum<{
-        file: "file";
         agent: "agent";
+        file: "file";
         tool: "tool";
         manual: "manual";
         test: "test";
@@ -113,8 +113,8 @@ export declare const MemoryRecordSchema: z.ZodObject<{
     }>;
     source: z.ZodObject<{
         type: z.ZodEnum<{
-            file: "file";
             agent: "agent";
+            file: "file";
             tool: "tool";
             manual: "manual";
             test: "test";
@@ -203,8 +203,8 @@ export declare const MemoryProposalSchema: z.ZodObject<{
         }>;
         source: z.ZodObject<{
             type: z.ZodEnum<{
-                file: "file";
                 agent: "agent";
+                file: "file";
                 tool: "tool";
                 manual: "manual";
                 test: "test";

package/dist/observability/catalog.d.ts

@@ -1,15 +1,16 @@
 /**
  * The event catalog (issue #2029).
  *
- * Exactly 43 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
  * structured close/archive result event), the 41st is the bounded diagnostic
  * projection of authoritative knowledge-receipt transitions (issue #2031).
  * The 42nd is the human-only `knowledge_maintenance` quarantine audit
- * (issue #2033), and the 43rd is the aggregate `context_pruned` transcript
- * mutation audit. These late additions are instances of
+ * (issue #2033), the 43rd is the aggregate `context_pruned` transcript
+ * mutation audit, and the 44th is the bounded `residue_health` atomic-write
+ * residue audit (issue #2035). These late additions are instances of
  * the defect class this contract exists to close: an event kind entering the
  * stream with no registration.
  *
@@ -64,7 +65,7 @@ export interface CatalogEntry {
     /**
      * Whether an event of this kind must carry `trace.parentSpanId`.
      *
-     * `false` for all 43 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/observability/envelope.d.ts

@@ -38,11 +38,11 @@ export declare const EventCategorySchema: z.ZodEnum<{
 export type EventCategory = z.infer<typeof EventCategorySchema>;
 /** Syslog-shaped severity ladder. */
 export declare const EventSeveritySchema: z.ZodEnum<{
-    error: "error";
     debug: "debug";
     info: "info";
     notice: "notice";
     warning: "warning";
+    error: "error";
     critical: "critical";
 }>;
 export type EventSeverity = z.infer<typeof EventSeveritySchema>;
@@ -297,11 +297,11 @@ export declare const ObservabilityEventSchema: z.ZodObject<{
         unrecognized: "unrecognized";
     }>;
     severity: z.ZodEnum<{
-        error: "error";
         debug: "debug";
         info: "info";
         notice: "notice";
         warning: "warning";
+        error: "error";
         critical: "critical";
     }>;
     occurredAt: z.ZodString;

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/services/swarm-residue.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Shared atomic-write residue surface (issue #2035): read-only inventory,
+ * gated recoverable quarantine, manifest-backed rollback, and the ONE
+ * formatter every reporting surface (close clean stage, close dry-run,
+ * config doctor, diagnose) renders from — so close and doctor report the
+ * same inventory from a shared implementation by construction.
+ *
+ * Safety contract (issue #2035 reqs 4-7):
+ *  - The scanner never traverses outside the canonical project `.swarm/`
+ *    root, never follows symlinks (Dirent + lstat only), never infers
+ *    ownership from content, and never reads content except a bounded
+ *    sha256 at quarantine time.
+ *  - Quarantine MOVES (never deletes) only verified stale residue: exact
+ *    registered-grammar match with an instance token, age ≥
+ *    RESIDUE_STALE_AGE_MS, git-untracked, non-symlink, no active lock,
+ *    size ≤ RESIDUE_HASH_MAX_BYTES, parsed target present, and unchanged
+ *    (mtime+size) between scan and move (TOCTOU re-check — a lockless
+ *    writer still filling its temp mutates these).
+ *  - Everything else — recent, active, tracked, ambiguous, constant-name,
+ *    malformed, unmatched, outside-root — is PRESERVED and reported.
+ *  - Rollback is exact, manifest-verified, and idempotent.
+ */
+import { type SwarmTempGrammar } from '../utils/atomic-write';
+/** Age gate: a temp older than this is "old". 30 min exceeds any legitimate
+ * single bounded write (≤256 MiB + AV/rename-retry adds seconds), while still
+ * catching session-old residue at close time. */
+export declare const RESIDUE_STALE_AGE_MS: number;
+/** Bounded scan: stop (and report `truncated`) beyond this many entries. */
+export declare const MAX_RESIDUE_SCAN_ENTRIES = 20000;
+/** Bounded scan depth below `.swarm/`. */
+export declare const RESIDUE_SCAN_DEPTH = 8;
+/** Hash/move bound per residue file. Larger candidates are reported only. */
+export declare const RESIDUE_HASH_MAX_BYTES: number;
+/** `.swarm/` immediate-child subtrees the scanner never descends into. */
+export declare const RESIDUE_SKIP_DIRS: readonly string[];
+export interface ResidueEntry {
+    /** Path relative to the `.swarm/` root (never absolute — no path leak). */
+    relPath: string;
+    grammarId: string;
+    grammarEra: SwarmTempGrammar['era'];
+    bytes: number;
+    mtimeMs: number;
+    ageMs: number;
+    isSymlink: boolean;
+    tracked: 'tracked' | 'untracked' | 'unknown';
+    lockHeld: boolean;
+    proposedAction: 'quarantine' | 'report_only';
+    reasons: readonly string[];
+}
+export interface ResidueInventorySummary {
+    matched: number;
+    eligible: number;
+    ambiguous: number;
+    totalBytes: number;
+    oldestAgeMs: number;
+}
+export interface ResidueInventory {
+    swarmRoot: string;
+    scannedEntries: number;
+    truncated: boolean;
+    /** Oldest first. Constant-name grammar hits are included only when stale. */
+    entries: readonly ResidueEntry[];
+    summary: ResidueInventorySummary;
+    gitState: 'ok' | 'unknown';
+}
+/**
+ * Test seam (repo `_internals` convention — never mock.module). `now` drives
+ * age math; `queryTracked`/`activeLockTargets` isolate the git/lock signals.
+ */
+export declare const _internals: {
+    now: () => number;
+    /** Rename seam for the per-entry guarded move (PRR-005 regression tests). */
+    renameResidueEntry: (from: string, to: string) => void;
+    queryTracked: (projectRoot: string, swarmRoot: string) => {
+        tracked: Set<string> | undefined;
+    };
+    activeLockTargets: (directory: string) => Set<string>;
+    sha256File: (absPath: string) => string;
+};
+/** Read-only inventory of registered-grammar residue under `<directory>/.swarm`. */
+export declare function inventorySwarmResidue(directory: string): Promise<ResidueInventory>;
+export interface QuarantineManifestEntry {
+    original_rel_path: string;
+    stored_rel_path: string;
+    sha256: string;
+    bytes: number;
+    mtime_ms: number;
+    grammar_id: string;
+    reason: string;
+}
+export interface QuarantineManifest {
+    /**
+     * Manifest format version. Forward-compat POLICY (PR review PRR-009):
+     * rollback hard-rejects any version it does not know — a FUTURE schema
+     * bump MUST ship its own reader/migration before (or with) the writer,
+     * because payloads on disk are only recoverable through a manifest the
+     * current code can parse. Deliberate design: a partial-reader migration
+     * is more dangerous than a readable "unsupported manifest shape" error
+     * naming the version. Mixed-version operation is therefore unsafe by
+     * construction across schema bumps: downgrade with v2 batches present
+     * blocks rollback of those batches until the newer plugin returns.
+     */
+    schema_version: 1;
+    batch_id: string;
+    created_at: string;
+    trigger: string;
+    entries: QuarantineManifestEntry[];
+}
+export interface QuarantineOutcomeItem {
+    relPath: string;
+    status: 'quarantined' | 'preserved';
+    reasons: readonly string[];
+}
+export interface QuarantineResult {
+    inventory: ResidueInventory;
+    /** Batch dir relative to `.swarm/` — undefined when nothing was moved. */
+    batchRelDir?: string;
+    quarantined: number;
+    /** report_only entries preserved at their original location. */
+    preserved: readonly QuarantineOutcomeItem[];
+}
+/**
+ * Quarantine verified stale residue (moves only — never deletes). Callers
+ * that can mutate pass an explicit trigger; `dryRun: true` returns the exact
+ * plan without touching the filesystem (preview/confirmation path).
+ */
+export declare function quarantineSwarmResidue(directory: string, options?: {
+    trigger?: string;
+    dryRun?: boolean;
+}): Promise<QuarantineResult>;
+export interface RollbackOutcomeItem {
+    relPath: string;
+    status: 'restored' | 'already-restored' | 'collision' | 'missing-copy';
+}
+export interface RollbackResult {
+    batchRelDir: string;
+    items: readonly RollbackOutcomeItem[];
+    /** True when every manifest entry resolved and the batch dir was removed. */
+    drained: boolean;
+}
+/**
+ * Roll back a quarantine batch (default: latest). Idempotent and
+ * order-independent across batches: an occupied original is compared by
+ * checksum — identical copies are dropped (already restored), differing
+ * content is left in place and reported as a collision, never overwritten.
+ */
+export declare function rollbackResidueQuarantine(directory: string, batchId?: string): Promise<RollbackResult>;
+/** Bounded human rendering of an inventory (≤ maxEntries detail lines). */
+export declare function formatResidueInventoryLines(inv: ResidueInventory, options?: {
+    maxEntries?: number;
+}): string[];

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
@@ -26,7 +32,7 @@ export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activa
  * `prm_hard_stop` TRIGGER emitted by `src/prm/escalation.ts`. A trigger with
  * no matching delivery means the containment never reached the agent.
  */
- | 'prm_hard_stop_delivered' | 'agent_conflict_detected' | 'close_archive_result' | 'knowledge_receipt_transition' | 'knowledge_maintenance';
+ | 'prm_hard_stop_delivered' | 'agent_conflict_detected' | 'close_archive_result' | 'knowledge_receipt_transition' | 'knowledge_maintenance' | 'residue_health';
 /** Stable classification for how a reviewer-gate decision was established. */
 export type ReviewerGateEvidenceKind = 'genuine' | 'fallback' | 'data_quality' | 'block';
 /**
@@ -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;
@@ -206,6 +217,25 @@ export declare const telemetry: {
             };
         }>;
     }): void;
+    /**
+     * Atomic-write residue health (issue #2035). Emitted after a residue
+     * quarantine run (close clean stage / doctor flag). Bounded payload:
+     * counts, one bounded age figure, total bytes, and per-grammar counts
+     * keyed by the frozen registry ids — never file names, paths, or content,
+     * enabling later reporting (PR 16/19) without leaking workspace layout.
+     */
+    residueHealth(data: {
+        trigger: string;
+        scanned: number;
+        matched: number;
+        eligible: number;
+        ambiguous: number;
+        quarantined: number;
+        preserved: number;
+        total_bytes: number;
+        oldest_age_ms: number;
+        grammar_counts: Record<string, number>;
+    }): void;
     /**
      * Issue #2063 C2 — the PRM hard-stop DENIAL was actually delivered to the
      * agent (thrown by the guardrails `toolBefore` consumer). `prm_hard_stop`

package/dist/tools/knowledge-receipt.d.ts

@@ -17,8 +17,8 @@ import { createSwarmTool } from './create-tool.js';
 declare const ignoredItem: z.ZodObject<{
     id: z.ZodString;
     reason: z.ZodEnum<{
-        other: "other";
         stale: "stale";
+        other: "other";
         superseded: "superseded";
         unsafe: "unsafe";
         too_generic: "too_generic";

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';