opencode-swarm 7.200.8 → 7.200.10

package/dist/cli/{index-2x015vjy.js → index-rck7v4r4.js}

@@ -4,7 +4,7 @@ import {
   getProjectDb,
   projectDbExists,
   withImmediateTransaction
-} from "./index-y7c4hqcj.js";
+} from "./index-ck7jpn0y.js";
 
 // src/db/coordination-store.ts
 import { createHash } from "crypto";

package/dist/cli/{index-vtpt8yns.js → index-rjsqf4hv.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   observeStoreHealth
-} from "./index-8srvdpw6.js";
+} from "./index-8xtdxy91.js";
 import {
   telemetry
-} from "./index-c2k7q723.js";
+} from "./index-6cppzd9c.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-z72545mf.js → index-rnm6c33a.js}

@@ -1,10 +1,7 @@
 // @bun
 import {
   readEffectiveSpecSync
-} from "./index-sg2sd66b.js";
-import {
-  readSwarmFileAsync
-} from "./index-4krkevgc.js";
+} from "./index-2dey2mtg.js";
 import {
   DURABILITY_CLASSES,
   DbWriteError,
@@ -13,7 +10,10 @@ import {
   classifyDbWriteError,
   getProjectDb,
   projectDbExists
-} from "./index-y7c4hqcj.js";
+} from "./index-ck7jpn0y.js";
+import {
+  readSwarmFileAsync
+} from "./index-001tkp0j.js";
 import {
   _internals,
   canonicalRootKeyFresh

package/dist/cli/{index-bk8r4m9j.js → index-rpvp88js.js}

@@ -1,14 +1,14 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-4krkevgc.js";
+} from "./index-001tkp0j.js";
 import {
   canonicalRootKey,
   sameProjectRoot
 } from "./index-te9hq2f4.js";
 import {
   atomicWriteSwarmFile
-} from "./index-mn75z39t.js";
+} from "./index-9qy3tzt5.js";
 import {
   init_git_executable,
   resolveGitExecutable

package/dist/cli/{index-v839c9mv.js → index-tggyracy.js}

@@ -4,7 +4,7 @@ import {
   getProjectDb,
   projectDbExists,
   withImmediateTransaction
-} from "./index-y7c4hqcj.js";
+} from "./index-ck7jpn0y.js";
 import {
   derivePlanId,
   derivePlanIdentityHash

package/dist/cli/{index-5z4c9acx.js → index-tm6nwe43.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-6b295cas.js";
 import {
   readEffectiveSpecSync
-} from "./index-sg2sd66b.js";
+} from "./index-2dey2mtg.js";
 import {
   _internals,
   clearWorktreeMergeStatus,
@@ -12,15 +12,6 @@ import {
   initDurableStatusPath,
   scanWorktreeMergeFailuresForRecovery
 } from "./index-697mg68b.js";
-import {
-  sanitizeContextText
-} from "./index-m9zzj4ee.js";
-import {
-  estimateCharsForTokens,
-  estimateTokens,
-  readSwarmFileAsync,
-  validateSwarmPath
-} from "./index-4krkevgc.js";
 import {
   LedgerStaleWriterError,
   appendLedgerEvent,
@@ -39,7 +30,7 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-zjjxe0q5.js";
+} from "./index-6e7jxxys.js";
 import {
   deleteCoordinationStateWithinTransaction,
   getCoordinationStateRaw,
@@ -48,26 +39,46 @@ import {
   transitionCoordinationState,
   transitionCoordinationStateWithinTransaction,
   withCoordinationTransaction
-} from "./index-2x015vjy.js";
+} from "./index-rck7v4r4.js";
 import {
   DURABILITY_CLASSES,
   getProjectDb,
   projectDbExists,
   withDurabilityClass
-} from "./index-y7c4hqcj.js";
+} from "./index-ck7jpn0y.js";
 import {
   appendCoreEventSync
-} from "./index-vtpt8yns.js";
+} from "./index-rjsqf4hv.js";
 import {
   derivePlanId,
   derivePlanIdentityHash
 } from "./index-7pmbnjvj.js";
