opencode-swarm 7.139.3 → 7.139.4

package/dist/prm/escalation.d.ts

@@ -3,6 +3,30 @@
  * Implements a 3-strike protocol for pattern detection escalation
  */
 import type { CourseCorrection, EscalationState, PatternMatch } from './types';
+/**
+ * Resolves the LADDER key for a match — the identity whose 1→2→3 strike count
+ * this detection belongs to (issue #2134 follow-up).
+ *
+ * The ladder used to be keyed by pattern TYPE alone, so unrelated occurrences
+ * accumulated into one count: a coder that read-then-re-read three different
+ * files produced three `repetition_loop` strikes on three different targets and
+ * hit the hard stop, even though it had not repeated itself even twice on any
+ * one of them. "Three strikes" has to mean "the same behaviour three times".
+ *
+ * A pattern reporting exactly ONE affected target gets a per-target ladder —
+ * `repetition_loop`, `ping_pong` and `stuck_on_test` all name the single file or
+ * target they are about, so that target IS the behaviour's identity.
+ *
+ * A pattern reporting a SET of targets keeps the per-pattern-type ladder.
+ * `context_thrash` and `expansion_drift` describe one ongoing episode over a
+ * growing collection of targets; keying those by target would mint a fresh
+ * ladder on every tool call and they could never escalate at all — the exact
+ * fail-open shape that the per-detector containment review caught the first time.
+ *
+ * Agents are deliberately not in the key. Escalation is about the work, not who
+ * did it, and `ping_pong` names two agents by construction.
+ */
+export declare function resolveLadderKey(match: PatternMatch): string;
 /**
  * Creates a default EscalationState with all counters reset and flags cleared.
  * Exported for testing purposes.
@@ -48,6 +72,16 @@ export declare class EscalationTracker {
      * @returns The current EscalationState copy
      */
     getState(): EscalationState;
+    /**
+     * Returns a defensive copy of just the ladder counts (issue #2134 follow-up).
+     *
+     * `src/prm/index.ts` mirrors these onto the session after every strike so a
+     * tracker rebuilt mid-session restores the same keyspace it counts in. Using
+     * `getState()` there deep-cloned the whole state — including `stepRange`,
+     * `affectedAgents` and `affectedTargets` of the last match — on the
+     * per-tool-call hot path, for one field.
+     */
+    getLadderCounts(): Map<string, number>;
     /**
      * Resets all escalation counts and flags to their default values.
      * Clears pattern counts and all flags.

package/dist/prm/index.d.ts

@@ -13,8 +13,8 @@
  * while PRM provides deeper multi-pattern detection and escalation.
  */
 export { formatCourseCorrectionForInjection, generateCourseCorrection, } from './course-correction';
-export { createDefaultEscalationState, EscalationTracker } from './escalation';
-export { detectContextThrash, detectExpansionDrift, detectPatterns, detectPingPong, detectRepetitionLoop, detectStuckOnTest, } from './pattern-detector';
+export { createDefaultEscalationState, EscalationTracker, resolveLadderKey, } from './escalation';
+export { detectContextThrash, detectExpansionDrift, detectPatterns, detectPingPong, detectRepetitionLoop, detectStuckOnTest, resolvePatternThreshold, } from './pattern-detector';
 export type { CourseCorrection, EscalationState, PatternDetectionResult, PatternMatch, PatternSeverity, PatternType, PrmConfig, TaxonomyCategory, TrajectoryEntry, } from './types';
 import type { LearningConfig } from '../config/schema.js';
 import { appendInsightCandidates } from '../hooks/micro-reflector.js';
@@ -78,6 +78,10 @@ interface ResettablePrmSessionState {
     prmHardStopInjectPending?: boolean;
     prmTrajectoryStep?: number;
     prmInjectedAdvisoryKeys?: Set<string>;
+    /** Issue #2134 — episode ledger; reset with the trajectory cursor it indexes. */
+    prmStruckEpisodes?: Map<string, number>;
+    /** Issue #2134 follow-up — ladder counts; reset with the ledger. */
+    prmLadderCounts?: Map<string, number>;
     replayArtifactPath?: string | null;
 }
 export declare function resetPrmSessionState(session: ResettablePrmSessionState, sessionId?: string): void;

