opencode-swarm 7.189.0 → 7.190.0

package/dist/cli/{index-skdpgjar.js → index-fb5s32c2.js}

@@ -4,17 +4,14 @@ import {
 } from "./index-6b295cas.js";
 import {
   readEffectiveSpecSync
-} from "./index-16m2m4ah.js";
+} from "./index-p69k8v0e.js";
 import {
-  getWorktreeMergeFailure
-} from "./index-zsrtt42s.js";
-import {
-  GitBinaryMissingError,
-  GitSpawnCwdError,
-  isGitBinaryMissing,
-  isSpawnCwdMissing,
-  isSpawnCwdUnreadable
-} from "./index-g4fs6z4e.js";
+  _internals,
+  clearWorktreeMergeStatus,
+  getWorktreeMergeFailure,
+  initDurableStatusPath,
+  scanWorktreeMergeFailuresForRecovery
+} from "./index-v3bmwmqw.js";
 import {
   sanitizeContextText
 } from "./index-m9zzj4ee.js";
@@ -23,11 +20,10 @@ import {
   estimateTokens,
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-7hr5m7yp.js";
+} from "./index-nkgzkt7c.js";
 import {
   bunHash,
-  bunWrite,
-  mergeEnvForChild
+  bunWrite
 } from "./index-2s7dvzff.js";
 import {
   LedgerStaleWriterError,
@@ -47,22 +43,25 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-bzbxn24k.js";
+} from "./index-ej1hdw16.js";
 import {
   appendCoreEventSync
-} from "./index-wrdktgpy.js";
+} from "./index-zk6ttjkt.js";
 import {
-  getCoordinationState,
-  importCoordinationOnce,
+  deleteCoordinationStateWithinTransaction,
+  getCoordinationStateRaw,
+  listCoordinationStateKeys,
   listCoordinationStates,
-  transitionCoordinationState
-} from "./index-ntda6tje.js";
+  transitionCoordinationState,
+  transitionCoordinationStateWithinTransaction,
+  withCoordinationTransaction
+} from "./index-feaxsjrt.js";
 import {
   DURABILITY_CLASSES,
   getProjectDb,
   projectDbExists,
   withDurabilityClass
-} from "./index-9tvjwv01.js";
+} from "./index-2fpv2wmc.js";
 import {
   derivePlanId,
   derivePlanIdentityHash
@@ -72,7 +71,7 @@ import {
 } from "./index-t7hmqgjy.js";
 import {
   emit
-} from "./index-d3rjvm9e.js";
+} from "./index-7vnr5cmp.js";
 import {
   canonicalRootKeyFresh
 } from "./index-fzpt2djt.js";
@@ -83,26 +82,24 @@ import {
   atomicWriteSwarmFileSync,
   invalidateCachedArtifact,
   readCachedParsedFile
-} from "./index-p2tqzwh6.js";
+} from "./index-qs9myayh.js";
 import {
   PlanSchema,
   normalizeCurrentPhaseInPlace,
   resolveActivePhaseId
 } from "./index-gx2vp8gx.js";
 import {
-  GIT_BINARY_ENV_VAR,
-  describeGitResolution,
-  init_git_executable,
-  resolveGitExecutable
-} from "./index-zxdawwc7.js";
+  init_config,
+  init_loader,
+  isEpicModeConfigEnabled,
+  loadPluginConfigWithMeta
+} from "./index-ejk34dnw.js";
 import {
-  init_executor,
-  isUntrustedEnvKey,
-  isValidEnvKey
-} from "./index-wvghb3x6.js";
+  exports_external,
+  init_zod
+} from "./index-gknz3bv1.js";
 import {
   criticalWarn,
-  error,
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
@@ -267,680 +264,772 @@ function updateTaskCheckpointReceipt(directory, descriptor, state, sha) {
   return rowAfter;
 }
 
-// src/utils/transient-retry.ts
-var MAX_TRANSIENT_RETRIES = 5;
-var RETRY_BASE_DELAY_MS = 200;
-function isTransientSpawnError(error2) {
-  if (!error2 || typeof error2 !== "object")
-    return false;
-  const code = error2.code;
-  return code === "ETIMEDOUT";
-}
-function transientBackoff(attempt) {
-  const delay = RETRY_BASE_DELAY_MS * 2 ** attempt;
-  try {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
-  } catch {
-    const start = Date.now();
-    while (Date.now() - start < delay) {}
-  }
-}
-
 // src/plan/manager.ts
 import {
-  closeSync,
+  closeSync as closeSync2,
   fsyncSync,
   mkdirSync as mkdirSync2,
-  openSync,
-  renameSync as renameSync2,
-  unlinkSync,
+  openSync as openSync2,
+  renameSync,
+  unlinkSync as unlinkSync2,
   writeFileSync
 } from "fs";
 import * as fsPromises from "fs/promises";
 import * as path3 from "path";
 
-// src/git/branch.ts
-init_executor();
-import * as child_process from "child_process";
-import * as fsSync from "fs";
-import path from "path";
-init_git_executable();
+// src/epic/merge-epoch.ts
+import * as path2 from "path";
 init_logger();
 
-// src/git/safe-ref.ts
-class UnsafeGitRefError extends Error {
-  ref;
-  context;
-  constructor(ref, context) {
-    super(`Refused unsafe git ref "${ref}" at ${context}: a ref argument ` + 'starting with "-" can be parsed by git as an option (issue #2265/#2476)');
-    this.ref = ref;
-    this.context = context;
-    this.name = "UnsafeGitRefError";
-  }
-}
-function isSafeGitRefArg(value) {
-  if (value.length === 0)
+// src/epic/lifecycle.ts
+init_zod();
+import { createHash as createHash2 } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+init_logger();
+
+// src/epic/config-gate.ts
+init_loader();
+init_config();
+init_config();
+var EPIC_MODE_CONFIG_DISABLED_MESSAGE = "Epic Mode is disabled by config. Set `epic.mode.enabled: true` in " + ".opencode/opencode-swarm.json (or your user config) to opt in, then retry. " + 'Example: `{ "epic": { "mode": { "enabled": true } } }` (no `turbo` block ' + "is needed).";
+var _internals2 = {
+  loadPluginConfigWithMeta
+};
+function isEpicModeConfigEnabledForDirectory(directory) {
+  try {
+    return isEpicModeConfigEnabled(_internals2.loadPluginConfigWithMeta(directory).config);
+  } catch {
     return false;
-  for (const side of value.split("..")) {
-    if (side.startsWith("-"))
-      return false;
-  }
-  return true;
-}
-function assertSafeGitRefArg(value, context) {
-  if (!isSafeGitRefArg(value)) {
-    throw new UnsafeGitRefError(value, context);
   }
-  return value;
 }
 
-// src/git/branch.ts
-var GIT_TIMEOUT_MS = 30000;
-var GIT_MAX_BUFFER_BYTES = 5 * 1024 * 1024;
-var MAX_RENDERED_GIT_CANDIDATES = 10;
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-function isNotGitRepositoryMessage(message) {
-  const lower = message.toLowerCase();
-  return lower.includes("not a git repository") || lower.includes("not a git repo");
-}
-function getChildProcessSpawnSync() {
-  return child_process.spawnSync;
-}
-var __spawnSyncSeam = {
-  spawnSync: (cmd, args, options) => {
-    const mergedEnv = mergeEnvForChild(options?.env, options?.envOverrides);
-    return getChildProcessSpawnSync()(cmd, args, {
-      ...options,
-      env: mergedEnv
-    });
-  }
+// src/epic/lifecycle.ts
+var EPIC_LIFECYCLE_NAMESPACE = "turbo.epic.lifecycle";
+var EPIC_SENTINEL_RELATIVE_PATH = path.join(".swarm", "epic", "epic.json");
+var PLAN_LEDGER_RELATIVE_PATH = path.join(".swarm", "plan-ledger.jsonl");
+var PLAN_JSON_RELATIVE_PATH = path.join(".swarm", "plan.json");
+var MAX_PLAN_JSON_BYTES = 8 * 1024 * 1024;
+var MAX_LEDGER_ROOT_LINE_BYTES = 1024 * 1024;
+var MAX_SENTINEL_BYTES = 64 * 1024;
+var LIFECYCLE_ROW_LIST_LIMIT = 8;
+class EpicStateUnreadableError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EpicStateUnreadableError";
+  }
+}
+var sizingSchema = exports_external.object({
+  epicSized: exports_external.boolean(),
+  reasons: exports_external.array(exports_external.string())
+}).passthrough();
+var waveSchema = exports_external.object({
+  seq: exports_external.number().int().min(1),
+  phase: exports_external.number().int(),
+  kind: exports_external.enum(["parallel", "exclusive", "serial-component"]),
+  taskIds: exports_external.array(exports_external.string()),
+  files: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())),
+  cochange: exports_external.object({
+    pairs: exports_external.array(exports_external.object({
+      fileA: exports_external.string(),
+      fileB: exports_external.string(),
+      npmi: exports_external.number(),
+      coChangeCount: exports_external.number()
+    }).passthrough()),
+    threshold: exports_external.object({ npmi: exports_external.number(), minCoChanges: exports_external.number() })
+  }).nullable(),
+  components: exports_external.object({
+    byTask: exports_external.record(exports_external.string(), exports_external.string()),
+    modes: exports_external.record(exports_external.string(), exports_external.enum(["exclusive", "serial-component", "parallel"])),
+    density: exports_external.record(exports_external.string(), exports_external.number()),
+    exclusive: exports_external.record(exports_external.string(), exports_external.enum([
+      "global-file",
+      "protected-path",
+      "no-scope",
+      "hot-file",
+      "hot-module"
+    ]).transform((reason) => reason === "hot-module" ? "hot-file" : reason)),
+    threshold: exports_external.number(),
+    truncated: exports_external.boolean()
+  }).passthrough().optional(),
+  baseHead: exports_external.string().nullable(),
+  issuedAt: exports_external.string(),
+  closedAt: exports_external.string().optional(),
+  closeHead: exports_external.string().nullable().optional(),
+  status: exports_external.enum(["issued", "closed", "aborted"]),
+  abortReason: exports_external.string().optional(),
+  mergeFailures: exports_external.record(exports_external.string(), exports_external.object({
+    outcome: exports_external.string(),
+    stage: exports_external.string(),
+    message: exports_external.string(),
+    at: exports_external.number().nullable()
+  }).passthrough()).optional(),
+  undeclared: exports_external.array(exports_external.string()).optional()
+}).passthrough();
+var taskOutcomeSchema = exports_external.object({
+  taskId: exports_external.string(),
+  phase: exports_external.number().int(),
+  waveSeq: exports_external.number().int(),
+  resolution: exports_external.enum(["completed", "closed", "removed"]),
+  resolvedAt: exports_external.string(),
+  generation: exports_external.number(),
+  stageAFailures: exports_external.number(),
+  stageBFailures: exports_external.number(),
+  mergeFailure: exports_external.object({
+    outcome: exports_external.string(),
+    stage: exports_external.string()
+  }).passthrough().nullable(),
+  declared: exports_external.array(exports_external.string()),
+  undeclared: exports_external.array(exports_external.string()),
+  attribution: exports_external.enum([
+    "session",
+    "git-single-task",
+    "unavailable",
+    "no-git"
+  ]),
+  reopened: exports_external.number(),
+  previous: exports_external.object({
+    waveSeq: exports_external.number(),
+    generation: exports_external.number(),
+    stageBFailures: exports_external.number(),
+    reopened: exports_external.number()
+  }).optional(),
+  marker: exports_external.object({
+    ref: exports_external.string().nullable(),
+    sha: exports_external.string().nullable(),
+    provenance: exports_external.enum([
+      "landing-commit",
+      "wave-close-head",
+      "repaired",
+      "no-git"
+    ])
+  }).nullable()
+}).passthrough();
+var phaseRecordSchema = exports_external.object({
+  status: exports_external.enum(["active", "review", "complete"]),
+  completeAtStart: exports_external.boolean().optional(),
+  reviewRuns: exports_external.number().int().min(0),
+  verdicts: exports_external.array(exports_external.string())
+}).passthrough();
+var recordSchema = exports_external.object({
+  schema: exports_external.literal("epic-record-v1"),
+  epicKey: exports_external.string().min(1),
+  token: exports_external.string().min(1),
+  planId: exports_external.string().min(1),
+  planIdentityHash: exports_external.string().min(1),
+  planEpoch: exports_external.string().nullable(),
+  planKey: exports_external.string().min(1),
+  ledgerRootDigest: exports_external.string().nullable(),
+  status: exports_external.enum(["open", "closing"]),
+  startedAt: exports_external.string().min(1),
+  startedBySession: exports_external.string(),
+  forced: exports_external.boolean(),
+  structureHashAtStart: exports_external.string(),
+  config: exports_external.object({
+    commitPolicy: exports_external.enum(["epic-branch", "current-branch"]),
+    isolation: exports_external.enum(["worktree", "main-tree-nogit"]),
+    maxParallel: exports_external.number().int().min(1)
+  }).passthrough(),
+  git: exports_external.object({
+    isRepo: exports_external.boolean(),
+    baseCommit: exports_external.string().nullable(),
+    originalBranch: exports_external.string().nullable(),
+    epicBranch: exports_external.string().nullable().default(null)
+  }).passthrough(),
+  sizing: sizingSchema,
+  priorDigest: exports_external.string().nullable().default(null),
+  closing: exports_external.object({
+    requestedAt: exports_external.string(),
+    outcome: exports_external.enum(["completed", "abandoned", "abandoned-by-swarm-close"]),
+    land: exports_external.enum(["squash", "merge", "none"]).nullable().default(null),
+    lastLandingAttempt: exports_external.object({
+      mode: exports_external.enum(["squash", "merge", "none"]),
+      status: exports_external.enum(["conflict", "failed"]),
+      at: exports_external.string(),
+      conflictFiles: exports_external.array(exports_external.string()),
+      detail: exports_external.string()
+    }).nullable().default(null)
+  }).nullable(),
+  waves: exports_external.array(waveSchema).default([]),
+  activeWaveSeq: exports_external.number().int().nullable().default(null),
+  tasks: exports_external.record(exports_external.string(), taskOutcomeSchema).default({}),
+  phases: exports_external.record(exports_external.string(), phaseRecordSchema).default({})
+}).passthrough();
+var sentinelSchema = exports_external.object({
+  schema: exports_external.literal("epic-sentinel-v1"),
+  epicKey: exports_external.string().min(1),
+  token: exports_external.string().min(1),
+  planId: exports_external.string(),
+  startedAt: exports_external.string()
+}).passthrough();
+var _internals3 = {
+  isEpicModeConfigEnabledForDirectory,
+  now: () => Date.now(),
+  warnedDirectories: new Set
 };