+import {
+  sanitizeContextText
+} from "./index-m9zzj4ee.js";
+import {
+  PlanSchema,
+  normalizeCurrentPhaseInPlace,
+  resolveActivePhaseId
+} from "./index-3t46mez1.js";
+import {
+  init_config,
+  init_loader,
+  isEpicModeConfigEnabled,
+  loadPluginConfigWithMeta
+} from "./index-ww5ne0g6.js";
+import {
+  estimateCharsForTokens,
+  estimateTokens,
+  readSwarmFileAsync,
+  validateSwarmPath
+} from "./index-001tkp0j.js";
 import {
   assertProjectRoot
 } from "./index-t7hmqgjy.js";
 import {
   emit
-} from "./index-c2k7q723.js";
+} from "./index-6cppzd9c.js";
 import {
   canonicalRootKeyFresh
 } from "./index-te9hq2f4.js";
@@ -78,18 +89,7 @@ import {
   atomicWriteSwarmFileSync,
   invalidateCachedArtifact,
   readCachedParsedFile
-} from "./index-mn75z39t.js";
-import {
-  PlanSchema,
-  normalizeCurrentPhaseInPlace,
-  resolveActivePhaseId
-} from "./index-3t46mez1.js";
-import {
-  init_config,
-  init_loader,
-  isEpicModeConfigEnabled,
-  loadPluginConfigWithMeta
-} from "./index-76xnddca.js";
+} from "./index-9qy3tzt5.js";
 import {
   bunHash,
   bunWrite,
@@ -2670,7 +2670,7 @@ ${markdown}`;
   }
 }
 async function defaultMaybeSaveAutoCheckpoint(directory, plan) {
-  const { maybeSaveAutoCheckpoint } = await import("./auto-checkpoint-6sacb90s.js");
+  const { maybeSaveAutoCheckpoint } = await import("./auto-checkpoint-15mvj9zm.js");
   return maybeSaveAutoCheckpoint(directory, plan);
 }
 async function updateTaskStatus(directory, taskId, status, options) {
@@ -2746,7 +2746,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-ec4g0hhc.js");
+          const { maybePropagateSpeckitCheckoff } = await import("./speckit-checkoff-jfdwsy5n.js");
           await maybePropagateSpeckitCheckoff(directory, {
             taskId,
             frRefs: completedTask?.fr_refs ?? [],

package/dist/cli/{index-c5wk61ak.js → index-vajbtn3v.js}

@@ -11,24 +11,24 @@ import {
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-4fkxdnc7.js";
+} from "./index-erp7fk72.js";
+import {
+  init_knowledge_types,
+  isActiveStatus
+} from "./index-bk5tah7q.js";
 import {
   atomicWriteFile
-} from "./index-yyrnkc3a.js";
+} from "./index-6m551cng.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
 import {
   readCachedParsedFile
-} from "./index-mn75z39t.js";
+} from "./index-9qy3tzt5.js";
 import {
   init_logger,
   log
 } from "./index-zgwm4ryv.js";
-import {
-  init_knowledge_types,
-  isActiveStatus
-} from "./index-bk5tah7q.js";
 import {
   __require,
   __toESM
@@ -739,7 +739,7 @@ async function applyConfidenceFloorAction(directory, touched, options) {
   const {
     readAuthoritativeKnowledgeCounterRollups,
     effectiveRetrievalOutcomes
-  } = await import("./knowledge-events-dcmpbb23.js");
+  } = await import("./knowledge-events-w3ep12sq.js");
   const rollups = await readAuthoritativeKnowledgeCounterRollups(directory);
   const flagIds = new Set;
   for (const e of atFloor) {
@@ -806,11 +806,11 @@ async function applyConfidenceFloorAction(directory, touched, options) {
     });
   }
   if (action === "quarantine" && toQuarantine.length > 0) {
-    const { quarantineEntry } = await import("./knowledge-validator-7q1w62s7.js");
-    const { KnowledgeConfigSchema } = await import("./schema-ff9v839b.js");
+    const { quarantineEntry } = await import("./knowledge-validator-zhy6mgxv.js");
+    const { KnowledgeConfigSchema } = await import("./schema-kep9t01t.js");
     let config;
     try {
-      const { loadPluginConfigWithMeta } = await import("./index-0tvkfdwp.js");
+      const { loadPluginConfigWithMeta } = await import("./index-c34tgnwm.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-4y90ecpz.js → index-vm3j8fvn.js}

@@ -1,13 +1,19 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-4krkevgc.js";
+} from "./index-001tkp0j.js";
+import {
+  assertProjectRoot
+} from "./index-t7hmqgjy.js";
 import {
   canonicalRootKeyFresh
 } from "./index-te9hq2f4.js";
+import {
+  tryAcquireLock
+} from "./index-ejhxgyvm.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-mn75z39t.js";
+} from "./index-9qy3tzt5.js";
 import {
   advisoryWarn,
   init_git_executable,
@@ -35,7 +41,7 @@ init_constants();
 import * as fs2 from "fs";
 import * as fsPromises from "fs/promises";
 import * as os from "os";
-import * as path from "path";
+import * as path2 from "path";
 
 // src/config/swarm-branch.ts
 init_constants();
@@ -222,12 +228,160 @@ function listLiveLaneOwners(directory) {
 init_warning_buffer();
 init_bun_compat();
 init_git_executable();
+
+// src/worktree/settlement-artifact-lifecycle.ts
+import { lstat, opendir, realpath } from "fs/promises";
+import * as path from "path";
+init_warning_buffer();
+var MAX_INVENTORY_ENTRIES = 200;
+var LIFECYCLE_TARGET = "locks/coder-settlement-artifacts";
+
+class SettlementArtifactLifecycleError extends Error {
+  code;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.code = code;
+    this.name = "SettlementArtifactLifecycleError";
+  }
+}
+function isSettlementArtifactLifecycleError(error) {
+  return error instanceof SettlementArtifactLifecycleError;
+}
+async function readWal(filePath, taskId) {
+  const { readWorkflowWalFile } = await import("./workflow-wal-file-xvvwcxr1.js");
+  return readWorkflowWalFile("coder-settlement", filePath, taskId);
+}
+async function canonicalizeArtifact(filePath) {
+  if (!path.isAbsolute(filePath))
+    throw uncertain("artifact path is not absolute");
+  let candidate = path.resolve(filePath);
+  const missing = [];
+  for (let depth = 0;depth < 256; depth++) {
+    try {
+      const physical = await _internals2.realpath(candidate);
+      const resolved = path.join(physical, ...missing.reverse());
+      return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "ENOTDIR")
+        throw error;
+      const parent = path.dirname(candidate);
+      if (parent === candidate)
+        throw error;
+      missing.push(path.basename(candidate));
+      candidate = parent;
+    }
+  }
+  throw uncertain("artifact ancestry exceeds the identity bound");
+}
 var _internals2 = {
+  tryAcquireLock,
+  opendir,
+  lstat,
+  realpath,
+  readWal,
+  canonicalize: canonicalizeArtifact,
+  assertProjectRoot
+};
+function uncertain(detail) {
+  return new SettlementArtifactLifecycleError("CODER_SETTLEMENT_ARTIFACT_UNCERTAIN", detail);
+}
+async function withSettlementArtifactLifecycle(directory, operation) {
+  let root;
+  let admission;
+  try {
+    _internals2.assertProjectRoot(directory);
+    root = await _internals2.realpath(directory);
+    validateSwarmPath(root, LIFECYCLE_TARGET);
+    admission = await _internals2.tryAcquireLock(root, LIFECYCLE_TARGET, "coder-settlement-artifact-lifecycle", "coder-settlement-artifact-lifecycle");
+  } catch (error) {
+    throw uncertain(`cannot acquire lifecycle admission (${error instanceof Error ? error.message : String(error)})`);
+  }
+  if (!admission.acquired)
+    throw uncertain("lifecycle admission is busy: a concurrent removal or dispatch holds the lifecycle lock; retry once it completes");
+  try {
+    return await operation();
+  } finally {
+    try {
+      await admission.lock._release?.();
+    } catch (error) {
+      advisoryWarn(`[worktree] settlement artifact lifecycle lock release failed (${error instanceof Error ? error.message : String(error)})`);
+    }
+  }
+}
+async function matchesPendingWal(wal, target, targetPath) {
+  if (wal.state !== "DISPATCHED" && wal.state !== "PREPARED")
+    return false;
+  if (target.branch && (wal.worktree?.branchName === target.branch || wal.mergeProvenance?.branchName === target.branch))
+    return true;
+  return Boolean(targetPath && wal.worktree && await _internals2.canonicalize(wal.worktree.worktreePath) === targetPath);
+}
+async function assertSettlementArtifactsRemovable(directory, target) {
+  if (!target.path && !target.branch)
+    throw uncertain("missing artifact identity");
+  let handle;
+  let failure;
+  try {
+    const inventoryPath = validateSwarmPath(directory, "coder-settlements");
+    try {
+      const stat = await _internals2.lstat(inventoryPath);
+      if (stat.isSymbolicLink() || !stat.isDirectory())
+        throw uncertain("settlement inventory is not a direct directory");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return;
+      throw error;
+    }
+    const targetPath = target.path ? await _internals2.canonicalize(target.path) : undefined;
+    handle = await _internals2.opendir(inventoryPath);
+    let count = 0;
+    while (true) {
+      const entry = await handle.read();
+      if (!entry)
+        break;
+      if (entry.isSymbolicLink())
+        throw uncertain("settlement inventory contains a symbolic entry");
+      if (!entry.name.endsWith(".json"))
+        continue;
+      if (++count > MAX_INVENTORY_ENTRIES)
+        throw uncertain(`settlement inventory exceeds ${MAX_INVENTORY_ENTRIES} records; run \`/swarm close\` to archive settled coder settlements`);
+      const filePath = path.join(inventoryPath, entry.name);
+      const stat = await _internals2.lstat(filePath);
+      if (!stat.isFile() || stat.isSymbolicLink())
+        throw uncertain("settlement record is not a direct regular file");
+      const wal = await _internals2.readWal(filePath, entry.name.slice(0, -5));
+      if (!wal)
+        throw uncertain("settlement record disappeared during inventory");
+      const after = await _internals2.lstat(filePath);
+      if (after.dev !== stat.dev || after.ino !== stat.ino || after.size !== stat.size || after.mtimeMs !== stat.mtimeMs)
+        throw uncertain("settlement record changed during inspection");
+      if (await matchesPendingWal(wal, target, targetPath)) {
+        throw new SettlementArtifactLifecycleError("CODER_SETTLEMENT_ARTIFACT_PROTECTED", `task ${wal.taskId} has a ${wal.state} settlement; preserve its lane artifacts`);
+      }
+    }
+  } catch (error) {
+    failure = isSettlementArtifactLifecycleError(error) ? error : uncertain(`cannot verify settlement inventory (${error instanceof Error ? error.message : String(error)})`);
+  } finally {
+    if (handle) {
+      try {
+        await handle.close();
+      } catch {
+        failure ??= uncertain("cannot close settlement inventory");
+      }
+    }
+  }
+  if (failure)
+    throw failure;
+}
+
+// src/worktree/core.ts
+var _internals3 = {
+  withSettlementArtifactLifecycle,
+  assertSettlementArtifactsRemovable,
   clearLiveLaneOwner,
   bunSpawn,
   resolveGitExecutable,
   platform: process.platform,
-  sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
+  sleep: (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)),
   osTmpdir: () => os.tmpdir(),
   getCoreLongPaths: async (directory) => {
     const result = await runGit(["config", "core.longpaths"], directory);
@@ -244,7 +398,7 @@ var _internals2 = {
     symlinkSync: fs2.symlinkSync
   },
   writeScopeToDisk: async (directory, taskId, files) => {
-    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-mzyqtkwv.js");
+    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-tx71g0ac.js");
     return realWrite(directory, taskId, files);
   },
   writeLaneProfileToDisk: async (_worktreePath, _laneIndex, _envOverrides) => {
@@ -273,15 +427,15 @@ async function writeLaneProfileToDiskReal(worktreePath, laneIndex, envOverrides)
   }
   if (lines.length === 0)
     return;
-  const lanesDir = path.join(worktreePath, ".swarm", "lanes");
+  const lanesDir = path2.join(worktreePath, ".swarm", "lanes");
   await fs2.promises.mkdir(lanesDir, { recursive: true });
-  const envPath = path.join(lanesDir, `${laneIndex}.env`);
+  const envPath = path2.join(lanesDir, `${laneIndex}.env`);
   await fs2.promises.writeFile(envPath, `${lines.join(`
 `)}
 `, "utf-8");
 }
 async function removeLaneProfileFromDiskReal(worktreePath, laneIndex) {
-  const envPath = path.join(worktreePath, ".swarm", "lanes", `${laneIndex}.env`);
+  const envPath = path2.join(worktreePath, ".swarm", "lanes", `${laneIndex}.env`);
   try {
     await fs2.promises.unlink(envPath);
   } catch (err) {
@@ -297,7 +451,7 @@ var GIT_SPAWN_FAILURE_EXIT_CODE = 1;
 async function runGit(args, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
   let proc;
   try {
-    proc = _internals2.bunSpawn([_internals2.resolveGitExecutable(), ...args], {
+    proc = _internals3.bunSpawn([_internals3.resolveGitExecutable(), ...args], {
       cwd,
       timeout: timeoutMs,
       stdin: "ignore",
@@ -330,19 +484,19 @@ async function runGit(args, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
   }
 }
 async function checkPathBudget(worktreeRoot, directory) {
-  if (_internals2.platform !== "win32") {
+  if (_internals3.platform !== "win32") {
     return { ok: true };
   }
   let longPaths;
   try {
-    longPaths = await _internals2.getCoreLongPaths(directory);
+    longPaths = await _internals3.getCoreLongPaths(directory);
   } catch {}
   if (longPaths === "true") {
     return { ok: true };
   }
   let proc;
   try {
-    proc = _internals2.bunSpawn([_internals2.resolveGitExecutable(), "ls-files"], {
+    proc = _internals3.bunSpawn([_internals3.resolveGitExecutable(), "ls-files"], {
       cwd: directory,
       timeout: WORKTREE_TIMEOUT_MS,
       stdin: "ignore",
@@ -384,23 +538,23 @@ async function checkPathBudget(worktreeRoot, directory) {
   }
 }
 function shortenWorktreePath(_directory, sessionId, laneId) {
-  let tmp = _internals2.osTmpdir();
+  let tmp = _internals3.osTmpdir();
   try {
     tmp = fs2.realpathSync(tmp);
   } catch {}
-  return path.join(tmp, "swwt", sessionId, laneId);
+  return path2.join(tmp, "swwt", sessionId, laneId);
 }
 function makeWorktreeBranchName(sessionId, id, options) {
   return buildSwarmBranchName(sessionId, id, options.purpose, options.branchStyle === "legacy-lane" && options.purpose === "lane");
 }
 function resolveWorktreeBaseDir(directory, worktreeDir) {
-  return worktreeDir ? path.resolve(directory, worktreeDir) : path.resolve(directory, SWARM_WORKTREE_DIR_NAME);
+  return worktreeDir ? path2.resolve(directory, worktreeDir) : path2.resolve(directory, SWARM_WORKTREE_DIR_NAME);
 }
 function isPathUnderSwarmWorktreeBase(targetPath, directory, worktreeDirOverrides = []) {
   const caseInsensitive = process.platform === "win32";
   let realTarget;
   try {
-    realTarget = fs2.realpathSync(path.resolve(directory, targetPath));
+    realTarget = fs2.realpathSync(path2.resolve(directory, targetPath));
   } catch {
     return false;
   }
@@ -414,13 +568,13 @@ function isPathUnderSwarmWorktreeBase(targetPath, directory, worktreeDirOverride
     try {
       realBase = fs2.realpathSync(base);
     } catch {
-      realBase = path.resolve(base);
+      realBase = path2.resolve(base);
     }
     const cmpBase = caseInsensitive ? realBase.toLowerCase() : realBase;
     if (cmpTarget === cmpBase)
       return true;
-    const rel = path.relative(cmpBase, cmpTarget);
-    return rel.length > 0 && !rel.startsWith("..") && !path.isAbsolute(rel);
+    const rel = path2.relative(cmpBase, cmpTarget);
+    return rel.length > 0 && !rel.startsWith("..") && !path2.isAbsolute(rel);
   });
 }
 async function provisionWorktree(directory, id, sessionId, options) {
@@ -430,7 +584,7 @@ async function provisionWorktree(directory, id, sessionId, options) {
       error: `Refusing to provision worktree: branch "${branchName}" does not match the swarm lane grammar, so lane permission scoping could not recognise it and the lane would hang on the first external-directory prompt. This is almost always an invalid sessionId ("${sessionId}"); it must look like "ses_" followed by letters/digits, and the execution-unit id ("${id}") must be a single path segment.`
     };
   }
-  let worktreePath = path.resolve(resolveWorktreeBaseDir(directory, options.worktreeDir), sessionId, id);
+  let worktreePath = path2.resolve(resolveWorktreeBaseDir(directory, options.worktreeDir), sessionId, id);
   const budgetResult = await checkPathBudget(worktreePath, directory);
   if (budgetResult.ok === false) {
     if (options.worktreeDir) {
@@ -575,18 +729,18 @@ async function provisionWorktree(directory, id, sessionId, options) {
   }
   const strategy = options.depsStrategy ?? "skip";
   if (strategy !== "skip") {
-    const hostDepDir = path.join(directory, "node_modules");
-    const laneDepDir = path.join(worktreePath, "node_modules");
-    if (_internals2.fs.existsSync(hostDepDir)) {
+    const hostDepDir = path2.join(directory, "node_modules");
+    const laneDepDir = path2.join(worktreePath, "node_modules");
+    if (_internals3.fs.existsSync(hostDepDir)) {
       try {
         if (strategy === "copy") {
-          await _internals2.fs.cp(hostDepDir, laneDepDir, {
+          await _internals3.fs.cp(hostDepDir, laneDepDir, {
             recursive: true,
             force: true
           });
         } else if (strategy === "link") {
-          const isWindows = _internals2.platform === "win32";
-          _internals2.fs.symlinkSync(hostDepDir, laneDepDir, isWindows ? "junction" : "dir");
+          const isWindows = _internals3.platform === "win32";
+          _internals3.fs.symlinkSync(hostDepDir, laneDepDir, isWindows ? "junction" : "dir");
         }
       } catch (e) {
         log(`[swarm] deps_strategy '${strategy}' preparation failed for ${id}: ${e instanceof Error ? e.message : String(e)}`);
@@ -599,12 +753,12 @@ async function provisionWorktree(directory, id, sessionId, options) {
   }
   if (options.scope?.taskId && Array.isArray(options.scope.files)) {
     try {
-      await _internals2.writeScopeToDisk(worktreePath, options.scope.taskId, options.scope.files);
+      await _internals3.writeScopeToDisk(worktreePath, options.scope.taskId, options.scope.files);
     } catch {}
   }
   if (options.laneProfile) {
     try {
-      await _internals2.writeLaneProfileToDisk(worktreePath, options.laneProfile.laneIndex, options.laneProfile.envOverrides);
+      await _internals3.writeLaneProfileToDisk(worktreePath, options.laneProfile.laneIndex, options.laneProfile.envOverrides);
     } catch {}
   }
   return {
@@ -616,14 +770,28 @@ async function provisionWorktree(directory, id, sessionId, options) {
   };
 }
 async function removeWorktree(worktreePath, projectRoot, options) {
-  const isWindows = _internals2.platform === "win32";
+  try {
+    return await _internals3.withSettlementArtifactLifecycle(projectRoot, async () => {
+      await _internals3.assertSettlementArtifactsRemovable(projectRoot, {
+        path: worktreePath
+      });
+      return removeWorktreeUnderLifecycleLock(worktreePath, projectRoot, options);
+    });
+  } catch (error) {
+    return {
+      error: `CODER_SETTLEMENT_ARTIFACT_REMOVAL_REFUSED: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function removeWorktreeUnderLifecycleLock(worktreePath, projectRoot, options) {
+  const isWindows = _internals3.platform === "win32";
   const MAX_RETRIES = 4;
   const RETRY_DELAY_MS = 2000;
   let lastError = "";
   for (let attempt = 0;attempt < MAX_RETRIES; attempt++) {
     const result = await runGit(["worktree", "remove", worktreePath], projectRoot);
     if (result.exitCode === 0) {
-      _internals2.clearLiveLaneOwner(projectRoot, worktreePath);
+      _internals3.clearLiveLaneOwner(projectRoot, worktreePath);
       if (fs2.existsSync(worktreePath)) {
         const trusted = isPathUnderSwarmWorktreeBase(worktreePath, projectRoot, options?.worktreeDir ? [options.worktreeDir] : []);
         if (!trusted) {
@@ -648,13 +816,13 @@ async function removeWorktree(worktreePath, projectRoot, options) {
     }
     lastError = result.stderr.trim() || result.stdout.trim();
     if (isWindows && (lastError.includes("EBUSY") || lastError.includes("EPERM")) && attempt < MAX_RETRIES - 1) {
-      await _internals2.sleep(RETRY_DELAY_MS);
+      await _internals3.sleep(RETRY_DELAY_MS);
       continue;
     }
     if (options?.force && isPathUnderSwarmWorktreeBase(worktreePath, projectRoot, options.worktreeDir ? [options.worktreeDir] : [])) {
       const forced = await runGit(["worktree", "remove", "--force", worktreePath], projectRoot);
       if (forced.exitCode === 0) {
-        _internals2.clearLiveLaneOwner(projectRoot, worktreePath);
+        _internals3.clearLiveLaneOwner(projectRoot, worktreePath);
         if (fs2.existsSync(worktreePath)) {
           try {
             fs2.rmSync(worktreePath, { recursive: true, force: true });
@@ -788,4 +956,4 @@ async function assertCleanWorkingTree(directory) {
   return { clean: true };
 }
 
-export { recordLiveLaneOwner, listLiveLaneOwners, _internals2 as _internals, writeLaneProfileToDiskReal, removeLaneProfileFromDiskReal, checkPathBudget, shortenWorktreePath, makeWorktreeBranchName, resolveWorktreeBaseDir, isPathUnderSwarmWorktreeBase, provisionWorktree, removeWorktree, isCleanWorktree, autoCommitDirty, cleanUntrackedFiles, assertCleanWorkingTree };
+export { recordLiveLaneOwner, listLiveLaneOwners, withSettlementArtifactLifecycle, assertSettlementArtifactsRemovable, _internals3 as _internals, writeLaneProfileToDiskReal, removeLaneProfileFromDiskReal, checkPathBudget, shortenWorktreePath, makeWorktreeBranchName, resolveWorktreeBaseDir, isPathUnderSwarmWorktreeBase, provisionWorktree, removeWorktree, isCleanWorktree, autoCommitDirty, cleanUntrackedFiles, assertCleanWorkingTree };