@theaileverage/marionette 0.2.0 → 0.2.1

package/dist/cli.js

@@ -5346,10 +5346,10 @@ var require_raw_body = __commonJS({
       if (done) {
         return readStream(stream, encoding, length, limit, wrap(done));
       }
-      return new Promise(function executor(resolve12, reject) {
+      return new Promise(function executor(resolve13, reject) {
         readStream(stream, encoding, length, limit, function onRead(err, buf) {
           if (err) return reject(err);
-          resolve12(buf);
+          resolve13(buf);
         });
       });
     }
@@ -18931,11 +18931,11 @@ var require_view = __commonJS({
     var debug = require_src()("express:view");
     var path = __require("node:path");
     var fs = __require("node:fs");
-    var dirname10 = path.dirname;
+    var dirname11 = path.dirname;
     var basename2 = path.basename;
     var extname = path.extname;
     var join = path.join;
-    var resolve12 = path.resolve;
+    var resolve13 = path.resolve;
     module.exports = View;
     function View(name, options) {
       var opts = options || {};
@@ -18969,8 +18969,8 @@ var require_view = __commonJS({
       debug('lookup "%s"', name);
       for (var i = 0; i < roots.length && !path2; i++) {
         var root = roots[i];
-        var loc = resolve12(root, name);
-        var dir = dirname10(loc);
+        var loc = resolve13(root, name);
+        var dir = dirname11(loc);
         var file = basename2(loc);
         path2 = this.resolve(dir, file);
       }
@@ -18994,7 +18994,7 @@ var require_view = __commonJS({
       });
       sync = false;
     };
-    View.prototype.resolve = function resolve13(dir, file) {
+    View.prototype.resolve = function resolve14(dir, file) {
       var ext = this.ext;
       var path2 = join(dir, file);
       var stat = tryStat(path2);
@@ -21253,7 +21253,7 @@ var require_application = __commonJS({
     var compileETag = require_utils3().compileETag;
     var compileQueryParser = require_utils3().compileQueryParser;
     var compileTrust = require_utils3().compileTrust;
-    var resolve12 = __require("node:path").resolve;
+    var resolve13 = __require("node:path").resolve;
     var once = require_once();
     var Router = require_router();
     var slice = Array.prototype.slice;
@@ -21307,7 +21307,7 @@ var require_application = __commonJS({
       this.mountpath = "/";
       this.locals.settings = this.settings;
       this.set("view", View);
-      this.set("views", resolve12("views"));
+      this.set("views", resolve13("views"));
       this.set("jsonp callback name", "callback");
       if (env === "production") {
         this.enable("view cache");
@@ -22887,7 +22887,7 @@ var require_send = __commonJS({
     var extname = path.extname;
     var join = path.join;
     var normalize = path.normalize;
-    var resolve12 = path.resolve;
+    var resolve13 = path.resolve;
     var sep = path.sep;
     var BYTES_RANGE_REGEXP = /^ *bytes=/;
     var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1e3;
@@ -22916,7 +22916,7 @@ var require_send = __commonJS({
       this._maxage = opts.maxAge || opts.maxage;
       this._maxage = typeof this._maxage === "string" ? ms(this._maxage) : Number(this._maxage);
       this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0;
-      this._root = opts.root ? resolve12(opts.root) : null;
+      this._root = opts.root ? resolve13(opts.root) : null;
     }
     util2.inherits(SendStream, Stream);
     SendStream.prototype.error = function error(status, err) {
@@ -23065,7 +23065,7 @@ var require_send = __commonJS({
           return res;
         }
         parts = normalize(path2).split(sep);
-        path2 = resolve12(path2);
+        path2 = resolve13(path2);
       }
       if (containsDotFile(parts)) {
         debug('%s dotfile "%s"', this._dotfiles, path2);
@@ -23443,7 +23443,7 @@ var require_response = __commonJS({
     var cookie = require_cookie();
     var send = require_send();
     var extname = path.extname;
-    var resolve12 = path.resolve;
+    var resolve13 = path.resolve;
     var vary = require_vary();
     var { Buffer: Buffer2 } = __require("node:buffer");
     var res = Object.create(http.ServerResponse.prototype);
@@ -23649,7 +23649,7 @@ var require_response = __commonJS({
       }
       opts = Object.create(opts);
       opts.headers = headers;
-      var fullPath = !opts.root ? resolve12(path2) : path2;
+      var fullPath = !opts.root ? resolve13(path2) : path2;
       return this.sendFile(fullPath, opts, done);
     };
     res.contentType = res.type = function contentType(type) {
@@ -23898,7 +23898,7 @@ var require_serve_static = __commonJS({
     var encodeUrl = require_encodeurl();
     var escapeHtml = require_escape_html();
     var parseUrl = require_parseurl();
-    var resolve12 = __require("path").resolve;
+    var resolve13 = __require("path").resolve;
     var send = require_send();
     var url = __require("url");
     module.exports = serveStatic;
@@ -23917,7 +23917,7 @@ var require_serve_static = __commonJS({
         throw new TypeError("option setHeaders must be function");
       }
       opts.maxage = opts.maxage || opts.maxAge || 0;
-      opts.root = resolve12(root);
+      opts.root = resolve13(root);
       var onDirectory = redirect ? createRedirectDirectoryListener() : createNotFoundDirectoryListener();
       return function serveStatic2(req, res, next) {
         if (req.method !== "GET" && req.method !== "HEAD") {
@@ -24044,8 +24044,8 @@ var require_express2 = __commonJS({
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, openSync as openSync3, closeSync as closeSync3, existsSync as existsSync8 } from "node:fs";
-import { resolve as resolve11 } from "node:path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, openSync as openSync4, closeSync as closeSync4, existsSync as existsSync9 } from "node:fs";
+import { resolve as resolve12 } from "node:path";
 import { spawn as spawn4 } from "node:child_process";
 
 // src/config.ts
@@ -24365,8 +24365,8 @@ var ZodError = class _ZodError extends Error {
           let i = 0;
           while (i < issue.path.length) {
             const el = issue.path[i];
-            const terminal2 = i === issue.path.length - 1;
-            if (!terminal2) {
+            const terminal3 = i === issue.path.length - 1;
+            if (!terminal3) {
               curr[el] = curr[el] || { _errors: [] };
             } else {
               curr[el] = curr[el] || { _errors: [] };
@@ -28138,7 +28138,9 @@ async function call(home2, action, input = {}) {
     method: "POST",
     headers: { "Content-Type": "application/json", Authorization: `Bearer ${c.token}` },
     body: JSON.stringify({ action, input }),
-    signal: AbortSignal.timeout(action === "profile.validate" ? 135e3 : 45e3)
+    signal: AbortSignal.timeout(
+      action.startsWith("cleanup.") ? 3e5 : action === "profile.validate" ? 135e3 : 45e3
+    )
   });
   const body = await response.json();
   if (!response.ok)
@@ -28150,9 +28152,9 @@ async function call(home2, action, input = {}) {
 
 // src/server.ts
 var import_express = __toESM(require_express2(), 1);
-import { timingSafeEqual, randomUUID as randomUUID8 } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2 } from "node:fs";
-import { resolve as resolve8, dirname as dirname7 } from "node:path";
+import { timingSafeEqual, randomUUID as randomUUID9 } from "node:crypto";
+import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "node:fs";
+import { resolve as resolve9, dirname as dirname8 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/store.ts
@@ -28285,8 +28287,8 @@ var Store = class {
 };
 
 // src/service.ts
-import { randomUUID as randomUUID5, randomBytes as randomBytes2 } from "node:crypto";
-import { realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
+import { randomUUID as randomUUID6, randomBytes as randomBytes2 } from "node:crypto";
+import { realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
 import { isAbsolute as isAbsolute2 } from "node:path";
 
 // src/continuation.ts
@@ -28341,7 +28343,7 @@ function digest(path) {
   }
 }
 function command(command2, args2, cwd, timeoutMs = 3e4) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const env = { ...process.env };
     for (const k of Object.keys(env))
       if (k.startsWith("MARIONETTE_") || k.startsWith("HERDR_")) delete env[k];
@@ -28372,7 +28374,7 @@ function command(command2, args2, cwd, timeoutMs = 3e4) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve12({ code, output, timedOut });
+      resolve13({ code, output, timedOut });
     });
   });
 }
@@ -28590,7 +28592,7 @@ var Continuation = class {
     }
   }
   async stop() {
-    while (this.busy.size) await new Promise((resolve12) => setTimeout(resolve12, 25));
+    while (this.busy.size) await new Promise((resolve13) => setTimeout(resolve13, 25));
   }
   async process(w) {
     if (!["waiting", "ready"].includes(w.state)) {
@@ -28913,6 +28915,776 @@ ${JSON.stringify(summary)}`;
   }
 };
 
+// src/cleanup.ts
+import { randomUUID as randomUUID3, createHash as createHash2 } from "node:crypto";
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync2,
+  realpathSync as realpathSync3,
+  openSync,
+  fsyncSync,
+  closeSync,
+  createReadStream,
+  statSync as statSync3
+} from "node:fs";
+import { dirname as dirname4, resolve as resolve4 } from "node:path";
+
+// src/worktrees.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
+import { dirname as dirname3, relative as relative2, resolve as resolve3 } from "node:path";
+var exec = promisify(execFile);
+async function git(cwd, args2) {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) if (key.startsWith("GIT_")) delete env[key];
+  env.GIT_TERMINAL_PROMPT = "0";
+  try {
+    const result = await exec("git", ["-c", "core.hooksPath=/dev/null", "-C", cwd, ...args2], {
+      env,
+      timeout: 12e4,
+      maxBuffer: 4 * 1024 * 1024
+    });
+    return result.stdout.trimEnd();
+  } catch (error) {
+    const e = error;
+    throw new AppError(
+      "worktree_git",
+      `Git worktree operation failed: ${e.stderr?.trim() || e.message}`
+    );
+  }
+}
+async function planWorktree(task, stateRoot) {
+  const repositoryRoot = realpathSync2(await git(task.cwd, ["rev-parse", "--show-toplevel"]));
+  const commonDir = realpathSync2(
+    await git(task.cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"])
+  );
+  const baseRef = task.execution?.mode === "worktree" ? task.execution.baseRef ?? "HEAD" : "HEAD";
+  const baseCommit = await git(task.cwd, [
+    "rev-parse",
+    "--verify",
+    "--end-of-options",
+    `${baseRef}^{commit}`
+  ]);
+  if (!inside(repositoryRoot, task.cwd))
+    throw new AppError("worktree_scope", "Task directory is outside its Git repository");
+  const path = safePath(stateRoot, `worktrees/${task.projectId}/${task.id}`);
+  return {
+    state: "planned",
+    repositoryRoot,
+    commonDir,
+    sourceCwd: task.cwd,
+    path,
+    cwd: resolve3(path, relative2(repositoryRoot, task.cwd)),
+    branch: `marionette/${task.id}`,
+    baseCommit
+  };
+}
+async function validateWorktree(w, requireClean = false) {
+  const listing = await git(w.repositoryRoot, ["worktree", "list", "--porcelain", "-z"]);
+  const records = listing.split("\0\0").map((record2) => record2.split("\0"));
+  const record = records.find((fields) => fields.includes(`worktree ${w.path}`));
+  if (!record || !record.includes(`branch refs/heads/${w.branch}`) || record.some((field) => /^(locked|prunable)( |$)/.test(field)) || !existsSync2(w.path) || realpathSync2(w.path) !== w.path)
+    throw new AppError(
+      "worktree_identity",
+      "Managed worktree is missing, incomplete, or has changed identity. Inspect it before retrying; existing work is preserved."
+    );
+  const commonDir = realpathSync2(
+    await git(w.path, ["rev-parse", "--path-format=absolute", "--git-common-dir"])
+  );
+  const root = realpathSync2(await git(w.path, ["rev-parse", "--show-toplevel"]));
+  const branch = await git(w.path, ["symbolic-ref", "HEAD"]);
+  if (commonDir !== w.commonDir || root !== w.path || branch !== `refs/heads/${w.branch}`)
+    throw new AppError(
+      "worktree_identity",
+      "Managed worktree repository or branch changed; refusing to reuse it."
+    );
+  if (requireClean) {
+    const head = await git(w.path, ["rev-parse", "HEAD"]);
+    const status = await git(w.path, ["status", "--porcelain", "--untracked-files=all"]);
+    if (head !== w.baseCommit || status)
+      throw new AppError(
+        "worktree_incomplete",
+        "Worktree creation was interrupted and its checkout is not clean at the pinned base. Inspect it before retrying; no files were reset."
+      );
+  }
+  const cwd = safePath(w.path, relative2(w.path, w.cwd), true);
+  if (!statSync2(cwd).isDirectory())
+    throw new AppError(
+      "worktree_cwd",
+      "Task working directory does not exist in the selected Git revision"
+    );
+  return cwd;
+}
+async function createWorktree(w) {
+  mkdirSync3(dirname3(w.path), { recursive: true, mode: 448 });
+  await git(w.repositoryRoot, ["worktree", "add", "-b", w.branch, "--", w.path, w.baseCommit]);
+  return validateWorktree(w, true);
+}
+
+// src/cleanup.ts
+var cleanupPolicySchema = external_exports.object({
+  autoRelease: external_exports.boolean().default(true),
+  collectAfterHours: external_exports.number().min(0).max(87600).nullable().default(null),
+  deleteMergedBranches: external_exports.boolean().default(false)
+}).strict();
+var terminal2 = (t) => ["completed", "failed", "cancelled"].includes(t.status);
+function refuse(message) {
+  throw new AppError("cleanup_blocked", message, 409);
+}
+function flush(path) {
+  const fd = openSync(path, "r");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+async function fileHash(path) {
+  const value = createHash2("sha256");
+  for await (const chunk of createReadStream(path)) value.update(chunk);
+  return value.digest("hex");
+}
+var Cleanup = class {
+  constructor(s) {
+    this.s = s;
+  }
+  s;
+  busy = /* @__PURE__ */ new Set();
+  stopped = false;
+  lastAutomatic = 0;
+  policy(projectId) {
+    return this.s.store.get("cleanup-policy", projectId) ?? cleanupPolicySchema.parse({});
+  }
+  archive(t) {
+    return t.archiveId ? this.s.store.get("archive", t.archiveId) : void 0;
+  }
+  group(t) {
+    return t.worktree ? this.s.store.all("task").filter((x) => x.worktree?.path === t.worktree.path || inside(t.worktree.path, x.cwd)) : [t];
+  }
+  assertMutable(t) {
+    if (t.archiveId || this.busy.has(t.id))
+      refuse(
+        "Task is archived or cleanup is in progress. Create a new assignment for further work."
+      );
+    const affected = /* @__PURE__ */ new Set([t.id]);
+    const tasks = this.s.store.all("task");
+    for (const id of affected) {
+      const parentId = tasks.find((child) => child.id === id)?.parentId;
+      for (const other of tasks)
+        if (other.dependencies.includes(id) || other.id === parentId) affected.add(other.id);
+    }
+    if ([...affected].some((id) => this.busy.has(id)))
+      refuse("Cleanup is inspecting a consumer of this task; retry after it finishes");
+    const r = t.runId ? this.s.store.get("run", t.runId) : void 0;
+    if (r?.cleanup && ["closing", "uncertain"].includes(r.cleanup.state))
+      refuse("Reconcile terminal cleanup before changing this task.");
+  }
+  active(taskId) {
+    return this.busy.has(taskId);
+  }
+  assertOutcomeMutable(outcomeId) {
+    if (this.s.store.all("task").some((t) => t.outcomeId === outcomeId && this.busy.has(t.id)))
+      refuse("Cleanup is inspecting this outcome; retry after it finishes");
+  }
+  consumers(tasks) {
+    const ids = new Set(tasks.map((t) => t.id));
+    const roots = tasks.map((t) => t.worktree?.path ?? t.cwd);
+    const reasons = [];
+    for (const t of this.s.store.all("task")) {
+      if (ids.has(t.id)) continue;
+      if (!terminal2(t) && (ids.has(t.parentId ?? "") || t.dependencies.some((id) => ids.has(id)) || (t.waitForChildren ?? []).some((id) => ids.has(id))))
+        reasons.push(`Task ${t.id} still consumes these results`);
+    }
+    for (const p of this.s.store.all("project")) {
+      if (roots.some((root) => tasks.some((t) => t.worktree?.path === root) && inside(root, p.root)))
+        reasons.push(`Registered project ${p.id} uses this checkout`);
+    }
+    return reasons;
+  }
+  runReasons(t, r, automatic) {
+    const reasons = [];
+    if (!terminal2(t) || r.phase !== "stopped")
+      reasons.push("Task and native run must be finished and settled");
+    if (t.resumePending) reasons.push("A parent continuation is pending");
+    if (this.s.store.all("operation").some((o) => o.taskId === t.id && !["done", "failed"].includes(o.phase)))
+      reasons.push("A task control is unresolved");
+    if (this.s.store.all("lead-wait").some(
+      (w) => w.adapter.type === "herdr" && w.adapter.paneId === r.paneId && !["invalidated", "acknowledged"].includes(w.state)
+    ))
+      reasons.push("This pane is pinned by a lead wait");
+    reasons.push(...this.consumers([t]));
+    if (automatic && (!this.policy(t.projectId).autoRelease || t.status !== "completed" || !t.outcomeId || this.s.orchestration.outcome(t.outcomeId).status !== "completed"))
+      reasons.push(
+        "Automatic release waits for the completed integrated outcome and enabled policy; failures require inspection"
+      );
+    return reasons;
+  }
+  groupReasons(t) {
+    const tasks = this.group(t), reasons = this.consumers(tasks);
+    if (!t.worktree || t.worktree.state !== "ready")
+      reasons.push("Only ready Marionette-managed worktrees can be collected");
+    for (const item of tasks) {
+      if (!terminal2(item)) reasons.push(`Task ${item.id} is ${item.status}`);
+      for (const r of this.s.store.all("run").filter((r2) => r2.taskId === item.id))
+        if (r.paneId && r.cleanup?.state !== "closed")
+          reasons.push(`Run ${r.id} must release its terminal first`);
+      if (item.status === "completed" && item.outcomeId && this.s.orchestration.outcome(item.outcomeId).status !== "completed")
+        reasons.push(`Outcome ${item.outcomeId} still needs integration`);
+      else if (item.status === "completed" && item.outcomeId && this.s.orchestration.unmet(this.s.orchestration.outcome(item.outcomeId)).length)
+        reasons.push(`Outcome ${item.outcomeId} evidence is no longer current`);
+    }
+    for (const o of this.s.store.all("outcome")) {
+      if (o.status === "completed") continue;
+      for (const ref of [
+        ...o.assessments.flatMap((a) => a.references),
+        ...o.integrated?.evidence ?? []
+      ]) {
+        if (tasks.some((t2) => ref.path.startsWith(`task:${t2.id}:`)))
+          reasons.push(`Outcome ${o.id} still references this checkout`);
+      }
+    }
+    return [...new Set(reasons)];
+  }
+  async preview(taskId) {
+    const t = this.s.task(taskId), runs = this.s.store.all("run").filter((r) => r.taskId === taskId), archive = this.archive(t);
+    let gitReason;
+    if (t.worktree && !archive)
+      try {
+        await this.clean(t.worktree);
+      } catch (e) {
+        gitReason = String(e);
+      }
+    return {
+      taskId,
+      policy: this.policy(t.projectId),
+      runs: runs.map((r) => ({
+        runId: r.id,
+        tabId: r.tabId,
+        cleanup: r.cleanup,
+        reasons: this.runReasons(t, r, true)
+      })),
+      delivery: this.s.store.get("delivery", taskId),
+      archive,
+      collectionReasons: [
+        ...this.groupReasons(t),
+        ...gitReason ? [gitReason] : [],
+        ...!this.s.store.get("delivery", taskId) && !archive ? ["Record delivery or explicit abandonment first"] : []
+      ],
+      boundary: "Completion retains branches and worktrees. Collection never removes sessions or workspaces."
+    };
+  }
+  async locked(tasks, fn) {
+    if (this.stopped || tasks.some((t) => this.busy.has(t.id)))
+      refuse("Cleanup is stopping or already in progress");
+    tasks.forEach((t) => this.busy.add(t.id));
+    try {
+      return await fn();
+    } finally {
+      tasks.forEach((t) => this.busy.delete(t.id));
+    }
+  }
+  recover() {
+    this.stopped = false;
+    for (const r of this.s.store.all("run"))
+      if (r.cleanup?.state === "closing")
+        this.saveRun(r, {
+          ...r.cleanup,
+          state: "uncertain",
+          error: "Restart during tab closure; inspect and reconcile. No automatic replay."
+        });
+  }
+  async stop() {
+    this.stopped = true;
+    while (this.busy.size) await new Promise((r) => setTimeout(r, 25));
+  }
+  tick() {
+    if (this.stopped || Date.now() - this.lastAutomatic < 1e4) return;
+    this.lastAutomatic = Date.now();
+    for (const t of this.s.store.all("task")) {
+      if (this.busy.has(t.id)) continue;
+      const p = this.policy(t.projectId);
+      const r = t.runId ? this.s.store.get("run", t.runId) : void 0;
+      if (p.autoRelease && r && !r.cleanup && !this.runReasons(t, r, true).length) {
+        void this.locked([t], () => this.release(t, r, "Integrated outcome completed", true)).catch(
+          (e) => this.s.store.event(t.projectId, "cleanup.error", String(e), t.id)
+        );
+        continue;
+      }
+      const delivery = this.s.store.get("delivery", t.id), a = this.archive(t);
+      if (p.collectAfterHours === null || !delivery || delivery.disposition === "abandoned" || a && a.taskId !== t.id || this.group(t).some((x) => x.status !== "completed"))
+        continue;
+      if (a?.phase === "collected" && (!p.deleteMergedBranches || a.branchDeleted || delivery.disposition !== "merged"))
+        continue;
+      if (Date.now() - Date.parse(delivery.createdAt) < p.collectAfterHours * 36e5 || this.groupReasons(t).length)
+        continue;
+      if (a?.error || a?.phase === "removing") continue;
+      void this.locked(this.group(t), async () => {
+        const guard = () => {
+          if (JSON.stringify(this.policy(t.projectId)) !== JSON.stringify(p))
+            refuse("Cleanup policy changed during inspection");
+        };
+        const archived = a ?? await this.createArchive(t, guard);
+        await this.collect(
+          archived,
+          p.deleteMergedBranches && delivery.disposition === "merged",
+          guard
+        );
+      }).catch((e) => this.s.store.event(t.projectId, "cleanup.error", String(e), t.id));
+    }
+  }
+  saveRun(r, cleanup) {
+    const latest = this.s.store.get("run", r.id);
+    this.s.store.put("run", r.id, { ...latest, cleanup: { ...cleanup, updatedAt: now() } });
+  }
+  async pinned(t, r) {
+    const p = this.s.project(t.projectId), h = this.s.port(p);
+    if (!r.tabId || !r.paneId || !r.terminalId || !r.nativeSession)
+      refuse("A full saved worker and native session identity is required");
+    const tab = (await h.call("tab.get", { tab_id: r.tabId })).tab;
+    const panes = (await h.call("pane.list", { workspace_id: p.workspaceId })).panes;
+    const members = panes?.filter((pane) => pane.tab_id === r.tabId);
+    if (tab?.workspace_id !== p.workspaceId || tab.tab_id !== r.tabId || tab.pane_count !== 1 || members?.length !== 1 || members[0].pane_id !== r.paneId || members[0].terminal_id !== r.terminalId)
+      refuse("Tab contents changed; refusing to close another pane");
+    const a = (await h.call("agent.get", { target: r.paneId })).agent;
+    if (a?.workspace_id !== p.workspaceId || a.pane_id !== r.paneId || a.terminal_id !== r.terminalId || a.name !== r.agentName || a.agent !== r.kind || a.agent_session?.value !== r.nativeSession || !["idle", "done"].includes(a.agent_status) || a.launch_pending || a.interactive_ready === false)
+      refuse("Native worker identity or readiness changed");
+    return h;
+  }
+  async absent(t, r) {
+    const h = this.s.port(this.s.project(t.projectId));
+    try {
+      await h.call("tab.get", { tab_id: r.tabId });
+      return false;
+    } catch (e) {
+      if (e.code !== "tab_not_found") throw e;
+    }
+    const panes = (await h.call("pane.list")).panes;
+    if (!Array.isArray(panes) || panes.some((p) => p.pane_id === r.paneId || p.terminal_id === r.terminalId))
+      refuse("Original terminal may have moved to another tab; inspect it before cleanup");
+    return true;
+  }
+  async checkReleased(tasks) {
+    for (const t of tasks) {
+      for (const r of this.s.store.all("run").filter((r2) => r2.taskId === t.id && r2.paneId))
+        if (r.cleanup?.state !== "closed" || !await this.absent(t, r))
+          refuse(
+            "A recorded worker terminal is still present; inspect it before collecting its checkout"
+          );
+    }
+  }
+  async release(t, r, reason, automatic, guard = () => {
+  }) {
+    if (r.cleanup?.state === "closed") return r.cleanup;
+    if (r.cleanup && ["closing", "uncertain"].includes(r.cleanup.state))
+      refuse("Reconcile ambiguous tab closure first");
+    try {
+      const reasons = this.runReasons(this.s.task(t.id), r, automatic);
+      if (reasons.length) refuse(reasons.join("; "));
+      if (await this.absent(t, r)) {
+        guard();
+        this.saveRun(r, { state: "closed", reason, updatedAt: now(), output: t.output });
+        return this.s.store.get("run", r.id).cleanup;
+      }
+      const h = await this.pinned(t, r);
+      const output = (await h.call("pane.read", {
+        pane_id: r.paneId,
+        source: "recent_unwrapped",
+        lines: 500,
+        format: "text"
+      })).read?.text ?? t.output;
+      await this.pinned(t, r);
+      guard();
+      const current = this.s.task(t.id);
+      if (current.revision !== t.revision || this.runReasons(current, this.s.store.get("run", r.id), automatic).length)
+        refuse("Task changed during cleanup inspection");
+      this.saveRun(r, {
+        state: "closing",
+        reason,
+        updatedAt: now(),
+        output: String(output).slice(-1e5)
+      });
+      await h.call("tab.close", { tab_id: r.tabId });
+      this.saveRun(r, { ...this.s.store.get("run", r.id).cleanup, state: "closed" });
+      this.s.store.event(
+        t.projectId,
+        "cleanup.released",
+        "Saved worker diagnostics and closed its settled tab",
+        t.id,
+        { runId: r.id }
+      );
+      return this.s.store.get("run", r.id).cleanup;
+    } catch (e) {
+      const current = this.s.store.get("run", r.id).cleanup;
+      this.saveRun(r, {
+        ...current,
+        state: current?.state === "closing" ? "uncertain" : "retained",
+        reason,
+        updatedAt: now(),
+        error: String(e)
+      });
+      throw e;
+    }
+  }
+  async clean(w) {
+    await validateWorktree(w);
+    const status = await git(w.path, [
+      "status",
+      "--porcelain",
+      "--untracked-files=all",
+      "--ignored"
+    ]);
+    if (status)
+      refuse(
+        "Worktree has modified, untracked, or ignored files; preserve or remove them explicitly before collection"
+      );
+    return git(w.path, ["rev-parse", "HEAD"]);
+  }
+  async checkDelivery(w, d) {
+    if (await this.clean(w) !== d.head) refuse("Worktree HEAD changed after delivery");
+    if (d.disposition !== "abandoned") {
+      if (!d.targetRef || !d.targetCommit) refuse("Delivery target is missing");
+      const current = await git(w.repositoryRoot, [
+        "rev-parse",
+        "--verify",
+        "--end-of-options",
+        `${d.targetRef}^{commit}`
+      ]);
+      await git(w.repositoryRoot, ["merge-base", "--is-ancestor", d.head, current]);
+    }
+  }
+  archiveRoot(id) {
+    return safePath(dirname4(this.s.store.path), `archives/${id}`);
+  }
+  /** Live files remain authoritative until collection actually removes the checkout. */
+  evidencePath(t, input) {
+    const a = this.archive(t);
+    if (!a || a.phase === "archived" || existsSync3(a.worktree.path))
+      return safePath(t.cwd, input, true);
+    const source = resolve4(t.cwd, input);
+    if (!inside(t.cwd, source)) refuse("Evidence escapes task directory");
+    const f = a.files.find((f2) => f2.source === source);
+    if (!f) refuse("Evidence was not preserved in this archive");
+    const path = safePath(this.archiveRoot(a.id), `files/${f.digest}`, true);
+    if (digest(path) !== f.digest) refuse("Archived evidence digest changed");
+    return path;
+  }
+  async createArchive(t, guard) {
+    const prior = this.archive(t);
+    if (prior) return prior;
+    const reasons = this.groupReasons(t);
+    if (reasons.length) refuse(reasons.join("; "));
+    const w = t.worktree, d = this.s.store.get("delivery", t.id);
+    if (!d) refuse("Record delivery or abandonment before archiving");
+    await this.checkDelivery(w, d);
+    const tasks = this.group(t), taskIds = new Set(tasks.map((t2) => t2.id));
+    await this.checkReleased(tasks);
+    const id = randomUUID3(), root = this.archiveRoot(id);
+    mkdirSync4(resolve4(root, "files"), { recursive: true, mode: 448 });
+    const files = /* @__PURE__ */ new Map();
+    const copy = (source, expected, alias = source) => {
+      const actual = digest(source);
+      if (!actual || expected && expected !== actual)
+        refuse("Evidence is missing or changed before archival");
+      const bytes = readFileSync4(source);
+      if (hash(bytes) !== actual) refuse("Evidence changed during archival");
+      writeFileSync2(resolve4(root, "files", actual), bytes, { mode: 384, flush: true });
+      files.set(source, actual);
+      files.set(alias, actual);
+    };
+    for (const item of tasks) {
+      for (const v of item.verification ?? [])
+        if (v.passed && v.check.type === "file")
+          copy(safePath(item.cwd, v.check.path, true), v.digest, resolve4(item.cwd, v.check.path));
+      for (const path of item.receipt?.artifacts ?? []) {
+        const source = safePath(item.cwd, path, true);
+        if (!item.ownership.some((owned) => inside(safePath(item.cwd, owned), source)))
+          refuse("Reported artifact no longer belongs to the task");
+        if (statSync3(source).isDirectory()) continue;
+        copy(source, void 0, resolve4(item.cwd, path));
+      }
+    }
+    for (const o of this.s.store.all("outcome")) {
+      for (const ref of [
+        ...o.assessments.flatMap((a2) => a2.references),
+        ...o.integrated?.evidence ?? []
+      ]) {
+        const match = /^task:([^:]+):(.+)$/.exec(ref.path);
+        if (match && taskIds.has(match[1]))
+          copy(
+            safePath(this.s.task(match[1]).cwd, match[2], true),
+            ref.digest,
+            resolve4(this.s.task(match[1]).cwd, match[2])
+          );
+        else if (!match) {
+          const path = resolve4(this.s.project(o.projectId).root, ref.path);
+          if (inside(w.path, path))
+            refuse(
+              "Project-relative evidence still uses this checkout; replace it with a task reference"
+            );
+        }
+      }
+    }
+    await git(w.repositoryRoot, [
+      "bundle",
+      "create",
+      resolve4(root, "commits.bundle"),
+      `refs/heads/${w.branch}`
+    ]);
+    await git(w.repositoryRoot, ["bundle", "verify", resolve4(root, "commits.bundle")]);
+    flush(resolve4(root, "commits.bundle"));
+    const bundleDigest = await fileHash(resolve4(root, "commits.bundle"));
+    const manifest = JSON.stringify(
+      {
+        tasks,
+        runs: this.s.store.all("run").filter((r) => taskIds.has(r.taskId)).map(({ tokenHash, ...r }) => r),
+        outcomes: this.s.store.all("outcome").filter((o) => tasks.some((t2) => t2.outcomeId === o.id)),
+        delivery: d,
+        files: [...files],
+        archivedAt: now()
+      },
+      null,
+      2
+    );
+    writeFileSync2(resolve4(root, "manifest.json"), manifest, { mode: 384, flush: true });
+    flush(resolve4(root, "files"));
+    flush(root);
+    flush(dirname4(root));
+    flush(dirname4(dirname4(root)));
+    await this.checkDelivery(w, d);
+    guard();
+    if (this.groupReasons(t).length || this.group(t).some((x) => !tasks.some((y) => x.id === y.id && x.revision === y.revision)))
+      refuse("Checkout consumers changed during archival");
+    for (const [path, expected] of files)
+      if (digest(path) !== expected) refuse("Evidence changed during archival");
+    const a = {
+      id,
+      taskId: t.id,
+      projectId: t.projectId,
+      taskIds: [...taskIds],
+      phase: "archived",
+      worktree: w,
+      delivery: d,
+      files: [...files].map(([source, digest2]) => ({ source, digest: digest2 })),
+      manifestDigest: hash(manifest),
+      bundleDigest,
+      createdAt: now(),
+      updatedAt: now()
+    };
+    this.s.store.transaction(() => {
+      this.s.store.put("archive", id, a);
+      for (const item of tasks) this.s.updateTask(item, { archiveId: id });
+      this.s.store.event(
+        t.projectId,
+        "cleanup.archived",
+        "Preserved evidence, diagnostics, and committed history; tasks are sealed",
+        t.id,
+        { archiveId: id }
+      );
+    });
+    return a;
+  }
+  async verifyArchive(a) {
+    const root = this.archiveRoot(a.id);
+    if (hash(readFileSync4(safePath(root, "manifest.json", true))) !== a.manifestDigest || await fileHash(safePath(root, "commits.bundle", true)) !== a.bundleDigest)
+      refuse("Archive integrity check failed");
+    for (const f of a.files)
+      if (digest(safePath(root, `files/${f.digest}`, true)) !== f.digest)
+        refuse("Archived evidence integrity check failed");
+  }
+  saveArchive(a, patch) {
+    const next = { ...this.s.store.get("archive", a.id), ...patch, updatedAt: now() };
+    this.s.store.put("archive", a.id, next);
+    return next;
+  }
+  async collect(a, deleteBranch, guard) {
+    if (a.phase === "collected" && (!deleteBranch || a.branchDeleted)) return a;
+    if (deleteBranch && a.delivery.disposition !== "merged" && a.delivery.disposition !== "abandoned")
+      refuse("Published PR branches are retained until merged or explicitly abandoned");
+    try {
+      await this.verifyArchive(a);
+      const t = this.s.task(a.taskId), reasons = this.groupReasons(t);
+      if (reasons.length) refuse(reasons.join("; "));
+      await this.checkReleased(this.group(t));
+      const w = a.worktree;
+      const common = realpathSync3(
+        await git(w.repositoryRoot, ["rev-parse", "--path-format=absolute", "--git-common-dir"])
+      );
+      if (common !== w.commonDir) refuse("Source repository identity changed");
+      if (existsSync3(w.path)) {
+        await this.checkDelivery(w, a.delivery);
+        for (const f of a.files)
+          if (digest(f.source) !== f.digest) refuse("Live evidence changed after archival");
+        guard();
+        if (this.groupReasons(t).length) refuse("Checkout consumers changed before collection");
+        a = this.saveArchive(a, { phase: "removing", error: void 0 });
+        await git(w.repositoryRoot, ["worktree", "remove", "--", w.path]);
+      }
+      const listing = await git(w.repositoryRoot, ["worktree", "list", "--porcelain", "-z"]);
+      if (common !== w.commonDir || listing.split("\0").includes(`worktree ${w.path}`) || existsSync3(w.path))
+        refuse("Worktree removal is incomplete; inspect its registration");
+      a = this.saveArchive(a, { phase: "worktree-removed", error: void 0 });
+      if (deleteBranch) {
+        const refs = await git(w.repositoryRoot, [
+          "for-each-ref",
+          "--format=%(refname) %(objectname)",
+          `refs/heads/${w.branch}`
+        ]);
+        if (refs) {
+          if (refs !== `refs/heads/${w.branch} ${a.delivery.head}`)
+            refuse("Branch moved after archival; preserving it");
+          if (listing.split("\0").includes(`branch refs/heads/${w.branch}`))
+            refuse("Another checkout still uses the branch");
+          if (a.delivery.disposition === "abandoned") {
+            guard();
+            await git(w.repositoryRoot, [
+              "update-ref",
+              "-d",
+              `refs/heads/${w.branch}`,
+              a.delivery.head
+            ]);
+          } else {
+            const target = await git(w.repositoryRoot, [
+              "rev-parse",
+              "--verify",
+              "--end-of-options",
+              `${a.delivery.targetRef}^{commit}`
+            ]);
+            await git(w.repositoryRoot, ["merge-base", "--is-ancestor", a.delivery.head, target]);
+            guard();
+            await git(w.repositoryRoot, [
+              "update-ref",
+              "-d",
+              `refs/heads/${w.branch}`,
+              a.delivery.head
+            ]);
+          }
+        }
+      }
+      a = this.saveArchive(a, {
+        phase: "collected",
+        branchDeleted: deleteBranch,
+        error: void 0
+      });
+      this.s.store.event(
+        a.projectId,
+        "cleanup.collected",
+        "Collected delivered worktree; archive retained",
+        a.taskId,
+        { archiveId: a.id, branchDeleted: deleteBranch }
+      );
+      return a;
+    } catch (e) {
+      this.saveArchive(a, { error: String(e) });
+      throw e;
+    }
+  }
+  async invoke(action, raw) {
+    if (action === "cleanup.preview") return this.preview(external_exports.string().parse(raw.taskId));
+    const c = this.s.guard(raw.lease), reason = external_exports.string().min(1).max(4e3).parse(raw.reason);
+    const guard = () => {
+      this.s.guard(raw.lease);
+    };
+    if (action === "cleanup.configure") {
+      const p = cleanupPolicySchema.parse(raw.policy);
+      this.s.store.put("cleanup-policy", c.projectId, p);
+      this.s.store.event(c.projectId, "cleanup.policy", `${c.owner}: ${reason}`, void 0, p);
+      return p;
+    }
+    const t = this.s.task(external_exports.string().parse(raw.taskId));
+    if (t.projectId !== c.projectId) refuse("Task and lead belong to different projects");
+    if (action === "cleanup.release" || action === "cleanup.reconcile") {
+      const r = this.s.store.get("run", external_exports.string().parse(raw.runId ?? t.runId));
+      if (!r || r.taskId !== t.id) refuse("Run does not belong to this task");
+      return this.locked([t], async () => {
+        if (action === "cleanup.release") return this.release(t, r, reason, false, guard);
+        if (r.cleanup?.state !== "uncertain")
+          refuse("Only uncertain cleanup needs reconciliation");
+        const resolution = external_exports.enum(["closed", "not-closed"]).parse(raw.resolution);
+        if (resolution === "closed") {
+          if (await this.absent(t, r)) {
+            guard();
+            this.saveRun(r, { ...r.cleanup, state: "closed", reason, error: void 0 });
+            return this.s.store.get("run", r.id).cleanup;
+          }
+          refuse("Original tab is still present");
+        }
+        await this.pinned(t, r);
+        guard();
+        this.saveRun(r, { ...r.cleanup, state: "retained", reason, error: void 0 });
+        return this.s.store.get("run", r.id).cleanup;
+      });
+    }
+    if (!t.worktree) refuse("Task has no managed worktree");
+    return this.locked(this.group(t), async () => {
+      if (action === "cleanup.deliver") {
+        const archived = this.archive(t);
+        const disposition = external_exports.enum(["merged", "published", "abandoned"]).parse(raw.disposition);
+        if (archived && archived.taskId !== t.id)
+          refuse("Update delivery on the task that owns the archive");
+        const head = archived && !existsSync3(t.worktree.path) ? await git(t.worktree.repositoryRoot, [
+          "rev-parse",
+          "--verify",
+          "--end-of-options",
+          `refs/heads/${t.worktree.branch}^{commit}`
+        ]) : await this.clean(t.worktree);
+        if (archived && (head !== archived.delivery.head || archived.branchDeleted))
+          refuse("Archived branch changed or was already deleted");
+        let targetRef, targetCommit;
+        if (disposition !== "abandoned") {
+          targetRef = external_exports.string().min(1).parse(raw.targetRef);
+          if (!/^refs\/(heads|remotes)\//.test(targetRef) || targetRef === `refs/heads/${t.worktree.branch}` || disposition === "published" && !targetRef.startsWith("refs/remotes/"))
+            refuse(
+              "Use an explicit target branch ref; published delivery needs a refreshed remote-tracking ref"
+            );
+          await git(t.worktree.repositoryRoot, ["check-ref-format", targetRef]);
+          targetCommit = await git(t.worktree.repositoryRoot, [
+            "rev-parse",
+            "--verify",
+            "--end-of-options",
+            `${targetRef}^{commit}`
+          ]);
+          await git(t.worktree.repositoryRoot, [
+            "merge-base",
+            "--is-ancestor",
+            head,
+            targetCommit
+          ]);
+        }
+        guard();
+        const d = {
+          taskId: t.id,
+          projectId: t.projectId,
+          disposition,
+          head,
+          targetRef,
+          targetCommit,
+          reason,
+          owner: c.owner,
+          createdAt: now()
+        };
+        const previous = this.s.store.get("delivery", t.id);
+        if (previous && JSON.stringify({ ...previous, createdAt: "" }) === JSON.stringify({ ...d, createdAt: "" }))
+          return previous;
+        this.s.store.put("delivery", t.id, d);
+        if (archived) this.saveArchive(archived, { delivery: d, error: void 0 });
+        this.s.store.event(t.projectId, "cleanup.delivered", `${disposition}: ${reason}`, t.id, d);
+        return d;
+      }
+      if (action === "cleanup.archive") return this.createArchive(t, guard);
+      if (action === "cleanup.collect") {
+        const a = this.archive(t);
+        if (!a || a.id !== raw.archiveId)
+          refuse("Preview and supply the current archiveId before collection");
+        return this.collect(a, external_exports.boolean().parse(raw.deleteBranch ?? false), guard);
+      }
+      throw new AppError("unknown_action", `Unknown action: ${action}`, 404);
+    });
+  }
+};
+
 // src/model-catalog.ts
 import { spawn as spawn2 } from "node:child_process";
 
@@ -28973,7 +29745,7 @@ var strategySchema = external_exports.object({
 
 // src/model-catalog.ts
 async function metadata(binary, args2, cwd, kind) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const child = spawn2(binary, args2, { cwd, stdio: ["pipe", "pipe", "pipe"] });
     let buffer = "", bytes = 0, finished = false, nextId = 2;
     const rows = [];
@@ -28983,7 +29755,7 @@ async function metadata(binary, args2, cwd, kind) {
       clearTimeout(timer);
       child.stdin.end();
       child.kill("SIGTERM");
-      error ? reject(error) : resolve12(rows);
+      error ? reject(error) : resolve13(rows);
     };
     const timer = setTimeout(
       () => finish(new AppError("catalog_timeout", `${binary} model metadata timed out`)),
@@ -29569,9 +30341,9 @@ async function probeProfile(profile, cwd) {
 }
 
 // src/orchestration.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname3, resolve as resolve3, relative as relative2 } from "node:path";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname5, resolve as resolve5, relative as relative3 } from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
 var fail = (code, message) => {
   throw new AppError(code, message, 409);
 };
@@ -29590,7 +30362,7 @@ var Orchestration = class {
           id: `legacy-${t.id}`,
           projectId: t.projectId,
           objective: t.prompt,
-          scope: t.ownership.map((path) => resolve3(t.worktree?.sourceCwd ?? t.cwd, path)),
+          scope: t.ownership.map((path) => resolve5(t.worktree?.sourceCwd ?? t.cwd, path)),
           category: "software",
           criteria: t.checks.map((check, index) => ({
             id: `check-${index + 1}`,
@@ -29660,7 +30432,7 @@ var Orchestration = class {
       if (!v.passed) return false;
       if (v.check.type !== "file") return true;
       try {
-        return !!v.digest && digest(safePath(t.cwd, v.check.path, true)) === v.digest;
+        return !!v.digest && digest(this.s.cleanup.evidencePath(t, v.check.path)) === v.digest;
       } catch {
         return false;
       }
@@ -29701,8 +30473,15 @@ var Orchestration = class {
     const t = this.s.task(taskReference[1]);
     if (t.projectId !== projectId)
       fail("evidence_scope", "Evidence task belongs to another project");
-    const path = safePath(t.cwd, taskReference[2], true);
-    if (!t.ownership.some((owned) => inside(safePath(t.cwd, owned), path)))
+    const original = resolve5(t.cwd, taskReference[2]);
+    const path = this.s.cleanup.evidencePath(t, taskReference[2]);
+    const archived = !inside(t.cwd, path);
+    if (!t.ownership.some(
+      (owned) => inside(
+        archived ? resolve5(t.cwd, owned) : safePath(t.cwd, owned),
+        archived ? original : path
+      )
+    ))
       fail("evidence_scope", "Task evidence must be inside its ownership");
     return path;
   }
@@ -29737,7 +30516,7 @@ var Orchestration = class {
   }
   revision(o, reason, owner, before, after, taskId, evidence = []) {
     const r = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       projectId: o.projectId,
       outcomeId: o.id,
       revision: o.revision,
@@ -29842,6 +30621,9 @@ var Orchestration = class {
   }
   references(projectId, paths) {
     return external_exports.array(text).min(1).parse(paths).map((path) => {
+      const taskReference = /^task:([^:]+):/.exec(path);
+      if (taskReference && this.s.cleanup.active(taskReference[1]))
+        fail("cleanup_busy", "Evidence is being archived; retry after cleanup finishes");
       const value = digest(this.evidencePath(projectId, path));
       if (!value)
         fail(
@@ -29922,6 +30704,7 @@ var Orchestration = class {
         fail("depth_limit", "Outcome delegation depth reached");
     }
     if (task.outcomeId) {
+      this.s.cleanup.assertOutcomeMutable(task.outcomeId);
       const o = this.outcome(task.outcomeId);
       if (o.projectId !== task.projectId)
         fail("outcome_scope", "Outcome belongs to another project");
@@ -29932,7 +30715,7 @@ var Orchestration = class {
             safePath(this.s.project(task.projectId).root, scope),
             task.worktree ? safePath(
               task.worktree.sourceCwd,
-              relative2(task.worktree.cwd, safePath(task.cwd, owned))
+              relative3(task.worktree.cwd, safePath(task.cwd, owned))
             ) : safePath(task.cwd, owned)
           )
         ))
@@ -29945,7 +30728,7 @@ var Orchestration = class {
       );
     } else {
       const o = {
-        id: randomUUID3(),
+        id: randomUUID4(),
         projectId: task.projectId,
         objective: task.prompt,
         scope: task.ownership.map((p) => safePath(task.cwd, p)),
@@ -30055,6 +30838,7 @@ var Orchestration = class {
   }
   reviseTask(raw, c) {
     const t = this.s.task(text.parse(raw.taskId));
+    this.s.cleanup.assertMutable(t);
     if (t.projectId !== c.projectId || !t.outcomeId)
       fail("project_mismatch", "Task must belong to this lead and an outcome");
     const o = this.outcome(t.outcomeId);
@@ -30062,6 +30846,9 @@ var Orchestration = class {
     if (t.revision !== external_exports.number().int().parse(raw.expectedRevision))
       fail("stale_revision", "Task changed; refresh before revising");
     const patch = planPatchSchema.parse(raw.patch), reason = text.parse(raw.reason);
+    for (const id of patch.dependencies ?? [])
+      if (this.s.cleanup.active(id))
+        fail("cleanup_busy", "Dependency is being cleaned up; retry after it finishes");
     if (t.runId && this.s.store.get("run", t.runId)?.phase !== "stopped" && !["paused", "waiting"].includes(t.status))
       fail("task_active", "Pause and settle the task before revising it");
     if (patch.supersededBy) {
@@ -30070,13 +30857,15 @@ var Orchestration = class {
         fail("supersede_scope", "Replacement must be required work in the same outcome");
     }
     for (const check of patch.checks ?? []) if (check.type === "file") safePath(t.cwd, check.path);
+    const released = t.runId && this.s.store.get("run", t.runId)?.cleanup?.state === "closed";
     const updated = {
       ...t,
       ...patch,
       revision: t.revision + 1,
       receipt: void 0,
       verification: void 0,
-      status: patch.supersededBy ? "cancelled" : t.runId ? "paused" : "queued",
+      runId: released ? void 0 : t.runId,
+      status: patch.supersededBy ? "cancelled" : t.runId && !released ? "paused" : "queued",
       updatedAt: now()
     };
     this.validateGraph(
@@ -30121,7 +30910,7 @@ var Orchestration = class {
     }
     if (raw.action === "finding") {
       const finding = {
-        id: randomUUID3(),
+        id: randomUUID4(),
         projectId: t.projectId,
         outcomeId: t.outcomeId,
         taskId: t.id,
@@ -30217,9 +31006,9 @@ var Orchestration = class {
           "profile_changed",
           "Profile changed during validation; validate the current configuration"
         );
-      const path = resolve3(dirname3(this.s.store.path), "profile-evidence", randomUUID3() + ".json");
-      mkdirSync3(dirname3(path), { recursive: true, mode: 448 });
-      writeFileSync2(path, result.output, { mode: 384 });
+      const path = resolve5(dirname5(this.s.store.path), "profile-evidence", randomUUID4() + ".json");
+      mkdirSync5(dirname5(path), { recursive: true, mode: 448 });
+      writeFileSync3(path, result.output, { mode: 384 });
       const updated = {
         ...profile,
         availability,
@@ -30244,7 +31033,7 @@ var Orchestration = class {
           const { key, ...fields } = i;
           const o2 = {
             ...fields,
-            id: randomUUID3(),
+            id: randomUUID4(),
             leadOwner: c.owner,
             revision: 1,
             status: "open",
@@ -30304,6 +31093,7 @@ var Orchestration = class {
       }
       if (action.startsWith("strategy.")) return this.strategy(action, raw, c);
       const o = this.outcome(text.parse(raw.outcomeId));
+      this.s.cleanup.assertOutcomeMutable(o.id);
       if (o.projectId !== c.projectId) fail("project_mismatch", "Outcome and lead differ");
       this.checkRevision(o, raw.expectedRevision);
       if (action === "outcome.revise") {
@@ -30372,6 +31162,8 @@ var Orchestration = class {
     });
   }
   strategy(action, raw, c) {
+    const cleanupOutcome = raw.strategy?.outcomeId ?? raw.outcomeId ?? (raw.strategyId ? this.s.store.get("strategy", raw.strategyId)?.outcomeId : void 0);
+    if (cleanupOutcome) this.s.cleanup.assertOutcomeMutable(cleanupOutcome);
     if (action === "strategy.create") {
       const i = strategySchema.parse(raw.strategy), o = this.outcome(i.outcomeId);
       if (o.projectId !== c.projectId) fail("project_mismatch", "Strategy and lead differ");
@@ -30382,7 +31174,7 @@ var Orchestration = class {
         fail("quorum", "Quorum exceeds participant count");
       const strategy2 = {
         ...i,
-        id: randomUUID3(),
+        id: randomUUID4(),
         projectId: c.projectId,
         revision: 1,
         round: 1,
@@ -30477,15 +31269,15 @@ var Orchestration = class {
 
 // src/herdr.ts
 import net from "node:net";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 var Herdr = class {
   constructor(socketPath) {
     this.socketPath = socketPath;
   }
   socketPath;
   call(method, params = {}, timeoutMs = 1e4) {
-    return new Promise((resolve12, reject) => {
-      const id = randomUUID4();
+    return new Promise((resolve13, reject) => {
+      const id = randomUUID5();
       let buffer = "";
       let settled2 = false;
       const socket = net.createConnection(this.socketPath);
@@ -30494,7 +31286,7 @@ var Herdr = class {
         settled2 = true;
         clearTimeout(timer);
         socket.destroy();
-        error ? reject(error) : resolve12(result);
+        error ? reject(error) : resolve13(result);
       };
       const timer = setTimeout(
         () => finish(
@@ -30551,6 +31343,7 @@ var Service = class {
   port;
   orchestration = new Orchestration(this);
   continuation = new Continuation(this);
+  cleanup = new Cleanup(this);
   project(id) {
     const p = this.store.get("project", id);
     if (!p) throw new AppError("not_found", "Project not found", 404);
@@ -30591,6 +31384,7 @@ var Service = class {
     );
     return {
       project,
+      cleanupPolicy: this.cleanup.policy(projectId),
       lead: this.publicLead(projectId),
       ...this.orchestration.board(projectId),
       tasks,
@@ -30613,7 +31407,7 @@ var Service = class {
     const existing = this.store.all("question").find((q2) => q2.taskId === task.id && !q2.answeredAt && q2.text === text2);
     if (existing) return existing;
     const q = {
-      id: randomUUID5(),
+      id: randomUUID6(),
       projectId: task.projectId,
       taskId: task.id,
       text: text2,
@@ -30641,6 +31435,7 @@ var Service = class {
     return result;
   }
   async invoke(action, raw = {}) {
+    if (action.startsWith("cleanup.")) return this.cleanup.invoke(action, raw);
     if (/^(lead\.wait|checkpoint\.|usage\.|adapter\.)/.test(action))
       return this.continuation.invoke(action, raw);
     if (/^(outcome\.|plan\.|profile\.|limits\.|strategy\.|board\.)/.test(action))
@@ -30661,8 +31456,8 @@ var Service = class {
         }).parse(raw);
         if (!isAbsolute2(input.root) || !isAbsolute2(input.socketPath))
           throw new AppError("absolute_paths", "root and socketPath must be absolute");
-        const root = realpathSync2(input.root);
-        if (!statSync2(root).isDirectory())
+        const root = realpathSync4(input.root);
+        if (!statSync4(root).isDirectory())
           throw new AppError("root", "Project root is not a directory");
         const existing = this.store.all("project").find((p2) => p2.socketPath === input.socketPath && p2.workspaceId === input.workspaceId);
         if (existing) {
@@ -30673,11 +31468,13 @@ var Service = class {
             409
           );
         }
-        const p = { ...input, root, id: randomUUID5(), createdAt: now() };
+        const p = { ...input, root, id: randomUUID6(), createdAt: now() };
         const h = this.port(p);
         await h.call("ping");
         await h.call("workspace.get", { workspace_id: p.workspaceId });
         return this.store.transaction(() => {
+          for (const task of this.store.all("task"))
+            if (task.worktree && inside(task.worktree.path, root)) this.cleanup.assertMutable(task);
           const concurrent = this.store.all("project").find((v) => v.socketPath === p.socketPath && v.workspaceId === p.workspaceId);
           if (concurrent) {
             if (concurrent.root === root) return concurrent;
@@ -30820,6 +31617,7 @@ var Service = class {
         const c = this.guard(raw.lease), t = this.task(external_exports.string().parse(raw.taskId)), key = external_exports.string().min(1).parse(raw.key);
         if (c.projectId !== t.projectId)
           throw new AppError("project_mismatch", "Task and lease differ");
+        this.cleanup.assertMutable(t);
         const cached = this.store.get("idempotency", t.projectId + ":retry:" + key);
         if (cached)
           return this.store.transaction(
@@ -30855,6 +31653,7 @@ var Service = class {
         }
         this.guard(raw.lease);
         const current = this.task(t.id);
+        this.cleanup.assertMutable(current);
         if (current.runId !== t.runId || !["failed", "cancelled"].includes(current.status))
           throw new AppError(
             "retry_state",
@@ -30968,7 +31767,7 @@ var Service = class {
       case "decision.record": {
         const c = this.guard(raw.lease), text2 = external_exports.string().min(1).parse(raw.text), rationale = external_exports.string().default("").parse(raw.rationale);
         const d = {
-          id: randomUUID5(),
+          id: randomUUID6(),
           projectId: c.projectId,
           text: text2,
           rationale,
@@ -31022,12 +31821,15 @@ var Service = class {
       checks: external_exports.array(checkSchema).min(1).optional()
     }).parse(raw);
     return this.store.transaction(() => {
-      const t = this.task(i.taskId);
+      let t = this.task(i.taskId);
+      this.cleanup.assertMutable(t);
       if (t.projectId !== c.projectId)
         throw new AppError("project_mismatch", "Task and lease differ");
       return this.idempotent(c.projectId, "control:" + i.key, i, () => {
         if (terminalStates.has(t.status))
           throw new AppError("task_finished", "Task is already finished", 409);
+        if (t.runId && this.store.get("run", t.runId)?.cleanup?.state === "closed")
+          t = this.updateTask(t, { runId: void 0 });
         if (["redirect", "reply"].includes(i.type) && !i.text?.trim())
           throw new AppError("text_required", "Provide the new instructions or answer");
         if (i.type === "keys" && !i.keys)
@@ -31048,7 +31850,7 @@ var Service = class {
           for (const check of i.checks) if (check.type === "file") safePath(t.cwd, check.path);
         }
         const op = {
-          id: randomUUID5(),
+          id: randomUUID6(),
           projectId: t.projectId,
           taskId: t.id,
           type: i.type,
@@ -31105,8 +31907,11 @@ var Service = class {
     const a = assignmentSchema.parse(rawAssignment);
     if (c.projectId !== a.projectId)
       throw new AppError("project_mismatch", "Lease does not match assignment");
-    const p = this.project(a.projectId), cwd = realpathSync2(a.cwd ?? p.root);
+    const p = this.project(a.projectId), cwd = realpathSync4(a.cwd ?? p.root);
     const parent = a.parentId ? this.task(a.parentId) : void 0;
+    if (parent) this.cleanup.assertMutable(parent);
+    for (const task of this.store.all("task"))
+      if (task.worktree && inside(task.worktree.path, cwd)) this.cleanup.assertMutable(task);
     const inheritedWorktree = parent?.projectId === p.id && parent.worktree?.state === "ready" && parent.cwd === cwd;
     if (!inside(p.root, cwd) && !inheritedWorktree)
       throw new AppError(
@@ -31137,6 +31942,12 @@ var Service = class {
       }
     for (const id of a.dependencies) {
       const d = this.task(id);
+      if (this.cleanup.active(d.id))
+        throw new AppError(
+          "cleanup_busy",
+          "Dependency is being cleaned up; retry after it finishes",
+          409
+        );
       if (d.projectId !== a.projectId)
         throw new AppError("dependency_scope", "Dependencies must belong to the same project");
     }
@@ -31146,7 +31957,7 @@ var Service = class {
         const task = {
           ...fields,
           cwd,
-          id: randomUUID5(),
+          id: randomUUID6(),
           status: a.deferStart ? "paused" : "queued",
           revision: 1,
           attempt: 0,
@@ -31168,6 +31979,7 @@ var Service = class {
   }
   workerGuard(taskId, token, revision) {
     const t = this.task(taskId), r = t.runId ? this.store.get("run", t.runId) : void 0;
+    this.cleanup.assertMutable(t);
     if (!r || hash(token) !== r.tokenHash)
       throw new AppError("worker_auth", "Invalid or obsolete worker token", 401);
     if (terminalStates.has(t.status) || revision !== t.revision || r.phase === "stopped")
@@ -31185,6 +31997,7 @@ var Service = class {
     }).parse(raw);
     return this.store.transaction(() => {
       const t = this.task(taskId), r = t.runId ? this.store.get("run", t.runId) : void 0;
+      this.cleanup.assertMutable(t);
       if (!r || hash(token) !== r.tokenHash)
         throw new AppError("worker_auth", "Invalid or obsolete worker token", 401);
       if (terminalStates.has(t.status) || i.revision !== t.revision)
@@ -31272,39 +32085,39 @@ var strategyInstructions = {
 
 // src/agy-trust.ts
 import {
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync4,
-  openSync,
-  closeSync,
-  readFileSync as readFileSync4,
-  writeFileSync as writeFileSync3,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync6,
+  openSync as openSync2,
+  closeSync as closeSync2,
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync4,
   renameSync,
   unlinkSync,
-  statSync as statSync3,
-  realpathSync as realpathSync3
+  statSync as statSync5,
+  realpathSync as realpathSync5
 } from "node:fs";
-import { dirname as dirname4, resolve as resolve5 } from "node:path";
+import { dirname as dirname6, resolve as resolve7 } from "node:path";
 import { homedir as homedir2 } from "node:os";
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 function agySettingsPath() {
-  return resolve5(
-    process.env.MARIONETTE_AGY_SETTINGS ?? resolve5(homedir2(), ".gemini/antigravity-cli/settings.json")
+  return resolve7(
+    process.env.MARIONETTE_AGY_SETTINGS ?? resolve7(homedir2(), ".gemini/antigravity-cli/settings.json")
   );
 }
 function trustAgyWorkspace(root, settingsPath = agySettingsPath()) {
-  root = realpathSync3(root);
-  if (!statSync3(root).isDirectory()) throw new Error("AGY trust requires a directory");
-  mkdirSync4(dirname4(settingsPath), { recursive: true, mode: 448 });
+  root = realpathSync5(root);
+  if (!statSync5(root).isDirectory()) throw new Error("AGY trust requires a directory");
+  mkdirSync6(dirname6(settingsPath), { recursive: true, mode: 448 });
   const lock = settingsPath + ".marionette.lock";
   let fd;
   try {
-    fd = openSync(lock, "wx", 384);
+    fd = openSync2(lock, "wx", 384);
   } catch {
     throw new Error(`AGY settings are being edited. Retry after checking ${lock}`);
   }
-  const temp = settingsPath + "." + randomUUID6() + ".tmp";
+  const temp = settingsPath + "." + randomUUID7() + ".tmp";
   try {
-    const before = existsSync2(settingsPath) ? readFileSync4(settingsPath, "utf8") : null;
+    const before = existsSync4(settingsPath) ? readFileSync5(settingsPath, "utf8") : null;
     const settings = before === null ? {} : JSON.parse(before);
     if (!settings || typeof settings !== "object" || Array.isArray(settings))
       throw new Error("AGY settings must be a JSON object");
@@ -31313,118 +32126,23 @@ function trustAgyWorkspace(root, settingsPath = agySettingsPath()) {
       throw new Error("AGY trustedWorkspaces must be a string array");
     if (trusted.includes(root)) return { changed: false, root, settingsPath };
     settings.trustedWorkspaces = [...trusted, root];
-    const mode = before === null ? 384 : statSync3(settingsPath).mode & 511;
-    writeFileSync3(temp, JSON.stringify(settings, null, 2) + "\n", { flag: "wx", mode });
-    const current = existsSync2(settingsPath) ? readFileSync4(settingsPath, "utf8") : null;
+    const mode = before === null ? 384 : statSync5(settingsPath).mode & 511;
+    writeFileSync4(temp, JSON.stringify(settings, null, 2) + "\n", { flag: "wx", mode });
+    const current = existsSync4(settingsPath) ? readFileSync5(settingsPath, "utf8") : null;
     if (current !== before) throw new Error("AGY settings changed during registration; retry");
     renameSync(temp, settingsPath);
     return { changed: true, root, settingsPath };
   } finally {
-    if (existsSync2(temp)) unlinkSync(temp);
-    closeSync(fd);
+    if (existsSync4(temp)) unlinkSync(temp);
+    closeSync2(fd);
     unlinkSync(lock);
   }
 }
 
 // src/supervisor.ts
-import { randomBytes as randomBytes3, randomUUID as randomUUID7 } from "node:crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync5, realpathSync as realpathSync5 } from "node:fs";
-import { dirname as dirname6, resolve as resolve7 } from "node:path";
-
-// src/worktrees.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { existsSync as existsSync3, mkdirSync as mkdirSync5, realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
-import { dirname as dirname5, relative as relative3, resolve as resolve6 } from "node:path";
-var exec = promisify(execFile);
-async function git(cwd, args2) {
-  const env = { ...process.env };
-  for (const key of Object.keys(env)) if (key.startsWith("GIT_")) delete env[key];
-  env.GIT_TERMINAL_PROMPT = "0";
-  try {
-    const result = await exec("git", ["-c", "core.hooksPath=/dev/null", "-C", cwd, ...args2], {
-      env,
-      timeout: 12e4,
-      maxBuffer: 4 * 1024 * 1024
-    });
-    return result.stdout.trimEnd();
-  } catch (error) {
-    const e = error;
-    throw new AppError(
-      "worktree_git",
-      `Git worktree operation failed: ${e.stderr?.trim() || e.message}`
-    );
-  }
-}
-async function planWorktree(task, stateRoot) {
-  const repositoryRoot = realpathSync4(await git(task.cwd, ["rev-parse", "--show-toplevel"]));
-  const commonDir = realpathSync4(
-    await git(task.cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"])
-  );
-  const baseRef = task.execution?.mode === "worktree" ? task.execution.baseRef ?? "HEAD" : "HEAD";
-  const baseCommit = await git(task.cwd, [
-    "rev-parse",
-    "--verify",
-    "--end-of-options",
-    `${baseRef}^{commit}`
-  ]);
-  if (!inside(repositoryRoot, task.cwd))
-    throw new AppError("worktree_scope", "Task directory is outside its Git repository");
-  const path = safePath(stateRoot, `worktrees/${task.projectId}/${task.id}`);
-  return {
-    state: "planned",
-    repositoryRoot,
-    commonDir,
-    sourceCwd: task.cwd,
-    path,
-    cwd: resolve6(path, relative3(repositoryRoot, task.cwd)),
-    branch: `marionette/${task.id}`,
-    baseCommit
-  };
-}
-async function validateWorktree(w, requireClean = false) {
-  const listing = await git(w.repositoryRoot, ["worktree", "list", "--porcelain", "-z"]);
-  const records = listing.split("\0\0").map((record2) => record2.split("\0"));
-  const record = records.find((fields) => fields.includes(`worktree ${w.path}`));
-  if (!record || !record.includes(`branch refs/heads/${w.branch}`) || record.some((field) => /^(locked|prunable)( |$)/.test(field)) || !existsSync3(w.path) || realpathSync4(w.path) !== w.path)
-    throw new AppError(
-      "worktree_identity",
-      "Managed worktree is missing, incomplete, or has changed identity. Inspect it before retrying; existing work is preserved."
-    );
-  const commonDir = realpathSync4(
-    await git(w.path, ["rev-parse", "--path-format=absolute", "--git-common-dir"])
-  );
-  const root = realpathSync4(await git(w.path, ["rev-parse", "--show-toplevel"]));
-  const branch = await git(w.path, ["symbolic-ref", "HEAD"]);
-  if (commonDir !== w.commonDir || root !== w.path || branch !== `refs/heads/${w.branch}`)
-    throw new AppError(
-      "worktree_identity",
-      "Managed worktree repository or branch changed; refusing to reuse it."
-    );
-  if (requireClean) {
-    const head = await git(w.path, ["rev-parse", "HEAD"]);
-    const status = await git(w.path, ["status", "--porcelain", "--untracked-files=all"]);
-    if (head !== w.baseCommit || status)
-      throw new AppError(
-        "worktree_incomplete",
-        "Worktree creation was interrupted and its checkout is not clean at the pinned base. Inspect it before retrying; no files were reset."
-      );
-  }
-  const cwd = safePath(w.path, relative3(w.path, w.cwd), true);
-  if (!statSync4(cwd).isDirectory())
-    throw new AppError(
-      "worktree_cwd",
-      "Task working directory does not exist in the selected Git revision"
-    );
-  return cwd;
-}
-async function createWorktree(w) {
-  mkdirSync5(dirname5(w.path), { recursive: true, mode: 448 });
-  await git(w.repositoryRoot, ["worktree", "add", "-b", w.branch, "--", w.path, w.baseCommit]);
-  return validateWorktree(w, true);
-}
-
-// src/supervisor.ts
+import { randomBytes as randomBytes3, randomUUID as randomUUID8 } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync6, realpathSync as realpathSync6 } from "node:fs";
+import { dirname as dirname7, resolve as resolve8 } from "node:path";
 var settled = (status) => status === "idle" || status === "done";
 var quote = (s) => "'" + s.replaceAll("'", "'\\''") + "'";
 function inputScreen(text2) {
@@ -31450,6 +32168,7 @@ var Supervisor = class {
   start() {
     this.recover();
     this.service.continuation.recover();
+    this.service.cleanup.recover();
     this.timer = setInterval(() => this.tick(), this.pollMs);
     this.tick();
   }
@@ -31457,6 +32176,7 @@ var Supervisor = class {
     this.stopped = true;
     if (this.timer) clearInterval(this.timer);
     await this.service.continuation.stop();
+    await this.service.cleanup.stop();
     while (this.busy.size) await new Promise((r) => setTimeout(r, 50));
   }
   recover() {
@@ -31532,9 +32252,10 @@ var Supervisor = class {
     if (this.stopped) return;
     this.service.orchestration.refreshEvidence();
     this.service.continuation.tick();
+    this.service.cleanup.tick();
     const s = this.service, all = s.store.all("task");
     for (const t of all)
-      if (t.runId && t.status !== "queued" && !this.busy.has(t.id) && (!terminalStates.has(t.status) || this.run(t).phase !== "stopped"))
+      if (t.runId && !this.service.cleanup.active(t.id) && !["closing", "closed", "uncertain"].includes(this.run(t).cleanup?.state ?? "") && t.status !== "queued" && !this.busy.has(t.id) && (!terminalStates.has(t.status) || this.run(t).phase !== "stopped"))
         this.launch(t.id, () => this.monitor(t.id));
     for (const t of s.store.all("task").filter(
       (t2) => t2.status === "waiting" || t2.resumePending && t2.status === "blocked" && t2.blockKind === "missing-report"
@@ -31551,7 +32272,9 @@ var Supervisor = class {
     }
     for (const project of s.store.all("project")) {
       const tasks = s.tasks(project.id);
-      for (const task of tasks.filter((t) => t.status === "queued" && !this.busy.has(t.id))) {
+      for (const task of tasks.filter(
+        (t) => t.status === "queued" && !t.archiveId && !this.service.cleanup.active(t.id) && !this.busy.has(t.id)
+      )) {
         const dependencies = task.dependencies.map((id) => s.task(id));
         let waitReason = dependencies.some((d) => d.status !== "completed") ? "Waiting for dependencies to complete" : void 0;
         if (!waitReason) waitReason = s.orchestration.capacity(task, (t) => !!this.holds(t));
@@ -31575,10 +32298,10 @@ var Supervisor = class {
     return !terminalStates.has(t.status) || t.runId && this.run(t)?.phase !== "stopped";
   }
   overlap(a, b) {
-    const root = (t) => t.worktree?.cwd ?? (t.execution?.mode === "worktree" ? resolve7(dirname6(this.service.store.path), "worktrees", t.projectId, t.id) : t.cwd);
+    const root = (t) => t.worktree?.cwd ?? (t.execution?.mode === "worktree" ? resolve8(dirname7(this.service.store.path), "worktrees", t.projectId, t.id) : t.cwd);
     const path = (t, owned) => {
       const cwd = root(t);
-      return t.execution?.mode === "worktree" && !existsSync4(cwd) ? resolve7(cwd, owned) : safePath(cwd, owned);
+      return t.execution?.mode === "worktree" && !existsSync5(cwd) ? resolve8(cwd, owned) : safePath(cwd, owned);
     };
     return a.ownership.some(
       (x) => b.ownership.some((y) => {
@@ -31684,7 +32407,7 @@ Report format: {"revision":${t.revision},"type":"complete","summary":"What chang
     try {
       if (t.execution?.mode === "worktree") {
         if (!t.worktree) {
-          const plan = await planWorktree(t, realpathSync5(dirname6(s.store.path)));
+          const plan = await planWorktree(t, realpathSync6(dirname7(s.store.path)));
           if (s.task(id).status !== "preparing") return;
           t = s.updateTask(t, { worktree: plan }, "Planned isolated Git worktree");
         }
@@ -31748,7 +32471,7 @@ ${JSON.stringify(children.map((child) => ({ id: child.id, title: child.title, st
     }
     const token = randomBytes3(32).toString("hex");
     const run = {
-      id: randomUUID7(),
+      id: randomUUID8(),
       taskId: id,
       attempt: t.attempt + 1,
       revision: t.revision,
@@ -31808,7 +32531,7 @@ ${JSON.stringify(children.map((child) => ({ id: child.id, title: child.title, st
           break;
         } catch (error) {
           if (/not an available shell/.test(String(error)) && attempt < 10) {
-            await new Promise((resolve12) => setTimeout(resolve12, 500));
+            await new Promise((resolve13) => setTimeout(resolve13, 500));
             continue;
           }
           if (["agent_not_ready", "agent_not_found"].includes(error.code)) break;
@@ -31822,7 +32545,7 @@ ${JSON.stringify(children.map((child) => ({ id: child.id, title: child.title, st
         } catch (error) {
           if (!["agent_not_ready", "agent_not_found"].includes(error.code))
             throw error;
-          await new Promise((resolve12) => setTimeout(resolve12, 500));
+          await new Promise((resolve13) => setTimeout(resolve13, 500));
           continue;
         }
         const read = await h.call("pane.read", {
@@ -31838,7 +32561,7 @@ ${JSON.stringify(children.map((child) => ({ id: child.id, title: child.title, st
         if (a.agent === run.kind && settled(a.agent_status) && !a.launch_pending && a.interactive_ready !== false)
           break;
         a = void 0;
-        await new Promise((resolve12) => setTimeout(resolve12, 500));
+        await new Promise((resolve13) => setTimeout(resolve13, 500));
       }
       if (!a) throw new AppError("startup_timeout", "Agent did not become ready within 30 seconds");
       run.nativeSession = a.agent_session?.value;
@@ -32171,7 +32894,7 @@ Ownership remains ${t.ownership.join(", ")}. Current acceptance checks: ${JSON.s
           if (!fileDigest) throw new Error("Artifact is not a regular file");
           if (!check.allowUnchanged && fileDigest === r.baseline[check.path])
             throw new Error("Artifact is unchanged from before dispatch");
-          if (check.contains !== void 0 && !readFileSync5(path, "utf8").includes(check.contains))
+          if (check.contains !== void 0 && !readFileSync6(path, "utf8").includes(check.contains))
             throw new Error("Artifact does not contain the expected content");
           if (check.sha256 && check.sha256 !== fileDigest)
             throw new Error("Artifact SHA-256 does not match");
@@ -32211,14 +32934,14 @@ ${result.output}`;
 };
 
 // src/version.ts
-var VERSION = "0.2.0";
+var VERSION = "0.2.1";
 var SETUP_VERSION = 2;
 
 // src/server.ts
 async function serve(home2, port) {
-  const config = initConfig(home2, port), lock = resolve8(home2, "supervisor.lock"), lockId = randomUUID8();
-  if (existsSync5(lock)) {
-    const old = JSON.parse(readFileSync6(lock, "utf8"));
+  const config = initConfig(home2, port), lock = resolve9(home2, "supervisor.lock"), lockId = randomUUID9();
+  if (existsSync6(lock)) {
+    const old = JSON.parse(readFileSync7(lock, "utf8"));
     try {
       process.kill(old.pid, 0);
       throw new AppError(
@@ -32231,13 +32954,13 @@ async function serve(home2, port) {
       unlinkSync2(lock);
     }
   }
-  writeFileSync4(lock, JSON.stringify({ pid: process.pid, id: lockId }), {
+  writeFileSync5(lock, JSON.stringify({ pid: process.pid, id: lockId }), {
     flag: "wx",
     mode: 384
   });
-  const store = new Store(resolve8(home2, "state.sqlite")), service = new Service(store);
-  const projectRoot = resolve8(dirname7(fileURLToPath(import.meta.url)), "..");
-  const cliPath = resolve8(projectRoot, "dist/cli.js");
+  const store = new Store(resolve9(home2, "state.sqlite")), service = new Service(store);
+  const projectRoot = resolve9(dirname8(fileURLToPath(import.meta.url)), "..");
+  const cliPath = resolve9(projectRoot, "dist/cli.js");
   const url = `http://127.0.0.1:${config.port}`;
   const supervisor = new Supervisor(service, url, cliPath);
   const app = (0, import_express.default)();
@@ -32312,7 +33035,7 @@ async function serve(home2, port) {
     res.json({ stopping: true });
     setTimeout(() => void shutdown(), 20);
   });
-  app.use(import_express.default.static(resolve8(projectRoot, "public"), { index: "index.html", maxAge: 0 }));
+  app.use(import_express.default.static(resolve9(projectRoot, "public"), { index: "index.html", maxAge: 0 }));
   app.use(
     (error, req, res, _next) => {
       const status = error instanceof AppError ? error.status : error instanceof ZodError ? 400 : 500;
@@ -32342,7 +33065,7 @@ async function serve(home2, port) {
       server.closeIdleConnections();
     });
     store.close();
-    if (existsSync5(lock) && JSON.parse(readFileSync6(lock, "utf8")).id === lockId) unlinkSync2(lock);
+    if (existsSync6(lock) && JSON.parse(readFileSync7(lock, "utf8")).id === lockId) unlinkSync2(lock);
   }
   process.once("SIGTERM", () => void shutdown());
   process.once("SIGINT", () => void shutdown());
@@ -32354,51 +33077,51 @@ async function serve(home2, port) {
 }
 
 // src/runtime.ts
-import { createHash as createHash2, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID10 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync7,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync8,
   readdirSync,
   renameSync as renameSync2,
   rmSync,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname8, resolve as resolve9, relative as relative4 } from "node:path";
+import { dirname as dirname9, resolve as resolve10, relative as relative4 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var packageRoot = resolve9(dirname8(fileURLToPath2(import.meta.url)), "..");
+var packageRoot = resolve10(dirname9(fileURLToPath2(import.meta.url)), "..");
 function installRuntime(home2, source = packageRoot) {
   const files = ["dist/cli.js", "dist/mcp.js", "package.json"];
-  if (existsSync6(resolve9(source, "THIRD_PARTY_NOTICES.md"))) files.push("THIRD_PARTY_NOTICES.md");
+  if (existsSync7(resolve10(source, "THIRD_PARTY_NOTICES.md"))) files.push("THIRD_PARTY_NOTICES.md");
   function walk(dir) {
-    for (const entry of readdirSync(resolve9(source, dir), { withFileTypes: true })) {
+    for (const entry of readdirSync(resolve10(source, dir), { withFileTypes: true })) {
       const path = dir + "/" + entry.name;
       entry.isDirectory() ? walk(path) : files.push(path);
     }
   }
-  if (!existsSync6(resolve9(source, "dist/cli.js")) || !existsSync6(resolve9(source, "public/index.html")))
+  if (!existsSync7(resolve10(source, "dist/cli.js")) || !existsSync7(resolve10(source, "public/index.html")))
     throw new Error("Build Marionette first with npm run build");
   walk("public");
-  const digest2 = createHash2("sha256");
-  for (const file of files.sort()) digest2.update(file).update(readFileSync7(resolve9(source, file)));
-  const version = JSON.parse(readFileSync7(resolve9(source, "package.json"), "utf8")).version;
-  const target = resolve9(home2, "runtimes", version + "-" + digest2.digest("hex").slice(0, 16));
+  const digest2 = createHash3("sha256");
+  for (const file of files.sort()) digest2.update(file).update(readFileSync8(resolve10(source, file)));
+  const version = JSON.parse(readFileSync8(resolve10(source, "package.json"), "utf8")).version;
+  const target = resolve10(home2, "runtimes", version + "-" + digest2.digest("hex").slice(0, 16));
   if (relative4(source, target) === "") return target;
-  if (existsSync6(resolve9(target, ".complete"))) return target;
-  mkdirSync6(dirname8(target), { recursive: true, mode: 448 });
-  const temp = target + "." + randomUUID9();
-  mkdirSync6(temp, { mode: 448 });
+  if (existsSync7(resolve10(target, ".complete"))) return target;
+  mkdirSync7(dirname9(target), { recursive: true, mode: 448 });
+  const temp = target + "." + randomUUID10();
+  mkdirSync7(temp, { mode: 448 });
   try {
     for (const file of files) {
-      mkdirSync6(dirname8(resolve9(temp, file)), { recursive: true });
-      cpSync(resolve9(source, file), resolve9(temp, file));
+      mkdirSync7(dirname9(resolve10(temp, file)), { recursive: true });
+      cpSync(resolve10(source, file), resolve10(temp, file));
     }
-    writeFileSync5(resolve9(temp, ".complete"), "1\n");
+    writeFileSync6(resolve10(temp, ".complete"), "1\n");
     try {
       renameSync2(temp, target);
     } catch (e) {
-      if (!existsSync6(resolve9(target, ".complete"))) throw e;
+      if (!existsSync7(resolve10(target, ".complete"))) throw e;
     }
   } finally {
     rmSync(temp, { recursive: true, force: true });
@@ -32408,20 +33131,20 @@ function installRuntime(home2, source = packageRoot) {
 
 // src/setup.ts
 import {
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync8,
-  writeFileSync as writeFileSync6,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync9,
+  writeFileSync as writeFileSync7,
   renameSync as renameSync3,
   unlinkSync as unlinkSync3,
-  openSync as openSync2,
-  closeSync as closeSync2,
-  realpathSync as realpathSync6,
-  statSync as statSync5
+  openSync as openSync3,
+  closeSync as closeSync3,
+  realpathSync as realpathSync7,
+  statSync as statSync6
 } from "node:fs";
-import { basename, dirname as dirname9, resolve as resolve10 } from "node:path";
+import { basename, dirname as dirname10, resolve as resolve11 } from "node:path";
 import { homedir as homedir3 } from "node:os";
-import { createHash as createHash3, randomUUID as randomUUID10 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID11 } from "node:crypto";
 import { createInterface } from "node:readline/promises";
 import { execFile as execFile2, spawn as spawn3 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
@@ -32445,22 +33168,22 @@ var setupSchema = external_exports.object({
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 var quote2 = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
 function privateJson(path, data) {
-  mkdirSync7(dirname9(path), { recursive: true, mode: 448 });
-  const temp = path + "." + randomUUID10() + ".tmp";
+  mkdirSync8(dirname10(path), { recursive: true, mode: 448 });
+  const temp = path + "." + randomUUID11() + ".tmp";
   try {
-    writeFileSync6(temp, JSON.stringify(data, null, 2) + "\n", { mode: 384, flag: "wx" });
+    writeFileSync7(temp, JSON.stringify(data, null, 2) + "\n", { mode: 384, flag: "wx" });
     renameSync3(temp, path);
   } finally {
-    if (existsSync7(temp)) unlinkSync3(temp);
+    if (existsSync8(temp)) unlinkSync3(temp);
   }
 }
 function setupPlan(input) {
   const supplied = setupSchema.partial().parse(input);
-  const root = realpathSync6(resolve10(supplied.project ?? process.cwd()));
-  if (!statSync5(root).isDirectory()) throw new Error("Project must be an existing directory");
-  const hash2 = createHash3("sha256").update(root).digest("hex").slice(0, 10);
-  const bindingPath = resolve10(root, ".marionette/project.json");
-  const binding = existsSync7(bindingPath) ? JSON.parse(readFileSync8(bindingPath, "utf8")) : null;
+  const root = realpathSync7(resolve11(supplied.project ?? process.cwd()));
+  if (!statSync6(root).isDirectory()) throw new Error("Project must be an existing directory");
+  const hash2 = createHash4("sha256").update(root).digest("hex").slice(0, 10);
+  const bindingPath = resolve11(root, ".marionette/project.json");
+  const binding = existsSync8(bindingPath) ? JSON.parse(readFileSync9(bindingPath, "utf8")) : null;
   const options = setupSchema.parse({
     lead: binding?.lead,
     leadName: binding?.leadName,
@@ -32469,13 +33192,13 @@ function setupPlan(input) {
     mcp: binding?.mcp,
     ...supplied
   });
-  const legacy = resolve10(root, ".marionette");
-  const home2 = resolve10(
-    options.home ?? process.env.MARIONETTE_HOME ?? binding?.home ?? (existsSync7(resolve10(legacy, "config.json")) ? legacy : resolve10(process.env.XDG_DATA_HOME ?? resolve10(homedir3(), ".local/share"), "marionette"))
+  const legacy = resolve11(root, ".marionette");
+  const home2 = resolve11(
+    options.home ?? process.env.MARIONETTE_HOME ?? binding?.home ?? (existsSync8(resolve11(legacy, "config.json")) ? legacy : resolve11(process.env.XDG_DATA_HOME ?? resolve11(homedir3(), ".local/share"), "marionette"))
   );
   const session = options.session ?? binding?.session ?? `marionette-${hash2}`;
-  const socket = resolve10(
-    options.socket ?? binding?.socket ?? resolve10(homedir3(), ".config/herdr/sessions", session, "herdr.sock")
+  const socket = resolve11(
+    options.socket ?? binding?.socket ?? resolve11(homedir3(), ".config/herdr/sessions", session, "herdr.sock")
   );
   return {
     ...options,
@@ -32546,11 +33269,11 @@ async function ensureHerdr(plan) {
     return h;
   } catch {
   }
-  if (plan.socket !== resolve10(homedir3(), ".config/herdr/sessions", plan.session, "herdr.sock"))
+  if (plan.socket !== resolve11(homedir3(), ".config/herdr/sessions", plan.session, "herdr.sock"))
     throw new Error(
       `Cannot connect to supplied socket ${plan.socket}; start its Herdr session first`
     );
-  const log = openSync2(resolve10(plan.home, "herdr.log"), "a", 384);
+  const log = openSync3(resolve11(plan.home, "herdr.log"), "a", 384);
   const child = spawn3("herdr", ["--session", plan.session, "server"], {
     detached: true,
     stdio: ["ignore", log, log]
@@ -32559,7 +33282,7 @@ async function ensureHerdr(plan) {
   child.on("error", (e) => {
     error = e;
   });
-  closeSync2(log);
+  closeSync3(log);
   child.unref();
   for (let n = 0; n < 100; n++) {
     if (error) throw error;
@@ -32570,14 +33293,14 @@ async function ensureHerdr(plan) {
     }
     await sleep(100);
   }
-  throw new Error(`Herdr session did not start; inspect ${resolve10(plan.home, "herdr.log")}`);
+  throw new Error(`Herdr session did not start; inspect ${resolve11(plan.home, "herdr.log")}`);
 }
 function mcpCommand(agent, name, runtime, home2) {
   const binary = agent === "codex-desktop" ? "codex" : agent;
   const serverArgs = [
     process.execPath,
     "--no-warnings",
-    resolve10(runtime, "dist/mcp.js"),
+    resolve11(runtime, "dist/mcp.js"),
     "--home",
     home2
   ];
@@ -32590,7 +33313,7 @@ function mcpCommand(agent, name, runtime, home2) {
   };
 }
 async function installMcp(command2, name, home2) {
-  const receipt = resolve10(home2, "clients", command2.binary + ".json");
+  const receipt = resolve11(home2, "clients", command2.binary + ".json");
   let found;
   try {
     const output = (await exec2(
@@ -32605,14 +33328,14 @@ async function installMcp(command2, name, home2) {
   }
   if (found) {
     if (found.includes(command2.server.args[1]) && found.includes(home2)) return "already-configured";
-    const old = existsSync7(receipt) ? JSON.parse(readFileSync8(receipt, "utf8")) : null;
+    const old = existsSync8(receipt) ? JSON.parse(readFileSync9(receipt, "utf8")) : null;
     if (!old || old.name !== name || !found.includes(old.runtime) || !found.includes(home2))
       throw new Error(
         `MCP server ${name} already has another configuration. Use --mcp print to review it.`
       );
   }
   await exec2(command2.binary, command2.args, { timeout: 3e4 });
-  privateJson(receipt, { name, runtime: dirname9(dirname9(command2.server.args[1])) });
+  privateJson(receipt, { name, runtime: dirname10(dirname10(command2.server.args[1])) });
   return "installed";
 }
 function leadPrompt(projectId, leadName, leasePath) {
@@ -32631,18 +33354,18 @@ async function runSetup(input) {
     }).catch(() => {
       throw new Error(`Install the selected lead CLI first, or use --mcp print.`);
     });
-  mkdirSync7(p.home, { recursive: true, mode: 448 });
-  const lockPath = resolve10(p.home, "setup.lock");
+  mkdirSync8(p.home, { recursive: true, mode: 448 });
+  const lockPath = resolve11(p.home, "setup.lock");
   let lock;
   try {
-    lock = openSync2(lockPath, "wx", 384);
-    writeFileSync6(lock, JSON.stringify({ pid: process.pid }));
+    lock = openSync3(lockPath, "wx", 384);
+    writeFileSync7(lock, JSON.stringify({ pid: process.pid }));
   } catch {
     throw new Error(`Another setup may be running. Check ${lockPath} before retrying.`);
   }
   try {
     const runtime = installRuntime(p.home);
-    if (!existsSync7(resolve10(p.home, "config.json")))
+    if (!existsSync8(resolve11(p.home, "config.json")))
       initConfig(p.home, await availablePort(p.port));
     const config = loadConfig(p.home);
     if (p.port && config.port !== p.port)
@@ -32651,7 +33374,7 @@ async function runSetup(input) {
       );
     await exec2(
       process.execPath,
-      ["--no-warnings", resolve10(runtime, "dist/cli.js"), "start", "--home", p.home],
+      ["--no-warnings", resolve11(runtime, "dist/cli.js"), "start", "--home", p.home],
       { timeout: 15e3 }
     );
     const health = await (await fetch(`http://127.0.0.1:${config.port}/health`, { signal: AbortSignal.timeout(3e3) })).json();
@@ -32672,9 +33395,9 @@ async function runSetup(input) {
     }
     await h.call("workspace.get", { workspace_id: workspaceId });
     privateJson(
-      resolve10(
+      resolve11(
         p.home,
-        "setup-project-" + createHash3("sha256").update(p.root).digest("hex").slice(0, 10) + ".json"
+        "setup-project-" + createHash4("sha256").update(p.root).digest("hex").slice(0, 10) + ".json"
       ),
       { root: p.root, session: p.session, socket: p.socket, workspace: workspaceId }
     );
@@ -32686,8 +33409,8 @@ async function runSetup(input) {
       workspaceId,
       trustAgyWorkspaces: p.trustAgy
     });
-    const leasePath = resolve10(p.home, "leads", project.id + ".json");
-    let lease = existsSync7(leasePath) ? credentialsSchema.parse(JSON.parse(readFileSync8(leasePath, "utf8"))) : null;
+    const leasePath = resolve11(p.home, "leads", project.id + ".json");
+    let lease = existsSync8(leasePath) ? credentialsSchema.parse(JSON.parse(readFileSync9(leasePath, "utf8"))) : null;
     const briefing = await call(p.home, "project.briefing", { projectId: project.id });
     const same = briefing.lead?.owner === p.leadName && briefing.lead?.agent === p.lead;
     if (briefing.lead && !(same && lease && lease.epoch === briefing.lead.epoch && lease.owner === briefing.lead.owner) && !p.takeover)
@@ -32724,15 +33447,15 @@ async function runSetup(input) {
       mcp: p.mcp
     };
     privateJson(p.bindingPath, binding);
-    const ignore = resolve10(dirname9(p.bindingPath), ".gitignore");
-    if (!existsSync7(ignore)) writeFileSync6(ignore, "*\n", { flag: "wx" });
+    const ignore = resolve11(dirname10(p.bindingPath), ".gitignore");
+    if (!existsSync8(ignore)) writeFileSync7(ignore, "*\n", { flag: "wx" });
     const trust = p.trustAgy ? trustAgyWorkspace(p.root) : { changed: false, disabled: true };
     const mcpName = "marionette-" + config.id.slice(0, 8);
     const command2 = mcpCommand(p.lead, mcpName, runtime, p.home);
     const mcpStatus = p.mcp === "install" ? await installMcp(command2, mcpName, p.home) : p.mcp;
     const prompt = leadPrompt(project.id, p.leadName, leasePath);
-    const promptPath = resolve10(p.home, "leads", project.id + ".md");
-    writeFileSync6(promptPath, prompt + "\n", { mode: 384 });
+    const promptPath = resolve11(p.home, "leads", project.id + ".md");
+    writeFileSync7(promptPath, prompt + "\n", { mode: 384 });
     return {
       ok: true,
       home: p.home,
@@ -32749,19 +33472,19 @@ async function runSetup(input) {
       prompt
     };
   } finally {
-    closeSync2(lock);
+    closeSync3(lock);
     unlinkSync3(lockPath);
   }
 }
 async function launchLead(project, printOnly, profileId) {
-  while (!existsSync7(resolve10(project, ".marionette/project.json"))) {
-    if (dirname9(project) === project)
+  while (!existsSync8(resolve11(project, ".marionette/project.json"))) {
+    if (dirname10(project) === project)
       throw new Error("No configured Marionette project found. Run marionette setup first.");
-    project = dirname9(project);
+    project = dirname10(project);
   }
-  const binding = JSON.parse(readFileSync8(resolve10(project, ".marionette/project.json"), "utf8"));
+  const binding = JSON.parse(readFileSync9(resolve11(project, ".marionette/project.json"), "utf8"));
   const brief = await call(binding.home, "project.briefing", { projectId: binding.projectId });
-  const lease = credentialsSchema.parse(JSON.parse(readFileSync8(binding.leasePath, "utf8")));
+  const lease = credentialsSchema.parse(JSON.parse(readFileSync9(binding.leasePath, "utf8")));
   if (!brief.lead || brief.lead.owner !== lease.owner || brief.lead.epoch !== lease.epoch)
     throw new Error(
       "The saved lead no longer controls this project. Refresh setup with an explicit handover or takeover."
@@ -32810,7 +33533,7 @@ var print = (v) => console.log(JSON.stringify(v, null, 2));
 async function main() {
   const cmd = args[0] ?? "help";
   if (cmd === "--version" || cmd === "version") {
-    console.log(JSON.parse(readFileSync9(resolve11(packageRoot, "package.json"), "utf8")).version);
+    console.log(JSON.parse(readFileSync10(resolve12(packageRoot, "package.json"), "utf8")).version);
     return;
   }
   if (cmd === "setup" || cmd === "init") {
@@ -32868,7 +33591,7 @@ async function main() {
         n++;
       }
     }
-    let input = flag("config") ? JSON.parse(readFileSync9(flag("config"), "utf8")) : {};
+    let input = flag("config") ? JSON.parse(readFileSync10(flag("config"), "utf8")) : {};
     for (const key of ["project", "home", "name", "session", "socket", "workspace", "lead", "mcp"])
       if (flag(key)) input[key] = flag(key);
     if (flag("lead-name")) input.leadName = flag("lead-name");
@@ -32907,7 +33630,7 @@ ${result.mcp.status === "print" ? "\nMCP install command:\n" + result.mcp.shell
   }
   if (cmd === "lead") {
     await launchLead(
-      resolve11(flag("project") ?? process.cwd()),
+      resolve12(flag("project") ?? process.cwd()),
       args.includes("--print"),
       flag("profile")
     );
@@ -32921,7 +33644,7 @@ ${result.mcp.status === "print" ? "\nMCP install command:\n" + result.mcp.shell
     } = process.env;
     if (!url || !taskId || !token)
       throw new Error("worker-report must run in a Marionette-created worker pane");
-    const input = JSON.parse(readFileSync9(flag("file") ?? 0, "utf8"));
+    const input = JSON.parse(readFileSync10(flag("file") ?? 0, "utf8"));
     const res = await fetch(
       `${url}/api/worker/${encodeURIComponent(taskId)}${cmd === "worker-call" ? "/call" : ""}`,
       {
@@ -32955,16 +33678,16 @@ ${result.mcp.status === "print" ? "\nMCP install command:\n" + result.mcp.shell
     } catch (e) {
       if (!String(e).includes("fetch failed") && !String(e).includes("TimeoutError")) throw e;
     }
-    const cli = resolve11(installRuntime(home), "dist/cli.js");
-    if (!existsSync8(cli))
+    const cli = resolve12(installRuntime(home), "dist/cli.js");
+    if (!existsSync9(cli))
       throw new Error("Run npm run build before starting the background supervisor");
-    const log = openSync3(resolve11(home, "supervisor.log"), "a", 384);
+    const log = openSync4(resolve12(home, "supervisor.log"), "a", 384);
     const child = spawn4(process.execPath, ["--no-warnings", cli, "serve", "--home", home], {
       detached: true,
       stdio: ["ignore", log, log],
       env: process.env
     });
-    closeSync3(log);
+    closeSync4(log);
     child.unref();
     for (let i = 0; i < 50; i++) {
       await new Promise((r) => setTimeout(r, 100));
@@ -32977,7 +33700,7 @@ ${result.mcp.status === "print" ? "\nMCP install command:\n" + result.mcp.shell
       } catch {
       }
     }
-    throw new Error(`Supervisor did not start. Read ${resolve11(home, "supervisor.log")}`);
+    throw new Error(`Supervisor did not start. Read ${resolve12(home, "supervisor.log")}`);
   }
   if (cmd === "stop") {
     const c = loadConfig(home), url = `http://127.0.0.1:${c.port}`;
@@ -33011,7 +33734,7 @@ ${result.mcp.status === "print" ? "\nMCP install command:\n" + result.mcp.shell
     return;
   }
   if (cmd === "mcp-config") {
-    const server = resolve11(installRuntime(home), "dist/mcp.js");
+    const server = resolve12(installRuntime(home), "dist/mcp.js");
     console.log(
       `[mcp_servers.marionette]
 command = ${JSON.stringify(process.execPath)}
@@ -33023,11 +33746,11 @@ args = ["--no-warnings", ${JSON.stringify(server)}, "--home", ${JSON.stringify(h
   if (cmd === "call") {
     const action = args[1];
     if (!action) throw new Error("Provide an action; see help");
-    const input = flag("file") ? JSON.parse(readFileSync9(flag("file"), "utf8")) : flag("json") ? JSON.parse(flag("json")) : {};
-    if (flag("lease")) input.lease = JSON.parse(readFileSync9(flag("lease"), "utf8"));
+    const input = flag("file") ? JSON.parse(readFileSync10(flag("file"), "utf8")) : flag("json") ? JSON.parse(flag("json")) : {};
+    if (flag("lease")) input.lease = JSON.parse(readFileSync10(flag("lease"), "utf8"));
     const result = await call(home, action, input);
     if (flag("save-lease") && result.lease) {
-      writeFileSync7(flag("save-lease"), JSON.stringify(result.lease, null, 2) + "\n", {
+      writeFileSync8(flag("save-lease"), JSON.stringify(result.lease, null, 2) + "\n", {
         mode: 384
       });
       const { lease, ...rest } = result;