package/dist/prm/pattern-detector.d.ts

@@ -2,7 +2,7 @@
  * PRM Pattern Detector
  * Rule-based pattern detection for trajectory analysis
  */
-import type { PatternDetectionResult, PatternMatch, PrmConfig, TrajectoryEntry } from './types';
+import type { PatternDetectionResult, PatternMatch, PatternType, PrmConfig, TrajectoryEntry } from './types';
 /**
  * Sanitize a string to prevent prompt injection attacks.
  * Removes newlines, carriage returns, backticks, and common injection patterns.
@@ -12,6 +12,27 @@ import type { PatternDetectionResult, PatternMatch, PrmConfig, TrajectoryEntry }
  * @returns Sanitized string safe for embedding in prompts
  */
 export declare function sanitizeString(input: string): string;
+/**
+ * Resolves the configured occurrence threshold for a pattern type, falling back
+ * to the built-in default.
+ *
+ * Exported for the escalation ladder (issue #2134): the ladder re-strikes a
+ * still-running episode once it has grown by another threshold's worth of
+ * occurrences, so it must resolve the threshold exactly the way the detectors do
+ * or the two layers disagree about what "another occurrence" means.
+ *
+ * The threshold is NOT in a single unit across detectors, and the ladder does not
+ * pretend otherwise — it is repeats for `repetition_loop`, run length for
+ * `context_thrash`, cycle count for `stuck_on_test`, alternating-entry count for
+ * `ping_pong` (whose `occurrenceCount` is ROUND TRIPS, i.e. half that unit, so it
+ * re-strikes at twice the nominal spacing), and a growth RATIO for
+ * `expansion_drift` (whose `occurrenceCount` is a float near 1.5–3.0, so the
+ * growth ground is effectively inert for it and its re-strikes come from the
+ * new-episode ground instead — its comparison window steps by `windowSize`, so
+ * its episode start step genuinely advances). Every one of the five is verified
+ * to still reach a hard stop; see `src/prm/__tests__/issue-2134-episode-gate.test.ts`.
+ */
+export declare function resolvePatternThreshold(config: PrmConfig, pattern: PatternType): number;
 /**
  * Detect repetition_loop pattern
  * Same agent targets same file with same action within N steps

package/dist/prm/types.d.ts

@@ -107,8 +107,18 @@ export interface PrmConfig {
  * Per-session escalation tracking state
  */
 export interface EscalationState {
-    /** Pattern type to detection count mapping */
-    patternCounts: Map<PatternType, number>;
+    /**
+     * Ladder identity to strike-count mapping.
+     *
+     * Keyed by `resolveLadderKey(match)` (issue #2134 follow-up), NOT by pattern
+     * type: `pattern|target` for a single-target pattern, bare `pattern` for one
+     * reporting a growing target set. Keying the ladder by pattern type alone let
+     * unrelated occurrences on different files accumulate into a hard stop.
+     *
+     * Distinct from `AgentSessionState.prmPatternCounts`, which stays keyed by
+     * pattern type as the observable per-pattern tally.
+     */
+    patternCounts: Map<string, number>;
     /** Current escalation level (0=none, 1=guidance, 2=strong guidance, 3=hard stop) */
     escalationLevel: number;
     /** Last pattern detected (if any) */

package/dist/state.d.ts

@@ -414,6 +414,55 @@ export interface AgentSessionState {
      * fields, and this one is additive.
      */
     prmHardStopInjectPending?: boolean;
+    /**
+     * Issue #2134 — episode ledger for the escalation ladder.
+     *
+     * Maps an episode key (`patternType|startStep`) to the occurrence count that
+     * episode had when it last recorded a strike. A detector re-emits the SAME
+     * ongoing episode on every tool call with a growing `stepRange[1]` (a coder
+     * reading more files extends one `context_thrash` run), and the trajectory
+     * cursor cannot suppress that because the episode's end step always advances
+     * past it. Counting each re-emission as a fresh strike walked ONE ordinary
+     * episode from level 1 to level 3 in three tool calls and wedged healthy coder
+     * sessions behind a hard stop.
+     *
+     * A match strikes when its episode is new, or when that episode has gained
+     * another full threshold's worth of occurrences since it last struck. Both
+     * rungs are needed: three of the five detectors never advance an episode's
+     * start step while it runs, so without the growth rung they would strike
+     * exactly once and could never reach level 2 or 3. See the EPISODE GATE
+     * comment in `src/prm/index.ts` for the per-detector derivation.
+     *
+     * Optional for the same reason as `prmHardStopInjectPending`: ~25 existing
+     * test/session literals enumerate the required PRM fields, and this is additive.
+     */
+    prmStruckEpisodes?: Map<string, number>;
+    /**
+     * Issue #2134 follow-up — mirror of the escalation tracker's LADDER counts,
+     * keyed by `resolveLadderKey(match)` (`pattern|target`, or bare `pattern` for
+     * a pattern reporting a growing target set).
+     *
+     * Deliberately separate from `prmPatternCounts`, which stays keyed by pattern
+     * type as the observable per-pattern tally that telemetry and tests read. The
+     * two are different keyspaces and must not be conflated: the tracker-rebuild
+     * path below used to seed itself from `prmPatternCounts`, which would now
+     * hand pattern-type keys to a ladder that counts by target and silently
+     * mis-restore every count.
+     */
+    prmLadderCounts?: Map<string, number>;
+    /**
+     * Issue #2134 — dispatch identity of the delegation whose start already reset
+     * this session's PRM state. Holds the Task tool `callID`, which is unique per
+     * dispatch.
+     *
+     * The reset hook (`delegationGateHooks.taskMetadata`) is driven by
+     * `message.part.updated`, which fires repeatedly for the SAME Task part as the
+     * child runs. An unguarded reset there would clear the escalation ladder on
+     * every part update and disarm PRM permanently — a fail-open far worse than
+     * the wedge it is meant to prevent. Comparing against this field makes the
+     * reset exactly once per dispatch.
+     */
+    prmDelegationCallId?: string;
     /** Per-session escalation tracker instance (set lazily by PRM hook) */
     prmEscalationTracker?: EscalationTracker;
     /** Cross-turn set of already-injected PRM advisory dedupe keys

package/dist/summaries/schema.d.ts

@@ -22,8 +22,8 @@ export declare const MAX_LIST_ITEMS = 5;
 /** Verdict vocabulary — mirrors the phase-council gate (APPROVE | CONCERNS | REJECT). */
 export declare const SupervisorVerdictSchema: z.ZodEnum<{
     APPROVE: "APPROVE";
-    CONCERNS: "CONCERNS";
     REJECT: "REJECT";
+    CONCERNS: "CONCERNS";
 }>;
 export type SupervisorVerdict = z.infer<typeof SupervisorVerdictSchema>;
 /** Count whitespace-delimited words in a string. */
@@ -130,8 +130,8 @@ export declare const ArchitectureSupervisorReportSchema: z.ZodObject<{
     phase: z.ZodNumber;
     verdict: z.ZodEnum<{
         APPROVE: "APPROVE";
-        CONCERNS: "CONCERNS";
         REJECT: "REJECT";
+        CONCERNS: "CONCERNS";
     }>;
     findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
         severity: z.ZodEnum<{

package/dist/tools/convene-council.d.ts

@@ -15,8 +15,8 @@ export declare const ArgsSchema: z.ZodObject<{
         }>;
         verdict: z.ZodEnum<{
             APPROVE: "APPROVE";
-            CONCERNS: "CONCERNS";
             REJECT: "REJECT";
+            CONCERNS: "CONCERNS";
         }>;
         confidence: z.ZodNumber;
         findings: z.ZodArray<z.ZodObject<{

package/dist/tools/pre-check-batch.d.ts

@@ -83,6 +83,10 @@ export interface PreCheckBatchResult {
  * field and replace optional payloads with bounded, UTF-8-safe summaries.
  */
 declare function serializePreCheckResult(result: PreCheckBatchResult): string;
+declare function isAcceptedProjectRootForPlatform(dir: string, workspaceDir: string, platform: NodeJS.Platform, hasExplicitBoundary: boolean): boolean;
+export declare const _test_exports: {
+    isAcceptedProjectRootForPlatform: typeof isAcceptedProjectRootForPlatform;
+};
 /**
  * Run a function with timeout
  */

package/dist/tools/resolve-working-directory.d.ts

@@ -23,10 +23,10 @@ export interface ResolveError {
  *
  * NOTE: This function intentionally does NOT use realpathSync for the resolved path
  * to avoid Windows 8.3 short filename issues. Symlink-based subdirectory bypasses
- * through this coarse filter are caught by the write-time validateProjectRoot guard
- * in evidence/manager.ts, which DOES use realpathSync. These two functions form a
- * defense-in-depth pair: resolveWorkingDirectory is the fast entry filter,
- * validateProjectRoot is the authoritative canonical check at write time.
+ * through this coarse filter are caught by the shared canonical project-root
+ * assertion at evidence, plan, and scope persistence sinks. These checks form a
+ * defense-in-depth pair: resolveWorkingDirectory is the fast entry filter and the
+ * persistence assertion is authoritative at write time.
  *
  * Priority: explicit working_directory param > injected directory (from createSwarmTool).
  *

package/dist/tools/submit-phase-council-verdicts.d.ts

@@ -15,8 +15,8 @@ export declare const ArgsSchema: z.ZodObject<{
         }>;
         verdict: z.ZodEnum<{
             APPROVE: "APPROVE";
-            CONCERNS: "CONCERNS";
             REJECT: "REJECT";
+            CONCERNS: "CONCERNS";
         }>;
         confidence: z.ZodNumber;
         findings: z.ZodArray<z.ZodObject<{

package/dist/tools/write-final-council-evidence.d.ts

@@ -16,8 +16,8 @@ export declare const ArgsSchema: z.ZodObject<{
         }>;
         verdict: z.ZodEnum<{
             APPROVE: "APPROVE";
-            CONCERNS: "CONCERNS";
             REJECT: "REJECT";
+            CONCERNS: "CONCERNS";
         }>;
         confidence: z.ZodNumber;
         findings: z.ZodArray<z.ZodObject<{

package/dist/utils/project-boundary.d.ts

@@ -0,0 +1,34 @@
+import * as fs from 'node:fs';
+/** Maximum depth to walk up the directory tree before failing closed. */
+export declare const MAX_PROJECT_ROOT_DEPTH = 20;
+/** File/directory names that indicate a real ancestor project root. */
+export declare const PROJECT_ROOT_INDICATORS: readonly ["package.json", ".git", ".opencode", "Cargo.toml", "go.mod", "pyproject.toml", "Gemfile", "composer.json", "pom.xml", "build.gradle", "CMakeLists.txt"];
+/**
+ * Return whether `directory` directly declares its own project boundary.
+ *
+ * Markers are local declarations, not verified Git metadata. A direct `.git`
+ * file/directory covers repositories, linked worktrees, and submodules; a
+ * direct `.opencode` directory is the manual opt-in. `lstatSync` is deliberate:
+ * marker symlinks/junctions do not grant an exemption. Missing, inaccessible,
+ * or ambiguous markers fail closed.
+ */
+export declare function hasExplicitProjectBoundary(directory: unknown): boolean;
+/**
+ * Test whether `candidate` is a strict lexical descendant of `root` using the
+ * host platform's path semantics (including case-insensitive Windows paths).
+ */
+export declare function isStrictPathDescendant(candidate: unknown, root: unknown): boolean;
+type ProjectRootProbeDependencies = Pick<typeof fs, 'realpathSync' | 'statSync'>;
+/**
+ * Authoritative write-time project-root assertion shared by persistence sinks.
+ *
+ * Direct boundary markers exempt a nested project from ancestor checks. Ordinary
+ * descendants are rejected when an ancestor contains both `.swarm/` and a
+ * project indicator. Ambiguous ancestor state fails closed.
+ */
+export declare function assertProjectRoot(directory: string, dependencies?: ProjectRootProbeDependencies, artifactLabel?: string): void;
+/** Narrow filesystem seam for deterministic marker error tests. */
+export declare const _internals: {
+    lstatSync: typeof fs.lstatSync;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.139.3",
+	"version": "7.139.4",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/dist/cli/curator-llm-factory-1r9vz0g2.js

@@ -1,61 +0,0 @@
-// @bun
-import {
-  createCuratorLLMDelegate
-} from "./index-tkg6rapy.js";
-import"./index-xsxrhakg.js";
-import"./index-ajwmn8gp.js";
-import"./index-0mzz46we.js";
-import"./index-1yd38ajy.js";
-import"./index-4fr94329.js";
-import"./index-hckq2r5m.js";
-import"./index-y8552snf.js";
-import"./index-4905hd2m.js";
-import"./index-134d35c1.js";
-import"./index-6axm8q3s.js";
-import"./index-xeyr62x0.js";
-import"./index-ba5e5e3n.js";
-import"./index-6mjf4vr1.js";
-import"./index-c8s9a3zh.js";
-import"./index-9ss2m4rs.js";
-import"./index-74hpm6sh.js";
-import"./index-xzzcfwwm.js";
-import"./index-1jbj7vzv.js";
-import"./index-jqn332jx.js";
-import"./index-rtry5xyf.js";
-import"./index-z6qe8wft.js";
-import"./index-hwnpd4tw.js";
-import"./index-ae75rja9.js";
-import"./index-6mvbjqbt.js";
-import"./index-2eet124q.js";
-import"./index-yawwwhmc.js";
-import"./index-gprxjmm7.js";
-import"./index-n832052r.js";
-import"./index-kyz7259r.js";
-import"./index-bk5tah7q.js";
-import"./index-8fwhhayc.js";
-import"./index-q1exe2b3.js";
-import"./index-5syvwd8g.js";
-import"./index-05mms0va.js";
-import"./index-556ja8an.js";
-import"./index-4xbyy6aw.js";
-import"./index-1kz6da87.js";
-import"./index-yh0q21nj.js";
-import"./index-b8zgtz81.js";
-import"./index-gen82t10.js";
-import"./index-4rhhvd1a.js";
-import"./index-4wjk296r.js";
-import"./index-mv0czd9c.js";
-import"./index-k87hs2ff.js";
-import"./index-ed5ykebp.js";
-import"./index-5j6chvj8.js";
-import"./index-7g4c7s5r.js";
-import"./index-a5eba0t8.js";
-import"./index-bpmtbmy9.js";
-import"./index-z6xqpmqg.js";
-import"./index-zjygnfay.js";
-import"./index-4nt52yr9.js";
-import"./index-zgwm4ryv.js";
-import"./index-a76rekgs.js";
-export {
-  createCuratorLLMDelegate
-};

package/dist/cli/guardrail-explain-y2wg00dp.js

@@ -1,62 +0,0 @@
-// @bun
-import {
-  handleGuardrailExplain
-} from "./index-mzck763x.js";
-import"./index-tkg6rapy.js";
-import"./index-xsxrhakg.js";
-import"./index-ajwmn8gp.js";
-import"./index-0mzz46we.js";
-import"./index-1yd38ajy.js";
-import"./index-4fr94329.js";
-import"./index-hckq2r5m.js";
-import"./index-y8552snf.js";
-import"./index-4905hd2m.js";
-import"./index-134d35c1.js";
-import"./index-6axm8q3s.js";
-import"./index-xeyr62x0.js";
-import"./index-ba5e5e3n.js";
-import"./index-6mjf4vr1.js";
-import"./index-c8s9a3zh.js";
-import"./index-9ss2m4rs.js";
-import"./index-74hpm6sh.js";
-import"./index-xzzcfwwm.js";
-import"./index-1jbj7vzv.js";
-import"./index-jqn332jx.js";
-import"./index-rtry5xyf.js";
-import"./index-z6qe8wft.js";
-import"./index-hwnpd4tw.js";
-import"./index-ae75rja9.js";
-import"./index-6mvbjqbt.js";
-import"./index-2eet124q.js";
-import"./index-yawwwhmc.js";
-import"./index-gprxjmm7.js";
-import"./index-n832052r.js";
-import"./index-kyz7259r.js";
-import"./index-bk5tah7q.js";
-import"./index-8fwhhayc.js";
-import"./index-q1exe2b3.js";
-import"./index-5syvwd8g.js";
-import"./index-05mms0va.js";
-import"./index-556ja8an.js";
-import"./index-4xbyy6aw.js";
-import"./index-1kz6da87.js";
-import"./index-yh0q21nj.js";
-import"./index-b8zgtz81.js";
-import"./index-gen82t10.js";
-import"./index-4rhhvd1a.js";
-import"./index-4wjk296r.js";
-import"./index-mv0czd9c.js";
-import"./index-k87hs2ff.js";
-import"./index-ed5ykebp.js";
-import"./index-5j6chvj8.js";
-import"./index-7g4c7s5r.js";
-import"./index-a5eba0t8.js";
-import"./index-bpmtbmy9.js";
-import"./index-z6xqpmqg.js";
-import"./index-zjygnfay.js";
-import"./index-4nt52yr9.js";
-import"./index-zgwm4ryv.js";
-import"./index-a76rekgs.js";
-export {
-  handleGuardrailExplain
-};

package/dist/cli/index-5j6chvj8.js

@@ -1,159 +0,0 @@
-// @bun
-import {
-  require_proper_lockfile
-} from "./index-7g4c7s5r.js";
-import {
-  emit
-} from "./index-a5eba0t8.js";
-import {
-  __toESM
-} from "./index-a76rekgs.js";
-
-// src/parallel/file-locks.ts
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import * as crypto from "crypto";
-import * as fs from "fs";
-import * as path from "path";
-var LOCKS_DIR = ".swarm/locks";
-var LOCK_TIMEOUT_MS = 5 * 60 * 1000;
-var _internals = {
-  tryAcquireLock,
-  writeFile: fs.promises.writeFile
-};
-function getLockFilePath(directory, filePath) {
-  const normalized = path.resolve(directory, filePath);
-  const baseDir = path.resolve(directory) + path.sep;
-  const pathOk = process.platform === "win32" ? normalized.toLowerCase().startsWith(baseDir.toLowerCase()) : normalized.startsWith(baseDir);
-  if (!pathOk) {
-    throw new Error("Invalid file path: path traversal not allowed");
-  }
-  const pathForHash = process.platform === "win32" ? normalized.toLowerCase() : normalized;
-  const hash = crypto.createHash("sha256").update(pathForHash).digest("hex");
-  const lockPath = path.join(directory, LOCKS_DIR, `${hash}.lock`);
-  const legacyPaths = [pathForHash];
-  if (process.platform === "win32" && normalized !== pathForHash) {
-    legacyPaths.push(normalized);
-  }
-  for (const legacyPath of legacyPaths) {
-    const oldHash = Buffer.from(legacyPath).toString("base64").replace(/[/+=]/g, "_");
-    const oldLockPath = path.join(directory, LOCKS_DIR, `${oldHash}.lock`);
-    if (fs.existsSync(oldLockPath)) {
-      return oldLockPath;
-    }
-  }
-  return lockPath;
-}
-async function tryAcquireLock(directory, filePath, agent, taskId) {
-  const lockPath = getLockFilePath(directory, filePath);
-  const locksDir = path.dirname(lockPath);
-  if (!fs.existsSync(locksDir)) {
-    fs.mkdirSync(locksDir, { recursive: true });
-  }
-  if (!fs.existsSync(lockPath)) {
-    fs.writeFileSync(lockPath, "", "utf-8");
-  }
-  let release;
-  try {
-    release = await import_proper_lockfile.default.lock(lockPath, {
-      stale: LOCK_TIMEOUT_MS,
-      retries: {
-        retries: 5,
-        minTimeout: 10,
-        maxTimeout: 500,
-        factor: 2
-      },
-      realpath: false
-    });
-  } catch (err) {
-    const code = err.code;
-    if (code === "ELOCKED" || code === "EEXIST") {
-      return { acquired: false };
-    }
-    throw err;
-  }
-  const lock = {
-    filePath,
-    agent,
-    taskId,
-    timestamp: new Date().toISOString(),
-    expiresAt: Date.now() + LOCK_TIMEOUT_MS,
-    _release: release
-  };
-  return { acquired: true, lock };
-}
-
-// src/evidence/lock.ts
-class EvidenceLockTimeoutError extends Error {
-  directory;
-  evidencePath;
-  agent;
-  taskId;
-  constructor(directory, evidencePath, agent, taskId, timeoutMs) {
-    super(`Evidence lock timeout after ${timeoutMs}ms for ${evidencePath} (agent=${agent}, task=${taskId})`);
-    this.name = "EvidenceLockTimeoutError";
-    this.directory = directory;
-    this.evidencePath = evidencePath;
-    this.agent = agent;
-    this.taskId = taskId;
-  }
-}
-var BACKOFF_START_MS = 50;
-var BACKOFF_MAX_MS = 2000;
-var BACKOFF_JITTER_RATIO = 0.25;
-function backoffMs(attempt) {
-  const base = Math.min(BACKOFF_START_MS * 2 ** attempt, BACKOFF_MAX_MS);
-  const jitter = base * BACKOFF_JITTER_RATIO * (Math.random() * 2 - 1);
-  return Math.max(1, Math.round(base + jitter));
-}
-async function withEvidenceLock(directory, evidencePath, agent, taskId, fn, timeoutMs = 60000) {
-  const deadline = Date.now() + timeoutMs;
-  let attempt = 0;
-  while (true) {
-    const result = await tryAcquireLock(directory, evidencePath, agent, taskId);
-    if (result.acquired) {
-      const lock = result.lock;
-      if (attempt > 0) {
-        emit("evidence_lock_stale_recovered", {
-          directory,
-          evidencePath,
-          agent,
-          taskId,
-          attempt
-        });
-      }
-      emit("evidence_lock_acquired", {
-        directory,
-        evidencePath,
-        agent,
-        taskId,
-        attempt
-      });
-      try {
-        return await fn();
-      } finally {
-        if (lock._release) {
-          try {
-            await lock._release();
-          } catch {}
-        }
-      }
-    }
-    if (Date.now() >= deadline) {
-      throw new EvidenceLockTimeoutError(directory, evidencePath, agent, taskId, timeoutMs);
-    }
-    emit("evidence_lock_contended", {
-      directory,
-      evidencePath,
-      agent,
-      taskId,
-      attempt
-    });
-    const delay = Math.min(backoffMs(attempt), deadline - Date.now());
-    if (delay > 0) {
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
-    }
-    attempt++;
-  }
-}
-
-export { tryAcquireLock, withEvidenceLock };

package/dist/cli/{index-z6xqpmqg.js → index-ee3x66a5.js}

@@ -1,10 +1,10 @@
 // @bun
-import {
-  init_merge
-} from "./index-zjygnfay.js";
 import {
   init_logger
 } from "./index-zgwm4ryv.js";
+import {
+  init_merge
+} from "./index-zjygnfay.js";
 
 // src/utils/errors.ts
 class SwarmError extends Error {