opencode-swarm 7.160.2 → 7.161.1

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

@@ -50,7 +50,8 @@ Caveat: this assumption breaks if the plan lacks a `plan_critic_gate`-tagged app
 
 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.
+- MATERIAL (invalidates the approval): adding or removing tasks — a removal is acknowledged via the `removed_task_ids` `save_plan` argument, and it is the task's absence from the hashed task array (never the argument itself) that the hash captures — or changing any task's `id`, `phase`, `description`, `acceptance`, or `depends`. 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.
+- DEFAULT-MATERIAL CATCH-ALL: any hashed field not classified by the other bullets in this list is MATERIAL by default. `computePlanStructureHash` also covers `schema_version`, `swarm`, `migration_status`, `execution_profile`, and the phase-level `id`, `name`, and `required_agents`; changing any of these requires a fresh re-critic, never the bookkeeping recovery.
 - `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.

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

@@ -67,7 +67,7 @@ All other gates: failure → return to coder. No self-fixes. No workarounds.
     -> PREFLIGHT CHECKLIST: Before first coder delegation, answer "SAST baseline captured before first coder delegation? yes/no/disabled/error". If the answer is no, do not delegate to coder; run 5b-BASE first. If disabled or error, record the exact tool result.
 5b. the active swarm's coder agent - Implement (if designer scaffold produced, include it as INPUT).
     → REQUIRED: The coder Task dispatch MUST contain a literal `ACCEPTANCE:` line — resolve per ACCEPTANCE FIELD RESOLUTION in your system prompt (list the mapped FR/SC ids when fr_refs is non-empty — the delegation gate injects their verbatim spec.md text automatically — otherwise a one-line task-derived DONE restatement). A missing line is BLOCKED by ACCEPTANCE_FIELD_REQUIRED before the coder runs. Do NOT confuse the plan-task `acceptance` field with this per-dispatch header — both are required.
-    → If this dispatch fails with `PLAN_CRITIC_GATE_VIOLATION`: the plan has no current critic-approved snapshot (commonly a plan approved before this mechanical gate existed). Do NOT retry the coder dispatch as-is — re-run MODE: CRITIC-GATE to get a fresh critic `APPROVED` verdict, then retry this step.
+    → If this dispatch fails with `PLAN_CRITIC_GATE_VIOLATION`: the plan has no current critic-approved snapshot (commonly a plan approved before this mechanical gate existed). Do NOT retry the coder dispatch as-is — re-run MODE: CRITIC-GATE to get a fresh critic `APPROVED` verdict, then retry this step. Exception: if the mismatch was caused by a bookkeeping-grade hashed-field repair covered by the critic-gate PLAN FREEZE rule (typically a `files_touched`-only scope reconciliation), that rule's `approve_plan_critic` recovery with a truthful reason replaces the full re-critic; any substantive change still requires the fresh re-critic above.
 5b-bis. **CODER OUTPUT VERIFICATION**: After the coder reports completion, do NOT accept the self-report alone. Run `diff` (step 5c) and inspect at least one of the modified files yourself to confirm the change exists. The coder may report DONE without having produced any diff. A 30-second read of the changed file(s) catches this failure mode. This is NOT a separate explorer dispatch — the existing `diff` tool at step 5c is the verification mechanism; the key discipline is checking that `diff` returns actual changes before proceeding, rather than forwarding the coder's self-report to the next gate.
 5c. Run `diff` tool. If `hasContractChanges` → the active swarm's explorer agent integration analysis. If COMPATIBILITY SIGNALS=INCOMPATIBLE or MIGRATION_SURFACE=yes → coder retry. If COMPATIBILITY SIGNALS=COMPATIBLE and MIGRATION_SURFACE=no → proceed.
     → REQUIRED: Print "diff: [PASS | CONTRACT CHANGE — details]"

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/cli/{coder-settlement-gzar5ypz.js → coder-settlement-2jteb5vy.js}

@@ -13,27 +13,27 @@ import {
   releaseCoderDispatchOwnership,
   settleCoderDispatch,
   transferCoderSettlementToBackground
-} from "./index-4d8cq6e1.js";
+} from "./index-qd9mrd7e.js";
 import"./index-3f7hqtgg.js";
 import"./index-awjx0wgk.js";
-import"./index-4dcz9fpn.js";
-import"./index-kqzba6ex.js";
+import"./index-32avgbyq.js";
+import"./index-c1geyan9.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-c9zp4xwc.js";
+import"./index-k55td019.js";
+import"./index-9xd073d4.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-ancn1sj7.js → config-doctor-1yn317qf.js}

@@ -12,10 +12,10 @@ import {
   shouldRunOnStartup,
   writeBackupArtifact,
   writeDoctorArtifact
-} from "./index-xtwny1ae.js";
+} from "./index-bn78ywnb.js";
 import"./index-z6xqpmqg.js";
-import"./index-6scakreq.js";
-import"./index-c9zp4xwc.js";
+import"./index-rracnf2y.js";
+import"./index-9xd073d4.js";
 import"./index-zjygnfay.js";
 import"./index-bk5tah7q.js";
 import"./index-bpmtbmy9.js";

package/dist/cli/{core-bhmqtxev.js → core-k687jrr3.js}

@@ -14,12 +14,12 @@ import {
   resolveWorktreeBaseDir,
   shortenWorktreePath,
   writeLaneProfileToDiskReal
-} from "./index-kqzba6ex.js";
+} from "./index-c1geyan9.js";
 import"./index-z6xqpmqg.js";
 import"./index-r3mvsbtq.js";
 import"./index-9e6fdz2h.js";
 import"./index-4rhhvd1a.js";
-import"./index-c9zp4xwc.js";
+import"./index-9xd073d4.js";
 import"./index-zjygnfay.js";
 import"./index-zgwm4ryv.js";
 import"./index-a76rekgs.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";

package/dist/cli/{curator-llm-factory-6mw01jx1.js → curator-llm-factory-m1ke17eq.js}

@@ -1,63 +1,63 @@
 // @bun
 import {
   createCuratorLLMDelegate
-} from "./index-s7w6ntw6.js";
-import"./index-j3ss86kf.js";
-import"./index-2123hwbj.js";
-import"./index-xtwny1ae.js";
-import"./index-zbnf26br.js";
-import"./index-nk498mx6.js";
+} from "./index-cs9w1hfs.js";
+import"./index-s33ee2w3.js";
+import"./index-29f9te70.js";
+import"./index-bn78ywnb.js";
+import"./index-7d79mj06.js";
+import"./index-dq41vsf9.js";
 import"./index-txdagbh7.js";
 import"./index-134d35c1.js";
 import"./index-3146wmgv.js";
-import"./index-re338hf1.js";
-import"./index-5xfx5sbw.js";
-import"./index-am5bz6mf.js";
+import"./index-yhadrxka.js";
+import"./index-zhdfqz89.js";
+import"./index-88wb0z9r.js";
 import"./index-70ha9e09.js";
 import"./index-c8s9a3zh.js";
 import"./index-9ss2m4rs.js";
-import"./index-497a3hhj.js";
+import"./index-y14mwbk8.js";
 import"./index-zsrtt42s.js";
-import"./index-4d8cq6e1.js";
+import"./index-qd9mrd7e.js";
 import"./index-3f7hqtgg.js";
 import"./index-awjx0wgk.js";
-import"./index-yp81ebrx.js";
-import"./index-znf683sm.js";
+import"./index-nm0cpfrv.js";
+import"./index-f5axf6vq.js";
 import"./index-rtry5xyf.js";
-import"./index-4dcz9fpn.js";
-import"./index-kqzba6ex.js";
-import"./index-k50kxd3w.js";
+import"./index-32avgbyq.js";
+import"./index-c1geyan9.js";
+import"./index-za42r41w.js";
 import"./index-ddszzne4.js";
-import"./index-xsd7y4hp.js";
-import"./index-5th50g17.js";
-import"./index-7h2armwf.js";
+import"./index-4p6x3xxy.js";
+import"./index-hq57ytm5.js";
+import"./index-7619tk9a.js";
 import"./index-556ja8an.js";
 import"./index-4fwbbad3.js";
 import"./index-b43rt5ph.js";
 import"./index-q7sjgr1y.js";
-import"./index-war2dt6a.js";
-import"./index-3a35tt6a.js";
-import"./index-xkmzsfg5.js";
-import"./index-q8hm27yj.js";
+import"./index-cbcfpgz9.js";
+import"./index-hvfsz7e3.js";
+import"./index-jm21vbyp.js";
+import"./index-zg9d392c.js";
 import"./index-n832052r.js";
 import"./index-dtn0pne5.js";
 import"./index-z6xqpmqg.js";
 import"./index-r3mvsbtq.js";
-import"./index-717pmdce.js";
-import"./index-6scakreq.js";
+import"./index-epjvntnm.js";
+import"./index-rracnf2y.js";
 import"./index-9e6fdz2h.js";
 import"./index-4rhhvd1a.js";
-import"./index-mmr96pwr.js";
-import"./index-c9zp4xwc.js";
+import"./index-k55td019.js";
+import"./index-9xd073d4.js";
 import"./index-zjygnfay.js";
 import"./index-ae75rja9.js";
-import"./index-prv20xq6.js";
-import"./index-7ezv5j23.js";
+import"./index-c6zyqgpq.js";
+import"./index-d8st72j7.js";
 import"./index-bk5tah7q.js";
-import"./index-b5adxpy6.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";