-function readLaneEnvFileFromDiskSync(worktreePath, laneIndex) {
-  const envPath = path.join(worktreePath, ".swarm", "lanes", `${laneIndex}.env`);
-  let content;
+var MAX_WARNED_DIRECTORIES = 64;
+function hasTraversalSegment(directory) {
+  return directory.split(/[\\/]/).includes("..");
+}
+function epicSentinelPath(directory) {
+  return path.join(directory, EPIC_SENTINEL_RELATIVE_PATH);
+}
+function epicSentinelExists(directory) {
+  if (typeof directory !== "string" || !directory)
+    return false;
+  if (hasTraversalSegment(directory))
+    return false;
+  return fs.existsSync(epicSentinelPath(directory));
+}
+function computeEpicKey(planId, planKey) {
+  const safeId = planId.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^[-_.]+/, "").slice(0, 40);
+  return `${safeId.length > 0 ? safeId : "plan"}-${planKey.slice(0, 12)}`;
+}
+function planIdentityOf(plan) {
+  return {
+    planId: derivePlanId(plan),
+    planIdentityHash: derivePlanIdentityHash(plan)
+  };
+}
+function readBoundedUtf8(filePath, maxBytes) {
+  let fd = null;
   try {
-    content = fsSync.readFileSync(envPath, "utf-8");
+    fd = fs.openSync(filePath, "r");
+    const buffer = Buffer.alloc(maxBytes);
+    const read = fs.readSync(fd, buffer, 0, maxBytes, 0);
+    return buffer.subarray(0, read).toString("utf-8");
   } catch {
-    return {};
-  }
-  const result = {};
-  for (const rawLine of content.split(`
-`)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#"))
-      continue;
-    const eqIdx = line.indexOf("=");
-    if (eqIdx < 0)
-      continue;
-    const k = line.slice(0, eqIdx);
-    const v = line.slice(eqIdx + 1);
-    if (!isValidEnvKey(k))
-      continue;
-    if (isUntrustedEnvKey(k))
-      continue;
-    result[k] = v;
-  }
-  return result;
-}
-function gitBinaryMissingMessage(cwd) {
-  const resolution = describeGitResolution();
-  const lines = [
-    `git executable is not available: spawning "${resolution.resolvedPath ?? "git"}" failed, and the working directory ${cwd} exists and is a directory.`
-  ];
-  if (resolution.attempts.length > 0) {
-    lines.push("Candidates tried:");
-    const shown = resolution.attempts.slice(0, MAX_RENDERED_GIT_CANDIDATES);
-    for (const attempt of shown) {
-      lines.push(`  - [${attempt.source}] ${attempt.candidate}: ${attempt.accepted ? "accepted" : attempt.reason ?? "rejected"}`);
-    }
-    const omitted = resolution.attempts.length - shown.length;
-    if (omitted > 0)
-      lines.push(`  ... and ${omitted} more`);
-  } else {
-    lines.push("No candidate probe results are recorded for this process (the resolver was pre-seeded or has not probed yet).");
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {}
+    }
   }
-  lines.push(resolution.overrideValue ? `The configured override (${resolution.overrideSource ?? "unknown"}) "${resolution.overrideValue}" did not work \u2014 point the ${GIT_BINARY_ENV_VAR} environment variable, or the "git.binary" value in your USER config (a project .opencode config is ignored for this key), at a working git executable.` : `No override is configured. Set the ${GIT_BINARY_ENV_VAR} environment variable, or the "git.binary" value in your USER config (a project .opencode config is ignored for this key), to point at a working git executable.`);
-  return lines.join(`
+}
+function readLedgerRootDigest(directory) {
+  const ledgerPath = path.join(directory, PLAN_LEDGER_RELATIVE_PATH);
+  if (!fs.existsSync(ledgerPath))
+    return null;
+  const head = readBoundedUtf8(ledgerPath, MAX_LEDGER_ROOT_LINE_BYTES);
+  if (head === null)
+    return "unreadable";
+  const newline = head.indexOf(`
 `);
+  const rootLine = (newline >= 0 ? head.slice(0, newline) : head).replace(/\r$/, "");
+  if (rootLine.trim().length === 0)
+    return null;
+  return createHash2("sha256").update(rootLine, "utf8").digest("hex");
 }
-function gitExec(args, cwd, laneEnv, laneIndex) {
-  const resolvedLaneEnv = laneEnv ?? (laneIndex !== undefined ? readLaneEnvFileFromDiskSync(cwd, laneIndex) : undefined);
-  const subcommand = args[0];
-  const hardenedArgs = subcommand === "commit" || subcommand === "tag" ? ["-c", "commit.gpgsign=false", "-c", "tag.gpgsign=false", ...args] : args;
-  const command = _internals.resolveGitExecutable();
-  for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
-    const result = _internals.spawnSync(command, hardenedArgs, {
-      cwd,
-      encoding: "utf-8",
-      timeout: GIT_TIMEOUT_MS,
-      windowsHide: true,
-      maxBuffer: GIT_MAX_BUFFER_BYTES,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
-      envOverrides: resolvedLaneEnv
-    });
-    if (!result.error && result.status === 0) {
-      return result.stdout;
-    }
-    if (result.error) {
-      if (isSpawnCwdMissing(result.error, cwd)) {
-        throw new GitSpawnCwdError(cwd, "missing", { cause: result.error });
-      }
-      if (isSpawnCwdUnreadable(result.error, cwd)) {
-        throw new GitSpawnCwdError(cwd, "unreadable", {
-          cause: result.error
-        });
-      }
-      if (isGitBinaryMissing(result.error, cwd)) {
-        throw new GitBinaryMissingError(gitBinaryMissingMessage(cwd), {
-          cause: result.error
-        });
-      }
-      if (isTransientSpawnError(result.error) && attempt < MAX_TRANSIENT_RETRIES - 1) {
-        transientBackoff(attempt);
-        continue;
-      }
-      throw new Error(errorMessage(result.error));
-    }
-    if (result.status !== 0) {
-      throw new Error(result.stderr || result.stdout || `git exited with ${result.status}`);
+function readCurrentPlanIdentity(directory) {
+  const planPath = path.join(directory, PLAN_JSON_RELATIVE_PATH);
+  try {
+    const stat = fs.statSync(planPath);
+    if (!stat.isFile() || stat.size > MAX_PLAN_JSON_BYTES)
+      return null;
+    const parsed = JSON.parse(fs.readFileSync(planPath, "utf-8"));
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.swarm !== "string" || typeof parsed.title !== "string") {
+      return null;
     }
+    return planIdentityOf(parsed);
+  } catch {
+    return null;
   }
-  throw new GitBinaryMissingError(process.platform === "win32" ? "git executable is not available on PATH or common Windows install locations" : "git executable is not available on PATH");
 }
-function getGitRepositoryStatus(cwd) {
+function parseEpicRecord(payload) {
+  let raw;
   try {
-    gitExec(["rev-parse", "--git-dir"], cwd);
-    return { isRepo: true };
-  } catch (err) {
-    if (err instanceof GitBinaryMissingError) {
-      return {
-        isRepo: false,
-        reason: "git_unavailable",
-        message: err.message
-      };
-    }
-    const message = errorMessage(err);
-    return {
-      isRepo: false,
-      reason: isNotGitRepositoryMessage(message) ? "not_git_repo" : "git_error",
-      message
-    };
+    raw = JSON.parse(payload);
+  } catch (error) {
+    throw new EpicStateUnreadableError(`Epic lifecycle row is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
   }
+  const parsed = recordSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new EpicStateUnreadableError(`Epic lifecycle row has an unexpected shape: ${parsed.error.issues.slice(0, 3).map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`);
+  }
+  const { lastDecision: _retired, ...record } = parsed.data;
+  return record;
 }
