opencode-swarm 7.183.1 → 7.184.1

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

@@ -159,8 +159,8 @@ export declare const DelegationLedgerHealthSchema: z.ZodObject<{
         pressurePct: z.ZodNumber;
         band: z.ZodEnum<{
             ok: "ok";
-            "compact-overdue": "compact-overdue";
             "fail-closed": "fail-closed";
+            "compact-overdue": "compact-overdue";
             nominal: "nominal";
         }>;
     }, z.core.$strict>;

package/dist/background/index.d.ts

@@ -17,6 +17,7 @@ export { createEvidenceSummaryIntegration, type EvidenceSummaryIntegrationConfig
 export { type AutomationFrameworkConfig, BackgroundAutomationManager, createAutomationManager, } from './manager';
 export { PlanSyncWorker, type PlanSyncWorkerOptions, type PlanSyncWorkerStatus, } from './plan-sync-worker';
 export { type PrEventSubscriberOptions, registerPrEventSubscribers, } from './pr-event-subscribers';
+export { dispatchPrFeedbackOversight, evaluatePrFeedbackCurrentHead, getPrFeedbackLoopRuntime, isPrFeedbackLoopEnabled, type PrFeedbackLoopOversightInput, type PrFeedbackLoopOversightOutcome, type PrFeedbackLoopRuntime, type PrFeedbackLoopRuntimeOptions, type PrFeedbackLoopRuntimeRegistration, registerPrFeedbackLoopRuntime, } from './pr-feedback-loop-runtime';
 export { PrMonitorWorker, type PrMonitorWorkerOptions, type PrMonitorWorkerStatus, } from './pr-monitor-worker';
 export { AutomationQueue, type QueueItem, type QueuePriority, type RetryMetadata, } from './queue';
 export { AutomationStatusArtifact, type AutomationStatusSnapshot, } from './status-artifact';

package/dist/background/pr-event-delivery.d.ts

@@ -7,9 +7,9 @@
  * prompt, instead of (or before) the passive advisory channel that only
  * surfaces on the session's next model turn.
  *
- * Registration: `src/index.ts` registers a module-level singleton with the
- * plugin SDK client when pr_monitor is enabled with prompt delivery, and
- * forwards `session.idle` events to `noteSessionIdle()`.
+ * Registration: `src/index.ts` registers one owner per canonical project root
+ * with the plugin SDK client when pr_monitor is enabled with prompt delivery,
+ * and forwards `session.idle` events to `noteSessionIdle()` with that root.
  *
  * Invariant 8 (session state — keyed and bounded): all per-session state is
  * keyed by sessionID in a bounded map (FIFO eviction beyond
@@ -24,8 +24,10 @@ import type { OpencodeClient } from '@opencode-ai/sdk';
 import type { PrMonitorConfig } from '../config/schema';
 import { activatePrWorkflow, readPrWorkflowGateState } from '../hooks/pr-workflow-gate';
 import { log } from '../utils';
+import { canonicalRootKeyFresh, canonicalRootKeyFreshAsync } from '../utils/canonical-root.js';
 import { withTimeout } from '../utils/timeout';
 import { claimPrFeedbackMonitorEvents, readPrFeedbackMonitorQueue } from './pr-feedback-event-queue.js';
+import { notifyPrFeedbackLoop } from './pr-feedback-loop.js';
 /** A single formatted PR event handed over by pr-event-subscribers. */
 export interface FormattedPrEvent {
     /** Automation event type, e.g. 'pr.ci.failed'. */
@@ -38,6 +40,8 @@ export interface FormattedPrEvent {
     message: string;
     /** `[pr-monitor:<type>:<repo>#<n>]` — used for queue dedup. */
     dedupToken: string;
+    /** Trusted mode marker produced by the subscriber for prompt delivery. */
+    modeSignal?: string;
     /** Lifecycle intake is durable but cannot enter the current workflow yet. */
     disposition?: 'queued-for-later';
 }
@@ -46,6 +50,9 @@ export interface PrEventDeliveryOptions {
     directory: string;
     config: PrMonitorConfig;
 }
+export type PrEventDeliveryRegistration = (() => void) & {
+    promote: () => Promise<void>;
+};
 /** Max sessions tracked at once; oldest-inserted evicted beyond this. */
 export declare const MAX_TRACKED_SESSIONS = 64;
 /** Max queued events per session; oldest dropped beyond this. */
@@ -53,15 +60,20 @@ export declare const MAX_QUEUED_EVENTS_PER_SESSION = 20;
 /** Deadline for the wake prompt call to be accepted by the SDK. */
 export declare const WAKE_PROMPT_TIMEOUT_MS = 15000;
 /**
- * Register the delivery singleton. Called from plugin init when
- * pr_monitor.enabled && event_delivery === 'prompt'. Idempotent — the last
- * registration wins.
+ * Register a delivery owner. Called from plugin init when
+ * pr_monitor.enabled && event_delivery === 'prompt'. A same-root re-init
+ * replaces only that root; different roots coexist. The returned cleanup is
+ * owner-guarded so stale disposal cannot remove a replacement.
+ */
+export declare function registerPrEventDelivery(options: PrEventDeliveryOptions): PrEventDeliveryRegistration;
+/**
+ * Unregister one owner. The no-argument form is retained for tests and
+ * process teardown; an owner token prevents a stale cleanup from removing a
+ * newer registration for the same canonical root.
  */
-export declare function registerPrEventDelivery(options: PrEventDeliveryOptions): void;
-/** Unregister and drop all per-session state (also used by tests). */
-export declare function unregisterPrEventDelivery(): void;
+export declare function unregisterPrEventDelivery(directory?: string, expectedOwnerToken?: string): void;
 /** Whether a wake deliverer is currently registered. */
-export declare function isPrEventDeliveryRegistered(): boolean;
+export declare function isPrEventDeliveryRegistered(directory?: string): boolean;
 /**
  * Deliver PR activity to a session. Returns true when the events were
  * accepted on the wake channel (prompted immediately, queued for the next
@@ -74,13 +86,13 @@ export declare function isPrEventDeliveryRegistered(): boolean;
  *
  * Never throws.
  */
-export declare function deliverPrActivity(sessionID: string, events: FormattedPrEvent[]): Promise<boolean>;
+export declare function deliverPrActivity(sessionID: string, events: FormattedPrEvent[], directory?: string): Promise<boolean>;
 /**
  * Called from the plugin `event` hook on `session.idle`. Marks the session
  * idle and flushes any queued events, coalescing them into ONE wake message.
  * No-op unless delivery is registered. Never throws.
  */
-export declare function noteSessionIdle(sessionID: string): void;
+export declare function noteSessionIdle(sessionID: string, directory?: string): Promise<void>;
 /**
  * Build the single-text-part wake message. Events are grouped per PR into
  * one `<pr-activity>` block each, followed by the standing instruction.
@@ -93,7 +105,7 @@ export declare function buildWakeMessage(events: FormattedPrEvent[]): string;
  * clients that lack it. Bounded by withTimeout; returns false on any
  * failure or timeout. Never throws.
  */
-declare function sendWakePrompt(sessionID: string, events: FormattedPrEvent[], messageID: string): Promise<boolean>;
+declare function sendWakePrompt(sessionID: string, events: FormattedPrEvent[], messageID: string, directory?: string): Promise<boolean>;
 export declare const _internals: {
     sendWakePrompt: typeof sendWakePrompt;
     withTimeout: typeof withTimeout;
@@ -101,13 +113,16 @@ export declare const _internals: {
     activatePrWorkflow: typeof activatePrWorkflow;
     readPrFeedbackMonitorQueue: typeof readPrFeedbackMonitorQueue;
     claimPrFeedbackMonitorEvents: typeof claimPrFeedbackMonitorEvents;
+    notifyPrFeedbackLoop: typeof notifyPrFeedbackLoop;
+    canonicalRootKeyFresh: typeof canonicalRootKeyFresh;
+    canonicalRootKeyFreshAsync: typeof canonicalRootKeyFreshAsync;
     wakePromptTimeoutMs: number;
     log: typeof log;
 };
 /** Test-only visibility into the bounded session map. */
 export declare function _getTrackedSessionCount(): number;
 /** Test-only visibility into a session's queue length / drop counter. */
-export declare function _getSessionQueueStats(sessionID: string): {
+export declare function _getSessionQueueStats(sessionID: string, directory?: string): {
     queued: number;
     dropped: number;
     busy: boolean;

package/dist/background/pr-event-subscribers.d.ts

@@ -24,13 +24,12 @@
  * are deduped by token inside the delivery queue.
  */
 import type { PrMonitorConfig } from '../config/schema';
-import { activatePrWorkflow, readPrWorkflowGateState } from '../hooks/pr-workflow-gate';
+import { readPrWorkflowGateState } from '../hooks/pr-workflow-gate';
 import { getAgentSession } from '../state';
 import { log } from '../utils';
 import { getGlobalEventBus } from './event-bus';
 import { deliverPrActivity, isPrEventDeliveryRegistered } from './pr-event-delivery';
-import { enqueuePrFeedbackMonitorEvent } from './pr-feedback-event-queue.js';
-import { notifyPrFeedbackLoop } from './pr-feedback-loop.js';
+import { enqueuePrFeedbackMonitorEventIfNotCancelled, notifyPrFeedbackLoop, readPrFeedbackLoopCancellation } from './pr-feedback-loop.js';
 import { listActive, updateSnapshot } from './pr-subscriptions';
 export interface PrEventSubscriberOptions {
     directory: string;
@@ -47,8 +46,8 @@ export declare const _internals: {
     updateSnapshot: typeof updateSnapshot;
     getAgentSession: typeof getAgentSession;
     readPrWorkflowGateState: typeof readPrWorkflowGateState;
-    activatePrWorkflow: typeof activatePrWorkflow;
-    enqueuePrFeedbackMonitorEvent: typeof enqueuePrFeedbackMonitorEvent;
+    readPrFeedbackLoopCancellation: typeof readPrFeedbackLoopCancellation;
+    enqueuePrFeedbackMonitorEvent: typeof enqueuePrFeedbackMonitorEventIfNotCancelled;
     notifyPrFeedbackLoop: typeof notifyPrFeedbackLoop;
     deliverPrActivity: typeof deliverPrActivity;
     isPrEventDeliveryRegistered: typeof isPrEventDeliveryRegistered;
@@ -77,6 +76,8 @@ interface PrEventPayload {
     reviewDecision?: string;
     /** pr.merge.conflict_resolved */
     mergeableState?: string;
+    /** Authenticated head observed by the monitor when it emitted the event. */
+    headRefOid?: string;
 }
 /**
  * Register subscribers on the global event bus for all gated PR event

package/dist/background/pr-feedback-event-queue.d.ts

@@ -9,7 +9,11 @@ export interface PrFeedbackMonitorEvent {
     dedupToken: string;
     authorized: boolean;
     queuedAt: string;
+    /** Head authenticated by the monitor when this event was emitted. */
+    headRefOid?: string;
     claimedWorkflowInstanceId?: string;
+    /** Exact process owner paired with the workflow instance id. */
+    claimedOwnerPid?: number;
     claimedAt?: string;
 }
 export interface PrFeedbackMonitorQueueRecord {
@@ -18,9 +22,9 @@ export interface PrFeedbackMonitorQueueRecord {
     sessionID: string;
     events: PrFeedbackMonitorEvent[];
 }
-export declare function enqueuePrFeedbackMonitorEvent(directory: string, sessionID: string, event: Omit<PrFeedbackMonitorEvent, 'claimedWorkflowInstanceId' | 'claimedAt'>): Promise<PrFeedbackMonitorQueueRecord>;
+export declare function enqueuePrFeedbackMonitorEvent(directory: string, sessionID: string, event: Omit<PrFeedbackMonitorEvent, 'claimedWorkflowInstanceId' | 'claimedAt' | 'claimedOwnerPid'>): Promise<PrFeedbackMonitorQueueRecord>;
 export declare function readPrFeedbackMonitorQueue(directory: string, sessionID: string): Promise<PrFeedbackMonitorQueueRecord | null>;
-export declare function claimPrFeedbackMonitorEvents(directory: string, sessionID: string, workflowInstanceId: string, prUrl: string, dedupTokens?: readonly string[]): Promise<PrFeedbackMonitorEvent[]>;
+export declare function claimPrFeedbackMonitorEvents(directory: string, sessionID: string, workflowInstanceId: string, prUrl: string, dedupTokens?: readonly string[], ownerPid?: number): Promise<PrFeedbackMonitorEvent[]>;
 /**
  * Remove queued events by dedup token (#2502 loop cancellation). Claimed but
  * unsettled events otherwise stay in the queue forever — a claim alone never
@@ -28,17 +32,30 @@ export declare function claimPrFeedbackMonitorEvents(directory: string, sessionI
  * every other write; returns the tokens actually removed.
  */
 export declare function clearPrFeedbackMonitorEvents(directory: string, sessionID: string, dedupTokens: readonly string[]): Promise<string[]>;
+/**
+ * Release one exact workflow-instance claim so a retryable pre-settlement
+ * admission failure does not strand the event. The token, workflow id, and
+ * owner PID are all required: a later worker must never be able to release
+ * another worker's claim (or an unrelated event with the same PR URL).
+ */
+export declare function releasePrFeedbackMonitorEventClaim(directory: string, sessionID: string, dedupToken: string, workflowInstanceId: string, ownerPid?: number): Promise<boolean>;
 export declare const _internals: {
     queueRelativePath: typeof queueRelativePath;
+    queueMetadataRelativePath: typeof queueMetadataRelativePath;
     queueLockRelativePath: typeof queueLockRelativePath;
     resetQueueCache: () => void;
     rename: typeof fsp.rename;
     nowMs: () => number;
     isProcessAlive: typeof isProcessAlive;
+    reclaimAbandonedQueueLock: typeof reclaimAbandonedQueueLock;
+    removeQueueLockIfOwned: typeof removeQueueLockIfOwned;
     beforeQueueFileOpen: (() => Promise<void>) | undefined;
     beforeQueueLockWrite: (() => Promise<void>) | undefined;
 };
+declare function reclaimAbandonedQueueLock(lockPath: string): Promise<boolean>;
+declare function removeQueueLockIfOwned(lockPath: string, ownerToken: string): Promise<boolean>;
 declare function isProcessAlive(pid: number): boolean;
 declare function queueRelativePath(sessionID: string): string;
+declare function queueMetadataRelativePath(sessionID: string): string;
 declare function queueLockRelativePath(sessionID: string): string;
 export {};

package/dist/background/pr-feedback-loop-runtime.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Production composition boundary for the opt-in PR feedback settling loop.
+ *
+ * The loop itself is deliberately independent of the OpenCode client and of
+ * plugin-instance state.  This module binds those dependencies to a canonical
+ * project root at plugin init and exposes only bounded, fail-closed adapters.
+ * Registration is synchronous and side-effect free: no filesystem, Git,
+ * network, agent discovery, or model work happens on the init path.
+ */
+import type { OpencodeClient } from '@opencode-ai/sdk';
+import type { PluginConfig } from '../config/schema.js';
+import { dispatchEphemeralAgent } from '../evaluation/ephemeral-agent-dispatcher.js';
+import { parseCriticResponseFields } from '../full-auto/critic-response-parser.js';
+import { getPRPollSnapshot } from '../git/pr.js';
+import { canonicalRootKeyFresh, canonicalRootKeyFreshAsync } from '../utils/canonical-root.js';
+import { log } from '../utils/logger.js';
+/** The input shape shared with `pr-feedback-loop` without a runtime import. */
+export interface PrFeedbackLoopOversightInput {
+    directory: string;
+    sessionID: string;
+    eventType: string;
+    actionClass: string;
+    repoFullName: string;
+    prNumber: number;
+    head: string | null;
+}
+export interface PrFeedbackLoopOversightOutcome {
+    dispatched: boolean;
+    verdict?: string;
+    decision?: string;
+}
+export type ResolveSessionAgent = (sessionID: string) => string | undefined;
+export interface PrFeedbackLoopRuntimeOptions {
+    client: OpencodeClient;
+    directory: string;
+    config: PluginConfig;
+    /** Exact names emitted by this plugin instance's agent factory. */
+    agentNames: readonly string[];
+    /** Resolves the current agent name from this plugin instance's session state. */
+    resolveSessionAgent: ResolveSessionAgent;
+}
+/**
+ * Return whether the autonomous PR feedback loop has all of its opt-in gates.
+ *
+ * Keep this policy in the runtime composition boundary so plugin init and the
+ * settling loop cannot drift into subtly different activation semantics.
+ */
+export declare function isPrFeedbackLoopEnabled(config: Pick<PluginConfig, 'pr_monitor' | 'pr_feedback_loop'>): boolean;
+export interface PrFeedbackLoopRuntime {
+    readonly directory: string;
+    evaluateCurrentHead(directory: string, repoFullName: string, prNumber: number): Promise<string | null>;
+    dispatchOversight(input: PrFeedbackLoopOversightInput): Promise<PrFeedbackLoopOversightOutcome>;
+}
+export type PrFeedbackLoopRuntimeRegistration = (() => void) & {
+    promote: () => Promise<void>;
+};
+/**
+ * Register a root-owned runtime and return an exact owner-guarded cleanup.
+ * Registration is intentionally synchronous and has no external side effects.
+ */
+export declare function registerPrFeedbackLoopRuntime(options: PrFeedbackLoopRuntimeOptions): PrFeedbackLoopRuntimeRegistration;
+/** Look up the runtime for the exact canonical root, or fail closed. */
+export declare function getPrFeedbackLoopRuntime(directory: string): PrFeedbackLoopRuntime | null;
+/** Adapter entry points for the settling loop's production seam. */
+export declare function evaluatePrFeedbackCurrentHead(directory: string, repoFullName: string, prNumber: number): Promise<string | null>;
+export declare function dispatchPrFeedbackOversight(input: PrFeedbackLoopOversightInput): Promise<PrFeedbackLoopOversightOutcome>;
+/** Test-only DI visibility; production behavior still uses these same calls. */
+export declare const _internals: {
+    getPRPollSnapshot: typeof getPRPollSnapshot;
+    dispatchEphemeralAgent: typeof dispatchEphemeralAgent;
+    parseCriticResponseFields: typeof parseCriticResponseFields;
+    canonicalRootKeyFresh: typeof canonicalRootKeyFresh;
+    canonicalRootKeyFreshAsync: typeof canonicalRootKeyFreshAsync;
+    log: typeof log;
+};

package/dist/background/pr-feedback-loop.d.ts

@@ -1,5 +1,8 @@
 import { type PrFeedbackMonitorEvent } from './pr-feedback-event-queue';
+import { listActive } from './pr-subscriptions';
 export declare const PR_FEEDBACK_LOOP_STATE_REL: string;
+export declare const MAX_IN_FLIGHT_SESSIONS = 64;
+export declare const MAX_CANCELLATION_REQUESTS = 64;
 export interface PrFeedbackLoopClassification {
     type: string;
     actionClass: string;
@@ -51,20 +54,40 @@ export interface PrFeedbackLoopResult {
     action: PrFeedbackLoopAction | null;
     terminal: PrFeedbackLoopTerminal | null;
 }
+/**
+ * Durable cancellation state exposed to the PR-event intake boundary.
+ *
+ * A read failure is deliberately distinct from "not cancelled": callers that
+ * can create new queue work must fail closed when the stop barrier cannot be
+ * read reliably.
+ */
+export interface PrFeedbackLoopCancellationStatus {
+    cancelled: boolean;
+    unavailable: boolean;
+    reason?: string;
+}
 interface CircuitState {
     failures: number;
     openUntil: number;
     halfOpenProbes: number;
+    halfOpenProbeStartedAt?: number;
+    halfOpenProbeOwnerToken?: string;
+    halfOpenProbeOwnerPid?: number;
 }
 interface InFlightClaim {
     dedupToken: string;
+    workflowInstanceId: string;
+    ownerPid: number;
     actionClass: string;
     head: string | null;
     performed: boolean;
     attempts: number;
     claimedAt: string;
+    actionStartedAt?: number;
 }
 interface CorrelationState {
+    /** Monotonic per-correlation CAS fence; legacy records normalize to zero. */
+    revision: number;
     sessionID: string;
     repoFullName: string;
     prNumber: number;
@@ -84,7 +107,7 @@ interface LoopStateV1 {
      * when the session has no prior settlement correlation). */
     sessionTerminals: Record<string, PrFeedbackLoopTerminal>;
 }
-export type EvaluateCurrentHead = (repoFullName: string, prNumber: number) => Promise<string | null>;
+export type EvaluateCurrentHead = (directory: string, repoFullName: string, prNumber: number) => Promise<string | null>;
 export type DispatchOversightInput = {
     directory: string;
     sessionID: string;
@@ -122,7 +145,29 @@ export declare const _internals: {
         corrupt: true;
     }>;
     writeState: (directory: string, state: LoopStateV1) => Promise<void>;
+    listActive: typeof listActive;
+    isProcessAlive: (pid: number) => boolean;
+    beforeLoopStateLockWrite?: () => Promise<void>;
+    resetLoopStateLock: () => void;
+    loopStateLockRelativePath: () => string;
+    reclaimAbandonedLoopStateLock: (lockPath: string) => Promise<boolean>;
+    removeLoopStateLockIfOwned: (lockPath: string, ownerToken: string) => Promise<boolean>;
 };
+/** Restore the production dependency bindings after a DI-seam test. */
+export declare function resetLoopInternalsForTests(): void;
+/**
+ * Read the current cancellation barrier before admitting new monitor work.
+ * This includes an in-process cancellation request while it is being durably
+ * recorded, and the session terminal persisted by a completed cancellation.
+ */
+export declare function readPrFeedbackLoopCancellation(directory: string, sessionID: string): Promise<PrFeedbackLoopCancellationStatus>;
+/**
+ * Admit a new monitor event while holding the loop-state lock. Cancellation
+ * persists its stop barrier under this same lock before it clears the queue;
+ * keeping the check and enqueue in the loop → queue order prevents a stop
+ * from racing between the check and a queue write after cleanup.
+ */
+export declare function enqueuePrFeedbackMonitorEventIfNotCancelled(directory: string, sessionID: string, event: Omit<PrFeedbackMonitorEvent, 'claimedWorkflowInstanceId' | 'claimedAt' | 'claimedOwnerPid'>): Promise<boolean>;
 /**
  * Process ONE queued monitor event end-to-end for the session (the #2502
  * completion-fixture unit): claim → classify → authorize → oversight → act →
@@ -147,16 +192,6 @@ export declare function cancelPrFeedbackLoop(directory: string, sessionID: strin
         clearedEvents: string[];
     };
 }>;
-/**
- * Bounded post-cycle tick (#2502 M7). Settlement today is driven entirely by
- * the per-session notify hook (handlePrEvent → notifyPrFeedbackLoop, which is
- * itself withTimeout-bounded per settlement); the queue store exposes no
- * session enumeration yet, so a cross-session sweep has nothing to iterate.
- * When enumeration lands, this becomes the bounded sweep (at most
- * TICK_SETTLEMENT_CAP settlements per poll cycle IN TOTAL); until then it is
- * an honest no-op that reports zero settlements.
- */
-export declare function tickPrFeedbackLoop(_directory: string): Promise<number>;
 /** Notify hook for pr-event-subscribers: fire-and-forget, fail-open. */
-export declare function notifyPrFeedbackLoop(directory: string, sessionID: string): void;
+export declare function notifyPrFeedbackLoop(directory: string, sessionID: string): Promise<void>;
 export {};

package/dist/cli/{coder-settlement-rserb0hm.js → coder-settlement-yvpewr52.js}

@@ -6,6 +6,7 @@ import {
   assertNoUnsettledCoderDispatch,
   beginCoderSettlement,
   completeCoderSettlementCleanup,
+  hasUnattributedEmptyScopeMutation,
   listCoderSettlementWalStates,
   recordCoderMergeProvenance,
   recoverCoderSettlement,
@@ -13,22 +14,23 @@ import {
   releaseCoderDispatchOwnership,
   settleCoderDispatch,
   transferCoderSettlementToBackground
-} from "./index-y5hhkx1n.js";
-import"./index-6h81yvyc.js";
-import"./index-0bpr8vag.js";
-import"./index-908k7jhw.js";
-import"./index-raws06d3.js";
-import"./index-nmh0s6dg.js";
+} from "./index-5ppx86w1.js";
+import"./index-131ay7x1.js";
+import"./index-3n5zsp31.js";
+import"./index-depfky1j.js";
+import"./index-2c91cxdv.js";
+import"./index-wy3zpwjy.js";
 import"./index-2s7dvzff.js";
-import"./index-wpn7ftw1.js";
-import"./index-77650pyg.js";
-import"./index-dg3f2sqq.js";
-import"./index-tt705bap.js";
-import"./index-1xnse449.js";
+import"./index-jvk95e6y.js";
+import"./index-zzvxj02e.js";
+import"./index-xf69xty9.js";
+import"./index-t7hmqgjy.js";
+import"./index-x1gyqgze.js";
+import"./index-mc72pk74.js";
 import"./index-c1ggtmpm.js";
 import"./index-ejhxgyvm.js";
 import"./index-7g4c7s5r.js";
-import"./index-5cve9g2b.js";
+import"./index-k53a69vb.js";
 import"./index-zxdawwc7.js";
 import"./index-wzec3c4g.js";
 import"./index-gknz3bv1.js";
@@ -44,6 +46,7 @@ export {
   recoverCoderSettlement,
   recordCoderMergeProvenance,
   listCoderSettlementWalStates,
+  hasUnattributedEmptyScopeMutation,
   completeCoderSettlementCleanup,
   beginCoderSettlement,
   assertNoUnsettledCoderDispatch,

package/dist/cli/{config-doctor-r4fmzprn.js → config-doctor-qgwpvrbz.js}

@@ -1,5 +1,7 @@
 // @bun
 import {
+  CURRENT_CONFIG_FORMAT_VERSION,
+  DEFAULT_FLIPS,
   LEAN_TURBO_GATE_PRODUCERS,
   applySafeAutoFixes,
   collectLeanTurboGateSatisfiabilityFindings,
@@ -14,11 +16,11 @@ import {
   shouldRunOnStartup,
   writeBackupArtifact,
   writeDoctorArtifact
-} from "./index-31e105jf.js";
+} from "./index-046psajf.js";
 import"./index-6b295cas.js";
 import"./index-ry16d01s.js";
 import"./index-c1ggtmpm.js";
-import"./index-rhw6m7s9.js";
+import"./index-0874kghs.js";
 import"./index-wzec3c4g.js";
 import"./index-bk5tah7q.js";
 import"./index-gknz3bv1.js";
@@ -39,5 +41,7 @@ export {
   createConfigBackup,
   collectLeanTurboGateSatisfiabilityFindings,
   applySafeAutoFixes,
-  LEAN_TURBO_GATE_PRODUCERS
+  LEAN_TURBO_GATE_PRODUCERS,
+  DEFAULT_FLIPS,
+  CURRENT_CONFIG_FORMAT_VERSION
 };

package/dist/cli/{core-rzek3e2n.js → core-9qt388hq.js}

@@ -14,12 +14,12 @@ import {
   resolveWorktreeBaseDir,
   shortenWorktreePath,
   writeLaneProfileToDiskReal
-} from "./index-raws06d3.js";
-import"./index-nmh0s6dg.js";
+} from "./index-2c91cxdv.js";
+import"./index-wy3zpwjy.js";
 import"./index-2s7dvzff.js";
-import"./index-1xnse449.js";
+import"./index-mc72pk74.js";
 import"./index-c1ggtmpm.js";
-import"./index-5cve9g2b.js";
+import"./index-k53a69vb.js";
 import"./index-zxdawwc7.js";
 import"./index-wzec3c4g.js";
 import"./index-zpsr8rpc.js";

package/dist/cli/{curation-policy-g0jjwrg5.js → curation-policy-49f8jx48.js}

@@ -5,17 +5,18 @@ import {
   authorizeCuration,
   buildConfigFingerprintInput,
   readCohortConfigFingerprint
-} from "./index-5t08vc6m.js";
+} from "./index-earq3mda.js";
 import"./index-rtry5xyf.js";
 import"./index-vzm6zre7.js";
-import"./index-hb1zqz50.js";
-import"./index-dg3f2sqq.js";
-import"./index-tt705bap.js";
-import"./index-1xnse449.js";
+import"./index-475bkab8.js";
+import"./index-xf69xty9.js";
+import"./index-t7hmqgjy.js";
+import"./index-x1gyqgze.js";
+import"./index-mc72pk74.js";
 import"./index-c1ggtmpm.js";
 import"./index-ejhxgyvm.js";
 import"./index-7g4c7s5r.js";
-import"./index-5cve9g2b.js";
+import"./index-k53a69vb.js";
 import"./index-gknz3bv1.js";
 import"./index-zpsr8rpc.js";
 import"./index-zgwm4ryv.js";

package/dist/cli/{curator-drift-a0r5krfx.js → curator-drift-wf0sm2te.js}

@@ -5,23 +5,23 @@ import {
   readPriorDriftReports,
   runDeterministicDriftCheck,
   writeDriftReport
-} from "./index-1hnknn34.js";
-import"./index-4xr4gtwd.js";
-import"./index-8me6m6ew.js";
-import"./index-nmh0s6dg.js";
+} from "./index-yk0r42nr.js";
+import"./index-7p4ym4q3.js";
+import"./index-76abqm8d.js";
+import"./index-wy3zpwjy.js";
 import"./index-2s7dvzff.js";
 import"./index-0725jpp7.js";
-import"./index-08x7gsnf.js";
+import"./index-w9hxzcz4.js";
 import"./index-rdm3px0g.js";
 import"./index-ry16d01s.js";
-import"./index-1xnse449.js";
+import"./index-mc72pk74.js";
 import"./index-c1ggtmpm.js";
 import"./index-ejhxgyvm.js";
 import"./index-7g4c7s5r.js";
-import"./index-5cve9g2b.js";
-import"./index-80qhm8aq.js";
+import"./index-k53a69vb.js";
+import"./index-49ptc9xx.js";
 import"./index-zxdawwc7.js";
-import"./index-rhw6m7s9.js";
+import"./index-0874kghs.js";
 import"./index-wzec3c4g.js";
 import"./index-bk5tah7q.js";
 import"./index-gknz3bv1.js";