opencode-swarm 7.160.1 → 7.161.0

package/.opencode/skills/critic-gate/SKILL.md

@@ -41,13 +41,20 @@ one-line `reason` (or ask the user to run `/swarm approve-plan-critic
 <reason>`). This records a manual `plan_critic_gate` approval snapshot
 tagged `method: "manual_override"`, audited to `.swarm/events.jsonl`.
 Architect-only. Use ONLY when a legitimate APPROVED was lost — this is an
-escape hatch, not a substitute for running the critic review.
+escape hatch, not a substitute for running the critic review. It is also the sanctioned recovery for a bookkeeping-grade hashed-field repair under PLAN FREEZE below.
 
 CRITIC-GATE TRIGGER: Run ONCE when you first write the complete .swarm/plan.md.
 Do NOT re-run CRITIC-GATE before every project phase.
 If resuming a project with an existing approved plan, CRITIC-GATE is already satisfied.
 Caveat: this assumption breaks if the plan lacks a `plan_critic_gate`-tagged approval snapshot (e.g. a plan approved before this mechanical gate existed, or one where the recording heuristic didn't fire) — in that case the first coder dispatch will fail with `PLAN_CRITIC_GATE_VIOLATION`. If that happens, do not assume CRITIC-GATE is satisfied; re-run it and get a fresh APPROVED verdict.
 
+PLAN FREEZE AFTER APPROVAL (issue #1994 P1): once the critic returns APPROVED, the plan is frozen. The coder dispatch gate compares the plan against the approval snapshot via the structure hash (`computePlanStructureHash`), so classify post-approval changes by what that hash actually covers:
+- STATUS-ONLY changes (task status transitions via `update_task_status`) are excluded from the hash and never invalidate the approval — no re-critic needed.
+- MATERIAL (invalidates the approval): adding or removing tasks; changing any task's `id`, `phase`, `description`, `acceptance`, or `depends`; or enumerating `removed_task_ids` on a re-save. Re-run MODE: CRITIC-GATE exactly ONCE on the revised plan and get a fresh APPROVED before the next coder dispatch — the dispatch fails `PLAN_CRITIC_GATE_VIOLATION` against the stale snapshot otherwise.
+- `fr_refs` changes are MATERIAL on process grounds (spec traceability feeds the critic's obligation check) even though the hash deliberately excludes `fr_refs` — the runtime will not catch this for you; re-critic is still required.
+- BOOKKEEPING-GRADE hashed fields (`size`, `evidence_path`, `blocked_reason`, `title`, `current_phase`, `files_touched`) trip the gate mechanically even for pure bookkeeping edits. For a genuine bookkeeping repair — most commonly a `files_touched`-only reconciliation aligned with an active `declare_scope` binding (the sanctioned `SCOPE_CONFLICT` repair path in the execute skill) — use the gate's own recovery: `approve_plan_critic` with a truthful one-line reason (audited to `.swarm/events.jsonl`), not a full re-critic. Any substantive scope growth beyond reconciliation is MATERIAL: re-critic.
+Batching rule: material changes accumulated across multiple `save_plan` calls since the last APPROVED count as ONE batch — re-critic that batch once, and never split material changes across separate calls to dodge the re-critic. The pre-change approval is never valid for the changed plan.
+
 6j. SPEC-GATE (Execute BEFORE any save_plan call):
 - An effective spec exists iff `/swarm sdd status` reports a resolved spec (it reflects `readEffectiveSpecSync`, which returns null — NO effective spec — for no sources, multiple competing sources (openspec+specify), multi-feature Spec-Kit without a selected feature, or any unresolvable state). `save_plan` rejects (SPEC_REQUIRED) when `/swarm sdd status` reports no resolved spec. The gate is overridable via `SWARM_SKIP_SPEC_GATE=1`.
 - Before calling save_plan, verify an effective spec exists (via `/swarm sdd status` or `lint_spec`).

package/.opencode/skills/execute/SKILL.md

@@ -73,8 +73,9 @@ All other gates: failure → return to coder. No self-fixes. No workarounds.
     → REQUIRED: Print "diff: [PASS | CONTRACT CHANGE — details]"
     5d. Run `syntax_check` tool. SYNTACTIC ERRORS → return to coder. NO ERRORS → proceed to placeholder_scan.
     → REQUIRED: Print "syntaxcheck: [PASS | FAIL — N errors]"
-    5e. Run `placeholder_scan` tool. PLACEHOLDER FINDINGS → return to coder. NO FINDINGS → proceed to imports.
-    → REQUIRED: Print "placeholderscan: [PASS | FAIL — N findings]"
+    5e. Run `placeholder_scan` tool WITH DIFF SCOPING: pass `added_lines` — a map of workspace-relative file path → the line numbers ADDED by this task's uncommitted work (from `git diff -U0 HEAD -- <task files>` for tracked files; the coder's edits are not committed yet, so a commit-range diff like `<base>...HEAD` returns zero added lines here) — so only task-added lines drive the verdict. PLACEHOLDER FINDINGS (on added lines) → return to coder. NO FINDINGS → proceed to imports.
+    → Diff-scope fallback: for a file whose added lines you cannot map (new/untracked file, no diff available) or whose computed added-line set is EMPTY, OMIT that file from `added_lines` entirely — the tool then scans it unfiltered (fail-closed) — and manually cross-check that file's findings against the changed lines before returning to coder. NEVER pass an empty line array for a file (an empty array suppresses every finding in it) and NEVER hand-enumerate guessed line numbers (a wrong map silently suppresses findings). A pre-existing TODO/FIXME on an unchanged line is existing debt to surface to the reviewer, not a coder bounce.
+    → REQUIRED: Print "placeholderscan: [PASS | FAIL — N findings (diff-scoped) | FAIL — N findings (unscoped — cross-checked against changed lines)]"
     5f. Run `imports` tool for dependency audit. ISSUES → return to coder.
     → REQUIRED: Print "imports: [PASS | ISSUES — details]"
     5g. Run `lint` tool with fix mode for auto-fixes. If issues remain → run `lint` tool with check mode. FAIL → return to coder.
@@ -193,7 +194,7 @@ This step supplements (not replaces) the existing regression-sweep and test-drif
 5o. ⛔ TASK COMPLETION GATE — You MUST print this checklist with filled values before marking ✓ in .swarm/plan.md:
   [TOOL] diff: PASS / SKIP — value: ___
   [TOOL] syntax_check: PASS — value: ___
-  [TOOL] placeholder_scan: PASS — value: ___
+  [TOOL] placeholder_scan: PASS — value: ___ (diff-scoped | unscoped — cross-checked)
   [TOOL] imports: PASS — value: ___
   [TOOL] lint: PASS — value: ___
   [TOOL] build_check: PASS / SKIPPED — value: ___

package/.opencode/skills/phase-wrap/SKILL.md

@@ -105,6 +105,8 @@ If any required agent is missing, `phase_complete` returns `{ success: false, st
 
 The `docs` agent requirement is controlled by `phase_complete.require_docs` in plugin configuration, not by the QA gate profile returned by `get_qa_gate_profile`. It defaults to `true`. Set it to `false` only when the phase genuinely has no documentation obligation. A successful docs completion is persisted as plan- and phase-bound participation proof so `phase_complete` can recover it after a session restart; unrelated task-gate evidence does not count as docs participation.
 
+Docs-attestation integrity (issue #1994 P2): when the docs agent concludes that a phase — especially a doc-only phase — needs no further documentation edits, that attestation is valid ONLY if the docs agent actually inspected the phase's changed files and recorded what it checked (files read, per-file verdict) in its completion report. A mechanical "no edits needed" reply dispatched only to satisfy `agentsDispatched` — without inspecting the phase's changes — is a process violation: the gate exists to catch documentation drift, not to be acknowledged past.
+
 The `coder` and `test_engineer` agents are required because every phase that modifies source code or tests must have at least one implementation and one test-verification delegation. For pure documentation or retrospective phases, these may be waived by the user explicitly.
 
 This is a hard enforcement mechanism, not a suggestion. `phase_complete` will not return `status: success` if any required agent is missing from `agentsDispatched`.

package/.opencode/skills/running-tests/SKILL.md

@@ -232,6 +232,12 @@ git worktree remove "$env:TEMP\repro-check"
 
 ---
 
+## Placeholder Scans Without Diff Line Numbers
+
+`placeholder_scan` is diff-aware: when you can supply `added_lines` (a map of workspace-relative file path → added line numbers from the task/PR diff), its verdict covers only the added lines, so a pre-existing TODO/FIXME on an unchanged line inside a changed file no longer fails the gate. When you CANNOT map a file's added lines (new/untracked file, no diff access) — or the computed added-line set is EMPTY — omit that file from `added_lines` entirely: the tool scans it unfiltered, fail-closed, and you manually cross-check that file's findings against the changed lines before treating a finding as introduced by the change. NEVER pass an empty line array for a file (an empty array suppresses every finding in it) and NEVER hand-enumerate guessed line numbers: a wrong `added_lines` map silently suppresses findings.
+
+---
+
 ## Failure Classification
 
 Not all failures are equal. Before deciding what to do, classify the failure:

package/.opencode/skills/swarm-implement/SKILL.md

@@ -117,6 +117,8 @@ Implement in coherent, reviewable chunks. Follow existing repository patterns.
 
 **`declare_scope` discipline.** Before every coder or test-engineer delegation (and before every retry), call `declare_scope({ taskId, files, replace_existing: true })` with the exact workspace-relative file list the delegated agent may modify — including generated or lockfile paths the change will produce (for example, `dist/*`, `package-lock.json`, or `bun.lock`). Direct and shell writes are both scope-enforced. If the file list is not completely obvious, declare the containing workspace-relative directories instead. Treat `SCOPE_CONFLICT`, `SCOPE_BINDING_EXPIRED`, `SCOPE_BINDING_AMBIGUOUS`, and `SCOPE_WORKSPACE_MISMATCH` as architect-owned recovery signals: reconcile the named scope sources or lane root, replace the declaration, then redispatch. Never instruct the delegated agent to bypass the gate or switch write mechanisms.
 
+**Smallest justified scope on `SCOPE_CONFLICT` (issue #1994 S4).** The replacement declaration must be the SMALLEST justified scope: first reconcile what the delegation actually intends to write (the task's files vs the conflicting scope source named in the diagnostic), then narrow the conflicting lower-precedence source to a subset of that list — repair stale plan scope with `save_plan` and/or the delegation's `FILE:` lines — and only then re-declare exactly that file list; re-declaring alone leaves the non-subset relation and reproduces the same `SCOPE_CONFLICT`. Split the task into separate delegations if the conflict reveals two disjoint write sets. NEVER resolve a `SCOPE_CONFLICT` by widening to a plan-inferred superset: auto-widening over-authorizes writes and hides an inaccurate plan or delegation prompt behind a bigger scope. This matches the execute skill's scope-recovery contract ("Do not widen scope just to make the sets agree"); a `save_plan` scope repair is a bookkeeping change covered by the critic-gate plan-freeze rule.
+
 If the project exposes `sast_scan` with `capture_baseline`, capture the
 phase-scoped SAST baseline before first coder delegation so later scans fail only
 on new findings rather than pre-existing infrastructure noise.

package/.opencode/skills/swarm-pr-review/SKILL.md

@@ -832,6 +832,7 @@ Tool candidate rules:
 
 - Confirm reachability before reporting.
 - Confirm PR-introducedness before reporting as a PR blocker.
+- When `placeholder_scan` output is used as a signal, pass `added_lines` (file path → PR-added line numbers from the merge-base diff) so only added lines drive the scan; a placeholder finding on an unchanged line is a pre-existing-debt candidate, not a PR blocker. If added-line mapping is unavailable, treat the findings as unscoped and cross-check them against the PR diff before recording the row.
 - Confirm that a framework, schema, middleware, caller guard, or test isolation rule does not already mitigate it.
 - Do not report scanner output verbatim without reviewer validation.
 - Redact secrets; never paste raw credentials into the final output.

package/dist/agents/architect.d.ts

@@ -20,7 +20,7 @@ export declare const ARCHITECT_MEMORY_OUTCOME_GUIDANCE = "After using recalled m
  * 5. Memory Rule (line ~101): Never store swarm identity in memory blocks
  * 6. CRITIC GATE (lines ~102-107): Plan review before implementation
  * 7. MANDATORY QA GATE (lines ~108-165):
- *    - Stage A: Automated tool gates (diff → syntax_check → placeholder_scan → imports → lint → build_check → pre_check_batch)
+ *    - Stage A: Automated tool gates (diff → syntax_check → placeholder_scan (diff-scoped via added_lines) → imports → lint → build_check → pre_check_batch)
  *    - Stage B: Agent review gates (reviewer → security reviewer → test_engineer)
  *    - ANTI-EXEMPTION RULES: 8 "WRONG thoughts" to ignore
  *    - PARTIAL GATE RATIONALIZATIONS: 6 "WRONG thoughts" to ignore

package/dist/background/delegation-lifecycle.d.ts

@@ -0,0 +1,374 @@
+/**
+ * Shared Task/lane delegation lifecycle operations (issue #2045).
+ *
+ * Task-tool delegations and `dispatch_lanes` lanes both persist their state in
+ * the background-delegations ledger and both record their start through
+ * `recordPendingDelegationDetailed`; before issue #2045 only the Task side
+ * settled terminals through `claimTerminalResult`, leaving lanes with the
+ * weaker status-only `appendDelegationTransition` write. This module gives
+ * lanes the same exactly-once terminal semantics — `settleDelegationTerminal`
+ * wraps the SAME `claimTerminalResult` primitive the Task completion observer
+ * calls directly (one claim implementation, no second lifecycle state machine)
+ * — and emits the lane-side terminal observations the Task side produces
+ * through its `tool.execute.*` hooks (cost telemetry, trajectory, knowledge
+ * receipt reconciliation), so equivalent Task and lane dispatches leave
+ * equivalent lifecycle facts behind.
+ *
+ * Every observation is fail-open and split into two durability classes — see
+ * the `settleDelegationTerminal` docstring for the contract: AUTHORITATIVE
+ * ledger-committed receipts re-run on `duplicate` replays (crash recovery),
+ * while DIAGNOSTIC observations run only on `claimed` (exactly-once-at-emit).
+ */
+import { type PricingConfig } from '../services/cost-accounting.js';
+import { type BackgroundDelegationRecord, type BackgroundDelegationResult, type BackgroundTerminalResult, claimTerminalResult, findByCorrelationId } from './pending-delegations.js';
+/** Terminal statuses a shared settle may establish (mirrors Task semantics). */
+export type DelegationTerminalStatus = 'completed' | 'error' | 'cancelled';
+/**
+ * Why `settleDelegationTerminal` returned without a fresh claim.
+ *
+ * `already_terminal_without_event` is deliberately distinct from `conflict`:
+ * a record terminalized WITHOUT an immutable event (the 30-minute stale sweep
+ * or a legacy status-only writer won the race) is a benign outcome that must
+ * not tick the late-terminal audit — the audit belongs to the writer that
+ * owns the conflicting *event*, and there is none.
+ */
+export type DelegationSettleKind = 'claimed' | 'duplicate' | 'conflict' | 'already_terminal_without_event' | 'not_open' | 'missing';
+export interface DelegationSettleOutcome {
+    kind: DelegationSettleKind;
+    record?: BackgroundDelegationRecord;
+}
+/**
+ * Settle outcomes that mean "the work item is already durably terminal; the
+ * caller's benign already-terminal handling applies" (no retry, no failure
+ * diagnostic — the race was routine).
+ */
+export declare function isBenignSettleOutcome(kind: DelegationSettleKind): boolean;
+export interface DelegationTerminalInput {
+    status: DelegationTerminalStatus;
+    result: BackgroundDelegationResult;
+}
+export interface DelegationObservationInput {
+    /** Full lane/delegate transcript text; drives knowledge reconciliation. */
+    transcript?: string;
+    /** Raw cost-evidence source (assistant info/metadata), when available. */
+    costRaw?: unknown;
+    /** Configured model for cost projection fallback. */
+    model?: string;
+    /** Pricing config for normalized cost estimation. */
+    pricing?: PricingConfig;
+    /** Wall-clock dispatch start (ms epoch), for trajectory elapsed_ms. */
+    startedAt?: number;
+}
+/**
+ * Build the immutable terminal event for a delegation record. The eventId is
+ * derived from trusted correlation + immutable result metadata (no timestamps,
+ * no process state), so a replayed observation of the same result claims
+ * idempotently and a different result is a distinct, auditable event.
+ */
+export declare function buildDelegationTerminal(record: Pick<BackgroundDelegationRecord, 'correlationId' | 'jobId'>, terminal: DelegationTerminalInput, now: number): BackgroundTerminalResult;
+/**
+ * Settle a delegation terminal exactly once through the shared claim, then —
+ * only on a fresh `claimed` disposition — run the terminal observations.
+ *
+ * Durability model (final-critic challenge, crash between claim and
+ * observations):
+ * - The AUTHORITATIVE receipts (validator/ledger-committed delegate ACK
+ *   terminals, unacknowledged-critical violations, and reviewer verdicts) are
+ *   re-run on `duplicate` replays: the receipt ledger's terminal authority is
+ *   idempotent (same-outcome replays are `idempotent_skips`), so a replay
+ *   after a crash closes the receipts exactly once — a lane whose observation
+ *   pass died mid-flight recovers on any later settle replay (restart,
+ *   concurrent collector).
+ * - The DIAGNOSTIC observations are exactly-once-at-emit on `claimed` only —
+ *   they have no deduplicating sink, and re-emitting them on replay would
+ *   duplicate records. This covers cost telemetry, trajectory, AND the
+ *   audit-only non-critical `unacknowledged` knowledge observation (which
+ *   bypasses the receipt ledger). It is the same crash window the Task
+ *   transport's `tool.execute.*` hook emissions have always had (documented
+ *   transport parity, not a regression).
+ *
+ * See {@link DelegationSettleKind} for the non-claim outcomes; callers map
+ * `duplicate`/`conflict`/`already_terminal_without_event` to their benign
+ * already-terminal handling and `missing`/`not_open` to their
+ * settle-failure diagnostics.
+ */
+export declare function settleDelegationTerminal(directory: string, record: BackgroundDelegationRecord, terminal: DelegationTerminalInput, observations?: DelegationObservationInput, now?: number): Promise<DelegationSettleOutcome>;
+/**
+ * Emit the `delegation_begin` pairing observation when a lane/delegation start
+ * record lands (issue #2045 Task/lane cost-event parity). Best-effort.
+ */
+export declare function emitDelegationBegin(record: Pick<BackgroundDelegationRecord, 'parentSessionId' | 'swarmPrefixedAgent' | 'planTaskId'>): void;
+/**
+ * Canonical cost-record identity material for a lane/delegation terminal.
+ * Joining back to the delegation record uses exactly these record fields —
+ * never agent-name matching. The `lane:` discriminator keeps lane identities
+ * disjoint from Task-tool records, whose material is `${sessionId}\0${callID}`.
+ */
+export declare function delegationCostRecordMaterial(record: Pick<BackgroundDelegationRecord, 'parentSessionId' | 'callID' | 'laneId'>): string;
+/** Bounded per-pass cap for terminal-lane receipt recovery (crash window). */
+export declare const MAX_TERMINAL_LANE_RECEIPT_RECOVERY = 64;
+/**
+ * Pre-record admission deadline for the directory-wide recovery pass
+ * (session-close hook): checked before EACH reconciliation, bounding how many
+ * records a pass may START — not the enumeration read/sort or an
+ * already-started reconciliation.
+ */
+export declare const TERMINAL_LANE_RECEIPT_RECOVERY_DEADLINE_MS = 5000;
+export interface TerminalLaneReceiptRecoveryResult {
+    /** Terminal lane records whose receipt reconciliation replay was attempted. */
+    recovered: number;
+    /** True when the pass ended before every candidate was attempted. */
+    exhaustedBudget: boolean;
+}
+export interface RecoverTerminalLaneReceiptsOptions {
+    /**
+     * Admission budget for STARTING a reconciliation. Default 5s; the pass
+     * stops cleanly before the next record when exhausted. Does not bound the
+     * enumeration or an in-flight reconciliation.
+     */
+    deadlineMs?: number;
+    /** Test seam for the clock. */
+    now?: () => number;
+}
+/**
+ * Durable crash-recovery pass for terminal lane records (final-critic
+ * challenge): a lane whose terminal claim landed but whose observation pass
+ * died is TERMINAL, so the collector's active-record filter skips it forever —
+ * the duplicate-replay path in {@link settleDelegationTerminal} would never be
+ * entered again on its own. This pass re-enters it: the durable transcript
+ * (`terminalResult.result.text`, persisted by the claim) is replayed through
+ * the ledger-idempotent receipt reconciliation in replay mode — authoritative
+ * receipts close exactly once; diagnostics never re-emit.
+ *
+ * Production wiring: (a) `collect_lane_results` runs it once per invocation
+ * over the batch's terminal records (the async-lane restart path — a batch is
+ * at most MAX_LANES records, so batch mode needs no cursor), and (b) the
+ * session-close maintenance trigger runs it directory-wide, which is what
+ * recovers BLOCKING lane records that have no collector.
+ *
+ * Forward progress (final-critic round 3): the directory-wide pass is bounded
+ * by a record cap and a pre-record admission deadline (checked before EACH
+ * reconciliation; it does not bound the candidate enumeration read/sort or an
+ * already-started reconciliation — those are bounded by the ledger read and
+ * the cap), and it persists an advancing
+ * cursor (`.swarm/lane-receipt-recovery-cursor.json`, ordered by
+ * `(updatedAt, correlationId)`), so each pass resumes after the last processed
+ * record and wraps to the oldest once the end is reached. Guarantees, stated
+ * exactly: under steady arrivals a candidate whose terminal commits with an
+ * ordering key OLDER than the cursor's position (a lock-contention straggler)
+ * is skipped until the next wrap — so a straggler is deferred, not lost, and
+ * an idle drain (a pass with nothing after the cursor) wraps immediately.
+ * Replays are ledger-idempotent, so a lost, stale, or wrapped cursor only
+ * causes harmless rework. Fail-open per record; never throws.
+ */
+export declare function recoverTerminalLaneReceipts(directory: string, records?: readonly BackgroundDelegationRecord[], options?: RecoverTerminalLaneReceiptsOptions): Promise<TerminalLaneReceiptRecoveryResult>;
+/**
+ * Test seam (repo convention): the telemetry sink and the claim are injectable
+ * so tests can stub them without `mock.module`.
+ */
+export declare const _internals: {
+    claimTerminalResult: typeof claimTerminalResult;
+    findByCorrelationId: typeof findByCorrelationId;
+    telemetry: {
+        sessionStarted(sessionId: string, agentName: string): void;
+        sessionEnded(sessionId: string, reason: string): void;
+        agentActivated(sessionId: string, agentName: string, oldName?: string): void;
+        delegationBegin(sessionId: string, agentName: string, taskId: string): void;
+        delegationEnd(sessionId: string, agentName: string, taskId: string, result: string, costFields?: Partial<import("../services/cost-accounting.js").DelegationCostFields>): void;
+        taskStateChanged(sessionId: string, taskId: string, newState: string, oldState?: string): void;
+        gatePassed(sessionId: string, gate: string, taskId: string): void;
+        gateParseError(taskId: string, error: Error): void;
+        gateFailed(sessionId: string, gate: string, taskId: string, reason: string): void;
+        reviewerGateDecision(sessionId: string, taskId: string, blocked: boolean, reasonCode: import("../telemetry.js").ReviewerGateReasonCode, evidenceKind: import("../telemetry.js").ReviewerGateEvidenceKind): void;
+        phaseChanged(sessionId: string, oldPhase: number, newPhase: number): void;
+        budgetUpdated(sessionId: string, budgetPct: number, agentName: string): void;
+        contextPruned(data: {
+            sessionId: string;
+            agentName: string;
+            trigger: "agent_switch" | "critical_threshold";
+            usageSource: "provider" | "estimated";
+            beforeTokens: number;
+            afterTokens: number;
+            modelLimit: number;
+            maskedMessages: number;
+            maskedToolParts: number;
+            maskedTokensFreed: number;
+            prunedMessages: number;
+            prunedTextParts: number;
+            prunedToolParts: number;
+            prunedTokensFreed: number;
+        }): void;
+        modelFallback(sessionId: string, agentName: string, fromModel: string, toModel: string, reason: string): void;
+        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;
+        noOpStrongWarning(sessionId: string, agentName: string, count: number, threshold: number): void;
+        gateDenialLoop(sessionId: string, tool: string, code: string, count: number): void;
+        executionStallWarning(sessionId: string, count: number, threshold: number): void;
+        executionStallDenied(sessionId: string, tool: string, count: number, threshold: number): void;
+        swarmInternalsReadDenied(sessionId: string, tool: string, target: string): void;
+        scopeViolation(sessionId: string, agentName: string, file: string, reason: string): void;
+        qaSkipViolation(sessionId: string, agentName: string, skipCount: number): void;
+        heartbeat(sessionId: string): void;
+        turboModeChanged(sessionId: string, enabled: boolean, agentName: string): void;
+        autoOversightEscalation(sessionId: string, reason: string, interactionCount: number, deadlockCount: number, phase?: number): void;
+        environmentDetected(sessionId: string, hostOS: string, shellFamily: string, executionMode: string): void;
+        prmPatternDetected(sessionId: string, pattern: string, severity: string, category: string, stepRange: [number, number]): void;
+        prmCourseCorrectionInjected(sessionId: string, pattern: string, level: number): void;
+        prmEscalationTriggered(sessionId: string, pattern: string, level: number, occurrenceCount: number): void;
+        prmHardStop(sessionId: string, pattern: string, level: number, occurrenceCount: number): void;
+        closeArchiveResult(data: {
+            archive_valid: boolean;
+            archive_empty: boolean;
+            file_count: number;
+            bundle: string;
+            artifacts: Array<{
+                artifact: string;
+                requiredness: string;
+                attempt: string;
+                validation: string;
+                source_disposition: string;
+                method: string;
+                reason_code: string;
+                row_counts?: {
+                    schema_migrations_max_version: number | null;
+                    project_constraints: number;
+                    qa_gate_profile: number;
+                };
+            }>;
+        }): void;
+        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;
+        contextTelemetryHealth(data: {
+            trigger: "compaction" | "close";
+            accepted_count: number;
+            compacted_count: number;
+            retained_count: number;
+            dropped_count: number;
+            corrupt_count: number;
+            oldest_timestamp: string | null;
+            newest_timestamp: string | null;
+            bytes: number;
+            limit_bytes: number;
+        }): void;
+        skillUsageHealth(data: {
+            trigger: "compaction" | "migration" | "consumption" | "pressure";
+            accepted: number;
+            compacted: number;
+            dropped: number;
+            skills_dropped: number;
+            corrupt: number;
+            pending_retained: number;
+            uncertain_retained: number;
+            uncertain_expired: number;
+            pending_evicted: number;
+            no_source_knowledge: number;
+            no_matching_knowledge: number;
+            bump_retry: number;
+            bump_unrecoverable: number;
+            bump_applied_zero: number;
+            pressure: number;
+            curator_skipped: number;
+            bytes: number;
+            limit_bytes: number;
+            oldest_timestamp: string | null;
+            newest_timestamp: string | null;
+            coverage: boolean;
+        }): void;
+        coreEventsHealth(data: {
+            trigger: "compaction" | "close";
+            accepted_count: number;
+            compacted_count: number;
+            retained_count: number;
+            dropped_count: number;
+            corrupt_count: number;
+            authority_index_count: number;
+            authority_evicted_count: number;
+            oldest_timestamp: string | null;
+            newest_timestamp: string | null;
+            bytes: number;
+            limit_bytes: number;
+        }): void;
+        shellAuditHealth(data: {
+            trigger: "compaction" | "close";
+            accepted_count: number;
+            compacted_count: number;
+            retained_count: number;
+            dropped_count: number;
+            corrupt_count: number;
+            oldest_timestamp: string | null;
+            newest_timestamp: string | null;
+            bytes: number;
+            limit_bytes: number;
+        }): void;
+        trajectoryHealth(data: {
+            trigger: "compaction" | "cleanup" | "append_skip";
+            retained_count: number;
+            dropped_count: number;
+            corrupt_count: number;
+            skipped_lock_count: number;
+            bytes: number;
+            limit_bytes: number;
+        }): void;
+        prSubscriptionHealth(data: {
+            trigger: "compact" | "migrate-complete" | "archive" | "foreign-rebind" | "corrupt-quarantine";
+            active_count: number;
+            terminal_count: number;
+            compactions: number;
+            corrupt_count: number;
+            dropped_audit_count: number;
+            recovery_resets: number;
+            checkpoint_bytes: number;
+            limit_bytes: number;
+        }): void;
+        learningHealthAlarm(data: {
+            alarm: string;
+            transition: "raised" | "sustained" | "recovered";
+            severity: "warning" | "critical";
+            scope_class: "session" | "identity" | "project";
+            session_ref?: string;
+            model?: string;
+            provider?: string;
+            window_ms: number;
+            coverage_facts: number;
+            raise_facts: number;
+            age_ms: number;
+            limit_source?: string;
+            denominator_fallback?: boolean;
+            pressure_pct?: number;
+            band?: string;
+            share_pct?: number;
+            field_count?: number;
+            non_field_count?: number;
+            store?: string;
+            dropped?: number;
+            corrupt?: number;
+            retained?: number;
+            accepted?: number;
+            gap_type?: "membership_to_terminal" | "terminal_to_application";
+            role?: string;
+            phase?: number;
+            reason?: string;
+        }): void;
+        prmHardStopDelivered(sessionId: string, pattern: string, level: number, occurrenceCount: number): void;
+        retrievalRouted(sessionId: string, data: {
+            mode: "graph" | "lexical" | "semantic" | "security" | "test" | "hybrid";
+            graph_hit: boolean;
+            fallback_reason: string | null;
+            token_budget_requested: number;
+            token_budget_used: number;
+            omitted_context_count: number;
+        }): void;
+    };
+};

package/dist/background/pending-delegations.d.ts

@@ -711,6 +711,12 @@ export declare function findByBatchId(directory: string, batchId: string, opts?:
     parentSessionId?: string;
 }): BackgroundDelegationRecord[];
 export declare function findOpenAsyncLaneBatches(directory: string): BackgroundDelegationRecord[];
+/**
+ * Public alias of the internal terminal predicate so shared lifecycle callers
+ * (issue #2045: `delegation-lifecycle.ts`) classify post-claim re-reads with
+ * the exact same status set as the store's own guards — never a second copy.
+ */
+export declare function isTerminalDelegationStatus(status: BackgroundDelegationStatus): boolean;
 /**
  * Public stale sweep: acquires the store lock and marks overdue pendings as `stale`.
  * Best-effort; returns the number swept (0 on lock timeout / error).

package/dist/build/command-resolution.d.ts

@@ -0,0 +1,13 @@
+export interface ResolvedCommand {
+    argv: string[];
+    shellCommand: string;
+}
+/**
+ * Tokenize a generated command into argv without invoking a shell. Supports
+ * single and double quotes for grouping, but never interprets shell
+ * metacharacters.
+ */
+export declare function tokenizeCommand(command: string): string[];
+/** Resolve a plugin-generated command without invoking a package downloader. */
+export declare function resolveLocalCommand(command: string, workingDir: string, isAvailable: (binary: string) => boolean, platform?: NodeJS.Platform): ResolvedCommand | null;
+export declare function resolveLocalNodeTool(tool: string, args: string[], workingDir: string, platform?: NodeJS.Platform, isAvailable?: (binary: string) => boolean): string[] | null;

package/dist/build/discovery.d.ts

@@ -1,4 +1,6 @@
 import { tool } from '@opencode-ai/plugin';
+import { detectProjectLanguages } from '../lang/detector';
+import { LANGUAGE_REGISTRY } from '../lang/profiles';
 import { bunSpawnSync } from '../utils/bun-compat';
 export interface BuildCommand {
     ecosystem: string;
@@ -8,10 +10,13 @@ export interface BuildCommand {
 }
 export interface BuildDiscoveryResult {
     commands: BuildCommand[];
-    skipped: {
-        ecosystem: string;
-        reason: string;
-    }[];
+    skipped: BuildDiscoverySkip[];
+}
+export interface BuildDiscoverySkip {
+    ecosystem: string;
+    reason: string;
+    code?: 'environment_unavailable';
+    required_commands?: string[];
 }
 export interface BuildDiscoveryOptions {
     scope?: 'changed' | 'all';
@@ -27,6 +32,8 @@ export declare const _internals: {
     discoverBuildCommands: typeof discoverBuildCommands;
     clearToolchainCache: typeof clearToolchainCache;
     getEcosystems: typeof getEcosystems;
+    detectProjectLanguagesImpl: typeof detectProjectLanguages;
+    getLanguageProfileImpl: typeof LANGUAGE_REGISTRY.get;
     spawnSyncImpl: typeof bunSpawnSync;
 };
 export declare function discoverBuildCommandsFromProfiles(workingDir: string): Promise<BuildDiscoveryResult>;

package/dist/cli/{coder-settlement-678ccmnf.js → coder-settlement-nayk1bbf.js}

@@ -13,27 +13,27 @@ import {
   releaseCoderDispatchOwnership,
   settleCoderDispatch,
   transferCoderSettlementToBackground
-} from "./index-dq93ar40.js";
+} from "./index-w9g58t3j.js";
 import"./index-3f7hqtgg.js";
 import"./index-awjx0wgk.js";
-import"./index-z0bxbb9g.js";
-import"./index-qc53dfzh.js";
+import"./index-t81fmfjj.js";
+import"./index-xy0e0r5f.js";
 import"./index-ddszzne4.js";
-import"./index-7h2armwf.js";
+import"./index-7619tk9a.js";
 import"./index-556ja8an.js";
 import"./index-dtn0pne5.js";
 import"./index-z6xqpmqg.js";
 import"./index-r3mvsbtq.js";
 import"./index-9e6fdz2h.js";
 import"./index-4rhhvd1a.js";
-import"./index-mmr96pwr.js";
+import"./index-k55td019.js";
 import"./index-c9zp4xwc.js";
 import"./index-zjygnfay.js";
-import"./index-7ezv5j23.js";
-import"./index-b5adxpy6.js";
+import"./index-d8st72j7.js";
+import"./index-nqbqkx4c.js";
 import"./index-dh5q6z7y.js";
 import"./index-ed5ykebp.js";
-import"./index-dke4wzkn.js";
+import"./index-fx3em0dr.js";
 import"./index-7g4c7s5r.js";
 import"./index-bpmtbmy9.js";
 import"./index-zgwm4ryv.js";

package/dist/cli/{config-doctor-fr8dfrt2.js → config-doctor-b1w7yvcs.js}

@@ -12,9 +12,9 @@ import {
   shouldRunOnStartup,
   writeBackupArtifact,
   writeDoctorArtifact
-} from "./index-f72612zc.js";
+} from "./index-h6wtxzvm.js";
 import"./index-z6xqpmqg.js";
-import"./index-7npz9n4s.js";
+import"./index-zkgrayya.js";
 import"./index-c9zp4xwc.js";
 import"./index-zjygnfay.js";
 import"./index-bk5tah7q.js";

package/dist/cli/{core-4j1hbhey.js → core-whesnhpf.js}

@@ -14,7 +14,7 @@ import {
   resolveWorktreeBaseDir,
   shortenWorktreePath,
   writeLaneProfileToDiskReal
-} from "./index-qc53dfzh.js";
+} from "./index-xy0e0r5f.js";
 import"./index-z6xqpmqg.js";
 import"./index-r3mvsbtq.js";
 import"./index-9e6fdz2h.js";

package/dist/cli/{curation-policy-47przjwg.js → curation-policy-ej9xc0cd.js}

@@ -4,14 +4,14 @@ import {
   authorizeCuration,
   buildConfigFingerprintInput,
   readCohortConfigFingerprint
-} from "./index-znf683sm.js";
+} from "./index-f5axf6vq.js";
 import"./index-rtry5xyf.js";
-import"./index-prv20xq6.js";
-import"./index-7ezv5j23.js";
-import"./index-b5adxpy6.js";
+import"./index-c6zyqgpq.js";
+import"./index-d8st72j7.js";
+import"./index-nqbqkx4c.js";
 import"./index-dh5q6z7y.js";
 import"./index-ed5ykebp.js";
-import"./index-dke4wzkn.js";
+import"./index-fx3em0dr.js";
 import"./index-7g4c7s5r.js";
 import"./index-bpmtbmy9.js";
 import"./index-zgwm4ryv.js";