-function isGitRepo(cwd) {
-  return getGitRepositoryStatus(cwd).isRepo;
-}
-function getCurrentBranch(cwd, laneEnv, laneIndex) {
-  const output = gitExec(["rev-parse", "--abbrev-ref", "HEAD"], cwd, laneEnv, laneIndex);
-  return output.trim();
-}
-function getDefaultBaseBranch(cwd) {
+function readEpicSentinel(directory) {
+  const text = readBoundedUtf8(epicSentinelPath(directory), MAX_SENTINEL_BYTES);
+  if (text === null)
+    return null;
   try {
-    gitExec(["rev-parse", "--verify", "origin/main"], cwd);
-    return "origin/main";
+    const parsed = sentinelSchema.safeParse(JSON.parse(text));
+    return parsed.success ? parsed.data : null;
   } catch {
-    try {
-      gitExec(["rev-parse", "--verify", "origin/master"], cwd);
-      return "origin/master";
-    } catch {
-      return "origin/main";
-    }
+    return null;
   }
 }
-function hasUncommittedChanges(cwd, laneEnv, laneIndex) {
-  const status = gitExec(["status", "--porcelain"], cwd, laneEnv, laneIndex);
-  return status.trim().length > 0;
+function listLifecycleRows(directory) {
+  try {
+    return listCoordinationStates(directory, EPIC_LIFECYCLE_NAMESPACE, LIFECYCLE_ROW_LIST_LIMIT);
+  } catch (error) {
+    throw new EpicStateUnreadableError(`Epic lifecycle rows could not be read: ${error instanceof Error ? error.message : String(error)}`);
+  }
 }
-function detectDefaultRemoteBranch(cwd) {
+function evaluateEpicIdentity(record, current, ledgerRootDigest) {
+  if (current === null)
+    return "plan-missing";
+  if (current.planIdentityHash !== record.planIdentityHash) {
+    return "plan-renamed-or-replaced";
+  }
+  if (ledgerRootDigest !== record.ledgerRootDigest) {
+    return "plan-ledger-replaced";
+  }
+  return null;
+}
+function inspectEpic(directory, plan) {
+  const sentinelPresent = epicSentinelExists(directory);
+  const sentinel = sentinelPresent ? readEpicSentinel(directory) : null;
+  const inspection = {
+    sentinelPresent,
+    sentinel,
+    record: null,
+    rowKeys: [],
+    unreadable: null,
+    orphanReason: null,
+    configEnabled: _internals3.isEpicModeConfigEnabledForDirectory(directory)
+  };
+  if (hasTraversalSegment(directory) || !projectDbExists(directory)) {
+    return inspection;
+  }
+  let rows;
   try {
-    const output = gitExec(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
-    const trimmed = output.trim();
-    if (trimmed.startsWith("refs/remotes/origin/")) {
-      return trimmed.slice("refs/remotes/origin/".length);
-    }
-  } catch {}
+    rows = listLifecycleRows(directory);
+  } catch (error) {
+    inspection.unreadable = error instanceof Error ? error.message : String(error);
+    try {
+      inspection.rowKeys = listLifecycleRowsRawKeys(directory);
+    } catch {}
+    return inspection;
+  }
+  inspection.rowKeys = rows.map((row) => row.entityKey);
+  if (rows.length === 0)
+    return inspection;
+  if (rows.length > 1) {
+    inspection.unreadable = `multiple Epic lifecycle rows present (${inspection.rowKeys.join(", ")})`;
+    return inspection;
+  }
   try {
-    const output = gitExec(["config", "init.defaultBranch"], cwd);
-    const branch = output.trim();
-    if (branch) {
-      return branch;
+    const record = parseEpicRecord(rows[0].payload);
+    if (record.epicKey !== rows[0].entityKey) {
+      throw new EpicStateUnreadableError(`Epic lifecycle row key ${rows[0].entityKey} does not match its payload epicKey ${record.epicKey}`);
     }
-  } catch {}
-  try {
-    gitExec(["rev-parse", "--verify", "origin/main"], cwd);
-    return "main";
-  } catch {}
-  try {
-    gitExec(["rev-parse", "--verify", "origin/master"], cwd);
-    return "master";
-  } catch {
+    inspection.record = record;
+    inspection.orphanReason = evaluateEpicIdentity(record, plan ? planIdentityOf(plan) : readCurrentPlanIdentity(directory), readLedgerRootDigest(directory));
+  } catch (error) {
+    inspection.unreadable = error instanceof Error ? error.message : String(error);
+  }
+  return inspection;
+}
+function getOpenEpic(directory, plan) {
+  if (!epicSentinelExists(directory))
+    return null;
+  if (!projectDbExists(directory))
+    return null;
+  const rows = listLifecycleRows(directory);
+  if (rows.length === 0)
     return null;
+  if (rows.length > 1) {
+    throw new EpicStateUnreadableError(`multiple Epic lifecycle rows present (${rows.map((row) => row.entityKey).join(", ")})`);
+  }
+  const record = parseEpicRecord(rows[0].payload);
+  if (record.epicKey !== rows[0].entityKey) {
+    throw new EpicStateUnreadableError(`Epic lifecycle row key ${rows[0].entityKey} does not match its payload epicKey ${record.epicKey}`);
+  }
+  if (record.status !== "open")
+    return null;
+  if (!_internals3.isEpicModeConfigEnabledForDirectory(directory))
+    return null;
+  const orphan = evaluateEpicIdentity(record, plan ? planIdentityOf(plan) : readCurrentPlanIdentity(directory), readLedgerRootDigest(directory));
+  return orphan === null ? record : null;
+}
+function warnUnreadableOnce(directory, message) {
+  const key = path.resolve(directory);
+  if (_internals3.warnedDirectories.has(key))
+    return;
+  if (_internals3.warnedDirectories.size >= MAX_WARNED_DIRECTORIES) {
+    const oldest = _internals3.warnedDirectories.values().next().value;
+    if (oldest !== undefined)
+      _internals3.warnedDirectories.delete(oldest);
   }
+  _internals3.warnedDirectories.add(key);
+  criticalWarn(`[epic] Epic lifecycle state is unreadable for ${directory}: ${message}. Epic behaviour is OFF until repaired \u2014 run \`/swarm epic status\` (diagnose) or \`/swarm epic close --abandon\` (repair).`);
 }
-async function resetToRemoteBranch(cwd, options) {
-  const warnings = [];
-  const prunedBranches = [];
+function isEpicOpenForProject(directory) {
   try {
-    const currentBranch = getCurrentBranch(cwd);
-    const defaultRemoteBranch = _internals.detectDefaultRemoteBranch(cwd);
-    if (!defaultRemoteBranch) {
-      return {
-        success: false,
-        targetBranch: "",
-        localBranch: currentBranch,
-        message: "Could not detect default remote branch",
-        alreadyAligned: false,
-        prunedBranches: [],
-        warnings: []
-      };
+    return getOpenEpic(directory) !== null;
+  } catch (error) {
+    warnUnreadableOnce(directory, error instanceof Error ? error.message : String(error));
+    return false;
+  }
+}
+function writeSentinelFile(directory, sentinel) {
+  const target = epicSentinelPath(directory);
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  atomicWriteSwarmFileSync(target, `${JSON.stringify(sentinel, null, 2)}
+`);
+}
+function sentinelFor(record) {
+  return {
+    schema: "epic-sentinel-v1",
+    epicKey: record.epicKey,
+    token: record.token,
+    planId: record.planId,
+    startedAt: record.startedAt
+  };
+}
+function unlinkSentinel(directory) {
+  try {
+    fs.unlinkSync(epicSentinelPath(directory));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+}
+function deleteSentinelIfMatches(directory, epicKey, token) {
+  const current = readEpicSentinel(directory);
+  const present = epicSentinelExists(directory);
+  if (!present)
+    return false;
+  if (current !== null) {
+    if (current.epicKey !== epicKey)
+      return false;
+    if (token !== null && current.token !== token)
+      return false;
+  }
+  unlinkSentinel(directory);
+  return true;
+}
+function createEpicRecord(directory, record) {
+  return withCoordinationTransaction(directory, () => {
+    const existing = listLifecycleRowsRawKeys(directory);
+    if (existing.length > 0) {
+      return { outcome: "exists", existingKeys: existing };
+    }
+    const result = transitionCoordinationStateWithinTransaction(directory, {
+      namespace: EPIC_LIFECYCLE_NAMESPACE,
+      entityKey: record.epicKey,
+      expectedRevision: null,
+      generation: 1,
+      status: record.status,
+      payload: JSON.stringify(record)
+    });
+    if (result.outcome !== "applied") {
+      return { outcome: "exists", existingKeys: [record.epicKey] };
     }
-    assertSafeGitRefArg(currentBranch, "resetToRemoteBranch currentBranch");
-    assertSafeGitRefArg(defaultRemoteBranch, "resetToRemoteBranch defaultRemoteBranch");
-    const targetBranch = `origin/${defaultRemoteBranch}`;
-    if (currentBranch === "HEAD") {
-      return {
-        success: false,
-        targetBranch,
-        localBranch: "HEAD",
-        message: "Cannot reset: detached HEAD state",
-        alreadyAligned: false,
-        prunedBranches: [],
-        warnings: []
-      };
+    writeSentinelFile(directory, sentinelFor(record));
+    return { outcome: "created", record };
+  });
+}
+function listLifecycleRowsRawKeys(directory) {
+  return listCoordinationStateKeys(directory, EPIC_LIFECYCLE_NAMESPACE, LIFECYCLE_ROW_LIST_LIMIT);
+}
+var MAX_RECORD_UPDATE_ATTEMPTS = 5;
+
+class EpicRecordTooLargeError extends Error {
+  constructor(epicKey) {
+    super(`Epic \`${epicKey}\`'s lifecycle row is near its size limit (over ${MAX_EPIC_RECORD_PAYLOAD_CHARS} serialized characters), so no further wave can be recorded. Close the epic (\`/swarm epic close\`) to land or abandon it, then start a new epic for the remaining work.`);
+    this.name = "EpicRecordTooLargeError";
+  }
+}
+var MAX_EPIC_RECORD_PAYLOAD_CHARS = 786432;
+function epicRecordPayloadTooLarge(record) {
+  return JSON.stringify(record).length > MAX_EPIC_RECORD_PAYLOAD_CHARS;
+}
+function updateEpicRecord(directory, epicKey, mutate, expectedToken = null) {
+  for (let attempt = 0;attempt < MAX_RECORD_UPDATE_ATTEMPTS; attempt += 1) {
+    const current = getCoordinationStateRaw(directory, EPIC_LIFECYCLE_NAMESPACE, epicKey);
+    if (!current)
+      return null;
+    const record = parseEpicRecord(current.payload);
+    if (expectedToken !== null && record.token !== expectedToken)
+      return null;
+    const next = mutate(record);
+    if (epicRecordPayloadTooLarge(next)) {
+      throw new EpicRecordTooLargeError(epicKey);
     }
-    if (hasUncommittedChanges(cwd)) {
-      return {
-        success: false,
-        targetBranch,
-        localBranch: currentBranch,
-        message: "Cannot reset: uncommitted changes in working tree",
-        alreadyAligned: false,
-        prunedBranches: [],
-        warnings: []
-      };
+    const result = transitionCoordinationState(directory, {
+      namespace: EPIC_LIFECYCLE_NAMESPACE,
+      entityKey: epicKey,
+      expectedRevision: current.revision,
+      generation: current.generation + 1,
+      status: next.status,
+      payload: JSON.stringify(next)
+    });
+    if (result.outcome === "applied")
+      return next;
+    if (result.outcome !== "revision_conflict" && result.outcome !== "stale_generation") {
+      throw new Error(`Epic record update failed: ${result.outcome}`);
     }
-    try {
-      const logOutput = gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
-      if (logOutput.trim().length > 0) {
+  }
+  throw new Error(`Epic record update failed: contention on ${epicKey}`);
+}
+function readPlanTaskRef(directory, taskId) {
+  const planPath = path.join(directory, PLAN_JSON_RELATIVE_PATH);
+  try {
+    const stat = fs.statSync(planPath);
+    if (!stat.isFile() || stat.size > MAX_PLAN_JSON_BYTES)
+      return null;
+    const parsed = JSON.parse(fs.readFileSync(planPath, "utf-8"));
+    if (!Array.isArray(parsed?.phases))
+      return null;
+    for (const phase of parsed.phases) {
+      if (!phase || !Array.isArray(phase.tasks))
+        continue;
+      for (const task of phase.tasks) {
+        if (task?.id !== taskId)
+          continue;
         return {
-          success: false,
-          targetBranch,
-          localBranch: currentBranch,
-          message: "Cannot reset: unpushed commits",
-          alreadyAligned: false,
-          prunedBranches: [],
-          warnings: []
+          id: taskId,
+          phase: typeof phase.id === "number" ? phase.id : 0,
+          description: typeof task.description === "string" ? task.description : undefined,
+          files: Array.isArray(task.files_touched) ? task.files_touched.filter((f) => typeof f === "string") : []
         };
       }
-    } catch {}
-    try {
-      gitExec(["fetch", "--prune", "origin"], cwd);
-    } catch (err) {
-      return {
-        success: false,
-        targetBranch,
-        localBranch: currentBranch,
-        message: `Fetch failed: ${err instanceof Error ? err.message : String(err)}`,
-        alreadyAligned: false,
-        prunedBranches: [],
-        warnings: []
-      };
     }
-    const headSha = gitExec(["rev-parse", "HEAD"], cwd).trim();
-    const remoteSha = gitExec(["rev-parse", `${targetBranch}`], cwd).trim();
-    if (headSha === remoteSha) {
-      return {
-        success: true,
-        targetBranch,
-        localBranch: currentBranch,
-        message: "Already aligned with remote",
-        alreadyAligned: true,
-        prunedBranches: [],
-        warnings: []
-      };
-    }
-    try {
-      gitExec(["checkout", currentBranch], cwd);
-    } catch (err) {
-      return {
-        success: false,
-        targetBranch,
-        localBranch: currentBranch,
-        message: `Checkout failed: ${err instanceof Error ? err.message : String(err)}`,
-        alreadyAligned: false,
-        prunedBranches: [],
-        warnings: []
-      };
+    return null;
+  } catch {
+    return null;
+  }
+}
+function markEpicClosing(directory, epicKey, outcome, expectedToken = null, land = null) {
+  return updateEpicRecord(directory, epicKey, (record) => record.status === "closing" && record.closing ? resumeClosing(record, record.closing, outcome, land) : {
+    ...record,
+    status: "closing",
+    closing: {
+      requestedAt: new Date(_internals3.now()).toISOString(),
+      outcome,
+      land,
+      lastLandingAttempt: null
     }
-    let resetSucceeded = false;
-    let lastError;
-    for (let retry = 0;retry < 4; retry++) {
-      if (retry > 0 && process.platform === "win32") {
-        await new Promise((resolve) => setTimeout(resolve, 500));
+  }, expectedToken);
+}
+function resumeClosing(record, closing, outcome, land) {
+  const nextOutcome = closing.outcome === "completed" && outcome !== "completed" ? outcome : closing.outcome;
+  if (closing.land === land && closing.outcome === nextOutcome)
+    return record;
+  return { ...record, closing: { ...closing, land, outcome: nextOutcome } };
+}
+function recordEpicBranch(directory, epicKey, expectedToken, epicBranch) {
+  return updateEpicRecord(directory, epicKey, (record) => ({ ...record, git: { ...record.git, epicBranch } }), expectedToken);
+}
+function recordEpicLandingAttempt(directory, epicKey, expectedToken, attempt) {
+  return updateEpicRecord(directory, epicKey, (record) => record.closing ? {
+    ...record,
+    closing: { ...record.closing, lastLandingAttempt: attempt }
+  } : record, expectedToken);
+}
+function payloadToken(payload) {
+  try {
+    const parsed = JSON.parse(payload);
+    return typeof parsed?.token === "string" ? parsed.token : null;
+  } catch {
+    return null;
+  }
+}
+function deleteEpicState(directory, epicKey, token) {
+  const result = { rowsDeleted: [], sentinelDeleted: false };
+  if (!projectDbExists(directory)) {
+    const sentinel = readEpicSentinel(directory);
+    result.sentinelDeleted = deleteSentinelIfMatches(directory, epicKey ?? sentinel?.epicKey ?? "", epicKey === null ? null : token);
+    return result;
+  }
+  return withCoordinationTransaction(directory, () => {
+    const keys = epicKey === null ? listLifecycleRowsRawKeys(directory) : [epicKey];
+    for (const key of keys) {
+      const raw = getCoordinationStateRaw(directory, EPIC_LIFECYCLE_NAMESPACE, key);
+      if (!raw)
+        continue;
+      if (epicKey !== null && token !== null && payloadToken(raw.payload) !== token) {
+        continue;
       }
-      try {
-        gitExec(["reset", "--hard", targetBranch], cwd);
-        resetSucceeded = true;
-        break;
-      } catch (err) {
-        lastError = err;
+      if (deleteCoordinationStateWithinTransaction(directory, EPIC_LIFECYCLE_NAMESPACE, key, raw.revision)) {
+        result.rowsDeleted.push(key);
       }
     }
-    if (!resetSucceeded) {
-      return {
-        success: false,
-        targetBranch,
-        localBranch: currentBranch,
-        message: `Reset failed: ${lastError instanceof Error ? lastError.message : String(lastError)}`,
-        alreadyAligned: false,
-        prunedBranches: [],
-        warnings: []
-      };
-    }
-    if (options?.pruneBranches) {
-      try {
-        const mergedOutput = gitExec(["branch", "--merged", targetBranch], cwd);
-        const mergedLines = mergedOutput.split(`
-`);
-        for (const line of mergedLines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || trimmedLine.startsWith("*")) {
-            continue;
-          }
-          try {
-            gitExec([
-              "branch",
-              "-d",
-              "--",
-              assertSafeGitRefArg(trimmedLine, "resetToRemoteBranch prune merged branch")
-            ], cwd);
-            prunedBranches.push(trimmedLine);
-          } catch {
-            warnings.push(`Could not safely delete branch: ${trimmedLine}`);
-          }
-        }
-      } catch (err) {
-        warnings.push(`Failed to get merged branches: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      try {
-        const branchVvOutput = gitExec(["branch", "-vv"], cwd);
-        const vvLines = branchVvOutput.split(`
-`);
-        for (const line of vvLines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || trimmedLine.startsWith("*")) {
-            continue;
-          }
-          if (trimmedLine.includes(": gone]")) {
-            const parts = trimmedLine.split(/\s+/);
-            const branchName = parts[0];
-            try {
-              gitExec([
-                "branch",
-                "-d",
-                "--",
-                assertSafeGitRefArg(branchName, "resetToRemoteBranch prune gone branch")
-              ], cwd);
-              prunedBranches.push(branchName);
-            } catch {
-              warnings.push(`Could not delete gone branch: ${branchName}`);
-            }
-          }
-        }
-      } catch (err) {
-        warnings.push(`Failed to prune gone branches: ${err instanceof Error ? err.message : String(err)}`);
-      }
+    const sentinel = readEpicSentinel(directory);
+    if (epicKey === null) {
+      result.sentinelDeleted = deleteSentinelIfMatches(directory, sentinel?.epicKey ?? "", null);
+    } else {
+      result.sentinelDeleted = deleteSentinelIfMatches(directory, epicKey, token);
     }
-    return {
-      success: true,
-      targetBranch,
-      localBranch: currentBranch,
-      message: "Successfully reset to remote branch",
-      alreadyAligned: false,
-      prunedBranches,
-      warnings
-    };
-  } catch (err) {
-    return {
-      success: false,
-      targetBranch: "",
-      localBranch: "",
-      message: `Unexpected error: ${err instanceof Error ? err.message : String(err)}`,
-      alreadyAligned: false,
-      prunedBranches: [],
-      warnings: []
-    };
-  }
+    return result;
+  });
 }
-var GITIGNORED_BUILD_ARTIFACTS = ["dist"];
-async function resetToMainAfterMerge(cwd, options) {
-  const warnings = [];
-  try {
-    const defaultBranch = _internals.detectDefaultRemoteBranch(cwd);
-    if (!defaultBranch) {
-      return {
-        success: false,
-        targetBranch: "",
-        previousBranch: "",
-        message: "Could not detect default remote branch",
-        branchDeleted: false,
-        changesDiscarded: false,
-        warnings
-      };
-    }
-    const currentBranch = getCurrentBranch(cwd);
-    assertSafeGitRefArg(currentBranch, "resetToMainAfterMerge currentBranch");
-    assertSafeGitRefArg(defaultBranch, "resetToMainAfterMerge defaultBranch");
-    const targetBranch = `origin/${defaultBranch}`;
-    if (currentBranch === "HEAD") {
-      return {
-        success: false,
-        targetBranch,
-        previousBranch: "HEAD",
-        message: "Cannot reset: detached HEAD state",
-        branchDeleted: false,
-        changesDiscarded: false,
-        warnings
-      };
-    }
-    if (currentBranch === defaultBranch) {
-      try {
-        const logOutput = _internals.gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
-        if (logOutput.trim().length > 0) {
-          return {
-            success: false,
-            targetBranch,
-            previousBranch: currentBranch,
-            message: `Cannot reset: ${defaultBranch} has unpushed commits. Push them first.`,
-            branchDeleted: false,
-            changesDiscarded: false,
-            warnings
-          };
-        }
-      } catch {}
-    } else {
-      try {
-        _internals.gitExec(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`], cwd);
-      } catch {
-        try {
-          const localSha = _internals.gitExec(["rev-parse", "HEAD"], cwd).trim();
-          const remoteSha = _internals.gitExec(["rev-parse", targetBranch], cwd).trim();
-          if (localSha !== remoteSha) {
-            return {
-              success: false,
-              targetBranch,
-              previousBranch: currentBranch,
-              message: `Cannot reset: branch ${currentBranch} is local-only and diverges from ${defaultBranch}. Push or check manually.`,
-              branchDeleted: false,
-              changesDiscarded: false,
-              warnings
-            };
-          }
-        } catch {
-          return {
-            success: false,
-            targetBranch,
-            previousBranch: currentBranch,
-            message: `Cannot reset: unable to compare ${currentBranch} with ${defaultBranch}`,
-            branchDeleted: false,
-            changesDiscarded: false,
-            warnings
-          };
-        }
-      }
+function repairEpicSentinel(directory) {
+  if (!projectDbExists(directory)) {
+    if (epicSentinelExists(directory)) {
+      unlinkSentinel(directory);
+      return "removed-stale-sentinel";
     }
+    return "none";
+  }
+  return withCoordinationTransaction(directory, () => {
+    let rows;
     try {
-      _internals.gitExec(["fetch", "--prune", "origin"], cwd);
-    } catch (err) {
-      return {
-        success: false,
-        targetBranch,
-        previousBranch: currentBranch,
-        message: `Cannot reset: fetch failed \u2014 ${err instanceof Error ? err.message : String(err)}`,
-        branchDeleted: false,
-        changesDiscarded: false,
-        warnings
-      };
-    }
-    const previousBranch = currentBranch;
-    let switchedBranch = false;
-    if (currentBranch !== defaultBranch) {
-      try {
-        _internals.gitExec(["checkout", defaultBranch], cwd);
-        switchedBranch = true;
-      } catch (err) {
-        return {
-          success: false,
-          targetBranch,
-          previousBranch,
-          message: `Checkout to ${defaultBranch} failed: ${err instanceof Error ? err.message : String(err)}`,
-          branchDeleted: false,
-          changesDiscarded: false,
-          warnings
-        };
-      }
-    }
+      rows = listLifecycleRows(directory);
+    } catch {
+      return "none";
+    }
+    const present = epicSentinelExists(directory);
+    if (rows.length === 0) {
+      if (!present)
+        return "none";
+      unlinkSentinel(directory);
+      return "removed-stale-sentinel";
+    }
+    if (rows.length > 1)
+      return "none";
+    let record;
     try {
-      _internals.gitExec(["reset", "--hard", targetBranch], cwd);
-    } catch (err) {
-      return {
-        success: false,
-        targetBranch,
-        previousBranch,
-        message: `Reset to ${targetBranch} failed: ${err instanceof Error ? err.message : String(err)}`,
-        branchDeleted: false,
-        changesDiscarded: false,
-        warnings
-      };
+      record = parseEpicRecord(rows[0].payload);
+    } catch {
+      return "none";
     }
-    let changesDiscarded = false;
-    if (hasUncommittedChanges(cwd)) {
-      let discardSucceeded = false;
-      for (let retry = 0;retry < 4; retry++) {
-        if (retry > 0 && process.platform === "win32") {
-          await new Promise((resolve) => setTimeout(resolve, 500));
-        }
-        try {
-          _internals.gitExec(["checkout", "--", "."], cwd);
-          discardSucceeded = true;
-          break;
-        } catch {}
-      }
-      if (!discardSucceeded) {
-        warnings.push("Could not discard all uncommitted changes after reset");
-      }
-      changesDiscarded = discardSucceeded;
+    const sentinel = present ? readEpicSentinel(directory) : null;
+    if (!present) {
+      if (record.status !== "open")
+        return "none";
+      writeSentinelFile(directory, sentinelFor(record));
+      return "restored-sentinel";
     }
-    try {
-      _internals.gitExec(["clean", "-fdX", "--", ...GITIGNORED_BUILD_ARTIFACTS], cwd);
-    } catch {
-      warnings.push("Could not clean build artifacts");
+    if (sentinel === null || sentinel.epicKey !== record.epicKey || sentinel.token !== record.token) {
+      writeSentinelFile(directory, sentinelFor(record));
+      return "rewrote-mismatched-sentinel";
     }
-    let branchDeleted = false;
-    if (switchedBranch && previousBranch !== defaultBranch) {
-      try {
-        const mergedOutput = _internals.gitExec(["branch", "--merged", defaultBranch], cwd);
-        const isMerged = mergedOutput.split(`
-`).some((line) => line.trim() === previousBranch || line.trim() === `* ${previousBranch}`);
-        if (isMerged) {
-          _internals.gitExec([
-            "branch",
-            "-d",
-            "--",
-            assertSafeGitRefArg(previousBranch, "resetToMainAfterMerge previousBranch")
-          ], cwd);
-          branchDeleted = true;
-        } else {
-          warnings.push(`Branch ${previousBranch} is not merged into ${defaultBranch} \u2014 keeping it`);
-        }
-      } catch {
-        warnings.push(`Could not delete branch ${previousBranch}`);
-      }
+    return "none";
+  });
+}
+
+// src/epic/merge-epoch.ts
+function classifyMergeFailure(failure, sinceMs) {
+  const at = failure.completedAt ?? failure.queuedAt;
+  if (typeof at !== "number" || !Number.isFinite(at))
+    return "undated";
+  return at >= sinceMs ? "current" : "stale";
+}
+function relevantMergeFailure(taskId, sinceMs) {
+  const failure = _internals4.getWorktreeMergeFailure(taskId);
+  if (!failure)
+    return;
+  return classifyMergeFailure(failure, sinceMs) === "stale" ? undefined : failure;
+}
+function boundStatusPath() {
+  try {
+    return _internals4.getBoundStatusPath();
+  } catch {
+    return null;
+  }
+}
+function relevantMergeFailureForProject(directory, taskId, sinceMs) {
+  const bound = boundStatusPath();
+  const ours = path2.join(directory, ".swarm", "worktree-merge-status.json");
+  if (bound !== null && path2.resolve(bound) === path2.resolve(ours)) {
+    const live = relevantMergeFailure(taskId, sinceMs);
+    if (live)
+      return live;
+  }
+  const scan = _internals4.scanWorktreeMergeFailuresForRecovery(directory);
+  if (scan.status !== "ok")
+    return;
+  const durable = scan.failures.find(([id]) => id === taskId)?.[1];
+  if (!durable)
+    return;
+  return classifyMergeFailure(durable, sinceMs) === "stale" ? undefined : durable;
+}
+function epicMergeFailureSkipsCheckpoint(directory, taskId) {
+  try {
+    if (!_internals4.epicSentinelExists(directory))
+      return false;
+    const epic = _internals4.getOpenEpic(directory);
+    if (!epic)
+      return false;
+    const started = Date.parse(epic.startedAt);
+    const failure = relevantMergeFailureForProject(directory, taskId, Number.isFinite(started) ? started : 0);
+    if (!failure)
+      return false;
+    criticalWarn(`[epic] auto-checkpoint SKIPPED for ${taskId}: its worktree merge-back ${failure.outcome} at stage '${failure.stage}', so its work is not on the epic branch. Resolve the preserved worktree (\`/swarm lanes\`) and re-dispatch the task. Detail: ${failure.message}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function describeMergeFailuresForStatus(directory, sinceMs) {
+  const scan = _internals4.scanWorktreeMergeFailuresForRecovery(directory);
+  if (scan.status === "uncertain") {
+    return [
+      "",
+      "### Worktree merge failures",
+      `- Could not read \`.swarm/worktree-merge-status.json\`: ${scan.reason}. Epic falls back to the in-memory registry; repair or remove the file (no swarm session running) if this persists.`
+    ];
+  }
+  if (scan.failures.length === 0)
+    return [];
+  const lines = ["", "### Worktree merge failures"];
+  const rootLabel = sinceMs === null ? "unknown (no plan ledger)" : new Date(sinceMs).toISOString();
+  lines.push(`Current plan root: ${rootLabel}`);
+  let blocking = 0;
+  for (const [taskId, failure] of scan.failures) {
+    const relevance = classifyMergeFailure(failure, sinceMs ?? Number.NEGATIVE_INFINITY);
+    const what = `${failure.outcome} at '${failure.stage}'`;
+    if (relevance === "stale") {
+      lines.push(`- ${taskId}: ${what} \u2014 stale (recorded before the current plan); ignored by Epic.`);
+      continue;
     }
-    if (options?.pruneBranches) {
-      try {
-        const mergedOutput = _internals.gitExec(["branch", "--merged", defaultBranch], cwd);
-        const mergedLines = mergedOutput.split(`
+    blocking += 1;
+    if (relevance === "undated") {
+      lines.push(`- ${taskId}: ${what} \u2014 NO timestamp, so it cannot be dated against the current plan; treated as BLOCKING (fail closed): an epic wave holding task ${taskId} will not close.`);
+    } else {
+      lines.push(`- ${taskId}: ${what} \u2014 BLOCKING: an epic wave holding task ${taskId} will not close.`);
+    }
+  }
+  if (blocking > 0) {
+    lines.push("Remedy: resolve the preserved worktree (`/swarm lanes`) and re-dispatch the task \u2014 a clean merge-back clears its record. If the work already landed, or an undated record belongs to an earlier plan, clear it with `/swarm epic clear-merge-failure <taskId> --confirm`.");
+  }
+  return lines;
+}
+function clearMergeFailureCommand(directory, args) {
+  const taskId = args.find((a) => !a.startsWith("--"))?.trim();
+  const confirm = args.includes("--confirm");
+  if (!taskId) {
+    return "Usage: /swarm epic clear-merge-failure <taskId> [--confirm]";
+  }
+  const scan = _internals4.scanWorktreeMergeFailuresForRecovery(directory);
+  const onDisk = scan.status === "ok" ? scan.failures.find(([id]) => id === taskId)?.[1] : undefined;
+  const failure = onDisk ?? _internals4.getWorktreeMergeFailure(taskId);
+  if (!failure) {
+    return `No worktree merge failure is recorded for task ${taskId}; nothing to clear.`;
+  }
+  const at = failure.completedAt ?? failure.queuedAt;
+  const detail = `${failure.outcome} at '${failure.stage}' (${typeof at === "number" && Number.isFinite(at) ? `recorded ${new Date(at).toISOString()}` : "no timestamp"}): ${failure.message}${failure.worktreePath ? ` \u2014 preserved worktree ${failure.worktreePath}` : ""}`;
+  if (!confirm) {
+    return [
+      `Task ${taskId} has a recorded worktree merge failure: ${detail}.`,
+      `Clearing it lets the epic wave holding task ${taskId} close, treating the task's work as landed. Clear it only if the task's work is on the epic branch (or the record belongs to an earlier plan); otherwise resolve the preserved worktree first (\`/swarm lanes\`).`,
+      `To clear, run: /swarm epic clear-merge-failure ${taskId} --confirm`
+    ].join(`
 `);
-        for (const line of mergedLines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || trimmedLine.startsWith("*") || trimmedLine === defaultBranch) {
-            continue;
-          }
-          try {
-            _internals.gitExec([
-              "branch",
-              "-d",
-              "--",
-              assertSafeGitRefArg(trimmedLine, "resetToMainAfterMerge prune branch")
-            ], cwd);
-          } catch {
-            warnings.push(`Could not prune branch: ${trimmedLine}`);
-          }
-        }
-      } catch (err) {
-        warnings.push(`Prune failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-    return {
-      success: true,
-      targetBranch,
-      previousBranch,
-      message: branchDeleted ? `Reset to ${defaultBranch} and deleted branch ${previousBranch}` : `Reset to ${defaultBranch}`,
-      branchDeleted,
-      changesDiscarded,
-      warnings
-    };
-  } catch (err) {
-    return {
-      success: false,
-      targetBranch: "",
-      previousBranch: "",
-      message: `Unexpected error: ${err instanceof Error ? err.message : String(err)}`,
-      branchDeleted: false,
-      changesDiscarded: false,
-      warnings
-    };
   }
+  _internals4.initDurableStatusPath(directory);
+  _internals4.clearWorktreeMergeStatus(taskId);
+  return `Cleared the recorded worktree merge failure for task ${taskId} (${detail}). The next \`epic_next_wave\` may close its wave.`;
 }
-var _internals = {
-  gitExec,
-  detectDefaultRemoteBranch,
-  getDefaultBaseBranch,
-  getGitRepositoryStatus,
-  resetToRemoteBranch,
-  resetToMainAfterMerge,
-  spawnSync: __spawnSyncSeam.spawnSync,
-  readLaneEnvFileFromDiskSync,
-  resolveGitExecutable
+var _internals4 = {
+  epicSentinelExists,
+  getOpenEpic,
+  clearWorktreeMergeStatus,
+  initDurableStatusPath,
+  getWorktreeMergeFailure,
+  scanWorktreeMergeFailuresForRecovery,
+  getBoundStatusPath: () => _internals.getDurableStatusPath()
 };
 
 // src/services/run-memory.ts
 import * as crypto from "crypto";
-import * as fs from "fs/promises";
+import * as fs2 from "fs/promises";
 init_logger();
 var RUN_MEMORY_FILENAME = "run-memory.jsonl";
 var MAX_SUMMARY_TOKENS = 500;
@@ -954,7 +1043,7 @@ async function recordOutcome(directory, entry) {
   const resolvedPath = validateSwarmPath(directory, RUN_MEMORY_FILENAME);
   const line = `${JSON.stringify(entry)}
 `;
-  await fs.appendFile(resolvedPath, line, { encoding: "utf-8" });
+  await fs2.appendFile(resolvedPath, line, { encoding: "utf-8" });
 }
 async function getTaskHistory(directory, taskId) {
   validateWorkspaceRoot(directory);
@@ -981,14 +1070,14 @@ async function recordTaskAttempt(directory, input) {
   try {
     let history = [];
     try {
-      history = await _internals2.getTaskHistory(directory, input.taskId);
+      history = await _internals5.getTaskHistory(directory, input.taskId);
     } catch (err) {
       warn(`[run-memory] history read for task ${input.taskId} failed; recording with attemptNumber 1: ${err instanceof Error ? err.message : String(err)}`);
     }
     const entry = {
       timestamp: new Date().toISOString(),
       taskId: input.taskId,
-      taskFingerprint: _internals2.generateTaskFingerprint(input.taskId, input.fileTargets ?? []),
+      taskFingerprint: _internals5.generateTaskFingerprint(input.taskId, input.fileTargets ?? []),
       agent: input.agent,
       outcome: input.outcome,
       attemptNumber: history.length + 1
@@ -1002,7 +1091,7 @@ async function recordTaskAttempt(directory, input) {
     if (typeof input.durationMs === "number") {
       entry.durationMs = input.durationMs;
     }
-    await _internals2.recordOutcome(directory, entry);
+    await _internals5.recordOutcome(directory, entry);
   } catch (err) {
     warn(`[run-memory] failed to record ${input.outcome} for task ${input.taskId}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -1066,10 +1155,10 @@ async function getRunMemorySummary(directory) {
   if (entries.length === 0) {
     return null;
   }
-  const groups = _internals2.groupByTaskId(entries);
+  const groups = _internals5.groupByTaskId(entries);
   const summaries = [];
   for (const [taskId, taskEntries] of groups) {
-    const summary = _internals2.summarizeTask(taskId, taskEntries);
+    const summary = _internals5.summarizeTask(taskId, taskEntries);
     if (summary) {
       summaries.push(summary);
     }
@@ -1099,7 +1188,7 @@ Use this data to avoid repeating known failure patterns.`;
   }
   return prefix + summaryText + suffix;
 }
-var _internals2 = {
+var _internals5 = {
   generateTaskFingerprint,
   recordOutcome,
   recordTaskAttempt,
@@ -1109,437 +1198,18 @@ var _internals2 = {
   summarizeTask
 };
 
-// src/turbo/epic/state.ts
-import { createHash as createHash3 } from "crypto";
-import * as fs2 from "fs";
-import * as path2 from "path";
-init_logger();
-var STATE_FILE = "epic-state.json";
-var COORDINATION_NAMESPACE = "turbo.epic.session";
-var MAX_SESSION_WRITE_ATTEMPTS = 5;
-function nowISO() {
-  return new Date().toISOString();
-}
-function ensureSwarmDir(directory) {
-  const swarmDir = path2.resolve(directory, ".swarm");
-  if (!fs2.existsSync(swarmDir)) {
-    fs2.mkdirSync(swarmDir, { recursive: true });
-  }
-  return swarmDir;
-}
-function stateFilePath(directory) {
-  return path2.join(directory, ".swarm", STATE_FILE);
-}
-function importedStateFilePath(directory) {
-  return `${stateFilePath(directory)}.imported`;
-}
-function archiveStateFileWithoutOverwrite(directory) {
-  const filePath = stateFilePath(directory);
-  if (!fs2.existsSync(filePath))
-    return;
-  const canonical = importedStateFilePath(directory);
-  if (!fs2.existsSync(canonical)) {
-    fs2.renameSync(filePath, canonical);
-    return;
-  }
-  for (let suffix = 1;suffix <= 1000; suffix += 1) {
-    const candidate = `${canonical}.${suffix}`;
-    if (fs2.existsSync(candidate))
-      continue;
-    fs2.renameSync(filePath, candidate);
-    return;
-  }
-  throw new Error("Epic state legacy archive collision limit exceeded");
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function validatePersistedShape(parsed) {
-  return isRecord(parsed) && parsed.version === 1 && isRecord(parsed.sessions);
-}
-function parsePersistedJson(raw) {
-  const parsed = JSON.parse(raw);
-  if (!validatePersistedShape(parsed)) {
-    const maybe = parsed;
-    throw new Error(`malformed shape (version=${maybe?.version}, sessions type=${Array.isArray(maybe?.sessions) ? "array" : typeof maybe?.sessions})`);
-  }
-  return {
-    version: 1,
-    updatedAt: typeof parsed.updatedAt === "string" && parsed.updatedAt.length > 0 ? parsed.updatedAt : nowISO(),
-    sessions: parsed.sessions
-  };
-}
-function parseSessionPayload(payload, entityKey) {
-  const parsed = JSON.parse(payload);
-  if (!isRecord(parsed) || parsed.sessionID !== entityKey) {
-    throw new Error(`session payload malformed for ${entityKey}: sessionID mismatch`);
-  }
-  return parsed;
-}
-function buildPersistedFromCoordination(directory) {
-  const rows = listCoordinationStates(directory, COORDINATION_NAMESPACE);
-  if (rows.length === 0)
-    return null;
-  const sessions = {};
-  let updatedAt = "";
-  for (const row of rows) {
-    sessions[row.entityKey] = parseSessionPayload(row.payload, row.entityKey);
-    if (!updatedAt || row.updatedAt > updatedAt)
-      updatedAt = row.updatedAt;
-  }
-  return {
-    version: 1,
-    updatedAt: updatedAt || nowISO(),
-    sessions
-  };
-}
-function readLegacyPersisted(directory) {
-  const filePath = stateFilePath(directory);
-  if (!fs2.existsSync(filePath))
-    return null;
-  const raw = fs2.readFileSync(filePath, "utf-8");
-  return {
-    persisted: parsePersistedJson(raw),
-    sourceDigest: createHash3("sha256").update(raw).digest("hex")
-  };
-}
-function writeProjection(directory, persisted) {
-  ensureSwarmDir(directory);
-  const filePath = stateFilePath(directory);
-  if (fs2.existsSync(filePath) && fs2.lstatSync(filePath).isDirectory()) {
-    throw new Error(`${STATE_FILE} is a directory`);
-  }
-  const payload = `${JSON.stringify(persisted, null, 2)}
-`;
-  atomicWriteSwarmFileSync(filePath, payload);
-}
-function seedProjectionBestEffort(directory, persisted) {
-  try {
-    writeProjection(directory, persisted);
-  } catch {}
-}
-function preflightProjectionTarget(directory) {
-  ensureSwarmDir(directory);
-  const filePath = stateFilePath(directory);
-  if (fs2.existsSync(filePath) && fs2.lstatSync(filePath).isDirectory()) {
-    throw new Error(`Epic state persistence prepare failed: ${STATE_FILE} is a directory`);
-  }
-}
-function importLegacyStateIfNeeded(directory) {
-  const legacy = readLegacyPersisted(directory);
-  if (!legacy)
-    return null;
-  const outcome = importCoordinationOnce(directory, {
-    source: STATE_FILE,
-    sourceDigest: legacy.sourceDigest,
-    rowCount: Object.keys(legacy.persisted.sessions).length,
-    emptyNamespace: COORDINATION_NAMESPACE
-  }, () => {
-    for (const [sessionID, state] of Object.entries(legacy.persisted.sessions)) {
-      const result = transitionCoordinationState(directory, {
-        namespace: COORDINATION_NAMESPACE,
-        entityKey: sessionID,
-        expectedRevision: null,
-        generation: 1,
-        status: state.active ? "active" : "inactive",
-        payload: JSON.stringify(state)
-      });
-      if (result.outcome !== "applied") {
-        throw new Error("Epic legacy import conflict");
-      }
-    }
-  });
-  if (outcome === "imported") {
-    archiveStateFileWithoutOverwrite(directory);
-  }
-  const authoritative = buildPersistedFromCoordination(directory) ?? emptyPersisted();
-  seedProjectionBestEffort(directory, authoritative);
-  return authoritative;
-}
-function unreadableStateError(directory) {
-  return new Error(`Epic state is unreadable for ${directory}. Repair .swarm/${STATE_FILE} before continuing.`);
-}
-function ensureReadableState(directory) {
-  if (stateUnreadableMap.get(stateKey(directory)))
-    throw unreadableStateError(directory);
-  if (!readPersisted(directory))
-    throw unreadableStateError(directory);
-}
-function refreshProjectionFromCoordination(directory) {
-  const persisted = buildPersistedFromCoordination(directory) ?? emptyPersisted();
-  writeProjection(directory, persisted);
-}
-function saveSessionRowAtomic(directory, state) {
-  preflightProjectionTarget(directory);
-  ensureReadableState(directory);
-  for (let attempt = 0;attempt < MAX_SESSION_WRITE_ATTEMPTS; attempt++) {
-    const current = getCoordinationState(directory, COORDINATION_NAMESPACE, state.sessionID);
-    const result = transitionCoordinationState(directory, {
-      namespace: COORDINATION_NAMESPACE,
-      entityKey: state.sessionID,
-      expectedRevision: current?.revision ?? null,
-      generation: (current?.generation ?? 0) + 1,
-      status: state.active ? "active" : "inactive",
-      payload: JSON.stringify(state)
-    });
-    if (result.outcome === "applied") {
-      refreshProjectionFromCoordination(directory);
-      return;
-    }
-    if (result.outcome === "revision_conflict" || result.outcome === "stale_generation") {
-      continue;
-    }
-    throw new Error(`Epic state persistence failed: ${result.outcome} for ${state.sessionID}`);
-  }
-  throw new Error(`Epic state persistence failed: contention for ${state.sessionID}`);
-}
-function mutateSessionRowAtomic(directory, sessionID, mutate) {
-  preflightProjectionTarget(directory);
-  ensureReadableState(directory);
-  for (let attempt = 0;attempt < MAX_SESSION_WRITE_ATTEMPTS; attempt++) {
-    const current = getCoordinationState(directory, COORDINATION_NAMESPACE, sessionID);
-    if (!current)
-      return null;
-    const nextState = parseSessionPayload(current.payload, sessionID);
-    mutate(nextState);
-    const result = transitionCoordinationState(directory, {
-      namespace: COORDINATION_NAMESPACE,
-      entityKey: sessionID,
-      expectedRevision: current.revision,
-      generation: current.generation + 1,
-      status: nextState.active ? "active" : "inactive",
-      payload: JSON.stringify(nextState)
-    });
-    if (result.outcome === "applied") {
-      refreshProjectionFromCoordination(directory);
-      return nextState;
-    }
-    if (result.outcome === "revision_conflict" || result.outcome === "stale_generation") {
-      continue;
-    }
-    throw new Error(`Epic state persistence failed: ${result.outcome} for ${sessionID}`);
-  }
-  throw new Error(`Epic state persistence failed: contention for ${sessionID}`);
-}
-function emptyPersisted() {
-  return { version: 1, updatedAt: nowISO(), sessions: {} };
-}
-function emptySessionState(sessionID) {
-  return { sessionID, active: false };
-}
-var stateUnreadableMap = new Map;
-function stateKey(directory) {
-  return canonicalRootKeyFresh(directory);
-}
-function isStateUnreadable(directory) {
-  return stateUnreadableMap.get(stateKey(directory)) ?? false;
-}
-function markStateUnreadable(directory, reason) {
-  stateUnreadableMap.set(stateKey(directory), true);
-  error(`[turbo/epic/state] state unreadable for ${directory}: ${reason} \u2014 failing closed`);
-}
-function readPersisted(directory) {
-  try {
-    const coordinated = buildPersistedFromCoordination(directory);
-    if (coordinated) {
-      const filePath = stateFilePath(directory);
-      if (fs2.existsSync(filePath)) {
-        let matches = false;
-        try {
-          matches = JSON.stringify(parsePersistedJson(fs2.readFileSync(filePath, "utf-8"))) === JSON.stringify(coordinated);
-        } catch {
-          matches = false;
-        }
-        if (!matches)
-          archiveStateFileWithoutOverwrite(directory);
-      }
-      seedProjectionBestEffort(directory, coordinated);
-      return coordinated;
-    }
-    const imported = importLegacyStateIfNeeded(directory);
-    if (imported)
-      return imported;
-    const seed = emptyPersisted();
-    seedProjectionBestEffort(directory, seed);
-    return seed;
-  } catch (error2) {
-    const reason = error2 instanceof Error ? error2.message : String(error2);
-    markStateUnreadable(directory, reason);
-    return null;
-  }
-}
-function loadEpicSessionState(directory, sessionID) {
-  if (stateUnreadableMap.get(stateKey(directory)))
-    return null;
-  const persisted = readPersisted(directory);
-  if (!persisted)
-    return null;
-  return persisted.sessions[sessionID] ?? null;
-}
-function isEpicModeActive(directory, sessionID) {
-  const state = loadEpicSessionState(directory, sessionID);
-  return state?.active === true;
-}
-function isEpicModeActiveForProject(directory) {
-  if (directory.split(/[\\/]/).includes(".."))
-    return false;
-  if (stateUnreadableMap.get(stateKey(directory)))
-    return false;
-  const hasLegacyFile = fs2.existsSync(stateFilePath(directory));
-  let hasCoordinationRows = false;
-  try {
-    hasCoordinationRows = projectDbExists(directory) && listCoordinationStates(directory, COORDINATION_NAMESPACE, 1).length > 0;
-  } catch {
-    return false;
-  }
-  if (!hasLegacyFile && !hasCoordinationRows) {
-    return false;
-  }
-  const persisted = readPersisted(directory);
-  if (!persisted)
-    return false;
-  for (const session of Object.values(persisted.sessions)) {
-    if (session?.active === true)
-      return true;
-  }
-  return false;
-}
-function enableEpicMode(directory, sessionID) {
-  const current = loadEpicSessionState(directory, sessionID);
-  if (!current) {
-    saveSessionRowAtomic(directory, {
-      ...emptySessionState(sessionID),
-      active: true,
-      enabledAt: nowISO(),
-      disabledAt: undefined
-    });
-    return;
-  }
-  mutateSessionRowAtomic(directory, sessionID, (state) => {
-    state.active = true;
-    state.enabledAt = nowISO();
-    state.disabledAt = undefined;
-  });
-}
-function disableEpicMode(directory, sessionID) {
-  const current = loadEpicSessionState(directory, sessionID);
-  if (!current) {
-    saveSessionRowAtomic(directory, {
-      ...emptySessionState(sessionID),
-      disabledAt: nowISO()
-    });
-    return;
-  }
-  mutateSessionRowAtomic(directory, sessionID, (state) => {
-    state.active = false;
-    state.disabledAt = nowISO();
-  });
-}
-
-// src/turbo/epic/task-commit.ts
-init_logger();
-function scrubTaskIdForGitSubject(taskId) {
-  return taskId.replace(/[^a-zA-Z0-9._-]/g, "_");
-}
-function formatTaskCommitMessage(taskId, description) {
-  const safeId = scrubTaskIdForGitSubject(taskId);
-  const summary = (description ?? "completed").replace(/\s+/g, " ").trim();
-  const truncated = summary.length > 60 ? `${summary.slice(0, 57)}...` : summary;
-  return `swarm(task ${safeId}): ${truncated || "completed"}`;
-}
-var INDEX_LOCK_BACKOFF_MS = [100, 200, 400, 800];
-var INDEX_LOCK_ERROR_RE = /index\.lock|unable to create.*\.lock/i;
-function isLockContentionError(err) {
-  const msg = err instanceof Error ? err.message : String(err);
-  return INDEX_LOCK_ERROR_RE.test(msg);
-}
-async function commitTaskCompletion(directory, taskId, description, scopePaths) {
-  if (!_internals3.isGitRepo(directory)) {
-    return { committed: false, reason: "no-git" };
-  }
-  try {
-    if (_internals3.hasExistingTaskCommit(directory, taskId)) {
-      return { committed: true, reason: "idempotent-skip" };
-    }
-  } catch {}
-  const rawPaths = (scopePaths ?? []).filter((p) => typeof p === "string" && p.trim().length > 0);
-  const droppedMagic = [];
-  const paths = rawPaths.filter((p) => {
-    if (p.startsWith(":")) {
-      droppedMagic.push(p);
-      return false;
-    }
-    return true;
-  });
-  if (droppedMagic.length > 0) {
-    criticalWarn(`[epic:task-commit] dropped ${droppedMagic.length} scope path(s) starting with ':' (git pathspec magic, not allowed): ${droppedMagic.slice(0, 5).join(", ")}${droppedMagic.length > 5 ? `, +${droppedMagic.length - 5} more` : ""}. Architect should declare literal file paths only.`);
-  }
-  const message = formatTaskCommitMessage(taskId, description);
-  let lastError = null;
-  for (let attempt = 0;attempt <= INDEX_LOCK_BACKOFF_MS.length; attempt++) {
-    try {
-      if (paths.length > 0) {
-        _internals3.stageScopedPaths(directory, paths);
-      }
-      _internals3.commitAllowEmpty(directory, message);
-      const sha = _internals3.gitHeadSha(directory);
-      return { committed: true, reason: "success", sha };
-    } catch (err) {
-      lastError = err;
-      if (attempt < INDEX_LOCK_BACKOFF_MS.length && isLockContentionError(err)) {
-        await _internals3.sleep(INDEX_LOCK_BACKOFF_MS[attempt]);
-        continue;
-      }
-      break;
-    }
-  }
-  const msg = lastError instanceof Error ? lastError.message : String(lastError);
-  criticalWarn(`[epic:task-commit] commit for task ${taskId} failed (non-fatal): ${msg}`);
-  return { committed: false, reason: "commit-failed", error: msg };
-}
-var _internals3 = {
-  isGitRepo: (cwd) => isGitRepo(cwd),
-  stageScopedPaths: (cwd, paths) => {
-    const CHUNK = 200;
-    for (let i = 0;i < paths.length; i += CHUNK) {
-      const chunk = paths.slice(i, i + CHUNK);
-      _internals.gitExec(["add", "--", ...chunk, ":(exclude,glob)**/.swarm/**"], cwd);
-    }
-  },
-  commitAllowEmpty: (cwd, message) => {
-    _internals.gitExec(["commit", "--allow-empty", "--no-verify", "-m", message], cwd);
-  },
-  gitHeadSha: (cwd) => {
-    return _internals.gitExec(["rev-parse", "HEAD"], cwd).trim();
-  },
-  sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
-  hasExistingTaskCommit: (cwd, taskId) => {
-    const safeId = scrubTaskIdForGitSubject(taskId);
-    const escaped = safeId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const output = _internals.gitExec([
-      "log",
-      "--extended-regexp",
-      `--grep=^swarm\\(task ${escaped}\\):`,
-      "--pretty=format:%H",
-      "-n",
-      "1"
-    ], cwd);
-    return output.trim().length > 0;
-  }
-};
-
 // src/utils/spec-hash.ts
 import { createHash as createHash4 } from "crypto";
-import * as fsSync2 from "fs";
-import { join as join2 } from "path";
+import * as fsSync from "fs";
+import { join as join3 } from "path";
 async function computeSpecHash(directory) {
-  const spec = _internals4.readEffectiveSpecSync(directory);
+  const spec = _internals6.readEffectiveSpecSync(directory);
   if (!spec)
     return null;
   return createHash4("sha256").update(spec.content, "utf-8").digest("hex");
 }
 async function isSpecStale(directory, plan) {
-  const currentHash = await _internals4.computeSpecHash(directory);
+  const currentHash = await _internals6.computeSpecHash(directory);
   if (!plan.specHash) {
     return { stale: false };
   }
@@ -1560,15 +1230,15 @@ async function isSpecStale(directory, plan) {
   return { stale: false };
 }
 function isObligationPreserving(directory) {
-  const snapshotPath = join2(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join3(directory, ".swarm", "spec-snapshot.md");
   try {
     let recordedContent;
     try {
-      recordedContent = fsSync2.readFileSync(snapshotPath, "utf-8");
+      recordedContent = fsSync.readFileSync(snapshotPath, "utf-8");
     } catch {
       return false;
     }
-    const currentResult = _internals4.readEffectiveSpecSync(directory);
+    const currentResult = _internals6.readEffectiveSpecSync(directory);
     if (!currentResult || !currentResult.content) {
       return false;
     }
@@ -1598,7 +1268,7 @@ function isObligationPreserving(directory) {
     return false;
   }
 }
-var _internals4 = {
+var _internals6 = {
   computeSpecDiff,
   computeSpecHash,
   isObligationPreserving,
@@ -1606,19 +1276,19 @@ var _internals4 = {
   readEffectiveSpecSync
 };
 function computeSpecDiff(directory) {
-  const snapshotPath = join2(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join3(directory, ".swarm", "spec-snapshot.md");
   let recordedContent;
   try {
-    const snapshotSize = fsSync2.statSync(snapshotPath).size;
+    const snapshotSize = fsSync.statSync(snapshotPath).size;
     const MAX_SNAPSHOT_BYTES = 512 * 1024;
     if (snapshotSize > MAX_SNAPSHOT_BYTES) {
       return null;
     }
-    recordedContent = fsSync2.readFileSync(snapshotPath, "utf-8");
+    recordedContent = fsSync.readFileSync(snapshotPath, "utf-8");
   } catch {
     return null;
   }
-  const spec = _internals4.readEffectiveSpecSync(directory);
+  const spec = _internals6.readEffectiveSpecSync(directory);
   if (!spec) {
     return null;
   }
@@ -1719,7 +1389,7 @@ var startupLedgerCheckedWorkspaces = new Set;
 var ledgerStaleWorkspaces = new Set;
 var recoveryMutexes = new Map;
 var PLAN_JSON_CACHE_NAMESPACE = "plan-json:validated:v1";
-var _internals5 = {
+var _internals7 = {
   loadPlan,
   loadPlanJsonOnly,
   readPlanJsonUtf8,
@@ -1731,10 +1401,7 @@ var _internals5 = {
   loadLastApprovedPlan,
   readLedgerEventsWithIntegrity,
   regeneratePlanMarkdown,
-  isGitRepo,
-  isEpicModeActiveForProject,
-  commitTaskCompletion,
-  getWorktreeMergeFailure,
+  epicMergeFailureSkipsCheckpoint,
   recordTaskAttempt,
   maybeSaveAutoCheckpoint: defaultMaybeSaveAutoCheckpoint
 };
@@ -1813,9 +1480,9 @@ async function retryCasWithBackoff(directory, eventInput, options) {
         planHashAfter: options.planHashAfter,
         preCommitCheck: options.preCommitCheck
       });
-    } catch (error2) {
-      if (!(error2 instanceof LedgerStaleWriterError) || attempt >= maxRetries) {
-        throw error2;
+    } catch (error) {
+      if (!(error instanceof LedgerStaleWriterError) || attempt >= maxRetries) {
+        throw error;
       }
       attempt++;
       const base = Math.min(CAS_BACKOFF_START_MS * 2 ** (attempt - 1), CAS_BACKOFF_CAP_MS);
@@ -1826,7 +1493,7 @@ async function retryCasWithBackoff(directory, eventInput, options) {
         expectedHashPrefix: currentExpected.slice(0, 8),
         delayMs
       });
-      await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+      await new Promise((resolve4) => setTimeout(resolve4, delayMs));
       if (options.verifyValid) {
         const stillValid = await options.verifyValid();
         if (!stillValid)
@@ -1839,8 +1506,8 @@ async function retryCasWithBackoff(directory, eventInput, options) {
 async function loadPlanJsonOnly(directory) {
   try {
     return await parsePlanJsonCached(directory);
-  } catch (error2) {
-    warn(`Plan validation failed for .swarm/plan.json: ${error2 instanceof Error ? error2.message : String(error2)}`);
+  } catch (error) {
+    warn(`Plan validation failed for .swarm/plan.json: ${error instanceof Error ? error.message : String(error)}`);
   }
   return null;
 }
@@ -1881,9 +1548,9 @@ async function surfaceLedgerStaleIfPersisted(directory, plan, options) {
       ledgerStaleWorkspaces.delete(resolvedWorkspace);
       return plan;
     }
-  } catch (error2) {
-    if (error2 instanceof PlanRecoverySupersededError)
-      throw error2;
+  } catch (error) {
+    if (error instanceof PlanRecoverySupersededError)
+      throw error;
   }
   plan._ledgerReplayStale = true;
   if (typeof plan._ledgerReplayStaleReason !== "string" || plan._ledgerReplayStaleReason.length === 0) {
@@ -1893,7 +1560,7 @@ async function surfaceLedgerStaleIfPersisted(directory, plan, options) {
 }
 async function parsePlanJsonCached(directory) {
   const planJsonPath = path3.resolve(directory, ".swarm", "plan.json");
-  return readCachedParsedFile(planJsonPath, PLAN_JSON_CACHE_NAMESPACE, () => _internals5.readPlanJsonUtf8(directory), (planJsonContent) => {
+  return readCachedParsedFile(planJsonPath, PLAN_JSON_CACHE_NAMESPACE, () => _internals7.readPlanJsonUtf8(directory), (planJsonContent) => {
     if (planJsonContent.includes("\x00")) {
       throw new Error("Plan rejected: .swarm/plan.json contains null bytes");
     }
@@ -1902,7 +1569,7 @@ async function parsePlanJsonCached(directory) {
   });
 }
 async function readPlanJsonUtf8(directory) {
-  return readSwarmFileAsync(directory, "plan.json", undefined, (filePath) => _internals5.readPlanFileUtf8(filePath), false);
+  return readSwarmFileAsync(directory, "plan.json", undefined, (filePath) => _internals7.readPlanFileUtf8(filePath), false);
 }
 async function readPlanFileUtf8(filePath) {
   return new TextDecoder("utf-8", { fatal: true }).decode(await fsPromises.readFile(filePath));
@@ -1970,10 +1637,10 @@ ${markdown}`;
   try {
     await bunWrite(mdTempPath, markdownWithHash);
     options?.preCommitCheck?.();
-    renameSync2(mdTempPath, mdPath);
+    renameSync(mdTempPath, mdPath);
   } finally {
     try {
-      unlinkSync(mdTempPath);
+      unlinkSync2(mdTempPath);
     } catch {}
   }
   invalidateCachedArtifact(mdPath);
@@ -1983,9 +1650,9 @@ async function loadPlan(directory, cache, options) {
   let planJsonContent = null;
   let claimedStartupWorkspace = null;
   try {
-    planJsonContent = await _internals5.readPlanJsonUtf8(directory);
-  } catch (error2) {
-    warn(`Plan rejected: .swarm/plan.json could not be decoded as valid UTF-8: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    planJsonContent = await _internals7.readPlanJsonUtf8(directory);
+  } catch (error) {
+    warn(`Plan rejected: .swarm/plan.json could not be decoded as valid UTF-8: ${error instanceof Error ? error.message : String(error)}`);
   }
   if (planJsonContent !== null) {
     if (planJsonContent.includes("\x00")) {
@@ -1999,7 +1666,7 @@ async function loadPlan(directory, cache, options) {
           const inSync = await isPlanMdInSync(directory, validated, cache);
           if (!inSync) {
             try {
-              await _internals5.regeneratePlanMarkdown(directory, validated, {
+              await _internals7.regeneratePlanMarkdown(directory, validated, {
                 preCommitCheck: options?.preCommitCheck
               });
             } catch (regenError) {
@@ -2115,9 +1782,9 @@ async function loadPlan(directory, cache, options) {
                     changedSections: diffInfo?.changedSections ?? []
                   }, null, 2), options?.preCommitCheck, "spec-staleness");
                   invalidateCachedArtifact(specStalenessPath);
-                } catch (error2) {
-                  if (error2 instanceof PlanRecoverySupersededError)
-                    throw error2;
+                } catch (error) {
+                  if (error instanceof PlanRecoverySupersededError)
+                    throw error;
                 }
                 try {
                   assertProjectRoot(directory);
@@ -2132,23 +1799,23 @@ async function loadPlan(directory, cache, options) {
                   };
                   options?.preCommitCheck?.();
                   appendCoreEventSync(directory, { ...event });
-                } catch (error2) {
-                  if (error2 instanceof PlanRecoverySupersededError)
-                    throw error2;
+                } catch (error) {
+                  if (error instanceof PlanRecoverySupersededError)
+                    throw error;
                 }
               }
             }
           }
           return await surfaceLedgerStaleIfPersisted(directory, validated, options);
         }
-      } catch (error2) {
-        if (error2 instanceof PlanRecoverySupersededError) {
+      } catch (error) {
+        if (error instanceof PlanRecoverySupersededError) {
           if (claimedStartupWorkspace !== null) {
             startupLedgerCheckedWorkspaces.delete(claimedStartupWorkspace);
           }
-          throw error2;
+          throw error;
         }
-        warn(`[loadPlan] plan.json validation failed: ${error2 instanceof Error ? error2.message : String(error2)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/plan-export/SWARM_PLAN.md for a checkpoint.`);
+        warn(`[loadPlan] plan.json validation failed: ${error instanceof Error ? error.message : String(error)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/plan-export/SWARM_PLAN.md for a checkpoint.`);
         let rawPlanId = null;
         let rawPlanJsonParseFailed = false;
         try {
@@ -2159,8 +1826,8 @@ async function loadPlan(directory, cache, options) {
         } catch {
           rawPlanJsonParseFailed = true;
         }
-        if (await _internals5.ledgerExists(directory)) {
-          const catchIntegrity = await _internals5.readLedgerEventsWithIntegrity(directory);
+        if (await _internals7.ledgerExists(directory)) {
+          const catchIntegrity = await _internals7.readLedgerEventsWithIntegrity(directory);
           const ledgerEventsForCatch = catchIntegrity.events;
           const catchFirstEvent = ledgerEventsForCatch.length > 0 ? ledgerEventsForCatch[0] : null;
           const identityMatch = rawPlanId === null || catchFirstEvent === null || catchFirstEvent.plan_id === rawPlanId;
@@ -2169,7 +1836,7 @@ async function loadPlan(directory, cache, options) {
           } else if (catchFirstEvent !== null && (rawPlanId !== null || rawPlanJsonParseFailed && !catchIntegrity.truncated)) {
             let rebuilt = null;
             try {
-              rebuilt = await _internals5.replayFromLedger(directory, {
+              rebuilt = await _internals7.replayFromLedger(directory, {
                 preCommitCheck: options?.preCommitCheck
               });
             } catch (replayError) {
@@ -2186,7 +1853,7 @@ async function loadPlan(directory, cache, options) {
               return rebuilt;
             }
             try {
-              const approved = await _internals5.loadLastApprovedPlan(directory, catchFirstEvent.plan_id);
+              const approved = await _internals7.loadLastApprovedPlan(directory, catchFirstEvent.plan_id);
               if (approved) {
                 const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, approved.plan, "load_plan_recovery_from_approved_snapshot", "restore from critic-approved snapshot", { preCommitCheck: options?.preCommitCheck });
                 if (removedCount > 0) {
@@ -2232,12 +1899,12 @@ async function loadPlan(directory, cache, options) {
       }
     }
   }
-  if (await _internals5.ledgerExists(directory)) {
+  if (await _internals7.ledgerExists(directory)) {
     const resolvedDir = canonicalRootKeyFresh(directory);
     const existingMutex = recoveryMutexes.get(resolvedDir);
     if (existingMutex) {
       await existingMutex;
-      const postRecoveryPlan = await _internals5.loadPlanJsonOnly(directory);
+      const postRecoveryPlan = await _internals7.loadPlanJsonOnly(directory);
       if (postRecoveryPlan)
         return postRecoveryPlan;
     }
@@ -2249,7 +1916,7 @@ async function loadPlan(directory, cache, options) {
     try {
       let rebuilt = null;
       try {
-        rebuilt = await _internals5.replayFromLedger(directory, {
+        rebuilt = await _internals7.replayFromLedger(directory, {
           preCommitCheck: options?.preCommitCheck
         });
       } catch (replayError) {
@@ -2268,14 +1935,14 @@ async function loadPlan(directory, cache, options) {
         return rebuilt;
       }
       try {
-        const anchorIntegrity = await _internals5.readLedgerEventsWithIntegrity(directory);
+        const anchorIntegrity = await _internals7.readLedgerEventsWithIntegrity(directory);
         const anchorEvents = anchorIntegrity.events;
         if (anchorEvents.length === 0) {
           warn("[loadPlan] Ledger present but no events readable \u2014 refusing approved-snapshot recovery (cannot verify plan identity).");
           return null;
         }
         const expectedPlanId = anchorEvents[0].plan_id;
-        const approved = await _internals5.loadLastApprovedPlan(directory, expectedPlanId);
+        const approved = await _internals7.loadLastApprovedPlan(directory, expectedPlanId);
         if (approved) {
           const approvedPhase = approved.approval && typeof approved.approval === "object" && "phase" in approved.approval ? approved.approval.phase : undefined;
           warn(`[loadPlan] Ledger replay returned no plan \u2014 recovered from critic-approved snapshot seq=${approved.seq} timestamp=${approved.timestamp} (approval phase=${approvedPhase ?? "unknown"}). This may roll the plan back to an earlier phase \u2014 verify before continuing.`);
@@ -2325,7 +1992,7 @@ async function loadPlan(directory, cache, options) {
   return null;
 }
 async function savePlanWithAutoAcknowledgedRemovals(directory, plan, source, reason, options) {
-  const existing = await _internals5.loadPlanJsonOnly(directory);
+  const existing = await _internals7.loadPlanJsonOnly(directory);
   const newIds = new Set;
   for (const phase of plan.phases) {
     for (const task of phase.tasks)
@@ -2372,14 +2039,14 @@ var PLAN_WRITE_VERIFY_READ_BACKOFF_MS = 200;
 async function verifyWrittenPlanJson(directory, expected) {
   let content;
   try {
-    content = await readSwarmFileAsync(directory, "plan.json", undefined, (filePath) => _internals5.readPlanFileUtf8(filePath), false);
-  } catch (error2) {
-    throw new PlanWriteVerificationError(`PLAN_WRITE_VERIFICATION_FAILED: plan.json read-back could not be read (${error2 instanceof Error ? error2.message : String(error2)})`);
+    content = await readSwarmFileAsync(directory, "plan.json", undefined, (filePath) => _internals7.readPlanFileUtf8(filePath), false);
+  } catch (error) {
+    throw new PlanWriteVerificationError(`PLAN_WRITE_VERIFICATION_FAILED: plan.json read-back could not be read (${error instanceof Error ? error.message : String(error)})`);
   }
   for (let attempt = 0;content === null && attempt < PLAN_WRITE_VERIFY_READ_RETRIES; attempt++) {
-    await new Promise((resolve3) => setTimeout(resolve3, PLAN_WRITE_VERIFY_READ_BACKOFF_MS * (attempt + 1)));
+    await new Promise((resolve4) => setTimeout(resolve4, PLAN_WRITE_VERIFY_READ_BACKOFF_MS * (attempt + 1)));
     try {
-      content = await readSwarmFileAsync(directory, "plan.json", undefined, (filePath) => _internals5.readPlanFileUtf8(filePath), false);
+      content = await readSwarmFileAsync(directory, "plan.json", undefined, (filePath) => _internals7.readPlanFileUtf8(filePath), false);
     } catch {}
   }
   if (content === null) {
@@ -2388,8 +2055,8 @@ async function verifyWrittenPlanJson(directory, expected) {
   let parsed;
   try {
     parsed = JSON.parse(content);
-  } catch (error2) {
-    throw new PlanWriteVerificationError(`PLAN_WRITE_VERIFICATION_FAILED: plan.json read-back did not parse (${error2 instanceof Error ? error2.message : String(error2)})`);
+  } catch (error) {
+    throw new PlanWriteVerificationError(`PLAN_WRITE_VERIFICATION_FAILED: plan.json read-back did not parse (${error instanceof Error ? error.message : String(error)})`);
   }
   if (JSON.stringify(parsed) !== JSON.stringify(expected)) {
     throw new PlanWriteVerificationError("PLAN_WRITE_VERIFICATION_FAILED: plan.json read-back content differs from the projected plan");
@@ -2408,10 +2075,10 @@ async function appendMigrationProvenanceEvent(directory, plan, preCommitCheck) {
         tasks_count: plan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0)
       }
     }, { preCommitCheck });
-  } catch (error2) {
-    if (error2 instanceof PlanRecoverySupersededError)
-      throw error2;
-    warn(`[loadPlan] Markdown-migration provenance event append failed (plan remains migrated): ${error2 instanceof Error ? error2.message : String(error2)}`);
+  } catch (error) {
+    if (error instanceof PlanRecoverySupersededError)
+      throw error;
+    warn(`[loadPlan] Markdown-migration provenance event append failed (plan remains migrated): ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 async function savePlan(directory, plan, options) {
@@ -2442,7 +2109,7 @@ async function savePlan(directory, plan, options) {
   }
   if (options?.preserveCompletedStatuses !== false) {
     try {
-      const currentPlan2 = await _internals5.loadPlanJsonOnly(directory);
+      const currentPlan2 = await _internals7.loadPlanJsonOnly(directory);
       if (currentPlan2) {
         const completedTaskIds = new Set;
         for (const phase of currentPlan2.phases) {
@@ -2465,7 +2132,7 @@ async function savePlan(directory, plan, options) {
   }
   derivePhaseStatusesInPlace(validated);
   normalizeCurrentPhaseInPlace(validated);
-  const currentPlan = await _internals5.loadPlanJsonOnly(directory);
+  const currentPlan = await _internals7.loadPlanJsonOnly(directory);
   const planId = derivePlanId(validated);
   const planHashForInit = computePlanLedgerHash(validated);
   if (!await ledgerExists(directory)) {
@@ -2504,7 +2171,7 @@ async function savePlan(directory, plan, options) {
       throw new PlanConcurrentModificationError("RECONCILE_LEDGER_PROJECTION_STALE: the ledger identity or tail changed before the recovery snapshot could be appended.");
     }
     try {
-      const integrity = await _internals5.readLedgerEventsWithIntegrity(directory);
+      const integrity = await _internals7.readLedgerEventsWithIntegrity(directory);
       if (integrity.truncated) {
         await replaceTruncatedLedgerWithRecoveryRoot(directory, validated, {
           seq: expected.expectedSeq,
@@ -2518,11 +2185,11 @@ async function savePlan(directory, plan, options) {
           expectedLedgerHash: expected.expectedLedgerHash
         });
       }
-    } catch (error2) {
-      if (error2 instanceof LedgerStaleWriterError) {
-        throw new PlanConcurrentModificationError(`RECONCILE_LEDGER_PROJECTION_STALE: ${error2.message}`);
+    } catch (error) {
+      if (error instanceof LedgerStaleWriterError) {
+        throw new PlanConcurrentModificationError(`RECONCILE_LEDGER_PROJECTION_STALE: ${error.message}`);
       }
-      throw error2;
+      throw error;
     }
   }
   const currentHash = computeCurrentPlanHash(directory);
@@ -2585,7 +2252,7 @@ async function savePlan(directory, plan, options) {
             planHashAfter: hashAfter,
             preCommitCheck: options?.preCommitCheck,
             verifyValid: async () => {
-              const onDisk = await _internals5.loadPlanJsonOnly(directory);
+              const onDisk = await _internals7.loadPlanJsonOnly(directory);
               if (!onDisk)
                 return true;
               for (const p of onDisk.phases) {
@@ -2596,11 +2263,11 @@ async function savePlan(directory, plan, options) {
             }
           });
         }
-      } catch (error2) {
-        if (error2 instanceof LedgerStaleWriterError) {
-          throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error2.message}. Please retry the operation.`);
+      } catch (error) {
+        if (error instanceof LedgerStaleWriterError) {
+          throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error.message}. Please retry the operation.`);
         }
-        throw error2;
+        throw error;
       }
     }
     try {
@@ -2625,7 +2292,7 @@ async function savePlan(directory, plan, options) {
               planHashAfter: hashAfter,
               preCommitCheck: options?.preCommitCheck,
               verifyValid: async () => {
-                const onDisk = await _internals5.loadPlanJsonOnly(directory);
+                const onDisk = await _internals7.loadPlanJsonOnly(directory);
                 if (!onDisk)
                   return true;
                 for (const p of onDisk.phases) {
@@ -2640,15 +2307,15 @@ async function savePlan(directory, plan, options) {
           }
         }
       }
-    } catch (error2) {
-      if (error2 instanceof LedgerStaleWriterError) {
-        throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error2.message}. Please retry the operation.`);
+    } catch (error) {
+      if (error instanceof LedgerStaleWriterError) {
+        throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error.message}. Please retry the operation.`);
       }
-      throw error2;
+      throw error;
     }
   }
   const ledgerStatusTaskIds = collectLedgerStatusTaskIds(await readLedgerEvents(directory));
-  const replayedBeforeProjection = await _internals5.replayFromLedger(directory, {
+  const replayedBeforeProjection = await _internals7.replayFromLedger(directory, {
     preCommitCheck: options?.preCommitCheck
   });
   const projectionCandidate = replayedBeforeProjection ? mergeStatusesTakingPrecedence(validated, replayedBeforeProjection, ledgerStatusTaskIds) : validated;
@@ -2675,14 +2342,14 @@ async function savePlan(directory, plan, options) {
   try {
     await bunWrite(tempPath, JSON.stringify(projectedPlan, null, 2));
     options?.preCommitCheck?.();
-    renameSync2(tempPath, planPath);
+    renameSync(tempPath, planPath);
   } finally {
     try {
-      unlinkSync(tempPath);
+      unlinkSync2(tempPath);
     } catch {}
   }
   invalidateCachedArtifact(planPath);
-  await _internals5.verifyWrittenPlanJson(directory, projectedPlan);
+  await _internals7.verifyWrittenPlanJson(directory, projectedPlan);
   try {
     const markerPath = path3.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
@@ -2693,9 +2360,9 @@ async function savePlan(directory, plan, options) {
       in_progress: true
     });
     await commitAsyncPreparedFile(markerPath, inProgressMarker, options?.preCommitCheck, "plan-write-marker");
-  } catch (error2) {
-    if (error2 instanceof PlanRecoverySupersededError)
-      throw error2;
+  } catch (error) {
+    if (error instanceof PlanRecoverySupersededError)
+      throw error;
   }
   let mdWriteError;
   try {
@@ -2708,10 +2375,10 @@ ${markdown}`;
     try {
       await bunWrite(mdTempPath, markdownWithHash);
       options?.preCommitCheck?.();
-      renameSync2(mdTempPath, mdPath);
+      renameSync(mdTempPath, mdPath);
     } finally {
       try {
-        unlinkSync(mdTempPath);
+        unlinkSync2(mdTempPath);
       } catch {}
     }
     invalidateCachedArtifact(mdPath);
@@ -2740,9 +2407,9 @@ ${markdown}`;
       in_progress: false
     });
     await commitAsyncPreparedFile(markerPath, marker, options?.preCommitCheck, "plan-write-marker");
-  } catch (error2) {
-    if (error2 instanceof PlanRecoverySupersededError)
-      throw error2;
+  } catch (error) {
+    if (error instanceof PlanRecoverySupersededError)
+      throw error;
   }
   if (currentPlan) {
     try {
@@ -2793,12 +2460,12 @@ async function commitAsyncPreparedFile(targetPath, content, preCommitCheck, temp
   try {
     await bunWrite(tempPath, content);
     preCommitCheck?.();
-    renameSync2(tempPath, targetPath);
-  } catch (error2) {
+    renameSync(tempPath, targetPath);
+  } catch (error) {
     try {
-      unlinkSync(tempPath);
+      unlinkSync2(tempPath);
     } catch {}
-    throw error2;
+    throw error;
   }
 }
 async function writeRebuildPlanMarkdown(tempPath, content) {
@@ -2819,20 +2486,20 @@ async function rebuildPlan(directory, plan, options) {
   const tempPlanPath = path3.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     {
-      const fd = openSync(tempPlanPath, "w");
+      const fd = openSync2(tempPlanPath, "w");
       try {
         writeFileSync(fd, JSON.stringify(targetPlan, null, 2), "utf8");
         fsyncSync(fd);
       } finally {
-        closeSync(fd);
+        closeSync2(fd);
       }
     }
     options?.preCommitCheck?.();
-    renameSync2(tempPlanPath, planPath);
+    renameSync(tempPlanPath, planPath);
     invalidateCachedArtifact(planPath);
   } finally {
     try {
-      unlinkSync(tempPlanPath);
+      unlinkSync2(tempPlanPath);
     } catch {}
   }
   try {
@@ -2845,9 +2512,9 @@ async function rebuildPlan(directory, plan, options) {
       in_progress: true
     });
     await commitAsyncPreparedFile(markerPath, inProgressMarker, options?.preCommitCheck, "rebuild");
-  } catch (error2) {
-    if (error2 instanceof PlanRecoverySupersededError)
-      throw error2;
+  } catch (error) {
+    if (error instanceof PlanRecoverySupersededError)
+      throw error;
   }
   let markdownWriteFailed = false;
   let markdownWriteError;
@@ -2859,18 +2526,18 @@ async function rebuildPlan(directory, plan, options) {
 ${markdown}`;
     const tempMdPath = path3.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await _internals5.writeRebuildPlanMarkdown(tempMdPath, markdownWithHash);
+      await _internals7.writeRebuildPlanMarkdown(tempMdPath, markdownWithHash);
       options?.preCommitCheck?.();
-      renameSync2(tempMdPath, mdPath);
+      renameSync(tempMdPath, mdPath);
       invalidateCachedArtifact(mdPath);
     } finally {
       try {
-        unlinkSync(tempMdPath);
+        unlinkSync2(tempMdPath);
       } catch {}
     }
-  } catch (error2) {
+  } catch (error) {
     markdownWriteFailed = true;
-    markdownWriteError = error2;
+    markdownWriteError = error;
   } finally {
     try {
       const markerPath = path3.join(swarmDir, ".plan-write-marker");
@@ -2883,9 +2550,9 @@ ${markdown}`;
         in_progress: false
       });
       await commitAsyncPreparedFile(markerPath, marker, options?.preCommitCheck, "rebuild");
-    } catch (error2) {
-      if (error2 instanceof PlanRecoverySupersededError) {
-        markerSupersededError = error2;
+    } catch (error) {
+      if (error instanceof PlanRecoverySupersededError) {
+        markerSupersededError = error;
       }
     }
   }
@@ -2911,9 +2578,9 @@ ${markdown}`;
         tasks_count: targetPlan.phases.reduce((sum, p) => sum + p.tasks.length, 0)
       }
     }, { planHashAfter, preCommitCheck: options?.preCommitCheck });
-  } catch (error2) {
-    if (error2 instanceof PlanRecoverySupersededError)
-      throw error2;
+  } catch (error) {
+    if (error instanceof PlanRecoverySupersededError)
+      throw error;
   }
   return targetPlan;
 }
@@ -2958,7 +2625,7 @@ async function closePlanTerminalState(directory, plan, options) {
   const planPath = path3.join(swarmDir, "plan.json");
   const tempPlanPath = path3.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(validated, null, 2));
-  renameSync2(tempPlanPath, planPath);
+  renameSync(tempPlanPath, planPath);
   invalidateCachedArtifact(planPath);
   try {
     const markerPath = path3.join(swarmDir, ".plan-write-marker");
@@ -2979,7 +2646,7 @@ async function closePlanTerminalState(directory, plan, options) {
 ${markdown}`;
     const mdTempPath = path3.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(mdTempPath, markdownWithHash);
-    renameSync2(mdTempPath, mdPath);
+    renameSync(mdTempPath, mdPath);
     invalidateCachedArtifact(mdPath);
   } finally {
     try {
@@ -2997,7 +2664,7 @@ ${markdown}`;
   }
 }
 async function defaultMaybeSaveAutoCheckpoint(directory, plan) {
-  const { maybeSaveAutoCheckpoint } = await import("./auto-checkpoint-m7c4x8bk.js");
+  const { maybeSaveAutoCheckpoint } = await import("./auto-checkpoint-qvk04fya.js");
   return maybeSaveAutoCheckpoint(directory, plan);
 }
 async function updateTaskStatus(directory, taskId, status, options) {
@@ -3015,7 +2682,7 @@ async function updateTaskStatus(directory, taskId, status, options) {
     return "pending";
   };
   {
-    const currentPlan = await _internals5.loadPlanJsonOnly(directory);
+    const currentPlan = await _internals7.loadPlanJsonOnly(directory);
     if (currentPlan) {
       const currentTask = currentPlan.phases.flatMap((p) => p.tasks).find((t) => t.id === taskId);
       const settled = currentTask && currentTask.status !== "pending" && currentTask.status !== "in_progress";
@@ -3028,7 +2695,7 @@ async function updateTaskStatus(directory, taskId, status, options) {
   }
   const MAX_OUTER_RETRIES = 1;
   for (let attempt = 0;attempt <= MAX_OUTER_RETRIES; attempt++) {
-    const plan = await _internals5.loadPlan(directory);
+    const plan = await _internals7.loadPlan(directory);
     if (plan === null) {
       throw new Error(`Plan not found in directory: ${directory}`);
     }
@@ -3059,7 +2726,7 @@ async function updateTaskStatus(directory, taskId, status, options) {
       if (status === "completed" || status === "blocked") {
         const recordedTask = updatedPlan.phases.flatMap((phase) => phase.tasks).find((candidate) => candidate.id === taskId);
         try {
-          await _internals5.recordTaskAttempt(directory, {
+          await _internals7.recordTaskAttempt(directory, {
             taskId,
             agent: "plan-status",
             outcome: status === "completed" ? "pass" : "fail",
@@ -3073,7 +2740,7 @@ async function updateTaskStatus(directory, taskId, status, options) {
       if (status === "completed") {
         try {
           const completedTask = updatedPlan.phases.flatMap((phase) => phase.tasks).find((candidate) => candidate.id === taskId);
-          const { maybePropagateSpeckitCheckoff } = await import("./speckit-checkoff-aj75vmjq.js");
+          const { maybePropagateSpeckitCheckoff } = await import("./speckit-checkoff-k5jm0abh.js");
           await maybePropagateSpeckitCheckoff(directory, {
             taskId,
             frRefs: completedTask?.fr_refs ?? [],
@@ -3083,35 +2750,9 @@ async function updateTaskStatus(directory, taskId, status, options) {
           warn(`[plan/manager] speckit check-off for ${taskId} failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
         }
       }
-      if (status === "completed" && _internals5.isGitRepo(directory) && _internals5.isEpicModeActiveForProject(directory)) {
-        const mergeFailure = _internals5.getWorktreeMergeFailure(taskId);
-        if (mergeFailure) {
-          criticalWarn(`[plan/manager] Rule 2 auto-commit SKIPPED for ${taskId}: worktree merge-back ${mergeFailure.outcome} at stage '${mergeFailure.stage}'. The task's changes are NOT in the main tree, so no completion marker is written (Rule 3 must not treat this task as satisfied). Resolve the preserved worktree, then re-run the task. Detail: ${mergeFailure.message}`);
-          return updatedPlan;
-        }
-        try {
-          let taskDescription;
-          for (const phase of updatedPlan.phases) {
-            const found = phase.tasks.find((t) => t.id === taskId);
-            if (found) {
-              taskDescription = found.description;
-              break;
-            }
-          }
-          const { readDeclaredScopeFilesFromBindings } = await import("./scope-persistence-tbv2ar4w.js");
-          const canonicalScope = readDeclaredScopeFilesFromBindings({
-            directory,
-            taskId,
-            plan: updatedPlan
-          });
-          await _internals5.commitTaskCompletion(directory, taskId, taskDescription, canonicalScope ?? undefined);
-        } catch (commitErr) {
-          criticalWarn(`[plan/manager] Rule 2 auto-commit for ${taskId} threw (non-fatal): ${commitErr instanceof Error ? commitErr.message : String(commitErr)}`);
-        }
-      }
-      if (status === "completed") {
+      if (status === "completed" && !_internals7.epicMergeFailureSkipsCheckpoint(directory, taskId)) {
         try {
-          const outcome = await _internals5.maybeSaveAutoCheckpoint(directory, updatedPlan);
+          const outcome = await _internals7.maybeSaveAutoCheckpoint(directory, updatedPlan);
           if (outcome && outcome.saved === false && outcome.warning) {
             criticalWarn(`[plan/manager] auto-checkpoint for ${taskId} was not saved (non-fatal): ${outcome.warning}`);
           }
@@ -3120,11 +2761,11 @@ async function updateTaskStatus(directory, taskId, status, options) {
         }
       }
       return updatedPlan;
-    } catch (error2) {
-      if (error2 instanceof PlanConcurrentModificationError && attempt < MAX_OUTER_RETRIES) {
+    } catch (error) {
+      if (error instanceof PlanConcurrentModificationError && attempt < MAX_OUTER_RETRIES) {
         continue;
       }
-      throw error2;
+      throw error;
     }
   }
   throw new Error("updateTaskStatus: unexpected loop exit");
@@ -3439,4 +3080,4 @@ function migrateLegacyPlan(planContent, swarmId) {
   return plan;
 }
 
-export { buildTaskCompletionDescriptor, ensureTaskCheckpointReceipt, updateTaskCheckpointReceipt, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, readLaneEnvFileFromDiskSync, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, detectDefaultRemoteBranch, resetToRemoteBranch, resetToMainAfterMerge, getRunMemorySummary, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, PlanRecoverySupersededError, loadPlanJsonOnly, loadPlan, withPlanLifecycleLock, savePlan, closePlanTerminalState, updateTaskStatus, derivePlanMarkdown, getCurrentTaskId };
+export { EPIC_MODE_CONFIG_DISABLED_MESSAGE, isEpicModeConfigEnabledForDirectory, epicSentinelExists, computeEpicKey, planIdentityOf, readLedgerRootDigest, inspectEpic, getOpenEpic, isEpicOpenForProject, createEpicRecord, updateEpicRecord, readPlanTaskRef, markEpicClosing, recordEpicBranch, recordEpicLandingAttempt, deleteEpicState, repairEpicSentinel, buildTaskCompletionDescriptor, ensureTaskCheckpointReceipt, updateTaskCheckpointReceipt, relevantMergeFailureForProject, describeMergeFailuresForStatus, clearMergeFailureCommand, getRunMemorySummary, PlanRecoverySupersededError, loadPlanJsonOnly, loadPlan, withPlanLifecycleLock, savePlan, closePlanTerminalState, updateTaskStatus, derivePlanMarkdown, getCurrentTaskId };