@theaileverage/marionette 0.2.0 → 0.2.2

package/dist/cli.js

@@ -886,15 +886,15 @@ var require_depd = __commonJS({
       return relative5(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
     }
     function getStack() {
-      var limit = Error.stackTraceLimit;
+      var limit2 = Error.stackTraceLimit;
       var obj = {};
       var prep = Error.prepareStackTrace;
       Error.prepareStackTrace = prepareObjectStackTrace;
-      Error.stackTraceLimit = Math.max(10, limit);
+      Error.stackTraceLimit = Math.max(10, limit2);
       Error.captureStackTrace(obj);
       var stack = obj.stack.slice(1);
       Error.prepareStackTrace = prep;
-      Error.stackTraceLimit = limit;
+      Error.stackTraceLimit = limit2;
       return stack;
     }
     function prepareObjectStackTrace(obj, stack) {
@@ -5341,15 +5341,15 @@ var require_raw_body = __commonJS({
         throw new TypeError("argument callback is required");
       }
       var encoding = opts.encoding !== true ? opts.encoding : "utf-8";
-      var limit = bytes.parse(opts.limit);
+      var limit2 = bytes.parse(opts.limit);
       var length = opts.length != null && !isNaN(opts.length) ? parseInt(opts.length, 10) : null;
       if (done) {
-        return readStream(stream, encoding, length, limit, wrap(done));
+        return readStream(stream, encoding, length, limit2, wrap(done));
       }
-      return new Promise(function executor(resolve12, reject) {
-        readStream(stream, encoding, length, limit, function onRead(err, buf) {
+      return new Promise(function executor(resolve13, reject) {
+        readStream(stream, encoding, length, limit2, function onRead(err, buf) {
           if (err) return reject(err);
-          resolve12(buf);
+          resolve13(buf);
         });
       });
     }
@@ -5359,14 +5359,14 @@ var require_raw_body = __commonJS({
         stream.pause();
       }
     }
-    function readStream(stream, encoding, length, limit, callback) {
+    function readStream(stream, encoding, length, limit2, callback) {
       var complete = false;
       var sync = true;
-      if (limit !== null && length !== null && length > limit) {
+      if (limit2 !== null && length !== null && length > limit2) {
         return done(createError(413, "request entity too large", {
           expected: length,
           length,
-          limit,
+          limit: limit2,
           type: "entity.too.large"
         }));
       }
@@ -5427,9 +5427,9 @@ var require_raw_body = __commonJS({
       function onData(chunk) {
         if (complete) return;
         received += chunk.length;
-        if (limit !== null && received > limit) {
+        if (limit2 !== null && received > limit2) {
           done(createError(413, "request entity too large", {
-            limit,
+            limit: limit2,
             received,
             type: "entity.too.large"
           }));
@@ -15608,11 +15608,11 @@ var require_utils = __commonJS({
         throw new TypeError("defaultType must be provided");
       }
       const inflate = options?.inflate !== false;
-      const limit = typeof options?.limit === "undefined" || options?.limit === null ? 102400 : bytes.parse(options.limit);
+      const limit2 = typeof options?.limit === "undefined" || options?.limit === null ? 102400 : bytes.parse(options.limit);
       const type = options?.type || defaultType;
       const verify = options?.verify || false;
       const defaultCharset = options?.defaultCharset || "utf-8";
-      if (limit === null) {
+      if (limit2 === null) {
         throw new TypeError(`option limit "${String(options.limit)}" is invalid`);
       }
       if (verify !== false && typeof verify !== "function") {
@@ -15621,7 +15621,7 @@ var require_utils = __commonJS({
       const shouldParse = typeof type !== "function" ? typeChecker(type) : type;
       return {
         inflate,
-        limit,
+        limit: limit2,
         verify,
         defaultCharset,
         shouldParse
@@ -17756,7 +17756,7 @@ var require_utils2 = __commonJS({
         return strWithoutPlus;
       }
     };
-    var limit = 1024;
+    var limit2 = 1024;
     var encode = function encode2(str, defaultEncoder, charset, kind, format) {
       if (str.length === 0) {
         return str;
@@ -17773,9 +17773,9 @@ var require_utils2 = __commonJS({
         });
       }
       var out = "";
-      for (var j = 0; j < string.length; j += limit) {
-        var segment = string.length >= limit ? string.slice(j, j + limit) : string;
-        if (j + limit < string.length) {
+      for (var j = 0; j < string.length; j += limit2) {
+        var segment = string.length >= limit2 ? string.slice(j, j + limit2) : string;
+        if (j + limit2 < string.length) {
           var last = segment.charCodeAt(segment.length - 1);
           if (last >= 55296 && last <= 56319) {
             segment = segment.slice(0, -1);
@@ -18246,13 +18246,13 @@ var require_parse = __commonJS({
       var obj = { __proto__: null };
       var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
       cleanStr = cleanStr.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
-      var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
+      var limit2 = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
       var parts = cleanStr.split(
         options.delimiter,
-        options.throwOnLimitExceeded && typeof limit !== "undefined" ? limit + 1 : limit
+        options.throwOnLimitExceeded && typeof limit2 !== "undefined" ? limit2 + 1 : limit2
       );
-      if (options.throwOnLimitExceeded && typeof limit !== "undefined" && parts.length > limit) {
-        throw new RangeError("Parameter limit exceeded. Only " + limit + " parameter" + (limit === 1 ? "" : "s") + " allowed.");
+      if (options.throwOnLimitExceeded && typeof limit2 !== "undefined" && parts.length > limit2) {
+        throw new RangeError("Parameter limit exceeded. Only " + limit2 + " parameter" + (limit2 === 1 ? "" : "s") + " allowed.");
       }
       var skipIndex = -1;
       var i;
@@ -18600,12 +18600,12 @@ var require_urlencoded = __commonJS({
         }
       };
     }
-    function parameterCount(body, limit) {
+    function parameterCount(body, limit2) {
       let count = 0;
       let index = -1;
       do {
         count++;
-        if (count > limit) return void 0;
+        if (count > limit2) return void 0;
         index = body.indexOf("&", index + 1);
       } while (index !== -1);
       return count;
@@ -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
@@ -28276,8 +28278,8 @@ var Store = class {
     const r = this.db.prepare("INSERT INTO events(project_id,data) VALUES(?,?)").run(projectId, JSON.stringify(event));
     return { ...event, id: Number(r.lastInsertRowid) };
   }
-  events(projectId, after = 0, limit = 200) {
-    return this.db.prepare("SELECT id,data FROM events WHERE project_id=? AND id>? ORDER BY id LIMIT ?").all(projectId, after, limit).map((r) => ({ ...JSON.parse(r.data), id: r.id }));
+  events(projectId, after = 0, limit2 = 200) {
+    return this.db.prepare("SELECT id,data FROM events WHERE project_id=? AND id>? ORDER BY id LIMIT ?").all(projectId, after, limit2).map((r) => ({ ...JSON.parse(r.data), id: r.id }));
   }
   close() {
     this.db.close();
@@ -28285,9 +28287,9 @@ 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 { isAbsolute as isAbsolute2 } from "node:path";
+import { randomUUID as randomUUID6, randomBytes as randomBytes2 } from "node:crypto";
+import { realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
+import { isAbsolute as isAbsolute4 } from "node:path";
 
 // src/continuation.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -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,789 @@ ${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,
+        paneId: r.paneId,
+        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 terminal 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 || !r.terminalScope && (tab.pane_count !== 1 || members?.length !== 1) || members?.filter((pane) => pane.pane_id === r.paneId && pane.terminal_id === r.terminalId).length !== 1)
+      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));
+    if (r.terminalScope === "pane") {
+      const panes2 = (await h.call("pane.list")).panes;
+      if (!Array.isArray(panes2)) refuse("Cannot inspect worker terminal membership");
+      if (panes2.some(
+        (pane) => (pane.pane_id === r.paneId || pane.terminal_id === r.terminalId) && (pane.pane_id !== r.paneId || pane.tab_id !== r.tabId || pane.terminal_id !== r.terminalId)
+      ))
+        refuse("Original terminal may have moved; inspect it before cleanup");
+      return !panes2.some(
+        (pane) => pane.pane_id === r.paneId || pane.terminal_id === r.terminalId
+      );
+    }
+    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 terminal 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)
+      });
+      if (r.terminalScope === "pane") await h.call("pane.close", { pane_id: r.paneId });
+      else 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 terminal",
+        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 worker terminal 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 +29758,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 +29768,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 +30354,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 +30375,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 +30445,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 +30486,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 +30529,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 +30634,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 +30717,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 +30728,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 +30741,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 +30851,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 +30859,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 +30870,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 +30923,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 +31019,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 +31046,7 @@ var Orchestration = class {
           const { key, ...fields } = i;
           const o2 = {
             ...fields,
-            id: randomUUID3(),
+            id: randomUUID4(),
             leadOwner: c.owner,
             revision: 1,
             status: "open",
@@ -30304,6 +31106,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 +31175,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 +31187,7 @@ var Orchestration = class {
         fail("quorum", "Quorum exceeds participant count");
       const strategy2 = {
         ...i,
-        id: randomUUID3(),
+        id: randomUUID4(),
         projectId: c.projectId,
         revision: 1,
         round: 1,
@@ -30475,68 +31280,620 @@ var Orchestration = class {
   }
 };
 
-// src/herdr.ts
+// src/herdr-protocol.ts
+var HERDR_METHODS = [
+  "ping",
+  "server.stop",
+  "server.live_handoff",
+  "server.reload_config",
+  "server.agent_manifests",
+  "server.reload_agent_manifests",
+  "notification.show",
+  "product_announcement.dismiss",
+  "release_notes.dismiss",
+  "command.invoke",
+  "client.window_title.set",
+  "client.window_title.clear",
+  "client_shell.surface.set",
+  "session.snapshot",
+  "workspace.create",
+  "workspace.list",
+  "workspace.get",
+  "workspace.focus",
+  "workspace.rename",
+  "workspace.move",
+  "workspace.move_block",
+  "workspace.report_metadata",
+  "workspace.close",
+  "worktree.list",
+  "worktree.create",
+  "worktree.open",
+  "worktree.remove",
+  "tab.create",
+  "tab.list",
+  "tab.get",
+  "tab.focus",
+  "tab.rename",
+  "tab.move",
+  "tab.close",
+  "agent.list",
+  "agent.get",
+  "agent.read",
+  "agent.explain",
+  "agent.send_keys",
+  "agent.rename",
+  "agent.view.set",
+  "agent.view.clear",
+  "agent.focus",
+  "agent.start",
+  "agent.prompt",
+  "agent.wait",
+  "pane.split",
+  "pane.swap",
+  "pane.move",
+  "pane.zoom",
+  "pane.layout",
+  "pane.process_info",
+  "layout.export",
+  "layout.apply",
+  "layout.set_split_ratio",
+  "pane.neighbor",
+  "pane.edges",
+  "pane.focus_direction",
+  "pane.resize",
+  "pane.scroll",
+  "pane.edit_scrollback",
+  "pane.selection.read",
+  "pane.copy_motion",
+  "pane.copy_search",
+  "pane.list",
+  "pane.current",
+  "pane.get",
+  "pane.focus",
+  "pane.input.set",
+  "pane.link.activate",
+  "pane.rename",
+  "pane.send_text",
+  "pane.send_keys",
+  "pane.send_input",
+  "pane.read",
+  "pane.graphics.set",
+  "pane.graphics.clear",
+  "pane.graphics.info",
+  "pane.report_agent",
+  "pane.report_agent_session",
+  "pane.report_metadata",
+  "pane.clear_agent_authority",
+  "pane.release_agent",
+  "pane.close",
+  "popup.close",
+  "events.subscribe",
+  "events.wait",
+  "pane.wait_for_output",
+  "integration.list",
+  "integration.install",
+  "integration.uninstall",
+  "plugin.link",
+  "plugin.list",
+  "plugin.unlink",
+  "plugin.enable",
+  "plugin.disable",
+  "plugin.action.list",
+  "plugin.action.invoke",
+  "plugin.log.list",
+  "plugin.pane.open",
+  "plugin.pane.focus",
+  "plugin.pane.close"
+];
+
+// src/herdr-streams.ts
+import { isAbsolute as isAbsolute3 } from "node:path";
+
+// src/herdr-transport.ts
 import net from "node:net";
-import { randomUUID as randomUUID4 } from "node:crypto";
-var Herdr = class {
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { isAbsolute as isAbsolute2 } from "node:path";
+var HerdrError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "HerdrError";
+  }
+  code;
+};
+function validateSocketPath(path) {
+  if (!isAbsolute2(path) && !/^\\\\[.?]\\pipe\\[^\\]/.test(path))
+    throw new TypeError("An absolute Herdr socket path or Windows named pipe is required");
+}
+function validateTimeout(value) {
+  if (value !== null && (!Number.isFinite(value) || value <= 0 || value > 2147483647))
+    throw new TypeError("timeoutMs must be a positive bounded duration or null");
+}
+function limit(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0)
+    throw new TypeError(`${name} must be a positive integer`);
+  return value;
+}
+var JsonConnection = class {
+  constructor(socketPath, options = {}) {
+    this.options = options;
+    validateSocketPath(socketPath);
+    this.maxMessageBytes = limit(options.maxResponseBytes ?? 32 * 1024 * 1024, "maxResponseBytes");
+    this.maxQueuedEvents = limit(options.maxQueuedEvents ?? 1024, "maxQueuedEvents");
+    this.maxQueuedBytes = limit(options.maxQueuedBytes ?? this.maxMessageBytes, "maxQueuedBytes");
+    if (options.signal?.aborted)
+      throw new HerdrError("herdr_aborted", "Herdr operation was aborted");
+    this.closed = new Promise((resolve13, reject) => {
+      this.resolveClosed = resolve13;
+      this.rejectClosed = reject;
+    });
+    void this.closed.catch(() => {
+    });
+    this.socket = net.createConnection(socketPath);
+    this.socket.setEncoding("utf8");
+    this.abort = () => this.fail(new HerdrError("herdr_aborted", "Herdr operation was aborted"), true);
+    options.signal?.addEventListener("abort", this.abort, { once: true });
+    this.socket.on(
+      "error",
+      (error) => this.fail(new HerdrError("herdr_unavailable", error.message))
+    );
+    this.socket.on("close", () => {
+      this.ended = true;
+      this.detachAbort();
+      this.rejectWrites(this.error());
+      if (this.failure || !this.explicitClose) this.rejectClosed(this.error());
+      else this.resolveClosed();
+      this.deliver();
+    });
+    this.socket.on("data", (data) => this.receive(data));
+  }
+  options;
+  id = randomUUID5();
+  closed;
+  resolveClosed;
+  rejectClosed;
+  socket;
+  buffer = "";
+  queue = [];
+  queuedBytes = 0;
+  reader;
+  writes = /* @__PURE__ */ new Set();
+  ended = false;
+  failure;
+  explicitClose = false;
+  maxMessageBytes;
+  maxQueuedEvents;
+  maxQueuedBytes;
+  abort;
+  error() {
+    return this.failure ?? new HerdrError(
+      "herdr_disconnected",
+      "Herdr disconnected before acknowledgement or stream completion"
+    );
+  }
+  detachAbort() {
+    this.options.signal?.removeEventListener("abort", this.abort);
+  }
+  rejectWrites(error) {
+    for (const reject of this.writes) reject(error);
+    this.writes.clear();
+  }
+  fail(error, discard = false) {
+    if (this.explicitClose) return;
+    this.failure ??= error;
+    this.ended = true;
+    this.buffer = "";
+    if (discard) {
+      this.queue = [];
+      this.queuedBytes = 0;
+    }
+    this.detachAbort();
+    this.socket.destroy();
+    this.rejectWrites(this.failure);
+    this.deliver();
+  }
+  close() {
+    this.explicitClose = true;
+    this.ended = true;
+    this.buffer = "";
+    this.queue = [];
+    this.queuedBytes = 0;
+    this.detachAbort();
+    this.socket.destroy();
+    this.rejectWrites(this.error());
+    this.deliver();
+  }
+  deliver() {
+    if (!this.reader) return;
+    const reader = this.reader;
+    if (this.failure) {
+      this.reader = void 0;
+      reader.reject(this.failure);
+      return;
+    }
+    const next = this.queue.shift();
+    if (next) {
+      this.reader = void 0;
+      this.queuedBytes -= next.bytes;
+      reader.resolve(next.value);
+    } else if (this.ended) {
+      this.reader = void 0;
+      if (this.explicitClose) reader.resolve(void 0);
+      else reader.reject(this.error());
+    }
+  }
+  receive(data) {
+    if (this.ended) return;
+    this.buffer += data;
+    let index;
+    while ((index = this.buffer.indexOf("\n")) >= 0) {
+      const line = this.buffer.slice(0, index);
+      this.buffer = this.buffer.slice(index + 1);
+      const bytes = Buffer.byteLength(line);
+      if (bytes > this.maxMessageBytes)
+        return this.fail(
+          new HerdrError("herdr_response_too_large", "Herdr message exceeded maxResponseBytes"),
+          true
+        );
+      let value;
+      try {
+        value = JSON.parse(line);
+      } catch (error) {
+        return this.fail(new HerdrError("herdr_invalid_response", String(error)), true);
+      }
+      if (value?.id !== void 0 && value.id !== this.id && !String(value.id).startsWith(this.id + ":"))
+        continue;
+      if (value?.error)
+        return this.fail(new HerdrError(value.error.code, value.error.message), true);
+      if (this.queue.length >= this.maxQueuedEvents || this.queuedBytes + bytes > this.maxQueuedBytes)
+        return this.fail(
+          new HerdrError(
+            "herdr_stream_overflow",
+            "Herdr consumer fell behind; stream closed without silently dropping events"
+          ),
+          true
+        );
+      this.queue.push({ value, bytes });
+      this.queuedBytes += bytes;
+      this.deliver();
+    }
+    if (Buffer.byteLength(this.buffer) > this.maxMessageBytes)
+      this.fail(
+        new HerdrError("herdr_response_too_large", "Herdr message exceeded maxResponseBytes"),
+        true
+      );
+  }
+  read() {
+    if (this.reader)
+      return Promise.reject(new Error("Only one reader may consume a Herdr connection"));
+    return new Promise((resolve13, reject) => {
+      this.reader = { resolve: resolve13, reject };
+      this.deliver();
+    });
+  }
+  write(data) {
+    if (this.ended) return Promise.reject(this.error());
+    return new Promise((resolve13, reject) => {
+      this.writes.add(reject);
+      this.socket.write(data, (error) => {
+        this.writes.delete(reject);
+        if (error) {
+          this.fail(new HerdrError("herdr_unavailable", error.message));
+          reject(this.error());
+        } else if (this.failure) reject(this.failure);
+        else resolve13();
+      });
+    });
+  }
+  async within(timeoutMs, action) {
+    validateTimeout(timeoutMs);
+    const timer = timeoutMs === null ? void 0 : setTimeout(
+      () => this.fail(
+        new HerdrError(
+          "herdr_timeout",
+          "Herdr response timed out; delivery may be ambiguous"
+        ),
+        true
+      ),
+      timeoutMs
+    );
+    try {
+      return await action();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async start(method, params, timeoutMs) {
+    return this.within(timeoutMs, async () => {
+      await this.write(JSON.stringify({ id: this.id, method, params }) + "\n");
+      const message = await this.read();
+      if (!message || message.id !== this.id || !Object.hasOwn(message, "result"))
+        throw new HerdrError("herdr_invalid_response", `${method}: missing correlated result`);
+      return message.result;
+    });
+  }
+};
+async function socketRequest(socketPath, method, params, options = {}) {
+  const timeoutMs = options.timeoutMs === void 0 ? 1e4 : options.timeoutMs;
+  validateTimeout(timeoutMs);
+  JSON.stringify(params);
+  const connection = new JsonConnection(socketPath, options);
+  try {
+    return await connection.start(method, params, timeoutMs);
+  } finally {
+    connection.close();
+  }
+}
+
+// src/herdr-streams.ts
+var HerdrEventStream = class _HerdrEventStream {
+  constructor(connection) {
+    this.connection = connection;
+  }
+  connection;
+  static async open(socketPath, subscriptions, options = {}) {
+    const timeout = options.timeoutMs === void 0 ? 1e4 : options.timeoutMs;
+    validateTimeout(timeout);
+    JSON.stringify(subscriptions);
+    const connection = new JsonConnection(socketPath, options);
+    try {
+      const result = await connection.start("events.subscribe", { subscriptions }, timeout);
+      if (result?.type !== "subscription_started")
+        throw new HerdrError("herdr_invalid_response", "Missing subscription acknowledgement");
+      return new _HerdrEventStream(connection);
+    } catch (error) {
+      connection.close();
+      throw error;
+    }
+  }
+  get closed() {
+    return this.connection.closed;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  async next() {
+    const value = await this.connection.read();
+    if (value === void 0) return { done: true, value: void 0 };
+    if (!value || typeof value.event !== "string" || !Object.hasOwn(value, "data")) {
+      const error = new HerdrError("herdr_invalid_response", "Expected a Herdr event envelope");
+      this.connection.fail(error, true);
+      throw error;
+    }
+    return { done: false, value };
+  }
+  close() {
+    this.connection.close();
+  }
+  async return() {
+    this.close();
+    return { done: true, value: void 0 };
+  }
+};
+var maxInlineBytes = 16 * 1024 * 1024;
+function integer(value, name, min = 0, max = Number.MAX_SAFE_INTEGER) {
+  if (!Number.isSafeInteger(value) || value < min || value > max)
+    throw new TypeError(`Invalid ${name}`);
+}
+function frameHeader(frame) {
+  integer(frame.image_width, "image_width", 1, 4294967295);
+  integer(frame.image_height, "image_height", 1, 4294967295);
+  if (!["png", "rgb", "rgba", "bgra"].includes(frame.format))
+    throw new TypeError("Invalid frame format");
+  return {
+    format: frame.format,
+    image_width: frame.image_width,
+    image_height: frame.image_height,
+    ...frame.placement ? { placement: frame.placement } : {}
+  };
+}
+function encodeHeader(header) {
+  const line = JSON.stringify(header) + "\n";
+  if (Buffer.byteLength(line) > 64 * 1024) throw new TypeError("Graphics header exceeds 64 KiB");
+  return line;
+}
+var HerdrGraphicsStream = class _HerdrGraphicsStream {
+  constructor(connection) {
+    this.connection = connection;
+  }
+  connection;
+  busy = false;
+  static async open(socketPath, params, options = {}) {
+    const timeout = options.timeoutMs === void 0 ? 1e4 : options.timeoutMs;
+    validateTimeout(timeout);
+    JSON.stringify(params);
+    const connection = new JsonConnection(socketPath, options);
+    try {
+      const result = await connection.start("pane.graphics.stream", params, timeout);
+      if (result?.type !== "ok")
+        throw new HerdrError("herdr_invalid_response", "Missing graphics stream acknowledgement");
+      return new _HerdrGraphicsStream(connection);
+    } catch (error) {
+      connection.close();
+      throw error;
+    }
+  }
+  /** Resolves after local close; rejects on remote failure, cancellation, or disconnect. */
+  get closed() {
+    return this.connection.closed;
+  }
+  async exclusive(action) {
+    if (this.busy)
+      throw new HerdrError("herdr_stream_busy", "Await the previous frame before sending another");
+    this.busy = true;
+    try {
+      return await action();
+    } finally {
+      this.busy = false;
+    }
+  }
+  /** Resolves after local socket write, not a render ACK: inline success has no wire reply. */
+  async frame(frame, data, timeoutMs = 3e4) {
+    validateTimeout(timeoutMs);
+    if (!data.byteLength || data.byteLength > maxInlineBytes)
+      throw new TypeError("Inline graphics data must be 1 byte to 16 MiB");
+    const header = encodeHeader({ ...frameHeader(frame), data_length: data.byteLength });
+    return this.exclusive(async () => {
+      const bytes = Buffer.from(data);
+      await this.connection.within(timeoutMs, async () => {
+        await this.connection.write(header);
+        await this.connection.write(bytes);
+      });
+    });
+  }
+  /** Keep the immutable source file until this method acknowledges its sequence and revision. */
+  async fileFrame(frame, timeoutMs = 3e4) {
+    validateTimeout(timeoutMs);
+    if (!["rgba", "bgra"].includes(frame.format) || !isAbsolute3(frame.file.path))
+      throw new TypeError("File frames require rgba/bgra and an absolute source path");
+    integer(frame.sequence, "sequence");
+    integer(frame.revision, "revision");
+    const { sequence, revision } = frame;
+    const header = encodeHeader({
+      ...frameHeader(frame),
+      file: { path: frame.file.path },
+      sequence,
+      revision
+    });
+    return this.exclusive(
+      () => this.connection.within(timeoutMs, async () => {
+        await this.connection.write(header);
+        const message = await this.connection.read();
+        const result = message?.result;
+        if (message?.id !== `${this.connection.id}:file:${sequence}` || result?.type !== "pane_graphics_frame_ack" || result.sequence !== sequence || result.revision !== revision) {
+          const error = new HerdrError(
+            "herdr_invalid_response",
+            "Graphics acknowledgement did not match the file frame"
+          );
+          this.connection.fail(error, true);
+          throw error;
+        }
+        return result;
+      })
+    );
+  }
+  close() {
+    this.connection.close();
+  }
+};
+
+// src/herdr-sdk.ts
+function deadline(method, params) {
+  if (method === "agent.start") return (params.timeout_ms ?? 3e4) + 5e3;
+  const wait = method === "agent.prompt" ? params.wait : ["agent.wait", "events.wait", "pane.wait_for_output"].includes(method) ? params : void 0;
+  if (wait) return wait.timeout_ms == null ? null : wait.timeout_ms + 5e3;
+  return 1e4;
+}
+var HerdrClient = class _HerdrClient {
   constructor(socketPath) {
     this.socketPath = socketPath;
+    validateSocketPath(socketPath);
   }
   socketPath;
+  static fromEnv(env = process.env) {
+    if (env.HERDR_ENV !== "1" || !env.HERDR_SOCKET_PATH)
+      throw new Error("Run inside Herdr or supply an explicitly selected socket path");
+    return new _HerdrClient(env.HERDR_SOCKET_PATH);
+  }
+  /** Escape hatch for future one-shot methods. Streams require their dedicated transports. */
   call(method, params = {}, timeoutMs = 1e4) {
-    return new Promise((resolve12, reject) => {
-      const id = randomUUID4();
-      let buffer = "";
-      let settled2 = false;
-      const socket = net.createConnection(this.socketPath);
-      const finish = (error, result) => {
-        if (settled2) return;
-        settled2 = true;
-        clearTimeout(timer);
-        socket.destroy();
-        error ? reject(error) : resolve12(result);
-      };
-      const timer = setTimeout(
-        () => finish(
-          new AppError(
-            "herdr_timeout",
-            `${method}: response timed out; delivery may be ambiguous`,
-            503
-          )
-        ),
-        timeoutMs
+    if (method === "events.subscribe" || method === "pane.graphics.stream")
+      return Promise.reject(
+        new TypeError("Use subscribe(), graphicsStream(), or api for a streaming method")
       );
-      socket.on("connect", () => socket.write(JSON.stringify({ id, method, params }) + "\n"));
-      socket.on(
-        "error",
-        (e) => finish(new AppError("herdr_unavailable", `${method}: ${e.message}`, 503))
-      );
-      socket.on(
-        "close",
-        () => finish(
-          new AppError("herdr_disconnected", `${method}: disconnected before acknowledgement`, 503)
+    return socketRequest(this.socketPath, method, params, { timeoutMs });
+  }
+  /** All schema-defined one-shot methods with exact typed parameter objects. */
+  request(method, ...args2) {
+    const [params = {}, options = {}] = args2;
+    if (!HERDR_METHODS.includes(method) || method === "events.subscribe")
+      return Promise.reject(
+        new TypeError(
+          "Unknown one-shot method; use call() for extensions or subscribe() for events"
         )
       );
-      socket.on("data", (data) => {
-        buffer += data.toString();
-        if (buffer.length > 8 * 1024 * 1024)
-          return finish(new Error("Herdr response exceeded 8 MiB"));
-        let index;
-        while ((index = buffer.indexOf("\n")) >= 0) {
-          const line = buffer.slice(0, index);
-          buffer = buffer.slice(index + 1);
-          try {
-            const v = JSON.parse(line);
-            if (v.id !== id) continue;
-            if (v.error) finish(new AppError(v.error.code, v.error.message, 502));
-            else finish(void 0, v.result);
-          } catch (e) {
-            finish(e);
-          }
-        }
-      });
+    return socketRequest(this.socketPath, method, params, {
+      ...options,
+      timeoutMs: options.timeoutMs === void 0 ? deadline(method, params) : options.timeoutMs
     });
   }
+  subscribe(subscriptions, options) {
+    return HerdrEventStream.open(this.socketPath, subscriptions, options);
+  }
+  graphicsStream(params, options) {
+    return HerdrGraphicsStream.open(this.socketPath, params, options);
+  }
+  /** One-to-one method names, including streams, for discovery and generated agent code. */
+  api = Object.freeze(
+    Object.fromEntries([
+      ...HERDR_METHODS.map((method) => [
+        method,
+        method === "events.subscribe" ? (params, options) => this.subscribe(params.subscriptions, options) : (params = {}, options) => this.request(method, params, options)
+      ]),
+      [
+        "pane.graphics.stream",
+        (params, options) => this.graphicsStream(params, options)
+      ]
+    ])
+  );
+  workspace = {
+    list: () => this.call("workspace.list"),
+    create: (options) => this.call("workspace.create", {
+      focus: false,
+      ...options
+    })
+  };
+  tab = {
+    create: (workspaceId, options) => this.call("tab.create", {
+      focus: false,
+      ...options,
+      workspace_id: workspaceId
+    }),
+    list: (workspaceId) => this.call("tab.list", { workspace_id: workspaceId }),
+    close: (tabId) => this.call("tab.close", { tab_id: tabId })
+  };
+  pane = {
+    list: (workspaceId) => this.call("pane.list", { workspace_id: workspaceId }),
+    layout: (paneId) => this.call("pane.layout", { pane_id: paneId }),
+    split: (paneId, options) => this.call("pane.split", { focus: false, ...options, target_pane_id: paneId }),
+    read: (paneId, lines = 120) => this.call("pane.read", {
+      pane_id: paneId,
+      source: "recent_unwrapped",
+      format: "text",
+      lines
+    }),
+    sendText: (paneId, text2) => this.call("pane.send_text", { pane_id: paneId, text: text2 }),
+    sendKeys: (paneId, keys) => this.call("pane.send_keys", { pane_id: paneId, keys }),
+    close: (paneId) => this.call("pane.close", { pane_id: paneId })
+  };
+  agent = {
+    start: (paneId, name, kind, args2 = [], timeoutMs = 3e4) => this.call(
+      "agent.start",
+      { pane_id: paneId, name, kind, args: args2, timeout_ms: timeoutMs },
+      timeoutMs + 5e3
+    ),
+    get: (target) => this.call("agent.get", { target }),
+    prompt: (target, text2, wait) => this.call(
+      "agent.prompt",
+      { target, text: text2, ...wait ? { wait } : {} },
+      wait ? wait.timeout_ms + 5e3 : 1e4
+    ),
+    wait: (target, options) => this.call("agent.wait", { target, ...options }, options.timeout_ms + 5e3),
+    sendKeys: (target, keys) => this.call("agent.send_keys", { target, keys })
+  };
+};
+
+// src/herdr.ts
+var Herdr = class extends HerdrClient {
+  async call(method, params = {}, timeoutMs = 1e4) {
+    try {
+      return await super.call(method, params, timeoutMs);
+    } catch (error) {
+      if (error instanceof HerdrError)
+        throw new AppError(error.code, error.message, error.code.startsWith("herdr_") ? 503 : 502);
+      throw error;
+    }
+  }
 };
 
 // src/service.ts
@@ -30551,6 +31908,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 +31949,7 @@ var Service = class {
     );
     return {
       project,
+      cleanupPolicy: this.cleanup.policy(projectId),
       lead: this.publicLead(projectId),
       ...this.orchestration.board(projectId),
       tasks,
@@ -30613,7 +31972,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 +32000,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))
@@ -30659,10 +32019,10 @@ var Service = class {
           agentArgs: external_exports.record(kindSchema, external_exports.array(external_exports.string())).default({}),
           trustAgyWorkspaces: external_exports.boolean().default(false)
         }).parse(raw);
-        if (!isAbsolute2(input.root) || !isAbsolute2(input.socketPath))
+        if (!isAbsolute4(input.root) || !isAbsolute4(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 +32033,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 +32182,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 +32218,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",
@@ -30902,29 +32266,55 @@ var Service = class {
               "No task prompt was attempted. Inspect the workspace and reconcile creation as not-delivered."
             );
           const project = this.project(t.projectId);
-          const tabs = (await h.call("tab.list", { workspace_id: project.workspaceId })).tabs ?? [];
-          const matches = tabs.filter(
-            (tab) => tab.workspace_id === project.workspaceId && tab.label === r.agentName
-          );
-          if (matches.length > 1)
-            throw new AppError(
-              "identity_changed",
-              "Multiple tabs match the interrupted creation; manual inspection is required",
-              409
+          if (r.creation?.mode === "pane") {
+            const all = (await h.call("pane.list", { workspace_id: project.workspaceId })).panes;
+            if (!Array.isArray(all) || !r.creation.beforePaneIds)
+              throw new AppError(
+                "identity_changed",
+                "Missing split membership; inspect the workspace",
+                409
+              );
+            const added = all.filter(
+              (pane) => !r.creation.beforePaneIds.includes(pane.pane_id)
             );
-          if (matches.length === 1) {
-            const panes = ((await h.call("pane.list", { workspace_id: project.workspaceId })).panes ?? []).filter((pane) => pane.tab_id === matches[0].tab_id);
-            if (panes.length !== 1 || panes[0].agent || panes[0].launch_pending || panes[0].workspace_id !== project.workspaceId || panes[0].cwd !== t.cwd)
+            const panes = added.filter((pane) => pane.tab_id === r.creation.tabId);
+            if (added.length !== panes.length || panes.length > 1 || panes.length === 1 && (panes[0].agent || panes[0].launch_pending || panes[0].workspace_id !== project.workspaceId || panes[0].cwd !== t.cwd))
               throw new AppError(
                 "identity_changed",
-                "The orphan tab is no longer an untouched shell; inspect it before recovery",
+                "Interrupted split is ambiguous or no longer an untouched shell; inspect it before recovery",
                 409
               );
-            Object.assign(r, {
-              paneId: panes[0].pane_id,
-              terminalId: panes[0].terminal_id,
-              tabId: panes[0].tab_id
-            });
+            if (panes.length === 1)
+              Object.assign(r, {
+                paneId: panes[0].pane_id,
+                terminalId: panes[0].terminal_id,
+                tabId: panes[0].tab_id
+              });
+          } else {
+            const tabs = (await h.call("tab.list", { workspace_id: project.workspaceId })).tabs ?? [];
+            const matches = tabs.filter(
+              (tab) => tab.workspace_id === project.workspaceId && tab.label === r.agentName
+            );
+            if (matches.length > 1)
+              throw new AppError(
+                "identity_changed",
+                "Multiple tabs match the interrupted creation; manual inspection is required",
+                409
+              );
+            if (matches.length === 1) {
+              const panes = ((await h.call("pane.list", { workspace_id: project.workspaceId })).panes ?? []).filter((pane) => pane.tab_id === matches[0].tab_id);
+              if (panes.length !== 1 || panes[0].agent || panes[0].launch_pending || panes[0].workspace_id !== project.workspaceId || panes[0].cwd !== t.cwd)
+                throw new AppError(
+                  "identity_changed",
+                  "The orphan tab is no longer an untouched shell; inspect it before recovery",
+                  409
+                );
+              Object.assign(r, {
+                paneId: panes[0].pane_id,
+                terminalId: panes[0].terminal_id,
+                tabId: panes[0].tab_id
+              });
+            }
           }
         } else {
           const a = (await h.call("agent.get", { target: r.paneId })).agent;
@@ -30968,7 +32358,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 +32412,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 +32441,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 +32498,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(
@@ -31114,7 +32510,7 @@ var Service = class {
         "Task directory must be within the registered root. Register external worktrees as projects."
       );
     for (const path of a.ownership) {
-      if (a.execution?.mode === "worktree" && isAbsolute2(path))
+      if (a.execution?.mode === "worktree" && isAbsolute4(path))
         throw new AppError(
           "worktree_path",
           "Worktree ownership paths must be relative to the task directory"
@@ -31128,7 +32524,7 @@ var Service = class {
     }
     for (const check of a.checks)
       if (check.type === "file") {
-        if (a.execution?.mode === "worktree" && isAbsolute2(check.path))
+        if (a.execution?.mode === "worktree" && isAbsolute4(check.path))
           throw new AppError(
             "worktree_path",
             "Worktree file checks must be relative to the task directory"
@@ -31137,6 +32533,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 +32548,7 @@ var Service = class {
         const task = {
           ...fields,
           cwd,
-          id: randomUUID5(),
+          id: randomUUID6(),
           status: a.deferStart ? "paused" : "queued",
           revision: 1,
           attempt: 0,
@@ -31168,6 +32570,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 +32588,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)
@@ -31254,6 +32658,52 @@ var Service = class {
   }
 };
 
+// src/worker-layout.ts
+async function planWorkerPane(h, workspaceId, runs) {
+  const panes = (await h.call("pane.list", { workspace_id: workspaceId })).panes;
+  if (!Array.isArray(panes)) throw new Error("Herdr did not return workspace panes");
+  const candidates = runs.filter(
+    (r) => r.terminalScope === "pane" && r.paneId && r.tabId && !r.cleanup && r.phase !== "creating"
+  );
+  for (const tabId of new Set(candidates.map((r) => r.tabId))) {
+    if (runs.some((r) => r.phase === "creating" && r.creation?.tabId === tabId)) continue;
+    const members = panes.filter((p) => p.workspace_id === workspaceId && p.tab_id === tabId);
+    if (!members.length || members.length >= 4) continue;
+    if (!members.every(
+      (p) => candidates.some(
+        (r) => r.paneId === p.pane_id && r.terminalId === p.terminal_id && r.tabId === p.tab_id
+      )
+    ))
+      continue;
+    const layout = (await h.call("pane.layout", { pane_id: members[0].pane_id })).layout;
+    if (layout?.workspace_id !== workspaceId || layout.tab_id !== tabId || !Array.isArray(layout.panes))
+      continue;
+    const choices = layout.panes.flatMap((p) => {
+      if (!members.some((m) => m.pane_id === p.pane_id)) return [];
+      const { width, height } = p.rect;
+      const right = width >= 121 && height >= 12;
+      const down = height >= 25 && width >= 60;
+      if (!right && !down) return [];
+      return [
+        {
+          paneId: p.pane_id,
+          area: width * height,
+          direction: right && (!down || width >= height * 3) ? "right" : "down"
+        }
+      ];
+    }).sort((a, b) => b.area - a.area);
+    if (choices.length)
+      return {
+        mode: "pane",
+        tabId,
+        targetPaneId: choices[0].paneId,
+        direction: choices[0].direction,
+        beforePaneIds: panes.map((p) => p.pane_id)
+      };
+  }
+  return { mode: "tab" };
+}
+
 // src/prompts.ts
 var leadContract = `Own the user's outcome through verified completion. Establish a persistent outcome with objective, explicit scope, observable criteria and required evidence before dispatch. Use criteria suited to the work: executable behavior checks for software, corroborated sources and traceable findings for research, reproducible calculations for analysis, and documented alternatives, tradeoffs and unresolved disagreements for decisions. Ask for clarification only when the evidence cannot resolve a necessary ambiguity.
 Choose exact available model profiles and an appropriate bounded collaboration strategy. Preserve a user's explicit model choice; if unavailable, report it and make any proposed fallback explicit. Stage independent council, debate or competing-proposal participants with deferStart: true, then use strategy_create to establish common evaluation criteria and release their initial assessments. Do not contaminate initial assessments by sharing another participant's conclusions. Use verified participant results in synthesis and preserve material disagreements. For later debate rounds, obtain fresh verified participant revisions before contributing their rebuttals.
@@ -31272,39 +32722,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 +32763,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) {
@@ -31447,9 +32802,26 @@ var Supervisor = class {
   timer;
   busy = /* @__PURE__ */ new Set();
   stopped = false;
+  layouts = /* @__PURE__ */ new Map();
+  async withLayout(projectId, action) {
+    const previous = this.layouts.get(projectId) ?? Promise.resolve();
+    let release;
+    const pending = new Promise((resolve13) => {
+      release = resolve13;
+    });
+    this.layouts.set(projectId, pending);
+    await previous;
+    try {
+      return await action();
+    } finally {
+      release();
+      if (this.layouts.get(projectId) === pending) this.layouts.delete(projectId);
+    }
+  }
   start() {
     this.recover();
     this.service.continuation.recover();
+    this.service.cleanup.recover();
     this.timer = setInterval(() => this.tick(), this.pollMs);
     this.tick();
   }
@@ -31457,6 +32829,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 +32905,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 +32925,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 +32951,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 +33060,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 +33124,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,
@@ -31775,23 +33151,38 @@ ${JSON.stringify(children.map((child) => ({ id: child.id, title: child.title, st
       t = s.updateTask(s.task(id), { runId: run.id, attempt: run.attempt });
     });
     try {
-      const created = await h.call("tab.create", {
-        workspace_id: p.workspaceId,
-        cwd: t.cwd,
-        label: run.agentName,
-        focus: false,
-        env: { MARIONETTE_WORKER_TOKEN: token, MARIONETTE_TASK_ID: id, MARIONETTE_URL: this.url }
-      });
-      const pane = created.root_pane;
-      if (!pane?.pane_id || pane.workspace_id !== p.workspaceId)
-        throw new Error("Herdr did not return the expected scoped root pane");
-      Object.assign(run, {
-        paneId: pane.pane_id,
-        terminalId: pane.terminal_id,
-        tabId: pane.tab_id,
-        phase: "starting"
+      await this.withLayout(p.id, async () => {
+        const taskIds = new Set(s.tasks(p.id).map((task) => task.id));
+        const runs = s.store.all("run").filter((r) => taskIds.has(r.taskId) && !s.cleanup.active(r.taskId));
+        run.creation = await planWorkerPane(h, p.workspaceId, runs);
+        run.terminalScope = "pane";
+        this.saveRun(run);
+        const options = {
+          workspace_id: p.workspaceId,
+          cwd: t.cwd,
+          focus: false,
+          env: { MARIONETTE_WORKER_TOKEN: token, MARIONETTE_TASK_ID: id, MARIONETTE_URL: this.url }
+        };
+        const splitting = run.creation.mode === "pane";
+        const created = await h.call(
+          splitting ? "pane.split" : "tab.create",
+          splitting ? {
+            ...options,
+            target_pane_id: run.creation.targetPaneId,
+            direction: run.creation.direction
+          } : { ...options, label: run.agentName }
+        );
+        const pane = splitting ? created.pane : created.root_pane;
+        if (!pane?.pane_id || !pane.terminal_id || !pane.tab_id || pane.workspace_id !== p.workspaceId || splitting && (pane.tab_id !== run.creation.tabId || run.creation.beforePaneIds.includes(pane.pane_id)))
+          throw new Error("Herdr did not return the expected new scoped pane");
+        Object.assign(run, {
+          paneId: pane.pane_id,
+          terminalId: pane.terminal_id,
+          tabId: pane.tab_id,
+          phase: "starting"
+        });
+        this.saveRun(run);
       });
-      this.saveRun(run);
       for (let attempt = 0; ; attempt++) {
         try {
           await h.call(
@@ -31808,7 +33199,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 +33213,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 +33229,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 +33562,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 +33602,14 @@ ${result.output}`;
 };
 
 // src/version.ts
-var VERSION = "0.2.0";
+var VERSION = "0.2.2";
 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 +33622,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 +33703,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 +33733,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 +33745,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 +33799,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 +33836,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 +33860,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 +33937,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 +33950,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 +33961,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 +33981,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 +33996,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 +34022,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 +34042,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 +34063,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 +34077,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 +34115,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 +34140,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 +34201,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 +34259,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 +34298,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 +34312,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 +34346,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 +34368,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 +34402,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 +34414,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;