@herdingchats/friday 0.1.550 → 0.1.561

package/herd.mjs

@@ -18,7 +18,7 @@ var __export = (target, all) => {
 var define_HERD_PACKAGE_default;
 var init_define_HERD_PACKAGE = __esm({
   "<define:HERD_PACKAGE>"() {
-    define_HERD_PACKAGE_default = { version: "0.1.550", gitHead: "8fdd8ce87ad61c0e396cc832c6e165e69c6fde22" };
+    define_HERD_PACKAGE_default = { version: "0.1.561", gitHead: "dc277703d4460a12bee165c4c4e6653088631c16" };
   }
 });
 
@@ -689,6 +689,8 @@ export default {
       activated: z7.boolean(),
       activation: agentActivationSchema.optional(),
       online: z7.boolean(),
+      /** A folder its machine works in that isn't there, so it's offered no work until it is. */
+      folderUnavailable: z7.object({ path: z7.string().min(1), target: z7.string().min(1).optional() }).optional(),
       // Its machine's repos, each marked whether herd has cloned it there. Older daemons send no `cloned`.
       repos: z7.array(
         z7.object({ name: z7.string(), remote: z7.string(), cloned: z7.boolean().optional() })
@@ -700,7 +702,7 @@ export default {
 
 // ../common-chat/src/machines.ts
 import { z as z8 } from "zod";
-var nonEmpty4, time2, terminalStateSchema, agentStatusSchema, machineRepoSchema, isCloned, machineCliSchema, machineRegistrationSchema, machineSchema, machinePresenceSchema, worktreeSchema, MAX_REPO_HINTS, repoHintSchema, terminalSchema, offerSchema, offerAnswerSchema, dispatchFrameSchema, machineMessageSchema;
+var nonEmpty4, time2, terminalStateSchema, agentStatusSchema, machineRepoSchema, isCloned, machineCliSchema, folderUnavailableSchema, machineRegistrationSchema, machineSchema, machinePresenceSchema, worktreeSchema, MAX_REPO_HINTS, repoHintSchema, terminalSchema, offerSchema, offerAnswerSchema, dispatchFrameSchema, machineMessageSchema;
 var init_machines = __esm({
   "../common-chat/src/machines.ts"() {
     "use strict";
@@ -732,6 +734,10 @@ var init_machines = __esm({
       capabilities: z8.array(capabilitySchema).optional(),
       activation: agentActivationSchema.optional()
     });
+    folderUnavailableSchema = z8.object({
+      path: z8.string().min(1).max(1e3),
+      target: z8.string().min(1).max(1e3).optional()
+    });
     machineRegistrationSchema = z8.object({
       id: nonEmpty4,
       name: nonEmpty4,
@@ -744,7 +750,9 @@ var init_machines = __esm({
       config: herdConfigSchema.optional(),
       configError: z8.string().max(1e3).optional(),
       // Whether its GitHub CLI is signed in, and as whom.
-      gh: gitHubCliSchema.optional()
+      gh: gitHubCliSchema.optional(),
+      // A folder it works in that isn't there, while it takes no work.
+      folderUnavailable: folderUnavailableSchema.optional()
     });
     machineSchema = machineRegistrationSchema.extend({
       ownerId: nonEmpty4,
@@ -1458,6 +1466,9 @@ var init_conversation_state = __esm({
       "author_not_linked",
       // The only agents that could take it showed their own sign-in, so a person has to sign in.
       "agent_signed_out",
+      // The only machines that could take it have a folder that isn't there, such as a drive not
+      // yet mounted.
+      "folder_unavailable",
       // The owner's "only" and "avoid" rules left no worker for the work.
       "no_suitable_worker",
       "notice_failed",
@@ -1557,6 +1568,7 @@ var init_conversation_state = __esm({
       author_not_linked: "the author's account isn't linked",
       delegate_waiting: "a delegate is waiting on someone",
       agent_signed_out: "its agent isn't signed in on its machine",
+      folder_unavailable: "its machine's folder isn't there",
       no_suitable_worker: "no worker may take it under its configuration",
       notice_failed: "a notice didn't reach the agent's terminal",
       machine_offline: "its machine is offline",
@@ -1937,12 +1949,12 @@ var init_self = __esm({
 
 // src/desk-display/usb.ts
 import { execFileSync as execFileSync7 } from "node:child_process";
-import { closeSync as closeSync4, constants, openSync as openSync5, readdirSync as readdirSync8, readSync as readSync2, writeSync } from "node:fs";
+import { closeSync as closeSync4, constants as constants2, openSync as openSync5, readdirSync as readdirSync9, readSync as readSync2, writeSync } from "node:fs";
 import { platform } from "node:os";
 import { setTimeout as delay } from "node:timers/promises";
 function candidates() {
   try {
-    const names = readdirSync8("/dev");
+    const names = readdirSync9("/dev");
     return platform() === "darwin" ? names.filter((name) => name.startsWith("cu.usbmodem")).map((name) => `/dev/${name}`) : names.filter((name) => name.startsWith("ttyACM")).map((name) => `/dev/${name}`);
   } catch {
     return [];
@@ -1975,7 +1987,7 @@ var init_usb = __esm({
       fd;
       buffered = "";
       static open(path) {
-        const fd = openSync5(path, constants.O_RDWR | constants.O_NOCTTY | constants.O_NONBLOCK);
+        const fd = openSync5(path, constants2.O_RDWR | constants2.O_NOCTTY | constants2.O_NONBLOCK);
         try {
           execFileSync7(
             "stty",
@@ -3134,16 +3146,16 @@ var init_desk_display = __esm({
 
 // src/package-entry.ts
 init_define_HERD_PACKAGE();
-import { realpathSync as realpathSync9 } from "node:fs";
+import { realpathSync as realpathSync11 } from "node:fs";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/friday/main.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { spawn as spawn5 } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "node:fs";
+import { spawn as spawn6 } from "node:child_process";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname9, join as join13 } from "node:path";
+import { dirname as dirname10, join as join14 } from "node:path";
 import { z as z22 } from "zod";
 
 // src/auth.ts
@@ -3208,7 +3220,7 @@ async function login(openBrowser2, { api = apiUrl(), timeoutMs = 10 * 60 * 1e3 }
   if (!metadata.success) throw new HerdError(`Couldn't find where to sign in for ${api}.`);
   const meta = metadata.data;
   const server = createServer();
-  await new Promise((resolve6) => server.listen(0, "127.0.0.1", resolve6));
+  await new Promise((resolve7) => server.listen(0, "127.0.0.1", resolve7));
   const address = server.address();
   const port = typeof address === "object" && address ? address.port : 0;
   const redirectUri = `http://127.0.0.1:${port}/callback`;
@@ -3240,7 +3252,7 @@ async function login(openBrowser2, { api = apiUrl(), timeoutMs = 10 * 60 * 1e3 }
       state,
       resource: api
     }).toString();
-    const code = new Promise((resolve6, reject) => {
+    const code = new Promise((resolve7, reject) => {
       const timer = setTimeout(
         () => reject(new HerdError("Nobody signed in within 10 minutes. Run herd login again.")),
         timeoutMs
@@ -3254,7 +3266,7 @@ async function login(openBrowser2, { api = apiUrl(), timeoutMs = 10 * 60 * 1e3 }
         res.writeHead(ok ? 200 : 400, { "Content-Type": "text/plain" }).end(ok ? "Signed in to herd. You can close this tab." : "Sign-in didn't complete.");
         if (error) return reject(new HerdError(`Sign-in was refused: ${error}.`));
         if (!ok) return reject(new HerdError("Sign-in came back for a different request."));
-        resolve6(url.searchParams.get("code") ?? "");
+        resolve7(url.searchParams.get("code") ?? "");
       });
     });
     code.catch(() => {
@@ -3453,9 +3465,9 @@ async function runLogout() {
 init_define_HERD_PACKAGE();
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, realpathSync as realpathSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir3, hostname } from "node:os";
-import { basename, dirname as dirname3, join as join5, resolve } from "node:path";
+import { basename, dirname as dirname4, join as join6, resolve } from "node:path";
 import { z as z18 } from "zod";
 
 // src/machine-facts.ts
@@ -3762,8 +3774,8 @@ init_src();
 import { execFile, execFileSync as execFileSync2 } from "node:child_process";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import {
-  existsSync,
-  mkdirSync as mkdirSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
   readdirSync as readdirSync2,
   readFileSync as readFileSync3,
   renameSync,
@@ -3771,9 +3783,83 @@ import {
   statSync as statSync3
 } from "node:fs";
 import { writeFile } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute, join as join4 } from "node:path";
+import { dirname as dirname3, isAbsolute, join as join5 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
+
+// src/local-files.ts
+init_define_HERD_PACKAGE();
+import { spawn as spawn2 } from "node:child_process";
+import { constants, copyFileSync, existsSync, lstatSync, mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+var INCLUDE_FILE = ".worktreeinclude";
+var DEFAULT_INCLUDE = ".env*";
+var HEAVY_FOLDERS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".next",
+  ".turbo",
+  ".cache"
+]);
+var MAX_COPIED = 500;
+function gitOut(env, cwd, args, input = "") {
+  return new Promise((resolve7) => {
+    const child = spawn2("git", ["-C", cwd, ...args], {
+      env: { ...env ?? process.env, GIT_TERMINAL_PROMPT: "0" },
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    let out = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      out += chunk;
+    });
+    child.on("error", () => resolve7(""));
+    child.on("close", () => resolve7(out));
+    child.stdin.end(input);
+  });
+}
+var split = (output2) => output2.split("\0").filter(Boolean);
+async function localFiles(checkout, env) {
+  const include = join4(checkout, INCLUDE_FILE);
+  const patterns = existsSync(include) ? [`--exclude-from=${include}`] : [`--exclude=${DEFAULT_INCLUDE}`];
+  const matched = split(
+    await gitOut(env, checkout, ["ls-files", "-z", "--others", "--ignored", ...patterns])
+  ).filter((path) => !path.split("/").some((part) => HEAVY_FOLDERS.has(part)));
+  if (matched.length === 0) return [];
+  const ignored = new Set(
+    split(
+      await gitOut(env, checkout, ["check-ignore", "-z", "--stdin"], `${matched.join("\0")}\0`)
+    )
+  );
+  return matched.filter((path) => ignored.has(path)).sort();
+}
+function describeCopied(folder, copied) {
+  const shown = copied.slice(0, 10).join(", ");
+  const more = copied.length > 10 ? `, and ${copied.length - 10} more` : "";
+  return `Copied ${copied.length === 1 ? "a local file" : "local files"} git ignores from the root's checkout into ${folder}: ${shown}${more}.`;
+}
+async function copyLocalFiles(checkout, worktree, env) {
+  const copied = [];
+  for (const path of await localFiles(checkout, env)) {
+    if (copied.length >= MAX_COPIED) break;
+    if (path.split("/").includes("..")) continue;
+    const from = join4(checkout, path);
+    const to = join4(worktree, path);
+    try {
+      if (!lstatSync(from).isFile() || existsSync(to)) continue;
+      mkdirSync2(dirname2(to), { recursive: true });
+      copyFileSync(from, to, constants.COPYFILE_EXCL);
+      copied.push(path);
+    } catch {
+    }
+  }
+  return copied;
+}
+
+// src/repo-store.ts
 var run = promisify(execFile);
 var StoreError = class extends Error {
 };
@@ -3806,8 +3892,8 @@ function gitError(error) {
   if (stderr) return stderr.slice(0, 1e3);
   return error instanceof Error ? error.message.slice(0, 1e3) : String(error);
 }
-var reposDir = (root) => join4(root, "repos");
-var convosDir = (root) => join4(root, "convos");
+var legacyConvosDir = (root) => join5(root, "convos");
+var checkoutLock = (root, key) => join5(root, ".herd", "locks", key);
 function localPath(remote) {
   if (remote.startsWith("file://")) {
     try {
@@ -3829,11 +3915,6 @@ function repoKey(remote) {
 }
 var repoName = (key) => key.split("/").at(-1) ?? key;
 var repoOwner = (key) => key.split("/").at(-2) ?? "";
-function storePath(root, remote) {
-  const key = repoKey(remote);
-  if (!key) throw new StoreError(`${remote} isn't a repo's URL.`);
-  return join4(reposDir(root), `${key}.git`);
-}
 function cloneUrl(key, known = []) {
   return known.find((remote) => repoKey(remote) === key) ?? `https://${key}`;
 }
@@ -3862,13 +3943,13 @@ function isStale(lock, content, staleMs) {
     return true;
   }
 }
-async function withStoreLock(store, work, options = {}) {
-  const lock = `${store}.lock`;
+async function withStoreLock(target, work, options = {}) {
+  const lock = `${target}.lock`;
   const pollMs = options.pollMs ?? LOCK_POLL_MS;
   const deadline = Date.now() + (options.timeoutMs ?? LOCK_TIMEOUT_MS);
   const token = `${process.pid} ${randomBytes2(8).toString("hex")}
 `;
-  mkdirSync2(dirname2(lock), { recursive: true });
+  mkdirSync3(dirname3(lock), { recursive: true });
   for (; ; ) {
     try {
       await writeFile(lock, token, { flag: "wx" });
@@ -3892,7 +3973,7 @@ async function withStoreLock(store, work, options = {}) {
     if (Date.now() > deadline) {
       throw new StoreError(`Another process has held ${lock} for too long.`);
     }
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
+    await new Promise((resolve7) => setTimeout(resolve7, pollMs));
   }
   try {
     return await work();
@@ -3903,38 +3984,63 @@ async function withStoreLock(store, work, options = {}) {
     }
   }
 }
-async function ensureClone(root, remote, env) {
-  const store = storePath(root, remote);
-  if (existsSync(store)) {
+function checkouts(root) {
+  const all = reposInFolder(root).map((repo) => ({
+    key: repo.key,
+    remote: repo.remote,
+    folder: repo.folder,
+    path: join5(root, repo.folder)
+  }));
+  const named = (repo) => repo.folder === repoName(repo.key) ? 0 : 1;
+  const best = /* @__PURE__ */ new Map();
+  for (const repo of [...all].sort((a, b) => named(a) - named(b))) {
+    if (!best.has(repo.key)) best.set(repo.key, repo);
+  }
+  return all.filter((repo) => best.get(repo.key) === repo);
+}
+var checkoutFor = (root, key) => checkouts(root).find((repo) => repo.key === key) ?? null;
+function checkoutsStamp(root) {
+  let entries;
+  try {
+    entries = readdirSync2(root);
+  } catch {
+    return "";
+  }
+  return entries.filter((name) => !name.startsWith(".") && existsSync2(join5(root, name, ".git"))).sort().join("\n");
+}
+async function ensureCheckout(root, remote, env) {
+  const key = repoKey(remote);
+  if (!key) throw new StoreError(`${remote} isn't a repo's URL.`);
+  const found = checkoutFor(root, key);
+  if (found) {
     let fetchFailed = null;
     try {
-      await git(env, store, "fetch", "--quiet", "--prune", "origin");
-      await git(env, store, "remote", "set-head", "origin", "--auto").catch(() => "");
+      await git(env, found.path, "fetch", "--quiet", "origin");
+      if (!await hasRef(env, found.path, "refs/remotes/origin/HEAD")) {
+        await git(env, found.path, "remote", "set-head", "origin", "--auto").catch(() => "");
+      }
     } catch (error) {
       fetchFailed = error instanceof Error ? error.message : String(error);
     }
-    return { store, created: false, fetchFailed };
+    return { path: found.path, created: false, fetchFailed };
   }
-  const building = `${store}.tmp-${process.pid}-${randomBytes2(4).toString("hex")}`;
-  mkdirSync2(dirname2(store), { recursive: true });
-  try {
-    await git(env, dirname2(store), "init", "--quiet", "--bare", building);
-    await git(env, building, "remote", "add", "origin", remote);
-    await git(
-      env,
-      building,
-      "config",
-      "remote.origin.fetch",
-      "+refs/heads/*:refs/remotes/origin/*"
+  const name = [repoName(key), `${repoOwner(key)}-${repoName(key)}`].filter(validFolderName).find((candidate) => !existsSync2(join5(root, candidate)));
+  if (!name) {
+    throw new StoreError(
+      `Both ${repoName(key)} and ${repoOwner(key)}-${repoName(key)} are taken in ${root}, so herd can't clone ${key} there.`
     );
-    await git(env, building, "fetch", "--quiet", "origin");
-    await git(env, building, "remote", "set-head", "origin", "--auto").catch(() => "");
-    renameSync(building, store);
+  }
+  const target = join5(root, name);
+  const building = join5(root, `.${name}.tmp-${process.pid}-${randomBytes2(4).toString("hex")}`);
+  mkdirSync3(root, { recursive: true });
+  try {
+    await git(env, root, "clone", "--quiet", remote, building);
+    renameSync(building, target);
   } catch (error) {
     rmSync3(building, { recursive: true, force: true });
     throw error instanceof StoreError ? error : new StoreError(gitError(error));
   }
-  return { store, created: true, fetchFailed: null };
+  return { path: target, created: true, fetchFailed: null };
 }
 async function hasRef(env, repo, ref) {
   try {
@@ -3944,16 +4050,16 @@ async function hasRef(env, repo, ref) {
     return false;
   }
 }
-async function remoteDefault(store, env) {
+async function remoteDefault(repo, env) {
   try {
-    return await git(env, store, "symbolic-ref", "--short", "refs/remotes/origin/HEAD");
+    return await git(env, repo, "symbolic-ref", "--short", "refs/remotes/origin/HEAD");
   } catch {
     for (const name of ["main", "master"]) {
-      if (await hasRef(env, store, `refs/remotes/origin/${name}`)) return `origin/${name}`;
+      if (await hasRef(env, repo, `refs/remotes/origin/${name}`)) return `origin/${name}`;
     }
     const first = await git(
       env,
-      store,
+      repo,
       "for-each-ref",
       "--count=1",
       "--format=%(refname:short)",
@@ -3967,111 +4073,72 @@ async function addWorktree(options) {
   const { root, remote, path, branch, env } = options;
   const key = repoKey(remote);
   if (!key) throw new StoreError(`${remote} isn't a repo's URL.`);
-  const store = storePath(root, remote);
   return withStoreLock(
-    store,
+    checkoutLock(root, key),
     async () => {
-      const clone = await ensureClone(root, remote, env);
+      const checkout = await ensureCheckout(root, remote, env);
+      const repo = checkout.path;
       const common = {
         path,
         remote: key,
         branch,
-        fetchFailed: clone.fetchFailed,
-        cloned: clone.created
+        fetchFailed: checkout.fetchFailed,
+        cloned: checkout.created,
+        checkout: repo
       };
-      if (existsSync(path)) {
+      if (existsSync2(path)) {
         return {
           ...common,
-          base: await remoteDefault(store, env).catch(() => "origin/HEAD"),
+          base: await remoteDefault(repo, env).catch(() => "origin/HEAD"),
           created: false,
+          copied: [],
           ...options.continueFrom ? { continued: true } : {}
         };
       }
-      mkdirSync2(dirname2(path), { recursive: true });
-      const own = await hasRef(env, store, `refs/heads/${branch}`);
+      mkdirSync3(dirname3(path), { recursive: true });
+      const own = await hasRef(env, repo, `refs/heads/${branch}`);
       const pushed = options.continueFrom ? `origin/${options.continueFrom}` : null;
-      if (pushed && await hasRef(env, store, `refs/remotes/${pushed}`)) {
+      let base;
+      let continued;
+      if (pushed && await hasRef(env, repo, `refs/remotes/${pushed}`)) {
         if (own) {
-          await git(env, store, "worktree", "add", "--quiet", path, branch);
+          await git(env, repo, "worktree", "add", "--quiet", path, branch);
           await git(env, path, "merge", "--quiet", "--ff-only", pushed).catch(() => "");
         } else {
+          await git(env, repo, "worktree", "add", "--quiet", "--track", "-b", branch, path, pushed);
+        }
+        base = pushed;
+        continued = true;
+      } else {
+        base = await remoteDefault(repo, env);
+        if (own) await git(env, repo, "worktree", "add", "--quiet", path, branch);
+        else
           await git(
             env,
-            store,
+            repo,
             "worktree",
             "add",
             "--quiet",
-            "--track",
+            "--no-track",
             "-b",
             branch,
             path,
-            pushed
+            base
           );
-        }
-        return { ...common, base: pushed, created: true, continued: true };
+        if (options.continueFrom) continued = false;
       }
-      const base = await remoteDefault(store, env);
-      if (own) await git(env, store, "worktree", "add", "--quiet", path, branch);
-      else
-        await git(env, store, "worktree", "add", "--quiet", "--no-track", "-b", branch, path, base);
+      const copied = await copyLocalFiles(repo, path, env);
       return {
         ...common,
         base,
         created: true,
-        ...options.continueFrom ? { continued: false } : {}
+        copied,
+        ...continued === void 0 ? {} : { continued }
       };
     },
     options.lock
   );
 }
-function clonedRepos(root) {
-  const found = [];
-  const walk = (dir, depth) => {
-    let entries;
-    try {
-      entries = readdirSync2(dir);
-    } catch {
-      return;
-    }
-    for (const name of entries.sort()) {
-      const path = join4(dir, name);
-      if (name.endsWith(".git")) {
-        try {
-          const remote = gitSync(path, "config", "--get", "remote.origin.url");
-          const key = repoKey(remote);
-          if (key) found.push({ key, remote, store: path });
-        } catch {
-        }
-      } else if (depth < 8 && !name.includes(".tmp-") && !name.endsWith(".lock")) {
-        try {
-          if (statSync3(path).isDirectory()) walk(path, depth + 1);
-        } catch {
-        }
-      }
-    }
-  };
-  walk(reposDir(root), 0);
-  return found;
-}
-function clonedStamp(root) {
-  const names = [];
-  const walk = (dir, depth) => {
-    let entries;
-    try {
-      entries = readdirSync2(dir);
-    } catch {
-      return;
-    }
-    for (const name of entries) {
-      if (name.endsWith(".git")) names.push(join4(dir, name));
-      else if (depth < 8 && !name.includes(".tmp-") && !name.endsWith(".lock")) {
-        walk(join4(dir, name), depth + 1);
-      }
-    }
-  };
-  walk(reposDir(root), 0);
-  return names.sort().join("\n");
-}
 function reposInFolder(folder) {
   let entries;
   try {
@@ -4082,8 +4149,8 @@ function reposInFolder(folder) {
   const found = [];
   for (const name of entries.sort()) {
     if (name.startsWith(".")) continue;
-    const path = join4(folder, name);
-    if (!existsSync(join4(path, ".git"))) continue;
+    const path = join5(folder, name);
+    if (!existsSync2(join5(path, ".git"))) continue;
     try {
       const remote = gitSync(path, "config", "--get", "remote.origin.url");
       const key = repoKey(remote);
@@ -4097,8 +4164,8 @@ function reposInFolder(folder) {
 }
 var validFolderName = (name) => /^[A-Za-z0-9_][A-Za-z0-9._-]{0,99}$/.test(name) && !name.endsWith(".git");
 function checkoutAt(path) {
-  if (!existsSync(path)) return { taken: false, key: null };
-  if (!existsSync(join4(path, ".git"))) return { taken: true, key: null };
+  if (!existsSync2(path)) return { taken: false, key: null };
+  if (!existsSync2(join5(path, ".git"))) return { taken: true, key: null };
   try {
     return {
       taken: true,
@@ -4115,7 +4182,7 @@ function folderFor(conversation, key, asked) {
   }
   const candidates2 = asked ? [asked] : [repoName(key), `${repoOwner(key)}-${repoName(key)}`].filter(validFolderName);
   for (const name of candidates2) {
-    const at = checkoutAt(join4(conversation, name));
+    const at = checkoutAt(join5(conversation, name));
     if (!at.taken) return { name, existing: false };
     if (at.key === key) return { name, existing: true };
   }
@@ -4138,9 +4205,9 @@ var configSchema = z18.object({
   /** The machine's root folder, holding herd's clones and its conversations' folders. */
   root: z18.string().optional()
 });
-var configPath = () => join5(herdHome(), "config.json");
+var configPath = () => join6(herdHome(), "config.json");
 function save(config) {
-  mkdirSync3(herdHome(), { recursive: true, mode: 448 });
+  mkdirSync4(herdHome(), { recursive: true, mode: 448 });
   writeFileSync3(configPath(), JSON.stringify(config, null, 2), { mode: 384 });
   return config;
 }
@@ -4151,7 +4218,7 @@ function loadConfig() {
     return save({ machineId: randomUUID(), machineName: hostname(), repos: [] });
   }
 }
-var defaultRoot = () => join5(homedir3(), "friday");
+var defaultRoot = () => join6(homedir3(), "friday");
 function readRoot() {
   try {
     return configSchema.parse(JSON.parse(readFileSync4(configPath(), "utf8"))).root ?? null;
@@ -4162,21 +4229,39 @@ function readRoot() {
 function setRoot(path) {
   return save({ ...loadConfig(), root: resolve(path) });
 }
-async function waitForRoot(root, {
-  pollMs = 2e3,
-  exists = existsSync2,
-  sleep: sleep8 = (ms) => new Promise((done) => setTimeout(done, ms)),
-  log = (line2) => console.log(line2)
-} = {}) {
-  const parent = dirname3(root);
-  if (exists(parent)) return;
-  log(
-    `Waiting for ${parent}, which holds this machine's root, to be there, as when its drive mounts.`
-  );
-  while (!exists(parent)) await sleep8(pollMs);
-  log(`${parent} is there.`);
-}
 var machineRoot = () => readRoot() ?? defaultRoot();
+var preferredConvos = () => join6(homedir3(), ".friday_convos");
+function workTreeOf(folder) {
+  let dir = resolve(folder);
+  while (!existsSync3(dir) && dirname4(dir) !== dir) dir = dirname4(dir);
+  try {
+    const top = execFileSync3("git", ["-C", dir, "rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return top || null;
+  } catch {
+    return null;
+  }
+}
+var convosChosen = /* @__PURE__ */ new Map();
+function convosPath(root = machineRoot()) {
+  if (process.env.HERD_CONVOS) return resolve(process.env.HERD_CONVOS);
+  const known = convosChosen.get(root);
+  if (known) return known;
+  const chosen = chooseConvos(root, preferredConvos(), workTreeOf);
+  convosChosen.set(root, chosen);
+  return chosen;
+}
+function convosHome(root = machineRoot()) {
+  const path = convosPath(root);
+  try {
+    return realpathSync2(path);
+  } catch {
+    return path;
+  }
+}
+var chooseConvos = (root, preferred, inWorkTree) => inWorkTree(preferred) ? join6(root, ".friday_convos") : preferred;
 function describeRepo(path) {
   const full = resolve(path);
   const git4 = (...args) => execFileSync3("git", ["-C", full, ...args], {
@@ -4241,7 +4326,8 @@ function registration(config, clis, facts = {}, cloned = []) {
     ...facts.tools ? { tools: facts.tools } : {},
     ...facts.config ? { config: facts.config } : {},
     ...facts.configError ? { configError: facts.configError.slice(0, 1e3) } : {},
-    ...facts.gh ? { gh: facts.gh } : {}
+    ...facts.gh ? { gh: facts.gh } : {},
+    ...facts.folderUnavailable ? { folderUnavailable: facts.folderUnavailable } : {}
   };
 }
 function describeCli(name, version) {
@@ -4332,15 +4418,15 @@ async function readSetup(fetch2, init) {
 // src/friday/agents.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname5, join as join7 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname6, join as join8 } from "node:path";
 
 // src/activation.ts
 init_define_HERD_PACKAGE();
 init_src();
 import { randomBytes as randomBytes4, randomUUID as randomUUID3 } from "node:crypto";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname4, join as join6 } from "node:path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname5, join as join7 } from "node:path";
 import { z as z21 } from "zod";
 
 // src/permissions.ts
@@ -4352,7 +4438,7 @@ import { z as z20 } from "zod";
 // src/local-socket.ts
 init_define_HERD_PACKAGE();
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { chmodSync as chmodSync2, existsSync as existsSync3, rmSync as rmSync4 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync4, rmSync as rmSync4 } from "node:fs";
 import { connect, createServer as createServer2 } from "node:net";
 import { z as z19 } from "zod";
 var localRequestSchema = z19.object({
@@ -4485,11 +4571,11 @@ var LocalSocket = class {
     }
   }
   async listen() {
-    if (existsSync3(this.path)) rmSync4(this.path);
+    if (existsSync4(this.path)) rmSync4(this.path);
     this.server = createServer2((socket) => this.serve(socket));
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve7, reject) => {
       this.server?.once("error", reject);
-      this.server?.listen(this.path, () => resolve6());
+      this.server?.listen(this.path, () => resolve7());
     });
     chmodSync2(this.path, 384);
   }
@@ -4501,7 +4587,7 @@ var LocalSocket = class {
   async close() {
     this.closing = true;
     for (const socket of this.open) socket.destroy();
-    await new Promise((resolve6) => this.server ? this.server.close(resolve6) : resolve6(null));
+    await new Promise((resolve7) => this.server ? this.server.close(resolve7) : resolve7(null));
     rmSync4(this.path, { force: true });
   }
   serve(socket) {
@@ -4548,7 +4634,7 @@ var LocalSocket = class {
   }
 };
 function askDaemon(path, request) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const socket = connect(path);
     let data = "";
     socket.on("connect", () => socket.write(`${JSON.stringify(request)}
@@ -4556,7 +4642,7 @@ function askDaemon(path, request) {
     socket.on("data", (chunk) => data += chunk);
     socket.on("end", () => {
       try {
-        resolve6(JSON.parse(data));
+        resolve7(JSON.parse(data));
       } catch {
         reject(new Error("The daemon's answer wasn't readable."));
       }
@@ -4566,14 +4652,14 @@ function askDaemon(path, request) {
   });
 }
 function isAnswering(path) {
-  return new Promise((resolve6) => {
-    if (!existsSync3(path)) return resolve6(false);
+  return new Promise((resolve7) => {
+    if (!existsSync4(path)) return resolve7(false);
     const socket = connect(path);
     socket.on("connect", () => {
       socket.destroy();
-      resolve6(true);
+      resolve7(true);
     });
-    socket.on("error", () => resolve6(false));
+    socket.on("error", () => resolve7(false));
   });
 }
 
@@ -4729,7 +4815,7 @@ async function permissionHook(raw, options = {}) {
     } catch {
       if (failingSince === null || Date.now() - started > 5e3) failingSince = Date.now();
       if (Date.now() - failingSince >= reconnectMs) return "";
-      await new Promise((resolve6) => setTimeout(resolve6, retryMs));
+      await new Promise((resolve7) => setTimeout(resolve7, retryMs));
     }
   }
 }
@@ -4746,14 +4832,14 @@ function newActivationCode() {
   return [...randomBytes4(8)].map((byte) => CODE_LETTERS[byte % CODE_LETTERS.length]).join("");
 }
 var activationTerminal = (agent) => `herd-activate-${agentShortName(agent)}`;
-var activationFolder = (root, agent) => join6(convosDir(root), ".activate", agentShortName(agent));
+var activationFolder = (root, agent) => join7(convosHome(root), ".activate", agentShortName(agent));
 var recordSchema = agentActivationSchema.extend({
   /** While it's waiting: the terminal it runs in, which `friday start` can attach to. */
   terminal: z21.string().optional()
 });
 var storeSchema = z21.object({ agents: z21.record(z21.string(), recordSchema) });
-var activationsPath = (home = herdHome()) => join6(home, "activations.json");
-var activationRequestPath = (home = herdHome()) => join6(home, "activate-request");
+var activationsPath = (home = herdHome()) => join7(home, "activations.json");
+var activationRequestPath = (home = herdHome()) => join7(home, "activate-request");
 function readActivations(path = activationsPath()) {
   try {
     return storeSchema.parse(JSON.parse(readFileSync5(path, "utf8"))).agents;
@@ -4762,7 +4848,7 @@ function readActivations(path = activationsPath()) {
   }
 }
 function requestActivation(home = herdHome(), now = Date.now()) {
-  mkdirSync4(home, { recursive: true, mode: 448 });
+  mkdirSync5(home, { recursive: true, mode: 448 });
   writeFileSync4(activationRequestPath(home), String(now), { mode: 384 });
 }
 function needsActivation(record, version) {
@@ -4779,7 +4865,7 @@ function activateDecision(request, code) {
     }
   };
 }
-var sleep = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 var label = (agent) => AGENTS[agent]?.label ?? agent;
 var Activator = class {
   constructor(options) {
@@ -4807,7 +4893,7 @@ var Activator = class {
   }
   record(agent, record) {
     const agents = { ...readActivations(this.path), [agent]: record };
-    mkdirSync4(dirname4(this.path), { recursive: true, mode: 448 });
+    mkdirSync5(dirname5(this.path), { recursive: true, mode: 448 });
     const temporary = `${this.path}.${process.pid}`;
     writeFileSync4(temporary, JSON.stringify({ agents }, null, 2), { mode: 384 });
     renameSync2(temporary, this.path);
@@ -4901,7 +4987,7 @@ var Activator = class {
     const terminal = activationTerminal(agent);
     const folder = activationFolder(this.options.root(), agent);
     rmSync5(folder, { recursive: true, force: true });
-    mkdirSync4(folder, { recursive: true });
+    mkdirSync5(folder, { recursive: true });
     const current = { agent, code, terminal, checkedIn: false, wake: () => {
     } };
     this.current = current;
@@ -4955,7 +5041,7 @@ var Activator = class {
         const until = Date.now() + (this.options.killWaitMs ?? KILL_WAIT_MS);
         while (await stillRunning()) {
           if (Date.now() >= until) return;
-          await new Promise((resolve6) => setTimeout(resolve6, Math.min(pollMs, 100)));
+          await new Promise((resolve7) => setTimeout(resolve7, Math.min(pollMs, 100)));
         }
       }
       const shell = process.env.SHELL ?? "/bin/sh";
@@ -5009,11 +5095,11 @@ var Activator = class {
         await start();
       }
       if (current.checkedIn) break;
-      await new Promise((resolve6) => {
-        const timer = setTimeout(resolve6, pollMs);
+      await new Promise((resolve7) => {
+        const timer = setTimeout(resolve7, pollMs);
         current.wake = () => {
           clearTimeout(timer);
-          resolve6();
+          resolve7();
         };
       });
     }
@@ -5087,8 +5173,8 @@ async function chooseAgents(options, print) {
   const asked = options.given ? null : await (options.pick?.(choices) ?? Promise.resolve(null));
   const shares = options.given ?? asked ?? // No terminal: what was chosen before, or what's installed.
   Object.fromEntries(choices.map((choice) => [choice.cli, choice.share]));
-  if (!sameChoice(saved, shares) || !existsSync4(options.configPath)) {
-    mkdirSync5(dirname5(options.configPath), { recursive: true, mode: 448 });
+  if (!sameChoice(saved, shares) || !existsSync5(options.configPath)) {
+    mkdirSync6(dirname6(options.configPath), { recursive: true, mode: 448 });
     writeFileSync5(options.configPath, configSource(withChoice(saved, shares)), { mode: 384 });
   }
   const chosen = ADAPTERS.map(({ cli }) => cli).filter((cli) => (shares[cli] ?? "off") !== "off");
@@ -5101,7 +5187,7 @@ function askToActivate(herdHome2, now = Date.now()) {
   requestActivation(herdHome2, now);
   return now;
 }
-var sleep2 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var sleep2 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 function settledLine(cli, activation) {
   if (activation.state === "activated") return `${label2(cli)} is activated.`;
   return `${label2(cli)} ${activationText(cli, activation).replace(" there", " on this computer")}.`;
@@ -5156,7 +5242,7 @@ async function awaitActivations(options, chosen, since, print) {
   }
   return settled;
 }
-var herdConfigIn = (herdHome2) => join7(herdHome2, "herd.config.ts");
+var herdConfigIn = (herdHome2) => join8(herdHome2, "herd.config.ts");
 
 // src/friday/home.ts
 init_define_HERD_PACKAGE();
@@ -5164,33 +5250,33 @@ init_src();
 import { spawnSync } from "node:child_process";
 import {
   closeSync as closeSync2,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync6,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync7,
   openSync as openSync2,
   readFileSync as readFileSync6,
   rmSync as rmSync6,
   statSync as statSync5,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname6, join as join8, resolve as resolve2 } from "node:path";
+import { dirname as dirname7, join as join9, resolve as resolve2 } from "node:path";
 var PACKAGE_NAME = FRIDAY_PACKAGE;
 function fridayPaths(herdHome2) {
-  const logs = join8(herdHome2, "logs");
+  const logs = join9(herdHome2, "logs");
   return {
     herdHome: herdHome2,
-    config: join8(herdHome2, "config.json"),
-    versions: join8(herdHome2, "versions"),
-    current: join8(herdHome2, "current"),
-    pin: join8(herdHome2, "pin"),
+    config: join9(herdHome2, "config.json"),
+    versions: join9(herdHome2, "versions"),
+    current: join9(herdHome2, "current"),
+    pin: join9(herdHome2, "pin"),
     logs,
-    daemonLog: join8(logs, "daemon.log"),
-    supervisorLog: join8(logs, "supervisor.log"),
-    updateLock: join8(herdHome2, "update.lock"),
-    status: join8(herdHome2, "supervisor.json"),
-    terminals: join8(herdHome2, "terminals")
+    daemonLog: join9(logs, "daemon.log"),
+    supervisorLog: join9(logs, "supervisor.log"),
+    updateLock: join9(herdHome2, "update.lock"),
+    status: join9(herdHome2, "supervisor.json"),
+    terminals: join9(herdHome2, "terminals")
   };
 }
-var packageDir = (versionDir) => join8(versionDir, "node_modules", ...PACKAGE_NAME.split("/"));
+var packageDir = (versionDir) => join9(versionDir, "node_modules", ...PACKAGE_NAME.split("/"));
 function alive2(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -5201,8 +5287,8 @@ function alive2(pid) {
   }
 }
 function takeLock(path, staleMs = 10 * 6e4) {
-  mkdirSync6(dirname6(path), { recursive: true });
-  if (existsSync5(path)) {
+  mkdirSync7(dirname7(path), { recursive: true });
+  if (existsSync6(path)) {
     const holder2 = Number(readFileSync6(path, "utf8").trim());
     const old = Date.now() - statSync5(path).mtimeMs > staleMs;
     if (old || !alive2(holder2)) rmSync6(path, { force: true });
@@ -5224,7 +5310,7 @@ function readStatus(paths) {
   }
 }
 function writeStatus(paths, status2) {
-  mkdirSync6(paths.herdHome, { recursive: true, mode: 448 });
+  mkdirSync7(paths.herdHome, { recursive: true, mode: 448 });
   writeFileSync6(paths.status, `${JSON.stringify(status2, null, 2)}
 `);
 }
@@ -5247,12 +5333,12 @@ function writeRoot(paths, root) {
   } catch {
     config = {};
   }
-  mkdirSync6(paths.herdHome, { recursive: true, mode: 448 });
+  mkdirSync7(paths.herdHome, { recursive: true, mode: 448 });
   writeFileSync6(paths.config, JSON.stringify({ ...config, root }, null, 2), { mode: 384 });
 }
 function insideWorkTree(folder) {
   let dir = resolve2(folder);
-  while (!existsSync5(dir) && dirname6(dir) !== dir) dir = dirname6(dir);
+  while (!existsSync6(dir) && dirname7(dir) !== dir) dir = dirname7(dir);
   const result = spawnSync("git", ["-C", dir, "rev-parse", "--show-toplevel"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"]
@@ -5316,7 +5402,7 @@ function pickInTerminal(choices, input = process.stdin, output2 = process.stdout
     for (const line2 of lines) output2.write(`\x1B[2K${line2}
 `);
   };
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const wasRaw = input.isRaw;
     input.setRawMode(true);
     input.resume();
@@ -5325,7 +5411,7 @@ function pickInTerminal(choices, input = process.stdin, output2 = process.stdout
       input.off("data", onData);
       input.setRawMode(wasRaw);
       input.pause();
-      resolve6(shares);
+      resolve7(shares);
     };
     const onData = (data) => {
       const next = pickerKey(state, data.toString("utf8"));
@@ -5340,25 +5426,27 @@ function pickInTerminal(choices, input = process.stdin, output2 = process.stdout
 
 // src/friday/service.ts
 init_define_HERD_PACKAGE();
-import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync6, mkdirSync as mkdirSync7, openSync as openSync3, readFileSync as readFileSync7, rmSync as rmSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { spawn as spawn3 } from "node:child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync8, openSync as openSync3, readFileSync as readFileSync7, rmSync as rmSync7, writeFileSync as writeFileSync7 } from "node:fs";
 import { userInfo } from "node:os";
-import { dirname as dirname7, join as join9 } from "node:path";
+import { dirname as dirname8, join as join10, win32 } from "node:path";
+var systemdBooted = () => existsSync7("/run/systemd/system");
 var LAUNCH_AGENT = "com.herdingchats.friday";
 var SYSTEMD_UNIT = "herdingchats-friday.service";
-async function detectService(run4, platform2 = process.platform, override = process.env.HERD_SERVICE) {
+async function detectService(run4, platform2 = process.platform, override = process.env.HERD_SERVICE, booted = systemdBooted) {
   if (override === "launchd" || override === "systemd" || override === "background")
     return override;
   if (platform2 === "darwin") return "launchd";
-  if (platform2 === "linux") {
+  if (platform2 === "linux" && booted()) {
     const probe = await run4("systemctl", ["--user", "show-environment"], { timeoutMs: 1e4 });
     if (probe.status === 0) return "systemd";
   }
   return "background";
 }
-function servicePath(node) {
+function servicePath(node, platform2 = process.platform, inherited = process.env.PATH ?? process.env.Path) {
+  if (platform2 === "win32") return [win32.dirname(node), inherited].filter(Boolean).join(";");
   return [
-    dirname7(node),
+    dirname8(node),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
@@ -5429,13 +5517,13 @@ WantedBy=default.target
 `;
 }
 function writeIfChanged(path, text4) {
-  if (existsSync6(path) && readFileSync7(path, "utf8") === text4) return false;
-  mkdirSync7(dirname7(path), { recursive: true });
+  if (existsSync7(path) && readFileSync7(path, "utf8") === text4) return false;
+  mkdirSync8(dirname8(path), { recursive: true });
   writeFileSync7(path, text4);
   return true;
 }
 function launchd(context2) {
-  const plist = join9(context2.home, "Library", "LaunchAgents", `${LAUNCH_AGENT}.plist`);
+  const plist = join10(context2.home, "Library", "LaunchAgents", `${LAUNCH_AGENT}.plist`);
   const domain = `gui/${userInfo().uid}`;
   const target = `${domain}/${LAUNCH_AGENT}`;
   const loaded = async () => (await context2.run("launchctl", ["print", target])).status === 0;
@@ -5461,7 +5549,7 @@ function launchd(context2) {
   };
 }
 function systemd(context2) {
-  const unit = join9(context2.home, ".config", "systemd", "user", SYSTEMD_UNIT);
+  const unit = join10(context2.home, ".config", "systemd", "user", SYSTEMD_UNIT);
   const systemctl = async (...args) => {
     const ran = await context2.run("systemctl", ["--user", ...args]);
     if (ran.status !== 0)
@@ -5485,15 +5573,26 @@ function systemd(context2) {
   };
 }
 function spawnInBackground(command, env, log) {
-  mkdirSync7(dirname7(log), { recursive: true });
+  mkdirSync8(dirname8(log), { recursive: true });
   const out = openSync3(log, "a");
   const [program = process.execPath, ...args] = command;
-  spawn2(program, args, {
+  spawn3(program, args, {
     detached: true,
+    // On Windows, a detached process otherwise opens a console window of its own.
+    windowsHide: true,
     stdio: ["ignore", out, out],
-    env: { ...process.env, ...env }
+    env: mergeEnv(process.env, env)
   }).unref();
 }
+function mergeEnv(base, extra) {
+  const replaced = new Set(Object.keys(extra).map((key) => key.toUpperCase()));
+  const merged = {};
+  for (const [key, value] of Object.entries(base)) {
+    if (value !== void 0 && !(key.toUpperCase() === "PATH" && replaced.has("PATH")))
+      merged[key] = value;
+  }
+  return { ...merged, ...extra };
+}
 function background(context2) {
   const launch = context2.spawnBackground ?? spawnInBackground;
   const supervisor = () => {
@@ -5529,25 +5628,25 @@ function serviceFor(kind, context2) {
 // src/friday/start.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { mkdirSync as mkdirSync9, realpathSync as realpathSync3 } from "node:fs";
-import { join as join12, resolve as resolve3 } from "node:path";
+import { mkdirSync as mkdirSync10, realpathSync as realpathSync4 } from "node:fs";
+import { join as join13, resolve as resolve3 } from "node:path";
 
 // src/friday/legacy.ts
 init_define_HERD_PACKAGE();
-import { existsSync as existsSync7, readdirSync as readdirSync3, rmSync as rmSync8 } from "node:fs";
+import { existsSync as existsSync8, readdirSync as readdirSync3, rmSync as rmSync8 } from "node:fs";
 import { userInfo as userInfo2 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 var OLD_LAUNCH_AGENT = "com.herdingchats.herd";
 var OLD_APPS = ["herd-daemon", "herd-updater"];
 function oldPm2s(paths) {
-  const dir = join10(paths.herdHome, "daemon");
-  if (!existsSync7(dir)) return [];
-  return readdirSync3(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join10(dir, entry.name, "node_modules", "pm2", "bin", "pm2")).filter((pm2) => existsSync7(pm2));
+  const dir = join11(paths.herdHome, "daemon");
+  if (!existsSync8(dir)) return [];
+  return readdirSync3(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join11(dir, entry.name, "node_modules", "pm2", "bin", "pm2")).filter((pm2) => existsSync8(pm2));
 }
 async function retireOldDaemon(paths, { home, run: run4 }) {
   const removed = [];
-  const plist = join10(home, "Library", "LaunchAgents", `${OLD_LAUNCH_AGENT}.plist`);
-  if (existsSync7(plist)) {
+  const plist = join11(home, "Library", "LaunchAgents", `${OLD_LAUNCH_AGENT}.plist`);
+  if (existsSync8(plist)) {
     await run4("launchctl", ["bootout", `gui/${userInfo2().uid}/${OLD_LAUNCH_AGENT}`]);
     rmSync8(plist, { force: true });
     removed.push(`the login item ${OLD_LAUNCH_AGENT}`);
@@ -5571,24 +5670,24 @@ async function retireOldDaemon(paths, { home, run: run4 }) {
 
 // src/friday/versions.ts
 init_define_HERD_PACKAGE();
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import {
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync8,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
   readFileSync as readFileSync8,
   readlinkSync,
-  realpathSync as realpathSync2,
+  realpathSync as realpathSync3,
   renameSync as renameSync3,
   rmSync as rmSync9,
   symlinkSync,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { basename as basename2, dirname as dirname8, join as join11 } from "node:path";
-var exec = (command, args, options = {}) => new Promise((resolve6) => {
+import { basename as basename2, dirname as dirname9, join as join12 } from "node:path";
+var exec = (command, args, options = {}) => new Promise((resolve7) => {
   let stdout = "";
   let stderr = "";
-  const child = spawn3(command, args, {
+  const child = spawn4(command, args, {
     cwd: options.cwd,
     env: options.env ?? process.env,
     stdio: ["ignore", "pipe", "pipe"]
@@ -5598,16 +5697,16 @@ var exec = (command, args, options = {}) => new Promise((resolve6) => {
   child.stderr.on("data", (data) => stderr += data);
   child.on("error", (error) => {
     if (timer) clearTimeout(timer);
-    resolve6({ status: 127, stdout, stderr: `${stderr}${error.message}` });
+    resolve7({ status: 127, stdout, stderr: `${stderr}${error.message}` });
   });
   child.on("close", (status2) => {
     if (timer) clearTimeout(timer);
-    resolve6({ status: status2 ?? 1, stdout, stderr });
+    resolve7({ status: status2 ?? 1, stdout, stderr });
   });
 });
 function npmCommand() {
-  const beside = join11(dirname8(process.execPath), "npm");
-  return existsSync8(beside) ? beside : "npm";
+  const beside = join12(dirname9(process.execPath), "npm");
+  return existsSync9(beside) ? beside : "npm";
 }
 function currentVersion(paths) {
   try {
@@ -5617,10 +5716,10 @@ function currentVersion(paths) {
   }
 }
 function installedVersions(paths) {
-  if (!existsSync8(paths.versions)) return [];
+  if (!existsSync9(paths.versions)) return [];
   return readdirSync4(paths.versions).filter((name) => VERSION.test(name)).sort(compareVersions);
 }
-var binOf = (versionDir, bin) => join11(packageDir(versionDir), `${bin}.mjs`);
+var binOf = (versionDir, bin) => join12(packageDir(versionDir), `${bin}.mjs`);
 async function versionRuns(versionDir, version, run4 = exec) {
   const ran = await run4(process.execPath, [binOf(versionDir, "herd"), "--version"], {
     timeoutMs: 3e4
@@ -5633,7 +5732,7 @@ async function versionRuns(versionDir, version, run4 = exec) {
 }
 function recordedIntegrity(dir) {
   try {
-    const lock = JSON.parse(readFileSync8(join11(dir, "package-lock.json"), "utf8"));
+    const lock = JSON.parse(readFileSync8(join12(dir, "package-lock.json"), "utf8"));
     return lock.packages?.[`node_modules/${PACKAGE_NAME}`]?.integrity ?? null;
   } catch {
     return null;
@@ -5647,8 +5746,8 @@ function npmFreeEnv() {
 async function installVersion(paths, version, { spec, integrity, run: run4 = exec, env = {}, log = () => {
 } } = {}) {
   if (!VERSION.test(version)) return { ok: false, reason: `${version} isn't a version.` };
-  const dir = join11(paths.versions, version);
-  if (existsSync8(dir)) {
+  const dir = join12(paths.versions, version);
+  if (existsSync9(dir)) {
     const installed2 = recordedIntegrity(dir);
     if (integrity && installed2 !== integrity)
       return { ok: false, reason: `the installed ${version} doesn't have the integrity named.` };
@@ -5657,12 +5756,12 @@ async function installVersion(paths, version, { spec, integrity, run: run4 = exe
     return { ok: false, reason: `the installed ${version} doesn't run: ${broken2}.` };
   }
   sweepStaging(paths);
-  const named = join11(paths.versions, `.staging-${version}-${process.pid}`);
+  const named = join12(paths.versions, `.staging-${version}-${process.pid}`);
   rmSync9(named, { recursive: true, force: true });
-  mkdirSync8(named, { recursive: true });
-  const staging = realpathSync2(named);
+  mkdirSync9(named, { recursive: true });
+  const staging = realpathSync3(named);
   writeFileSync8(
-    join11(staging, "package.json"),
+    join12(staging, "package.json"),
     `${JSON.stringify({ private: true, allowScripts: { "node-pty": true } }, null, 2)}
 `
   );
@@ -5697,21 +5796,21 @@ async function installVersion(paths, version, { spec, integrity, run: run4 = exe
   }
   const broken = await versionRuns(staging, version, run4);
   if (broken) return fail(broken);
-  renameSync3(staging, join11(realpathSync2(paths.versions), version));
+  renameSync3(staging, join12(realpathSync3(paths.versions), version));
   return { ok: true, dir };
 }
 function sweepStaging(paths) {
-  if (!existsSync8(paths.versions)) return;
+  if (!existsSync9(paths.versions)) return;
   for (const name of readdirSync4(paths.versions)) {
     const match = /^\.staging-.+-(\d+)$/.exec(name);
     if (match && !alive2(Number(match[1])))
-      rmSync9(join11(paths.versions, name), { recursive: true, force: true });
+      rmSync9(join12(paths.versions, name), { recursive: true, force: true });
   }
 }
 function activate(paths, version) {
   const next = `${paths.current}.next-${process.pid}`;
   rmSync9(next, { force: true });
-  symlinkSync(join11("versions", version), next);
+  symlinkSync(join12("versions", version), next);
   renameSync3(next, paths.current);
 }
 function pruneVersions(paths, { inUse = [], keep = 3 } = {}) {
@@ -5726,7 +5825,7 @@ function pruneVersions(paths, { inUse = [], keep = 3 } = {}) {
   const removed = [];
   for (const version of versions) {
     if (kept.has(version)) continue;
-    rmSync9(join11(paths.versions, version), { recursive: true, force: true });
+    rmSync9(join12(paths.versions, version), { recursive: true, force: true });
     removed.push(version);
   }
   return removed;
@@ -5736,7 +5835,7 @@ async function hostVersions(paths, run4 = exec) {
   if (ran.status !== 0) return installedVersions(paths);
   const roots = /* @__PURE__ */ new Set([paths.versions]);
   try {
-    roots.add(realpathSync2(paths.versions));
+    roots.add(realpathSync3(paths.versions));
   } catch {
   }
   const found = /* @__PURE__ */ new Set();
@@ -5774,13 +5873,13 @@ async function missingBuildTools(run4) {
 }
 var real = (path) => {
   try {
-    return realpathSync3(path);
+    return realpathSync4(path);
   } catch {
     return resolve3(path);
   }
 };
 function chooseRoot(cwd, home) {
-  return real(cwd) === real(home) ? join12(home, "friday") : resolve3(cwd);
+  return real(cwd) === real(home) ? join13(home, "friday") : resolve3(cwd);
 }
 async function runStart(options) {
   const { paths, run: run4 } = options;
@@ -5790,7 +5889,7 @@ async function runStart(options) {
   const wanted = chooseRoot(options.cwd, options.home);
   const running = runningSupervisor(paths);
   if (existing && real(existing) !== real(wanted)) {
-    print(`This machine's root is ${existing}, where Friday keeps its repos and conversations.`);
+    print(`This machine's root is ${existing}, which holds the repos Friday works on.`);
     if (running) {
       print(`Friday is running there, version ${running.version}, so nothing changed.`);
       await waitForAgents(options, await chooseAndAsk(options, print), print);
@@ -5808,7 +5907,7 @@ async function runStart(options) {
   const repo = insideWorkTree(root);
   if (repo) {
     throw new StartError(
-      `${root} is inside the git repo ${repo}, so it can't be the machine's root: every conversation would load that repo's settings. Run ${START_COMMAND} in an empty folder outside any repo, such as ~/friday.`
+      `${root} is inside the git repo ${repo}, so it can't be the machine's root: every conversation would load that repo's settings. Run ${START_COMMAND} in a folder outside any repo, such as the one that holds your checkouts, like ~/code.`
     );
   }
   if ((options.platform ?? process.platform) === "linux") {
@@ -5830,7 +5929,7 @@ async function runStart(options) {
       `Stopped the old daemon: removed ${retired.join(" and ")}. Its checkout is left as it was.`
     );
   await ensureInstalled(options, print);
-  mkdirSync9(root, { recursive: true });
+  mkdirSync10(root, { recursive: true });
   writeRoot(paths, root);
   const command = [process.execPath, binOf(paths.current, "friday"), "supervise"];
   const env = { HERD_HOME: paths.herdHome, ...options.env };
@@ -5908,14 +6007,14 @@ async function ensureInstalled(options, print) {
 // src/friday/supervisor.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import {
   closeSync as closeSync3,
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync10,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync11,
   openSync as openSync4,
   readFileSync as readFileSync9,
-  realpathSync as realpathSync4,
+  realpathSync as realpathSync5,
   renameSync as renameSync4,
   statSync as statSync6
 } from "node:fs";
@@ -5985,7 +6084,7 @@ var Supervisor = class {
     if (this.options.daemonCommand) return this.options.daemonCommand();
     let dir;
     try {
-      dir = realpathSync4(this.options.paths.current);
+      dir = realpathSync5(this.options.paths.current);
     } catch {
       throw new Error(`Nothing is installed in ~/.herd/current. Run ${START_COMMAND}.`);
     }
@@ -5994,16 +6093,16 @@ var Supervisor = class {
   spawnDaemon() {
     if (this.stopping) return;
     const { daemonLog, logs } = this.options.paths;
-    mkdirSync10(logs, { recursive: true });
+    mkdirSync11(logs, { recursive: true });
     try {
-      if (existsSync9(daemonLog) && statSync6(daemonLog).size > MAX_LOG_BYTES2)
+      if (existsSync10(daemonLog) && statSync6(daemonLog).size > MAX_LOG_BYTES2)
         renameSync4(daemonLog, `${daemonLog}.1`);
     } catch {
     }
     const out = openSync4(daemonLog, "a");
     const [program = process.execPath, ...args] = this.daemonCommand();
     const startedAt = Date.now();
-    const child = spawn4(program, args, { stdio: ["ignore", out, out], env: process.env });
+    const child = spawn5(program, args, { stdio: ["ignore", out, out], env: process.env });
     closeSync3(out);
     this.daemon = child;
     this.status.daemonPid = child.pid ?? null;
@@ -6027,7 +6126,7 @@ var Supervisor = class {
   async stopDaemon() {
     const child = this.daemon;
     if (!child || child.exitCode !== null || child.signalCode !== null) return;
-    const exited = new Promise((resolve6) => child.once("exit", () => resolve6()));
+    const exited = new Promise((resolve7) => child.once("exit", () => resolve7()));
     child.kill("SIGTERM");
     const timer = setTimeout(() => child.kill("SIGKILL"), this.options.stopMs ?? 15e3);
     await exited;
@@ -6134,8 +6233,8 @@ var HELP = `friday: run HerdingChats' agent daemon on this computer.
 
 Usage: ${FRIDAY_COMMAND} <command>
 
-  start       Make this computer a machine, with the folder this runs in as its root, where
-              Friday keeps its repos and conversations. Signs in through your browser when
+  start       Make this computer a machine, with the folder this runs in as its root, which
+              holds your repos, such as ~/code. Signs in through your browser when
               needed, asks how much of each agent you have, starts the daemon now and whenever
               you log in, waits for each agent to check in, then shows what's left to set up.
               Safe to run again. --agents claude=lot,codex=little sets the shares without
@@ -6149,7 +6248,7 @@ Agents use the herd command, which comes with this one. herd setup shows what's
 function defaults() {
   const home = homedir4();
   return {
-    paths: fridayPaths(process.env.HERD_HOME ?? join13(home, ".herd")),
+    paths: fridayPaths(process.env.HERD_HOME ?? join14(home, ".herd")),
     home,
     cwd: process.cwd(),
     run: exec,
@@ -6259,12 +6358,12 @@ function agentsFlag(args) {
   return parsed.shares;
 }
 function attachTo(paths, terminal) {
-  const herd = existsSync10(binOf(paths.current, "herd")) ? binOf(paths.current, "herd") : join13(dirname9(process.argv[1] ?? ""), "herd.mjs");
-  const child = spawn5(process.execPath, [herd, "attach", terminal], {
+  const herd = existsSync11(binOf(paths.current, "herd")) ? binOf(paths.current, "herd") : join14(dirname10(process.argv[1] ?? ""), "herd.mjs");
+  const child = spawn6(process.execPath, [herd, "attach", terminal], {
     stdio: "inherit",
     env: { ...process.env, HERD_HOME: paths.herdHome }
   });
-  return new Promise((resolve6) => child.on("close", () => resolve6()));
+  return new Promise((resolve7) => child.on("close", () => resolve7()));
 }
 async function runStop(deps) {
   const status2 = readStatus(deps.paths);
@@ -6309,13 +6408,28 @@ function runStatus(deps) {
   );
   if (version) print(`Installed: ${version}${pin ? `, pinned to ${pin} in ${paths.pin}` : ""}.`);
   if (root) print(`Root: ${root}`);
+  const missing = readMissingFolder(paths.herdHome);
+  if (running && missing) {
+    print(
+      `Taking no work or builds: ${missing.target ? `${missing.path} links to ${missing.target}, which isn't there` : `${missing.path} isn't there`}. It takes work again once it is.`
+    );
+  }
   if (running && status2.checkedAt) print(`Last asked for a release ${ago(status2.checkedAt)}.`);
   if (status2?.problem) print(`Last problem: ${status2.problem}`);
   print(`Logs: ${paths.logs}`);
   return running ? 0 : 1;
 }
+function readMissingFolder(herdHome2) {
+  try {
+    return folderUnavailableSchema.parse(
+      JSON.parse(readFileSync10(join14(herdHome2, "folder-unavailable.json"), "utf8"))
+    );
+  } catch {
+    return null;
+  }
+}
 function tail(path, count) {
-  if (!existsSync10(path)) return [];
+  if (!existsSync11(path)) return [];
   const lines = readFileSync10(path, "utf8").split("\n");
   if (lines.at(-1) === "") lines.pop();
   return lines.slice(-count);
@@ -6323,14 +6437,14 @@ function tail(path, count) {
 async function runLogs(args, deps) {
   const { paths, print } = deps;
   const follow = args.includes("-f") || args.includes("--follow");
-  const files = [paths.supervisorLog, paths.daemonLog].filter((file) => existsSync10(file));
+  const files = [paths.supervisorLog, paths.daemonLog].filter((file) => existsSync11(file));
   if (files.length === 0) {
     print(`There are no logs in ${paths.logs} yet.`);
     return 0;
   }
   if (follow) {
-    const child = spawn5("tail", ["-n", "50", "-F", ...files], { stdio: "inherit" });
-    return await new Promise((resolve6) => child.on("close", (code) => resolve6(code ?? 0)));
+    const child = spawn6("tail", ["-n", "50", "-F", ...files], { stdio: "inherit" });
+    return await new Promise((resolve7) => child.on("close", (code) => resolve7(code ?? 0)));
   }
   for (const file of files) {
     print(`==> ${file} <==`);
@@ -6371,9 +6485,9 @@ init_define_HERD_PACKAGE();
 
 // src/build-sandbox.ts
 init_define_HERD_PACKAGE();
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { appendFileSync, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname10, join as join14 } from "node:path";
+import { dirname as dirname11, join as join15 } from "node:path";
 var DEPLOY_HOSTS = ["api.cloudflare.com", "api.github.com", "registry.npmjs.org"];
 function buildPolicy(input) {
   const platform2 = input.platform ?? process.platform;
@@ -6389,7 +6503,7 @@ function buildPolicy(input) {
       ...platform2 === "darwin" ? { allowUnixSockets: [input.home] } : { allowAllUnixSockets: true }
     },
     filesystem: {
-      denyRead: [.../* @__PURE__ */ new Set([input.ownerHome, input.root])],
+      denyRead: [.../* @__PURE__ */ new Set([input.ownerHome, input.root, input.convos])],
       allowRead: [input.worktree, input.store, input.nodePrefix, input.home],
       allowWrite: [input.worktree, input.worktreeGitDir, input.home],
       denyWrite: []
@@ -6403,7 +6517,7 @@ function describePolicy(policy, platform2 = process.platform) {
   const hosts = policy.network.allowedDomains.join(", ");
   return `Sandboxed with ${kind}: the owner's home is unreadable, writes go only to the worktree and the build's home, and the only hosts it reaches are ${hosts}.`;
 }
-var nodePrefix = (execPath = process.execPath) => dirname10(dirname10(execPath));
+var nodePrefix = (execPath = process.execPath) => dirname11(dirname11(execPath));
 var shellQuote = (args) => args.map((arg) => `'${arg.replace(/'/g, "'\\''")}'`).join(" ");
 var BLOCKED_LOG = "blocked.log";
 async function runSandboxed(args) {
@@ -6420,7 +6534,7 @@ async function runSandboxed(args) {
     return 3;
   }
   await SandboxManager.initialize(policy, void 0, true);
-  const blocked = join14(process.env.HOME ?? ".", BLOCKED_LOG);
+  const blocked = join15(process.env.HOME ?? ".", BLOCKED_LOG);
   let written = 0;
   const unsubscribe = SandboxManager.getSandboxViolationStore().subscribe((violations) => {
     const fresh = violations.slice(written).map((violation) => describeRefusal(violation.line)).filter((line2) => line2 !== null);
@@ -6433,13 +6547,13 @@ async function runSandboxed(args) {
     }
   });
   const wrapped = await SandboxManager.wrapWithSandbox(shellQuote(command));
-  const child = spawn6(wrapped, { shell: true, stdio: "inherit" });
+  const child = spawn7(wrapped, { shell: true, stdio: "inherit" });
   const forward = (signal2) => () => child.kill(signal2);
   process.once("SIGTERM", forward("SIGTERM"));
   process.once("SIGINT", forward("SIGINT"));
-  const status2 = await new Promise((resolve6) => {
-    child.on("error", () => resolve6(1));
-    child.on("exit", (code, signal2) => resolve6(code ?? (signal2 ? 1 : 0)));
+  const status2 = await new Promise((resolve7) => {
+    child.on("error", () => resolve7(1));
+    child.on("exit", (code, signal2) => resolve7(code ?? (signal2 ? 1 : 0)));
   });
   unsubscribe();
   SandboxManager.cleanupAfterCommand();
@@ -6470,7 +6584,7 @@ async function fromTerminal(request) {
     reply = await askDaemon(socket, { secret, ...request }).catch(() => null);
     if (reply) break;
     if (Date.now() > deadline) throw new HerdError("Couldn't reach herd's daemon. Is it running?");
-    await new Promise((resolve6) => setTimeout(resolve6, 500));
+    await new Promise((resolve7) => setTimeout(resolve7, 500));
   }
   if (!reply.ok) throw new HerdError(reply.error);
   return reply;
@@ -6897,8 +7011,8 @@ init_define_HERD_PACKAGE();
 // src/build-runner-key.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { chmodSync as chmodSync3, existsSync as existsSync11, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join15 } from "node:path";
+import { chmodSync as chmodSync3, existsSync as existsSync12, mkdirSync as mkdirSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join16 } from "node:path";
 import { z as z24 } from "zod";
 var BUILDS_URL = "https://builds.herdingchats.com";
 var runnerKeySchema = z24.object({
@@ -6906,10 +7020,10 @@ var runnerKeySchema = z24.object({
   key: z24.string().min(20),
   url: z24.string().url()
 });
-var runnerKeyPath = () => join15(herdHome(), "build-runner.json");
+var runnerKeyPath = () => join16(herdHome(), "build-runner.json");
 function readRunnerKey() {
   const path = runnerKeyPath();
-  if (!existsSync11(path)) return null;
+  if (!existsSync12(path)) return null;
   try {
     return runnerKeySchema.parse(JSON.parse(readFileSync13(path, "utf8")));
   } catch {
@@ -6919,7 +7033,7 @@ function readRunnerKey() {
   }
 }
 function saveRunnerKey(key) {
-  mkdirSync11(herdHome(), { recursive: true, mode: 448 });
+  mkdirSync12(herdHome(), { recursive: true, mode: 448 });
   const path = runnerKeyPath();
   writeFileSync9(path, JSON.stringify(runnerKeySchema.parse(key), null, 2), { mode: 384 });
   chmodSync3(path, 384);
@@ -6934,7 +7048,7 @@ async function registerRunner({
   url = buildsUrl(),
   fetchImpl = fetch,
   say = (line2) => console.log(line2),
-  sleep: sleep8 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms)),
+  sleep: sleep8 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms)),
   pollMs = 2e3,
   waitMs = 15 * 60 * 1e3
 }) {
@@ -6973,8 +7087,8 @@ async function registerRunner({
 
 // src/builds-admin.ts
 init_define_HERD_PACKAGE();
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync14, rmSync as rmSync10, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join16 } from "node:path";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync14, rmSync as rmSync10, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join17 } from "node:path";
 var NOT_ADMIN = "builds are only for the admin's machines";
 async function isAdmin(fetch2) {
   const response = await fetch2("/api/people/me").catch(() => null);
@@ -6982,13 +7096,13 @@ async function isAdmin(fetch2) {
   const body = await response.json().catch(() => ({}));
   return body.admin === true;
 }
-var refusalPath = () => join16(herdHome(), "builds", "refused.json");
+var refusalPath = () => join17(herdHome(), "builds", "refused.json");
 function writeBuildsRefusal(reason) {
   if (!reason) {
     rmSync10(refusalPath(), { force: true });
     return;
   }
-  mkdirSync12(join16(herdHome(), "builds"), { recursive: true });
+  mkdirSync13(join17(herdHome(), "builds"), { recursive: true });
   writeFileSync10(refusalPath(), JSON.stringify({ reason }));
 }
 function readBuildsRefusal() {
@@ -7134,7 +7248,7 @@ async function runConversations(rest) {
 init_define_HERD_PACKAGE();
 init_src();
 import { availableParallelism, totalmem } from "node:os";
-import { join as join31 } from "node:path";
+import { join as join33 } from "node:path";
 
 // src/agent.ts
 init_define_HERD_PACKAGE();
@@ -7243,17 +7357,34 @@ function readClaudeScreen(raw) {
 
 // src/worktrees.ts
 init_define_HERD_PACKAGE();
-import { isAbsolute as isAbsolute2, join as join17, relative } from "node:path";
-var worktreesRoot = () => join17(herdHome(), "worktrees");
+import { existsSync as existsSync13, realpathSync as realpathSync6 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join18, relative } from "node:path";
+var worktreesRoot = () => join18(herdHome(), "worktrees");
 var WORD_ID = /^[a-z]+-[a-z]+-[a-z]+$/;
 var conversationPrefix = (conversationId) => WORD_ID.test(conversationId) ? conversationId : conversationId.replace(/[^A-Za-z0-9]/g, "").slice(0, 12).toLowerCase();
 var conversationBranch = (conversationId) => `herd/${conversationPrefix(conversationId)}`;
-var conversationFolder = (root, conversationId) => join17(convosDir(root), conversationPrefix(conversationId));
+var conversationFolder = (convos, conversationId) => join18(convos, conversationPrefix(conversationId));
+function folderForConversation(root, conversationId) {
+  const earlier = conversationFolder(legacyConvosDir(root), conversationId);
+  return existsSync13(earlier) ? earlier : conversationFolder(convosHome(root), conversationId);
+}
 var within = (dir, path) => {
   const between = relative(dir, path);
   return between !== "" && !between.startsWith("..") && !isAbsolute2(between);
 };
-var isHerdFolder = (path, root = machineRoot()) => within(convosDir(root), path) || within(worktreesRoot(), path);
+var real2 = (path) => {
+  try {
+    return realpathSync6(path);
+  } catch {
+    return path;
+  }
+};
+function isHerdFolder(path, root = machineRoot()) {
+  const at = real2(path);
+  return [convosPath(root), convosHome(root), legacyConvosDir(root), worktreesRoot()].some(
+    (dir) => within(dir, path) || within(real2(dir), at)
+  );
+}
 
 // src/agent.ts
 var FOLDER_PARAGRAPH = "This folder is this conversation's own, and holds only the repos added to it: `herd repo <url or owner/name>` checks a repo out here, on a branch named for this conversation, and `herd repos` lists the repos here and the ones to choose from, with what your owner says each is. Work in each repo's folder, and follow each repo's own AGENTS.md or README to set it up. ";
@@ -7274,7 +7405,7 @@ var ownPrompt = (draft) => OWN_PROMPTS.find(
 var SESSION_ID = /^[A-Za-z0-9-]{1,100}$/;
 var SUBMIT_RETRIES = 3;
 var DEFAULT_TIMING = { settleMs: 800, pollMs: 150, startMs: 6e4, confirmMs: 3e3 };
-var sleep3 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var sleep3 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 var EXIT_WAIT_MS = 5e3;
 var AgentDriver = class {
   constructor(terminals, timing = {}) {
@@ -7421,12 +7552,12 @@ var AgentDriver = class {
     if (before.draft && !leftover) return { status: "draft", draft: before.draft };
     const sent = leftover ?? text4;
     let taken = false;
-    const hooked = new Promise((resolve6) => {
+    const hooked = new Promise((resolve7) => {
       this.waiters.set(name, {
         text: sent,
         taken: () => {
           taken = true;
-          resolve6();
+          resolve7();
         }
       });
     });
@@ -7533,9 +7664,9 @@ function readAgyScreen(raw) {
 
 // src/agy-settings.ts
 init_define_HERD_PACKAGE();
-import { lstatSync, mkdirSync as mkdirSync13, realpathSync as realpathSync5, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join18, sep } from "node:path";
-var AGY_SETTINGS_FILE = join18(".herd", "agy-settings.json");
+import { lstatSync as lstatSync2, mkdirSync as mkdirSync14, realpathSync as realpathSync7, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join19, sep } from "node:path";
+var AGY_SETTINGS_FILE = join19(".herd", "agy-settings.json");
 var AGY_HOOK_EVENTS = ["SessionStart", "PreInvocation", "Stop"];
 var agyHookCommand = (event2, herd) => `${herd} hook agy ${event2} || true`;
 function agyHooks(herd) {
@@ -7552,25 +7683,25 @@ function agySettings(herd) {
   return { statusLine: { type: "command", command: `${herd} statusline agy` } };
 }
 function ownFolder(worktree, name) {
-  const folder = join18(worktree, name);
-  if (lstatSync(folder, { throwIfNoEntry: false })?.isSymbolicLink()) {
+  const folder = join19(worktree, name);
+  if (lstatSync2(folder, { throwIfNoEntry: false })?.isSymbolicLink()) {
     throw new Error(`${name} in the worktree is a link`);
   }
-  mkdirSync13(folder, { recursive: true });
-  if (!realpathSync5(folder).startsWith(realpathSync5(worktree) + sep)) {
+  mkdirSync14(folder, { recursive: true });
+  if (!realpathSync7(folder).startsWith(realpathSync7(worktree) + sep)) {
     throw new Error(`${name} leads outside the worktree`);
   }
   return folder;
 }
 function writeAgyFiles(worktree, herd) {
   const agents = ownFolder(worktree, ".agents");
-  writeFileSync11(join18(agents, "hooks.json"), `${JSON.stringify(agyHooks(herd), null, 2)}
+  writeFileSync11(join19(agents, "hooks.json"), `${JSON.stringify(agyHooks(herd), null, 2)}
 `);
-  writeFileSync11(join18(agents, ".gitignore"), "*\n");
+  writeFileSync11(join19(agents, ".gitignore"), "*\n");
   const herdFolder = ownFolder(worktree, ".herd");
-  writeFileSync11(join18(herdFolder, ".gitignore"), "*\n");
+  writeFileSync11(join19(herdFolder, ".gitignore"), "*\n");
   writeFileSync11(
-    join18(worktree, AGY_SETTINGS_FILE),
+    join19(worktree, AGY_SETTINGS_FILE),
     `${JSON.stringify(agySettings(herd), null, 2)}
 `
   );
@@ -7579,7 +7710,7 @@ function writeAgyFiles(worktree, herd) {
 // src/agy-driver.ts
 var AGY_FLAGS = `--dangerously-skip-permissions --settings ${AGY_SETTINGS_FILE}`;
 var DEFAULT_TIMING2 = { settleMs: 800, pollMs: 150, startMs: 6e4, confirmMs: 3e3 };
-var sleep4 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var sleep4 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 var EXIT_WAIT_MS2 = 5e3;
 var AgyDriver = class {
   constructor(terminals, timing = {}) {
@@ -7669,12 +7800,12 @@ var AgyDriver = class {
     if (before.draft && !leftover) return { status: "draft", draft: before.draft };
     const sent = leftover ?? text4;
     let taken = false;
-    const reported = new Promise((resolve6) => {
+    const reported = new Promise((resolve7) => {
       this.waiters.set(name, {
         text: sent,
         taken: () => {
           taken = true;
-          resolve6();
+          resolve7();
         }
       });
     });
@@ -7722,6 +7853,78 @@ var AgyDriver = class {
   }
 };
 
+// src/bare-clones.ts
+init_define_HERD_PACKAGE();
+import { randomBytes as randomBytes5 } from "node:crypto";
+import { existsSync as existsSync14, mkdirSync as mkdirSync15, readdirSync as readdirSync5, renameSync as renameSync5, rmSync as rmSync11, statSync as statSync7 } from "node:fs";
+import { dirname as dirname12, join as join20 } from "node:path";
+function bareClonePath(dir, remote) {
+  const key = repoKey(remote);
+  if (!key) throw new StoreError(`${remote} isn't a repo's URL.`);
+  return join20(dir, `${key}.git`);
+}
+async function ensureBareClone(store, remote, env) {
+  if (existsSync14(store)) {
+    let fetchFailed = null;
+    try {
+      await git(env, store, "fetch", "--quiet", "--prune", "origin");
+      await git(env, store, "remote", "set-head", "origin", "--auto").catch(() => "");
+    } catch (error) {
+      fetchFailed = error instanceof Error ? error.message : String(error);
+    }
+    return { store, created: false, fetchFailed };
+  }
+  const building = `${store}.tmp-${process.pid}-${randomBytes5(4).toString("hex")}`;
+  mkdirSync15(dirname12(store), { recursive: true });
+  try {
+    await git(env, dirname12(store), "init", "--quiet", "--bare", building);
+    await git(env, building, "remote", "add", "origin", remote);
+    await git(
+      env,
+      building,
+      "config",
+      "remote.origin.fetch",
+      "+refs/heads/*:refs/remotes/origin/*"
+    );
+    await git(env, building, "fetch", "--quiet", "origin");
+    await git(env, building, "remote", "set-head", "origin", "--auto").catch(() => "");
+    renameSync5(building, store);
+  } catch (error) {
+    rmSync11(building, { recursive: true, force: true });
+    throw error instanceof StoreError ? error : new StoreError(gitError(error));
+  }
+  return { store, created: true, fetchFailed: null };
+}
+function bareClones(dir) {
+  const found = [];
+  const walk = (at, depth) => {
+    let entries;
+    try {
+      entries = readdirSync5(at);
+    } catch {
+      return;
+    }
+    for (const name of entries.sort()) {
+      const path = join20(at, name);
+      if (name.endsWith(".git")) {
+        try {
+          const remote = gitSync(path, "config", "--get", "remote.origin.url");
+          const key = repoKey(remote);
+          if (key) found.push({ key, remote, store: path });
+        } catch {
+        }
+      } else if (depth < 8 && !name.includes(".tmp-") && !name.endsWith(".lock")) {
+        try {
+          if (statSync7(path).isDirectory()) walk(path, depth + 1);
+        } catch {
+        }
+      }
+    }
+  };
+  walk(dir, 0);
+  return found;
+}
+
 // src/build-connection.ts
 init_define_HERD_PACKAGE();
 init_src();
@@ -7880,28 +8083,28 @@ var BuildConnection = class {
 
 // src/builds.ts
 init_define_HERD_PACKAGE();
-import { execFile as execFile2, execFileSync as execFileSync4, spawn as spawn7 } from "node:child_process";
+import { execFile as execFile2, execFileSync as execFileSync4, spawn as spawn8 } from "node:child_process";
 import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
 import {
-  existsSync as existsSync12,
-  mkdirSync as mkdirSync15,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync17,
   mkdtempSync,
-  readdirSync as readdirSync6,
+  readdirSync as readdirSync7,
   readFileSync as readFileSync16,
-  realpathSync as realpathSync6,
-  rmSync as rmSync12,
+  realpathSync as realpathSync8,
+  rmSync as rmSync13,
   writeFileSync as writeFileSync13
 } from "node:fs";
 import { homedir as homedir6, tmpdir } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join22 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // src/check-registry.ts
 init_define_HERD_PACKAGE();
-import { mkdirSync as mkdirSync14, readdirSync as readdirSync5, readFileSync as readFileSync15, rmSync as rmSync11, writeFileSync as writeFileSync12 } from "node:fs";
+import { mkdirSync as mkdirSync16, readdirSync as readdirSync6, readFileSync as readFileSync15, rmSync as rmSync12, writeFileSync as writeFileSync12 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join19 } from "node:path";
-var checkRegistryDir = () => process.env.HERDINGCHATS_CHECK_RUNNING ?? join19(homedir5(), ".cache", "herdingchats", "check", "running");
+import { join as join21 } from "node:path";
+var checkRegistryDir = () => process.env.HERDINGCHATS_CHECK_RUNNING ?? join21(homedir5(), ".cache", "herdingchats", "check", "running");
 var RESERVED_MB = 6 * 1024;
 var MIN_MEMORY_MB = 1024;
 var alive3 = (pid) => {
@@ -7913,15 +8116,15 @@ var alive3 = (pid) => {
   }
 };
 function registerCheck(dir, pid, startedAt = Date.now()) {
-  mkdirSync14(dir, { recursive: true });
-  const file = join19(dir, `${pid}.json`);
+  mkdirSync16(dir, { recursive: true });
+  const file = join21(dir, `${pid}.json`);
   writeFileSync12(file, JSON.stringify({ pid, startedAt }));
-  return () => rmSync11(file, { force: true });
+  return () => rmSync12(file, { force: true });
 }
 function runningChecks(dir, isAlive = alive3) {
   let names = [];
   try {
-    names = readdirSync5(dir).filter((name) => /^\d+\.json$/.test(name));
+    names = readdirSync6(dir).filter((name) => /^\d+\.json$/.test(name));
   } catch {
     return 0;
   }
@@ -7930,12 +8133,12 @@ function runningChecks(dir, isAlive = alive3) {
     const pid = Number(name.slice(0, -".json".length));
     let entry = null;
     try {
-      entry = JSON.parse(readFileSync15(join19(dir, name), "utf8"));
+      entry = JSON.parse(readFileSync15(join21(dir, name), "utf8"));
     } catch {
       continue;
     }
     if (entry?.pid === pid && isAlive(pid)) count += 1;
-    else rmSync11(join19(dir, name), { force: true });
+    else rmSync12(join21(dir, name), { force: true });
   }
   return count;
 }
@@ -7943,9 +8146,9 @@ var memoryShareOf = (totalMb, running) => Math.max(MIN_MEMORY_MB, Math.floor((to
 
 // src/builds.ts
 init_self();
-var sandboxStatusPath = () => join20(herdHome(), "builds", "sandbox.json");
+var sandboxStatusPath = () => join22(herdHome(), "builds", "sandbox.json");
 function writeSandboxStatus(status2, now = Date.now()) {
-  mkdirSync15(join20(herdHome(), "builds"), { recursive: true });
+  mkdirSync17(join22(herdHome(), "builds"), { recursive: true });
   writeFileSync13(sandboxStatusPath(), JSON.stringify({ ...status2, at: now }));
 }
 function readSandboxStatus() {
@@ -7969,17 +8172,17 @@ async function storeGit(env, store, ...args) {
     throw new StoreError(gitError(error));
   }
 }
-var real2 = (path) => {
+var real3 = (path) => {
   try {
-    return realpathSync6(path);
+    return realpathSync8(path);
   } catch {
     return path;
   }
 };
 function worktreeOf(dir, store) {
-  if (!existsSync12(join20(dir, ".git"))) return false;
+  if (!existsSync15(join22(dir, ".git"))) return false;
   try {
-    return real2(git2(dir, "rev-parse", "--path-format=absolute", "--git-common-dir")) === real2(store);
+    return real3(git2(dir, "rev-parse", "--path-format=absolute", "--git-common-dir")) === real3(store);
   } catch {
     return false;
   }
@@ -7989,23 +8192,23 @@ function cloneFolder(from, to) {
   execFileSync4("cp", [...args, from, to]);
 }
 function moduleFolders(dir) {
-  const found = existsSync12(join20(dir, "node_modules")) ? ["node_modules"] : [];
-  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+  const found = existsSync15(join22(dir, "node_modules")) ? ["node_modules"] : [];
+  for (const entry of readdirSync7(dir, { withFileTypes: true })) {
     if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-      if (existsSync12(join20(dir, entry.name, "node_modules")))
-        found.push(join20(entry.name, "node_modules"));
+      if (existsSync15(join22(dir, entry.name, "node_modules")))
+        found.push(join22(entry.name, "node_modules"));
     }
   }
   return found;
 }
 function lockHash(dir) {
-  const lock = readFileSync16(join20(dir, "package-lock.json"));
+  const lock = readFileSync16(join22(dir, "package-lock.json"));
   const major = process.versions.node.split(".")[0];
   return createHash3("sha256").update(lock).update(`${process.platform}-${process.arch}-${major}`).digest("hex").slice(0, 32);
 }
-var npmCi = (dir) => new Promise((resolve6, reject) => {
+var npmCi = (dir) => new Promise((resolve7, reject) => {
   const network = insideBuildSandbox() ? ["--offline"] : ["--prefer-offline"];
-  const child = spawn7(
+  const child = spawn8(
     "npm",
     ["ci", ...network, "--no-audit", "--no-fund", "--no-update-notifier"],
     {
@@ -8016,7 +8219,7 @@ var npmCi = (dir) => new Promise((resolve6, reject) => {
   child.on("error", reject);
   child.on(
     "close",
-    (code) => code === 0 ? resolve6() : reject(new Error(`npm ci exited with ${code}`))
+    (code) => code === 0 ? resolve7() : reject(new Error(`npm ci exited with ${code}`))
   );
 });
 var BuildRunner = class _BuildRunner {
@@ -8026,11 +8229,15 @@ var BuildRunner = class _BuildRunner {
   options;
   running = /* @__PURE__ */ new Map();
   home() {
-    return this.options.home ?? join20(herdHome(), "builds");
+    return this.options.home ?? join22(herdHome(), "builds");
+  }
+  /** Where builds' own bare clones are, apart from the root's checkouts. */
+  clonesDir() {
+    return join22(this.home(), "clones");
   }
-  /** Herd's clone of a build's repo in the machine's root, whether or not it's there yet. */
+  /** Herd's bare clone of a build's repo, for builds, whether or not it's there yet. */
   storeFor(build) {
-    return storePath(this.options.root(), this.source(build));
+    return bareClonePath(this.clonesDir(), this.source(build));
   }
   /** What to clone a build's repo from: a remote the machine knows for it, or its HTTPS URL. */
   source(build) {
@@ -8038,21 +8245,21 @@ var BuildRunner = class _BuildRunner {
   }
   /**
    * The worktree for one of the repo's build slots, made or updated to the build's commit. The repo
-   * is cloned into the root first if it isn't there, and fetched otherwise, outside the sandbox and
-   * holding the clone's lock, which conversations adding worktrees of it share.
+   * is cloned bare into the builds' own folder first if it isn't there, and fetched otherwise,
+   * outside the sandbox and holding the clone's lock. Builds never work from the root's checkouts,
+   * which hold the person's own local files.
    */
   async prepare(build, slot) {
-    const root = this.options.root();
     const remote = this.source(build);
-    const store = storePath(root, remote);
+    const store = bareClonePath(this.clonesDir(), remote);
     const env = this.options.gitEnv?.();
     const name = (repoKey(build.repo) ?? build.repo).replace(/[^A-Za-z0-9._-]+/g, "_");
-    const dir = join20(this.home(), name, String(slot));
-    mkdirSync15(join20(this.home(), name), { recursive: true });
+    const dir = join22(this.home(), name, String(slot));
+    mkdirSync17(join22(this.home(), name), { recursive: true });
     await withStoreLock(
       store,
       async () => {
-        const clone = await ensureClone(root, remote, env);
+        const clone = await ensureBareClone(store, remote, env);
         if (clone.created) this.options.log?.(`Cloned ${build.repo} into ${store}.`);
         if (clone.fetchFailed)
           this.options.log?.(`Couldn't fetch ${build.repo}: ${clone.fetchFailed}`);
@@ -8062,7 +8269,7 @@ var BuildRunner = class _BuildRunner {
           await storeGit(env, store, "fetch", "--quiet", "origin", build.sha);
         }
         if (!worktreeOf(dir, store)) {
-          rmSync12(dir, { recursive: true, force: true });
+          rmSync13(dir, { recursive: true, force: true });
           await storeGit(env, store, "worktree", "prune");
           await storeGit(
             env,
@@ -8087,30 +8294,30 @@ var BuildRunner = class _BuildRunner {
   /** Makes `node_modules` match the checkout's lockfile: kept, copied from the cache, or installed. */
   async ensureModules(dir) {
     const wanted = lockHash(dir);
-    const marker = join20(dir, "node_modules", ".herd-lock");
-    if (existsSync12(marker) && readFileSync16(marker, "utf8") === wanted) return;
-    const cache = join20(this.home(), "node_modules", wanted);
+    const marker = join22(dir, "node_modules", ".herd-lock");
+    if (existsSync15(marker) && readFileSync16(marker, "utf8") === wanted) return;
+    const cache = join22(this.home(), "node_modules", wanted);
     for (const folder of moduleFolders(dir))
-      rmSync12(join20(dir, folder), { recursive: true, force: true });
-    if (existsSync12(join20(cache, ".complete"))) {
-      for (const folder of readFileSync16(join20(cache, ".complete"), "utf8").split("\n").filter(Boolean)) {
-        cloneFolder(join20(cache, folder), join20(dir, folder));
+      rmSync13(join22(dir, folder), { recursive: true, force: true });
+    if (existsSync15(join22(cache, ".complete"))) {
+      for (const folder of readFileSync16(join22(cache, ".complete"), "utf8").split("\n").filter(Boolean)) {
+        cloneFolder(join22(cache, folder), join22(dir, folder));
       }
     } else {
       this.options.log?.(`Installing node_modules for lockfile ${wanted.slice(0, 8)}.`);
       await (this.options.install ?? npmCi)(dir);
-      const staging = mkdtempSync(join20(this.home(), "node_modules-"));
+      const staging = mkdtempSync(join22(this.home(), "node_modules-"));
       const folders = moduleFolders(dir);
       for (const folder of folders) {
-        mkdirSync15(join20(staging, folder, ".."), { recursive: true });
-        cloneFolder(join20(dir, folder), join20(staging, folder));
+        mkdirSync17(join22(staging, folder, ".."), { recursive: true });
+        cloneFolder(join22(dir, folder), join22(staging, folder));
       }
-      writeFileSync13(join20(staging, ".complete"), folders.join("\n"));
-      mkdirSync15(join20(this.home(), "node_modules"), { recursive: true });
-      rmSync12(cache, { recursive: true, force: true });
+      writeFileSync13(join22(staging, ".complete"), folders.join("\n"));
+      mkdirSync17(join22(this.home(), "node_modules"), { recursive: true });
+      rmSync13(cache, { recursive: true, force: true });
       execFileSync4("mv", [staging, cache]);
     }
-    mkdirSync15(join20(dir, "node_modules"), { recursive: true });
+    mkdirSync17(join22(dir, "node_modules"), { recursive: true });
     writeFileSync13(marker, wanted);
   }
   /**
@@ -8121,7 +8328,7 @@ var BuildRunner = class _BuildRunner {
     const env = {
       PATH: process.env.PATH ?? "/usr/bin:/bin",
       HOME: home,
-      TMPDIR: join20(home, "tmp"),
+      TMPDIR: join22(home, "tmp"),
       LANG: process.env.LANG ?? "en_US.UTF-8",
       HERD_BUILD_ID: build.id,
       HERD_BUILD_SECRET: build.secret,
@@ -8133,7 +8340,7 @@ var BuildRunner = class _BuildRunner {
       // The sandbox's proxy is the only way out, and Node's own requests use it only when asked.
       NODE_USE_ENV_PROXY: "1",
       // Where `srt` points TMPDIR inside the sandbox: the build's own temporary folder.
-      CLAUDE_CODE_TMPDIR: join20(home, "tmp")
+      CLAUDE_CODE_TMPDIR: join22(home, "tmp")
     };
     return env;
   }
@@ -8144,8 +8351,8 @@ var BuildRunner = class _BuildRunner {
   /** Runs `scripts/build.mjs` from the build's own commit, in a process group of its own. */
   async run(build, slot) {
     const dir = await this.prepare(build, slot);
-    const home = mkdtempSync(join20(this.options.scratch ?? scratchRoot(), "hb-"));
-    mkdirSync15(join20(home, "tmp"), { recursive: true });
+    const home = mkdtempSync(join22(this.options.scratch ?? scratchRoot(), "hb-"));
+    mkdirSync17(join22(home, "tmp"), { recursive: true });
     const run4 = randomUUID4();
     const env = {
       ..._BuildRunner.environment(build, home),
@@ -8155,12 +8362,13 @@ var BuildRunner = class _BuildRunner {
       env.HERD_CHECK_CPUS = String(Math.max(1, Math.floor(this.options.cpus())));
     if (this.options.memoryMb)
       env.HERD_CHECK_MEMORY_MB = String(Math.max(1, Math.floor(this.options.memoryMb())));
-    let command = [process.execPath, join20(dir, "scripts", "build.mjs")];
+    let command = [process.execPath, join22(dir, "scripts", "build.mjs")];
     let policyPath = null;
     if (this.sandboxed()) {
       const policy = buildPolicy({
         ownerHome: this.options.ownerHome ?? homedir6(),
         root: this.options.root(),
+        convos: convosHome(this.options.root()),
         worktree: dir,
         store: this.storeFor(build),
         worktreeGitDir: git2(dir, "rev-parse", "--path-format=absolute", "--git-dir"),
@@ -8169,8 +8377,8 @@ var BuildRunner = class _BuildRunner {
         main: build.main,
         buildsUrl: build.url
       });
-      mkdirSync15(join20(this.home(), "policies"), { recursive: true });
-      policyPath = join20(this.home(), "policies", `${build.id}.json`);
+      mkdirSync17(join22(this.home(), "policies"), { recursive: true });
+      policyPath = join22(this.home(), "policies", `${build.id}.json`);
       writeFileSync13(policyPath, JSON.stringify(policy), { mode: 384 });
       env.HERD_BUILD_SANDBOX = describePolicy(policy);
       command = [process.execPath, HERD_BIN, "build-sandbox", policyPath, "--", ...command];
@@ -8178,15 +8386,15 @@ var BuildRunner = class _BuildRunner {
       env.HERD_BUILD_SANDBOX = insideBuildSandbox() ? "Inside the sandbox of the build that started this one." : "";
     }
     const [executable, ...args] = command;
-    const child = spawn7(executable, args, { cwd: dir, env, stdio: "ignore", detached: true });
-    const done = new Promise((resolve6) => {
-      child.on("error", () => resolve6(1));
-      child.on("close", (code) => resolve6(code ?? 1));
+    const child = spawn8(executable, args, { cwd: dir, env, stdio: "ignore", detached: true });
+    const done = new Promise((resolve7) => {
+      child.on("error", () => resolve7(1));
+      child.on("close", (code) => resolve7(code ?? 1));
     });
     let markEnded = () => {
     };
-    const ended = new Promise((resolve6) => {
-      markEnded = resolve6;
+    const ended = new Promise((resolve7) => {
+      markEnded = resolve7;
     });
     const entry = { pid: child.pid ?? 0, done, dir, ended, run: run4 };
     this.running.set(build.id, entry);
@@ -8198,8 +8406,8 @@ var BuildRunner = class _BuildRunner {
       unregister();
       await this.stopBuildProcesses(run4, dir, entry.pid);
       if (this.running.get(build.id) === entry) this.running.delete(build.id);
-      rmSync12(home, { recursive: true, force: true });
-      if (policyPath) rmSync12(policyPath, { force: true });
+      rmSync13(home, { recursive: true, force: true });
+      if (policyPath) rmSync13(policyPath, { force: true });
       markEnded();
     }
   }
@@ -8219,7 +8427,7 @@ var BuildRunner = class _BuildRunner {
    * It goes only by where they run from, never by a build ID, since the daemon a build's own tests
    * start must never stop the build it runs in.
    */
-  static async sweep(home = join20(herdHome(), "builds"), list = listProcesses) {
+  static async sweep(home = join22(herdHome(), "builds"), list = listProcesses) {
     const left = buildProcesses(list(), null, home);
     await stopPids(left);
     return left.length;
@@ -8231,50 +8439,51 @@ var BuildRunner = class _BuildRunner {
    */
   static async probe(options = { buildsUrl: "" }) {
     if (insideBuildSandbox()) return { ok: true };
-    const herd = options.home ?? join20(herdHome(), "builds");
-    const dir = mkdtempSync(join20(scratchRoot(), "hp-"));
-    const secret = join20(dir, "owner", "secret");
+    const herd = options.home ?? join22(herdHome(), "builds");
+    const dir = mkdtempSync(join22(scratchRoot(), "hp-"));
+    const secret = join22(dir, "owner", "secret");
     try {
-      mkdirSync15(herd, { recursive: true });
-      for (const sub of ["work", "git", "home", "owner"]) mkdirSync15(join20(dir, sub));
+      mkdirSync17(herd, { recursive: true });
+      for (const sub of ["work", "git", "home", "owner"]) mkdirSync17(join22(dir, sub));
       writeFileSync13(secret, "probe");
       const policy = buildPolicy({
-        ownerHome: join20(dir, "owner"),
-        root: join20(dir, "owner"),
-        worktree: join20(dir, "work"),
-        store: join20(dir, "git"),
-        worktreeGitDir: join20(dir, "git"),
-        home: join20(dir, "home"),
+        ownerHome: join22(dir, "owner"),
+        root: join22(dir, "owner"),
+        convos: join22(dir, "owner"),
+        worktree: join22(dir, "work"),
+        store: join22(dir, "git"),
+        worktreeGitDir: join22(dir, "git"),
+        home: join22(dir, "home"),
         nodePrefix: nodePrefix(),
         main: false,
         buildsUrl: options.buildsUrl || "https://builds.herdingchats.com"
       });
-      const policyPath = join20(herd, "probe-policy.json");
+      const policyPath = join22(herd, "probe-policy.json");
       writeFileSync13(policyPath, JSON.stringify(policy), { mode: 384 });
       const script = [
         'const fs = require("node:fs");',
         `try { fs.readFileSync(${JSON.stringify(secret)}); process.exit(10); } catch {}`,
-        `fs.writeFileSync(${JSON.stringify(join20(dir, "home", "ok"))}, "ok");`
+        `fs.writeFileSync(${JSON.stringify(join22(dir, "home", "ok"))}, "ok");`
       ].join(" ");
-      const child = spawn7(
+      const child = spawn8(
         process.execPath,
         [HERD_BIN, "build-sandbox", policyPath, "--", process.execPath, "-e", script],
         {
-          env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: join20(dir, "home") },
+          env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: join22(dir, "home") },
           stdio: ["ignore", "ignore", "pipe"]
         }
       );
       let stderr = "";
       child.stderr.on("data", (data) => stderr += data);
       const timer = setTimeout(() => child.kill("SIGKILL"), options.timeoutMs ?? 3e4);
-      const status2 = await new Promise((resolve6) => {
-        child.on("error", () => resolve6(1));
-        child.on("close", (code) => resolve6(code ?? 1));
+      const status2 = await new Promise((resolve7) => {
+        child.on("error", () => resolve7(1));
+        child.on("close", (code) => resolve7(code ?? 1));
       });
       clearTimeout(timer);
       if (status2 === 10)
         return { ok: false, reason: "the sandbox let a build read the owner's files" };
-      if (status2 !== 0 || !existsSync12(join20(dir, "home", "ok"))) {
+      if (status2 !== 0 || !existsSync15(join22(dir, "home", "ok"))) {
         const why = stderr.trim().split("\n").at(-1) || `the probe exited with ${status2}`;
         return { ok: false, reason: why.slice(0, 300) };
       }
@@ -8282,7 +8491,7 @@ var BuildRunner = class _BuildRunner {
     } catch (error) {
       return { ok: false, reason: String(error).slice(0, 300) };
     } finally {
-      rmSync12(dir, { recursive: true, force: true });
+      rmSync13(dir, { recursive: true, force: true });
     }
   }
   /** Stops a build's process group and every process it started, however it got away. */
@@ -8291,7 +8500,7 @@ var BuildRunner = class _BuildRunner {
     if (done) {
       const ended = await Promise.race([
         done.then(() => true),
-        new Promise((resolve6) => setTimeout(() => resolve6(false), 3e3).unref())
+        new Promise((resolve7) => setTimeout(() => resolve7(false), 3e3).unref())
       ]);
       if (!ended && pid) signal(-pid, "SIGKILL");
     } else if (pid) {
@@ -8311,7 +8520,7 @@ function listProcesses() {
 function listFromProc() {
   let pids = [];
   try {
-    pids = readdirSync6("/proc").filter((name) => /^\d+$/.test(name));
+    pids = readdirSync7("/proc").filter((name) => /^\d+$/.test(name));
   } catch {
     return [];
   }
@@ -8351,7 +8560,7 @@ async function stopPids(pids) {
   if (live.length === 0) return;
   const deadline = Date.now() + 3e3;
   while (Date.now() < deadline && live.some((pid) => signal(pid, 0))) {
-    await new Promise((resolve6) => setTimeout(resolve6, 100));
+    await new Promise((resolve7) => setTimeout(resolve7, 100));
   }
   for (const pid of live) signal(pid, "SIGKILL");
 }
@@ -8360,32 +8569,32 @@ async function stopPids(pids) {
 init_define_HERD_PACKAGE();
 import { execFile as execFile3 } from "node:child_process";
 function listClaudeAgents(timeoutMs = 1e4, command = "claude") {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     execFile3(
       command,
       ["agents", "--json", "--all"],
       { env: terminalEnv({}), timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024 },
       (error, stdout) => {
-        if (error) return resolve6([]);
+        if (error) return resolve7([]);
         try {
           const rows = JSON.parse(stdout);
-          resolve6(Array.isArray(rows) ? rows : []);
+          resolve7(Array.isArray(rows) ? rows : []);
         } catch {
-          resolve6([]);
+          resolve7([]);
         }
       }
     );
   });
 }
 function findClaude(shell = process.env.SHELL || "/bin/sh", timeoutMs = 1e4) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     execFile3(
       shell,
       ["-ilc", "command -v claude"],
       { env: terminalEnv({}), timeout: timeoutMs },
       (_error, stdout) => {
         const found = String(stdout ?? "").split("\n").map((line2) => line2.trim()).reverse().find((line2) => line2.startsWith("/"));
-        resolve6(found ?? null);
+        resolve7(found ?? null);
       }
     );
   });
@@ -8493,7 +8702,7 @@ var DEFAULT_TIMING3 = {
   confirmMs: 8e3,
   pasteMs: 600
 };
-var sleep5 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var sleep5 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 var EXIT_WAIT_MS3 = 5e3;
 var CodexDriver = class {
   constructor(terminals, timing = {}) {
@@ -8583,12 +8792,12 @@ var CodexDriver = class {
     if (before.draft && !leftover) return { status: "draft", draft: before.draft };
     const sent = leftover ?? text4;
     let taken = false;
-    const reported = new Promise((resolve6) => {
+    const reported = new Promise((resolve7) => {
       this.waiters.set(name, {
         text: sent,
         taken: () => {
           taken = true;
-          resolve6();
+          resolve7();
         }
       });
     });
@@ -8633,7 +8842,7 @@ var CodexDriver = class {
 
 // src/daemon.ts
 init_define_HERD_PACKAGE();
-import { join as join21 } from "node:path";
+import { join as join23 } from "node:path";
 
 // src/dispatch-connection.ts
 init_define_HERD_PACKAGE();
@@ -8737,7 +8946,7 @@ var DispatchConnection = class {
 
 // src/daemon.ts
 var CONFIG_POLL_MS = 2e3;
-var daemonSocketPath = () => join21(herdHome(), "daemon.sock");
+var daemonSocketPath = () => join23(herdHome(), "daemon.sock");
 var Daemon = class {
   constructor(options) {
     this.options = options;
@@ -8819,9 +9028,11 @@ var Daemon = class {
     return this.registering;
   }
   async register() {
-    const reposStamp = clonedStamp(this.root());
+    const reposStamp = checkoutsStamp(this.root());
     const gh = this.options.gh?.();
+    const folderUnavailable = this.options.folderUnavailable?.() ?? void 0;
     const facts = {
+      ...folderUnavailable ? { folderUnavailable } : {},
       ...this.options.facts,
       ...this.herdConfig ? { config: this.herdConfig } : {},
       ...this.configError ? { configError: this.configError } : {},
@@ -8831,7 +9042,7 @@ var Daemon = class {
     const response = await this.options.api.fetch("/api/machines", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(registration(this.config, this.clis, facts, clonedRepos(this.root())))
+      body: JSON.stringify(registration(this.config, this.clis, facts, checkouts(this.root())))
     });
     if (!response.ok) {
       const body = await response.json().catch(() => ({}));
@@ -8859,7 +9070,7 @@ var Daemon = class {
     }
   }
   /**
-   * Registers again when `herd.config.ts` changed, or a repo was cloned into the root, so routing
+   * Registers again when `herd.config.ts` changed, or a checkout came or went in the root, so routing
    * uses it within seconds.
    */
   async refreshHerdConfig() {
@@ -8869,7 +9080,7 @@ var Daemon = class {
     };
     if (this.refreshing) return false;
     const configChanged = source.stamp() !== this.configStamp;
-    if (!configChanged && clonedStamp(this.root()) === this.reposStamp) return false;
+    if (!configChanged && checkoutsStamp(this.root()) === this.reposStamp) return false;
     this.refreshing = true;
     try {
       if (configChanged) await this.readHerdConfig();
@@ -8891,16 +9102,41 @@ var Daemon = class {
     this.connection?.stop();
     await this.local.close();
   }
+  /** Messages held while a folder isn't there, by conversation, delivered once it is. */
+  held = /* @__PURE__ */ new Map();
+  /**
+   * A folder came or went: registers again, so dispatch knows, and once nothing is missing,
+   * delivers what was held meanwhile.
+   */
+  async foldersChanged() {
+    await this.reregister();
+    if (this.options.folderUnavailable?.()) return;
+    for (const [conversationId, delivery] of [...this.held]) {
+      this.held.delete(conversationId);
+      await this.options.work.onMessage(conversationId, delivery);
+      this.connection?.acknowledge(conversationId);
+    }
+  }
   async onFrame(frame) {
     if (frame.type === "offer") return this.onOffer(frame.offer);
     if (frame.type === "sign_in") return this.options.onSignIn?.(frame);
     if (frame.type === "message") {
+      if (this.options.folderUnavailable?.()) {
+        if (this.held.get(frame.conversationId) !== "interrupt") {
+          this.held.set(frame.conversationId, frame.delivery);
+        }
+        return;
+      }
       await this.options.work.onMessage(frame.conversationId, frame.delivery);
       this.connection?.acknowledge(frame.conversationId);
     }
   }
   async onOffer(offer) {
-    const decision = await this.options.work.onOffer(offer, this.config);
+    const missing = this.options.folderUnavailable?.();
+    const decision = missing ? {
+      accept: false,
+      reason: `A folder this machine works in isn't there: ${missing.target ? `${missing.path} links to ${missing.target}` : missing.path}.`
+    } : await this.options.work.onOffer(offer, this.config);
     const answer2 = decision.accept ? { answer: "accept" } : { answer: "refuse", reason: decision.reason };
     const response = await this.options.api.fetch(
       `/api/machines/${encodeURIComponent(this.config.machineId)}/offers/${encodeURIComponent(offer.id)}`,
@@ -8920,10 +9156,101 @@ var Daemon = class {
   }
 };
 
+// src/folders.ts
+init_define_HERD_PACKAGE();
+import { existsSync as existsSync16, lstatSync as lstatSync3, readlinkSync as readlinkSync2, rmSync as rmSync14, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname13, resolve as resolve4 } from "node:path";
+var FOLDER_WAIT_MS = 2 * 60 * 1e3;
+var FOLDER_CHECK_MS = 30 * 1e3;
+function linkOf(path) {
+  try {
+    if (!lstatSync3(path).isSymbolicLink()) return null;
+    return resolve4(dirname13(path), readlinkSync2(path));
+  } catch {
+    return null;
+  }
+}
+function missingFolder(path, required, { exists = existsSync16, linkTarget = linkOf } = {}) {
+  if (exists(path)) return null;
+  const target = linkTarget(path);
+  if (target) return { path, target };
+  return required ? { path } : null;
+}
+function machineFolderProblem(root, convos, checks = {}) {
+  return missingFolder(dirname13(root), true, checks) ?? missingFolder(convos, false, checks);
+}
+async function waitForFolders(problem, {
+  timeoutMs = FOLDER_WAIT_MS,
+  pollMs = 2e3,
+  sleep: sleep8 = (ms) => new Promise((done) => setTimeout(done, ms)),
+  now = Date.now,
+  log = (line2) => console.log(line2)
+} = {}) {
+  let missing = problem();
+  if (!missing) return null;
+  log(`Waiting for ${describeMissing(missing)} to be there, as when its drive mounts.`);
+  const deadline = now() + timeoutMs;
+  while (missing && now() < deadline) {
+    await sleep8(pollMs);
+    missing = problem();
+  }
+  if (!missing) {
+    log("It's there.");
+    return null;
+  }
+  log(
+    `Taking no work or builds: ${describeMissing(missing)} still isn't there after ${Math.round(timeoutMs / 1e3)} seconds. Looking again every ${FOLDER_CHECK_MS / 1e3} seconds.`
+  );
+  return missing;
+}
+var waitForRoot = (root, options = {}) => waitForFolders(() => missingFolder(dirname13(root), true, options), options);
+var waitForConvos = (convos, options = {}) => waitForFolders(() => missingFolder(convos, false, options), options);
+var describeMissing = (missing) => missing.target ? `${missing.path}, which links to ${missing.target},` : missing.path;
+var FolderWatch = class {
+  constructor(options) {
+    this.options = options;
+    this.current = options.initial;
+    this.write();
+  }
+  options;
+  current;
+  timer = null;
+  /** What's missing now, or null. */
+  get problem() {
+    return this.current;
+  }
+  start() {
+    this.timer = setInterval(() => void this.tick(), this.options.everyMs ?? FOLDER_CHECK_MS);
+    this.timer.unref?.();
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+  }
+  /** Looks once, and tells `onChange` when what's missing changed. */
+  async tick() {
+    const next = this.options.check();
+    if (JSON.stringify(next) === JSON.stringify(this.current)) return;
+    this.current = next;
+    this.write();
+    const log = this.options.log ?? ((line2) => console.log(line2));
+    log(
+      next ? `Taking no work or builds: ${describeMissing(next)} isn't there.` : "The machine's folders are there again, so it takes work again."
+    );
+    await this.options.onChange(next);
+  }
+  write() {
+    try {
+      if (this.current) writeFileSync14(this.options.statusPath, JSON.stringify(this.current));
+      else rmSync14(this.options.statusPath, { force: true });
+    } catch {
+    }
+  }
+};
+
 // src/gh.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { execFile as execFile4, spawn as spawn8 } from "node:child_process";
+import { execFile as execFile4, spawn as spawn9 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 var GH_CHECK_MS = 10 * 60 * 1e3;
 var GH_CODE_WAIT_MS = 30 * 1e3;
@@ -8994,7 +9321,7 @@ function readDeviceCode(output2) {
   return code && url === GITHUB_DEVICE_URL ? { code, url: GITHUB_DEVICE_URL } : null;
 }
 async function signInGh(options) {
-  const spawnGh = options.spawnGh ?? ((args) => spawn8("gh", args, {
+  const spawnGh = options.spawnGh ?? ((args) => spawn9("gh", args, {
     env: options.env?.() ?? process.env,
     stdio: ["ignore", "pipe", "pipe"]
   }));
@@ -9003,8 +9330,8 @@ async function signInGh(options) {
   let sent = false;
   let resolveCode = () => {
   };
-  const codeShown = new Promise((resolve6) => {
-    resolveCode = resolve6;
+  const codeShown = new Promise((resolve7) => {
+    resolveCode = resolve7;
   });
   const read = (chunk) => {
     output2 += chunk.toString();
@@ -9012,9 +9339,9 @@ async function signInGh(options) {
   };
   child.stdout?.on("data", read);
   child.stderr?.on("data", read);
-  const exited = new Promise((resolve6) => {
-    child.once("close", () => resolve6());
-    child.once("error", () => resolve6());
+  const exited = new Promise((resolve7) => {
+    child.once("close", () => resolve7());
+    child.once("error", () => resolve7());
   });
   void exited.then(() => resolveCode(false));
   const codeTimer = setTimeout(() => resolveCode(false), options.codeWaitMs ?? GH_CODE_WAIT_MS);
@@ -9047,23 +9374,23 @@ init_define_HERD_PACKAGE();
 import { execFileSync as execFileSync5 } from "node:child_process";
 import {
   appendFileSync as appendFileSync2,
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync16,
+  existsSync as existsSync17,
+  mkdirSync as mkdirSync18,
   readFileSync as readFileSync17,
-  renameSync as renameSync5,
-  writeFileSync as writeFileSync14
+  renameSync as renameSync6,
+  writeFileSync as writeFileSync15
 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join22 } from "node:path";
-var LOCAL_SETTINGS = join22(".claude", "settings.local.json");
+import { isAbsolute as isAbsolute3, join as join24 } from "node:path";
+var LOCAL_SETTINGS = join24(".claude", "settings.local.json");
 var git3 = (cwd, ...args) => execFileSync5("git", ["-C", cwd, ...args], {
   encoding: "utf8",
   stdio: ["ignore", "pipe", "pipe"]
 }).trim();
 var shellQuote2 = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
 function writeWorktreeSettings(worktree, settings, ownCommand) {
-  const path = join22(worktree, LOCAL_SETTINGS);
+  const path = join24(worktree, LOCAL_SETTINGS);
   let current = {};
-  if (existsSync13(path)) {
+  if (existsSync17(path)) {
     try {
       const parsed = JSON.parse(readFileSync17(path, "utf8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
@@ -9085,11 +9412,11 @@ function writeWorktreeSettings(worktree, settings, ownCommand) {
     }
     next.hooks = hooks;
   }
-  mkdirSync16(join22(worktree, ".claude"), { recursive: true });
+  mkdirSync18(join24(worktree, ".claude"), { recursive: true });
   const temporary = `${path}.herd-${process.pid}`;
-  writeFileSync14(temporary, `${JSON.stringify(next, null, 2)}
+  writeFileSync15(temporary, `${JSON.stringify(next, null, 2)}
 `);
-  renameSync5(temporary, path);
+  renameSync6(temporary, path);
   ignoreLocalSettings(worktree);
   return true;
 }
@@ -9105,12 +9432,12 @@ function ignoreLocalSettings(worktree) {
   } catch {
     return;
   }
-  const info = join22(isAbsolute3(common) ? common : join22(worktree, common), "info");
-  const exclude = join22(info, "exclude");
+  const info = join24(isAbsolute3(common) ? common : join24(worktree, common), "info");
+  const exclude = join24(info, "exclude");
   const line2 = "/.claude/settings.local.json";
-  const existing = existsSync13(exclude) ? readFileSync17(exclude, "utf8") : "";
+  const existing = existsSync17(exclude) ? readFileSync17(exclude, "utf8") : "";
   if (existing.split("\n").includes(line2)) return;
-  mkdirSync16(info, { recursive: true });
+  mkdirSync18(info, { recursive: true });
   appendFileSync2(exclude, `${existing && !existing.endsWith("\n") ? "\n" : ""}${line2}
 `);
 }
@@ -9157,7 +9484,7 @@ function loginShellEnv() {
 
 // src/machine-checks.ts
 init_define_HERD_PACKAGE();
-import { existsSync as existsSync14, rmSync as rmSync13 } from "node:fs";
+import { existsSync as existsSync18, rmSync as rmSync15 } from "node:fs";
 var REQUEST_POLL_MS = 2e3;
 var MachineChecks = class {
   constructor(options) {
@@ -9203,8 +9530,8 @@ var MachineChecks = class {
   /** `friday start` asked for every agent to be activated again. */
   takeRequest() {
     const path = activationRequestPath(this.options.herdHome);
-    if (!existsSync14(path)) return;
-    rmSync13(path, { force: true });
+    if (!existsSync18(path)) return;
+    rmSync15(path, { force: true });
     this.activateChosen(true);
   }
   start() {
@@ -9252,22 +9579,22 @@ var MachineChecks = class {
 
 // src/terminals.ts
 init_define_HERD_PACKAGE();
-import { spawn as spawn9 } from "node:child_process";
-import { mkdirSync as mkdirSync17, readdirSync as readdirSync7, rmSync as rmSync14 } from "node:fs";
+import { spawn as spawn10 } from "node:child_process";
+import { mkdirSync as mkdirSync19, readdirSync as readdirSync8, rmSync as rmSync16 } from "node:fs";
 import { connect as connect2 } from "node:net";
-import { join as join23 } from "node:path";
+import { join as join25 } from "node:path";
 init_self();
 import {
   HOST_PROTOCOL,
   hostVersion
 } from "./terminal-host.mjs";
-var hostsDir = () => join23(herdHome(), "terminals");
-var legacyHostSocketPath = () => join23(herdHome(), "terminals.sock");
-var currentHostSocketPath = (version = hostVersion()) => join23(hostsDir(), `${version}.sock`);
+var hostsDir = () => join25(herdHome(), "terminals");
+var legacyHostSocketPath = () => join25(herdHome(), "terminals.sock");
+var currentHostSocketPath = (version = hostVersion()) => join25(hostsDir(), `${version}.sock`);
 var speaksProtocol = (protocol) => protocol === HOST_PROTOCOL || protocol === HOST_PROTOCOL - 1;
-var sleep6 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var sleep6 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 function askHost(path, request) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const socket = connect2(path);
     let data = "";
     socket.on("connect", () => socket.write(`${JSON.stringify(request)}
@@ -9276,7 +9603,7 @@ function askHost(path, request) {
     socket.on("end", () => {
       try {
         const reply = JSON.parse(data);
-        if (reply.ok) resolve6(reply);
+        if (reply.ok) resolve7(reply);
         else reject(new HerdError(reply.error ?? "The terminal host refused that."));
       } catch {
         reject(new HerdError("The terminal host's answer wasn't readable."));
@@ -9311,10 +9638,10 @@ var HostTerminals = class {
     const dir = hostsDir();
     let names = [];
     try {
-      names = readdirSync7(dir).filter((name) => name.endsWith(".sock"));
+      names = readdirSync8(dir).filter((name) => name.endsWith(".sock"));
     } catch {
     }
-    const paths = [legacyHostSocketPath(), ...names.map((name) => join23(dir, name))];
+    const paths = [legacyHostSocketPath(), ...names.map((name) => join25(dir, name))];
     const found = [];
     for (const path of paths) {
       try {
@@ -9326,7 +9653,7 @@ var HostTerminals = class {
           speaks: speaksProtocol(hello.protocol)
         });
       } catch (error) {
-        if (isDead(error) && path !== legacyHostSocketPath()) rmSync14(path, { force: true });
+        if (isDead(error) && path !== legacyHostSocketPath()) rmSync16(path, { force: true });
       }
     }
     this.hosts = found;
@@ -9347,8 +9674,8 @@ var HostTerminals = class {
     }
     if (this.current()) return;
     const path = currentHostSocketPath(this.version);
-    mkdirSync17(hostsDir(), { recursive: true, mode: 448 });
-    const child = spawn9(process.execPath, [herdBin, "terminal-host", "--socket", path], {
+    mkdirSync19(hostsDir(), { recursive: true, mode: 448 });
+    const child = spawn10(process.execPath, [herdBin, "terminal-host", "--socket", path], {
       detached: true,
       stdio: "ignore",
       env: { ...process.env, HERD_HOME: herdHome() }
@@ -9475,7 +9802,7 @@ var HostTerminals = class {
         await sleep6(100);
         if (!await askHost(host.path, { op: "hello" }).catch(() => null)) break;
       }
-      rmSync14(host.path, { force: true });
+      rmSync16(host.path, { force: true });
     }
     return true;
   }
@@ -9594,8 +9921,8 @@ var UsageReporter = class {
 // src/workspaces/index.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { mkdirSync as mkdirSync21, readFileSync as readFileSync18, writeFileSync as writeFileSync17 } from "node:fs";
-import { join as join30 } from "node:path";
+import { mkdirSync as mkdirSync23, readFileSync as readFileSync18, writeFileSync as writeFileSync18 } from "node:fs";
+import { join as join32 } from "node:path";
 
 // src/workspaces/codex.ts
 init_define_HERD_PACKAGE();
@@ -9607,7 +9934,7 @@ init_define_HERD_PACKAGE();
 init_define_HERD_PACKAGE();
 init_src();
 init_self();
-import { join as join24 } from "node:path";
+import { join as join26 } from "node:path";
 import { z as z25 } from "zod";
 function hasThread(events) {
   return events.some(
@@ -9642,7 +9969,7 @@ function filesByMessage(events) {
   }
   return files;
 }
-var FILES_FOLDER = join24(".herd", "files");
+var FILES_FOLDER = join26(".herd", "files");
 function safeFileName(name) {
   const chars = Array.from(name.replace(/[/\\\p{Cc}]/gu, "_").trim());
   while (Buffer.byteLength(chars.join("")) > 200) chars.shift();
@@ -9864,11 +10191,11 @@ async function claimChange(ws, workspace, change) {
 // src/workspaces/delivery.ts
 init_define_HERD_PACKAGE();
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { join as join28 } from "node:path";
+import { join as join30 } from "node:path";
 
 // src/workspaces/repos.ts
 init_define_HERD_PACKAGE();
-import { join as join25 } from "node:path";
+import { join as join27 } from "node:path";
 var rootOf = (ws) => ws.options.root?.() ?? ws.options.config().root ?? defaultRoot();
 var gitEnvOf = (ws) => ws.options.gitEnv?.() ?? loginShellEnv();
 function knownRemotes(ws) {
@@ -9920,7 +10247,7 @@ function repoContext(ws, workspace) {
       remote: repo.remote || remotesOf(ws, { ...workspace, worktrees: [repo] })[0] || "",
       branch: repo.branch
     })),
-    cloned: clonedRepos(root).map(({ key, remote }) => ({ key, remote })),
+    cloned: checkouts(root).map(({ key, remote }) => ({ key, remote })),
     described: (ws.options.herdConfig?.()?.repos ?? []).map((repo) => ({
       remote: repo.remote,
       key: repoKey(repo.remote),
@@ -9980,7 +10307,7 @@ async function addHints(ws, workspace, hints, handedOff) {
       const added = await addWorktree({
         root,
         remote: cloneSource(hint.remote, knownRemotes(ws)),
-        path: join25(workspace.folder, place.name),
+        path: join27(workspace.folder, place.name),
         branch,
         ...handedOff ? { continueFrom: hint.branch ?? branch } : {},
         env: gitEnvOf(ws),
@@ -10000,6 +10327,8 @@ async function addHints(ws, workspace, hints, handedOff) {
           true
         );
       }
+      if (added.copied.length > 0)
+        await ws.note(id2, describeCopied(place.name, added.copied), true);
       const found = reposInFolder(workspace.folder).find((repo) => repo.folder === place.name);
       await recordRepo(ws, id2, {
         folder: place.name,
@@ -10030,14 +10359,14 @@ function handoffRepos(workspace) {
   return workspace.worktrees.map((repo) => ({
     folder: repo.folder,
     branch: repo.branch,
-    unpushed: hasUnpushed(join25(workspace.folder, repo.folder))
+    unpushed: hasUnpushed(join27(workspace.folder, repo.folder))
   }));
 }
 
 // src/workspaces/setup.ts
 init_define_HERD_PACKAGE();
-import { chmodSync as chmodSync4, mkdirSync as mkdirSync18, writeFileSync as writeFileSync15 } from "node:fs";
-import { join as join26 } from "node:path";
+import { chmodSync as chmodSync4, mkdirSync as mkdirSync20, writeFileSync as writeFileSync16 } from "node:fs";
+import { join as join28 } from "node:path";
 
 // src/hooks.ts
 init_define_HERD_PACKAGE();
@@ -10070,7 +10399,7 @@ function configureClaude(ws, workspace) {
   configureClaudeIn(workspace.folder, (line2) => ws.log(`${workspace.conversationId}: ${line2}`));
 }
 function configureClaudeIn(folder, log) {
-  const herd = shellQuote2(join26(herdPathDir(), "herd"));
+  const herd = shellQuote2(join28(herdPathDir(), "herd"));
   try {
     const written = writeWorktreeSettings(
       folder,
@@ -10095,10 +10424,10 @@ function configureClaudeIn(folder, log) {
   }
 }
 function herdPathDir() {
-  const dir = join26(herdHome(), "bin");
-  mkdirSync18(dir, { recursive: true, mode: 448 });
-  const shim = join26(dir, "herd");
-  writeFileSync15(shim, `#!/bin/sh
+  const dir = join28(herdHome(), "bin");
+  mkdirSync20(dir, { recursive: true, mode: 448 });
+  const shim = join28(dir, "herd");
+  writeFileSync16(shim, `#!/bin/sh
 exec "${process.execPath}" "${herdBin}" "$@"
 `);
   chmodSync4(shim, 493);
@@ -10116,8 +10445,8 @@ async function setUp(ws, conversationId) {
   const hints = ws.offeredRepos.get(conversationId) ?? [];
   ws.offeredRepos.delete(conversationId);
   const handedOff = ws.handedOff.delete(conversationId);
-  const folder = conversationFolder(rootOf(ws), conversationId);
-  mkdirSync18(folder, { recursive: true });
+  const folder = folderForConversation(rootOf(ws), conversationId);
+  mkdirSync20(folder, { recursive: true });
   const lead = `herd-${conversationPrefix(conversationId)}-1`;
   const secret = ws.options.local().grant({ terminalId: lead, conversationId });
   const workspace = {
@@ -10236,8 +10565,8 @@ init_define_HERD_PACKAGE();
 // src/workspaces/investigation.ts
 init_define_HERD_PACKAGE();
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync19 } from "node:fs";
-import { join as join27 } from "node:path";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync21 } from "node:fs";
+import { join as join29 } from "node:path";
 function needsInvestigator(ws, workspace, reading) {
   const failedAt = workspace.noticeFailedAt;
   if (workspace.agent === "codex" || workspace.agent === "agy") return false;
@@ -10393,9 +10722,9 @@ async function followInvestigation(ws, workspace) {
 }
 function saveScreen(ws, conversationId, screen, key) {
   try {
-    const dir = join27(herdHome(), "dialogs");
-    mkdirSync19(dir, { recursive: true });
-    const file = join27(dir, `${conversationId}-${Date.now()}.txt`);
+    const dir = join29(herdHome(), "dialogs");
+    mkdirSync21(dir, { recursive: true });
+    const file = join29(dir, `${conversationId}-${Date.now()}.txt`);
     appendFileSync3(file, `${screen.join("\n")}
 
 Way out: ${key}
@@ -10599,7 +10928,7 @@ async function deliver(ws, conversationId, delivery) {
     await ensureLeadTerminal(ws, workspace);
     const codex = workspace.agent === "codex";
     if (workspace.agent === "agy") {
-      writeAgyFiles(workspace.folder, shellQuote2(join28(herdPathDir(), "herd")));
+      writeAgyFiles(workspace.folder, shellQuote2(join30(herdPathDir(), "herd")));
     } else if (!codex) configureClaude(ws, workspace);
     const ownId = codex || workspace.agent === "agy";
     if (!workspace.started) {
@@ -10733,15 +11062,15 @@ init_define_HERD_PACKAGE();
 init_src();
 import {
   createWriteStream,
-  lstatSync as lstatSync2,
-  mkdirSync as mkdirSync20,
-  realpathSync as realpathSync8,
-  renameSync as renameSync6,
-  rmSync as rmSync15,
-  statSync as statSync8,
-  writeFileSync as writeFileSync16
+  lstatSync as lstatSync4,
+  mkdirSync as mkdirSync22,
+  realpathSync as realpathSync10,
+  renameSync as renameSync7,
+  rmSync as rmSync17,
+  statSync as statSync9,
+  writeFileSync as writeFileSync17
 } from "node:fs";
-import { dirname as dirname11, join as join29, sep as sep2 } from "node:path";
+import { dirname as dirname14, join as join31, sep as sep2 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 
@@ -10754,8 +11083,8 @@ import { readFile } from "node:fs/promises";
 // src/attachments.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { realpathSync as realpathSync7, statSync as statSync7 } from "node:fs";
-import { basename as basename3, extname, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve4 } from "node:path";
+import { realpathSync as realpathSync9, statSync as statSync8 } from "node:fs";
+import { basename as basename3, extname, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve5 } from "node:path";
 var TYPES = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -10785,33 +11114,33 @@ function isInside(root, path) {
 function resolveAttachments(worktree, files) {
   let root;
   try {
-    root = realpathSync7(worktree);
+    root = realpathSync9(worktree);
   } catch {
     return { ok: false, error: "This terminal's conversation folder is missing." };
   }
   const resolved = [];
   for (const file of files) {
-    let real3;
+    let real4;
     try {
-      real3 = realpathSync7(resolve4(worktree, file.path));
+      real4 = realpathSync9(resolve5(worktree, file.path));
     } catch {
       return { ok: false, error: `There's no file at ${file.path}.` };
     }
-    if (!isInside(root, real3)) {
+    if (!isInside(root, real4)) {
       return {
         ok: false,
         error: `${file.path} is outside this conversation's folder, so it can't be attached.`
       };
     }
-    const stats = statSync7(real3);
+    const stats = statSync8(real4);
     if (!stats.isFile()) return { ok: false, error: `${file.path} isn't a file.` };
     if (stats.size > MAX_FILE_BYTES) {
       return { ok: false, error: `${file.path} is larger than 100 MB, so it can't be attached.` };
     }
     resolved.push({
-      path: real3,
+      path: real4,
       name: basename3(file.path),
-      type: mediaTypeFor(real3),
+      type: mediaTypeFor(real4),
       size: stats.size,
       ...file.title ? { title: file.title } : {},
       ...file.alt ? { alt: file.alt } : {}
@@ -10969,11 +11298,11 @@ async function permission(ws, workspace, request, gone) {
         }
         if (state.state === "cancelled") return { ok: true, decision: null };
       }
-      await new Promise((resolve6) => {
-        const timer = setTimeout(resolve6, ws.options.promptPollMs ?? 1500);
+      await new Promise((resolve7) => {
+        const timer = setTimeout(resolve7, ws.options.promptPollMs ?? 1500);
         gone.addEventListener("abort", () => {
           clearTimeout(timer);
-          resolve6();
+          resolve7();
         });
       });
     }
@@ -11327,7 +11656,7 @@ async function automations(ws, workspace, request, gone = new AbortController().
       const deadline = Date.now() + (asked.waitMs ?? 9e4);
       const promptPath = `${ws.conversationPath(workspace.conversationId)}/prompts/${encodeURIComponent(promptId ?? "")}`;
       while (promptId && Date.now() < deadline && !gone.aborted) {
-        await new Promise((resolve6) => setTimeout(resolve6, ws.options.promptPollMs ?? 1500));
+        await new Promise((resolve7) => setTimeout(resolve7, ws.options.promptPollMs ?? 1500));
         const prompt = await ws.api(promptPath).catch(() => null);
         if (!prompt?.ok) continue;
         const state = await prompt.json();
@@ -11716,34 +12045,34 @@ async function bringIn(ws, workspace, files) {
   return listed;
 }
 async function download(ws, workspace, file) {
-  const path = join29(FILES_FOLDER, safeFileName(file.id), safeFileName(file.name));
-  const target = join29(workspace.folder, path);
-  if (statSync8(target, { throwIfNoEntry: false })?.size === file.size) return path;
-  const herd = join29(workspace.folder, ".herd");
-  if (lstatSync2(herd, { throwIfNoEntry: false })?.isSymbolicLink()) {
+  const path = join31(FILES_FOLDER, safeFileName(file.id), safeFileName(file.name));
+  const target = join31(workspace.folder, path);
+  if (statSync9(target, { throwIfNoEntry: false })?.size === file.size) return path;
+  const herd = join31(workspace.folder, ".herd");
+  if (lstatSync4(herd, { throwIfNoEntry: false })?.isSymbolicLink()) {
     throw new Error("its folder leads outside the worktree");
   }
-  mkdirSync20(dirname11(target), { recursive: true });
-  if (!realpathSync8(dirname11(target)).startsWith(realpathSync8(workspace.folder) + sep2)) {
+  mkdirSync22(dirname14(target), { recursive: true });
+  if (!realpathSync10(dirname14(target)).startsWith(realpathSync10(workspace.folder) + sep2)) {
     throw new Error("its folder leads outside the worktree");
   }
-  writeFileSync16(join29(herd, ".gitignore"), "*\n");
+  writeFileSync17(join31(herd, ".gitignore"), "*\n");
   const response = await ws.api(
     `${ws.conversationPath(workspace.conversationId)}/files/${encodeURIComponent(file.id)}`
   );
   if (!response.ok || !response.body) throw new Error(`the server answered ${response.status}`);
   const partial = `${target}.partial`;
-  rmSync15(partial, { force: true });
+  rmSync17(partial, { force: true });
   try {
     await pipeline(
       Readable.fromWeb(response.body),
       createWriteStream(partial, { flags: "wx" })
     );
-    const { size } = statSync8(partial);
+    const { size } = statSync9(partial);
     if (size !== file.size) throw new Error(`it came to ${size} bytes, not ${file.size}`);
-    renameSync6(partial, target);
+    renameSync7(partial, target);
   } finally {
-    rmSync15(partial, { force: true });
+    rmSync17(partial, { force: true });
   }
   return path;
 }
@@ -12017,7 +12346,7 @@ var Workspaces = class {
     return this.driver;
   }
   // ---- State, kept on disk so a restarted daemon picks up where it was.
-  statePath = () => join30(herdHome(), "state.json");
+  statePath = () => join32(herdHome(), "state.json");
   load() {
     try {
       return stateSchema.parse(JSON.parse(readFileSync18(this.statePath(), "utf8"))).workspaces;
@@ -12026,8 +12355,8 @@ var Workspaces = class {
     }
   }
   save(workspaces) {
-    mkdirSync21(herdHome(), { recursive: true, mode: 448 });
-    writeFileSync17(this.statePath(), JSON.stringify({ workspaces }, null, 2), { mode: 384 });
+    mkdirSync23(herdHome(), { recursive: true, mode: 448 });
+    writeFileSync18(this.statePath(), JSON.stringify({ workspaces }, null, 2), { mode: 384 });
   }
   get(conversationId) {
     return this.load()[conversationId] ?? null;
@@ -12237,7 +12566,19 @@ async function runDaemon(args) {
     const root = setRoot(defaultRoot()).root;
     console.log(`No root folder is set for this machine, so it works from ${root}.`);
   }
-  await waitForRoot(machineRoot(), { pollMs: Number(process.env.HERD_ROOT_POLL_MS) || 2e3 });
+  const folderTiming = {
+    pollMs: Number(process.env.HERD_ROOT_POLL_MS) || 2e3,
+    ...process.env.HERD_FOLDER_WAIT_MS ? { timeoutMs: Number(process.env.HERD_FOLDER_WAIT_MS) } : {}
+  };
+  const missing = await waitForRoot(machineRoot(), folderTiming) ?? await waitForConvos(convosPath(machineRoot()), folderTiming);
+  let daemon = null;
+  const folders = new FolderWatch({
+    check: () => machineFolderProblem(machineRoot(), convosPath(machineRoot())),
+    initial: missing,
+    statusPath: join33(herdHome(), "folder-unavailable.json"),
+    ...process.env.HERD_FOLDER_CHECK_MS ? { everyMs: Number(process.env.HERD_FOLDER_CHECK_MS) } : {},
+    onChange: () => daemon?.foldersChanged()
+  });
   const api = apiUrl();
   const terminals = new HostTerminals({ log: (line2) => console.log(line2) });
   await terminals.ensureHost();
@@ -12248,7 +12589,6 @@ async function runDaemon(args) {
       headers: isLocal(api) ? localSignIn() : { Authorization: `Bearer ${await accessToken()}` }
     })
   };
-  let daemon = null;
   let activator = null;
   let checks = null;
   const log = (line2) => console.log(line2);
@@ -12330,7 +12670,7 @@ async function runDaemon(args) {
     env: (secret) => envFor(workspaces, secret),
     // As for a conversation: Claude Code's hooks and status line, or agy's. Codex has none.
     configure: (agent, folder) => {
-      if (agent === "agy") writeAgyFiles(folder, shellQuote2(join31(herdPathDir(), "herd")));
+      if (agent === "agy") writeAgyFiles(folder, shellQuote2(join33(herdPathDir(), "herd")));
       else if (agent === "claude-code") configureClaudeIn(folder, log);
     },
     ...shellCommand ? { shellCommand } : {},
@@ -12368,9 +12708,11 @@ async function runDaemon(args) {
     activations: () => activator?.states() ?? {},
     gh: () => checks?.gh ?? null,
     onSignIn: (frame) => void checks?.signIn(frame),
-    onConfigChanged: () => checks?.activateChosen()
+    onConfigChanged: () => checks?.activateChosen(),
+    folderUnavailable: () => folders.problem
   });
   await daemon.start();
+  folders.start();
   checks.start();
   usage.start();
   const display = process.env.HERD_DISPLAY === "off" ? null : new (await Promise.resolve().then(() => (init_desk_display(), desk_display_exports))).DeskDisplay({
@@ -12411,9 +12753,11 @@ async function runDaemon(args) {
         headers: { Authorization: `Bearer ${runnerKey.key}` }
       }),
       serviceUrl: runnerKey.url,
-      capacity: () => sandbox.ok ? runnerCapacity(daemon?.configuration().config?.builds) : 0,
-      // As many as the service's hello takes, to put this runner first for their builds.
-      repos: () => clonedRepos(machineRoot()).map((repo) => repo.key).filter((key) => key.length <= 300).slice(0, 100),
+      // None while a folder it works in isn't there, as for its conversations.
+      capacity: () => sandbox.ok && !folders.problem ? runnerCapacity(daemon?.configuration().config?.builds) : 0,
+      // The repos builds have cloned here, as many as the service's hello takes, to put this runner
+      // first for their builds.
+      repos: () => bareClones(join33(herdHome(), "builds", "clones")).map((repo) => repo.key).filter((key) => key.length <= 300).slice(0, 100),
       runner: new BuildRunner({
         root: () => machineRoot(),
         gitEnv,
@@ -12446,10 +12790,11 @@ async function runDaemon(args) {
   const codexFollower = setInterval(() => {
     void workspaces.followCodex().catch((error) => console.error(`Reading Codex's sessions failed: ${error}`));
   }, 250);
-  await new Promise((resolve6) => {
-    for (const signal2 of ["SIGINT", "SIGTERM"]) process.once(signal2, () => resolve6());
+  await new Promise((resolve7) => {
+    for (const signal2 of ["SIGINT", "SIGTERM"]) process.once(signal2, () => resolve7());
   });
   builds?.stop();
+  folders.stop();
   checks.stop();
   activator.stop();
   usage.stop();
@@ -12543,11 +12888,11 @@ function agyAnswer(event2, output2) {
 }
 
 // src/hook-client.ts
-var sleep7 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var sleep7 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 function within2(promise, ms) {
   let timer;
-  const timeout = new Promise((resolve6) => {
-    timer = setTimeout(() => resolve6(null), ms);
+  const timeout = new Promise((resolve7) => {
+    timer = setTimeout(() => resolve7(null), ms);
   });
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
@@ -12596,11 +12941,11 @@ async function runAgyHook(event2, stdin, env, options = {}) {
 
 // src/statusline.ts
 init_define_HERD_PACKAGE();
-import { spawn as spawn10 } from "node:child_process";
+import { spawn as spawn11 } from "node:child_process";
 import { readFileSync as readFileSync21 } from "node:fs";
 import { connect as connect3 } from "node:net";
 import { homedir as homedir7 } from "node:os";
-import { join as join32 } from "node:path";
+import { join as join34 } from "node:path";
 var MAX_INPUT = 64 * 1024;
 var REPORT_TIMEOUT_MS = 300;
 var OWN_COMMAND_TIMEOUT_MS = 5e3;
@@ -12637,7 +12982,7 @@ function agyStateFrom(input) {
 function ownAgyStatusLine(home = homedir7()) {
   try {
     const settings = JSON.parse(
-      readFileSync21(join32(home, ".gemini", "antigravity-cli", "settings.json"), "utf8")
+      readFileSync21(join34(home, ".gemini", "antigravity-cli", "settings.json"), "utf8")
     );
     const command = settings.statusLine?.command;
     if (typeof command !== "string" || !command.trim()) return null;
@@ -12657,25 +13002,25 @@ function commandIn(path) {
   }
 }
 function ownStatusLine(projectDir, home = homedir7()) {
-  return commandIn(join32(projectDir, ".claude", "settings.json")) ?? commandIn(join32(home, ".claude", "settings.json"));
+  return commandIn(join34(projectDir, ".claude", "settings.json")) ?? commandIn(join34(home, ".claude", "settings.json"));
 }
 function runOwnCommand(command, input, cwd, timeoutMs = OWN_COMMAND_TIMEOUT_MS) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let output2 = "";
     let child;
     try {
-      child = spawn10("sh", ["-c", command], {
+      child = spawn11("sh", ["-c", command], {
         cwd,
         detached: true,
         stdio: ["pipe", "pipe", "ignore"]
       });
     } catch {
-      return resolve6("");
+      return resolve7("");
     }
     const finish = (text4) => {
       clearTimeout(timer);
       child.stdout?.destroy();
-      resolve6(text4);
+      resolve7(text4);
     };
     const timer = setTimeout(() => {
       try {
@@ -12693,12 +13038,12 @@ function runOwnCommand(command, input, cwd, timeoutMs = OWN_COMMAND_TIMEOUT_MS)
   });
 }
 function tellDaemon(path, request, timeoutMs = REPORT_TIMEOUT_MS) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const socket = connect3(path);
     const done = () => {
       clearTimeout(timer);
       socket.destroy();
-      resolve6();
+      resolve7();
     };
     const timer = setTimeout(done, timeoutMs);
     socket.on("connect", () => socket.write(`${JSON.stringify(request)}
@@ -12950,7 +13295,7 @@ init_define_HERD_PACKAGE();
 import { connect as connect4 } from "node:net";
 var DETACH_KEY = "";
 function attach(name, { stdin, stdout } = { stdin: process.stdin, stdout: process.stdout }, path = currentHostSocketPath()) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const socket = connect4(path);
     const size = () => ({ cols: stdout.columns || 120, rows: stdout.rows || 40 });
     let buffer = "";
@@ -12964,7 +13309,7 @@ function attach(name, { stdin, stdout } = { stdin: process.stdin, stdout: proces
       stdin.pause();
       stdout.off("resize", onResize);
       socket.end();
-      resolve6(result);
+      resolve7(result);
     };
     const onInput = (chunk) => {
       const data = chunk.toString("utf8");
@@ -13049,20 +13394,21 @@ async function runTerminalHost(rest) {
 
 // src/commands/repo.ts
 init_define_HERD_PACKAGE();
-import { join as join33 } from "node:path";
+import { join as join35 } from "node:path";
 import { z as z32 } from "zod";
 var REPO_HELP = `Usage: herd repo <url or owner/name> [folder]
 
 Checks a repo out in this conversation's folder, on a branch named for the conversation, started
-from the freshly fetched default branch, and records it in the conversation. herd clones the repo
-the first time this machine needs it, with your owner's own git credentials, and keeps that clone
-for every conversation. owner/name means one of the repos herd repos lists, or else
+from the freshly fetched default branch, and records it in the conversation. It comes from your
+owner's own checkout of the repo in the machine's root, and gets that checkout's local files git
+ignores, such as .env, copied in. A repo the root doesn't have is cloned into it first, with your
+owner's own git credentials. owner/name means one of the repos herd repos lists, or else
 github.com/owner/name. The folder is the repo's name, or <owner>-<name> when that's taken, unless
 you give one. Running it again for a repo that's already here changes nothing.`;
 var REPOS_HELP = `Usage: herd repos [--json]
 
-Lists the repos in this conversation's folder, the repos herd has cloned on this machine, and the
-repos your owner's herd.config.ts describes, with what each is for. Add one with herd repo.`;
+Lists the repos in this conversation's folder, the repos checked out in this machine's root, and
+the repos your owner's herd.config.ts describes, with what each is for. Add one with herd repo.`;
 var repoContextSchema = z32.object({
   folder: z32.string(),
   root: z32.string(),
@@ -13136,7 +13482,7 @@ async function runRepo(rest) {
       folderName ? `${folderName} is already taken in this conversation's folder. Give another name.` : `Both ${repoName(key)} and ${repoOwner(key)}-${repoName(key)} are taken in this conversation's folder. Give a folder name: herd repo ${asked} <folder>.`
     );
   }
-  const path = join33(here.folder, place.name);
+  const path = join35(here.folder, place.name);
   const recorded = here.recorded.some((repo) => repo.folder === place.name);
   if (place.existing && recorded) {
     const branch = here.recorded.find((repo) => repo.folder === place.name)?.branch ?? here.branch;
@@ -13178,13 +13524,14 @@ ${error.message}`);
     note = ` The conversation couldn't record it: ${error instanceof Error ? error.message : error}`;
   }
   const lines = [
-    added.created ? `Added ${key} in ${path}, on ${added.branch} from ${added.base}.${added.cloned ? " herd cloned it for this machine first." : ""}` : `${key} is already here, in ${path}.`
+    added.created ? `Added ${key} in ${path}, on ${added.branch} from ${added.base}.${added.cloned ? " herd cloned it into the root first." : ""}` : `${key} is already here, in ${path}.`
   ];
   if (added.fetchFailed) {
     lines.push(
       `Couldn't fetch it, so it started from the last fetched ${added.base}: ${added.fetchFailed}`
     );
   }
+  if (added.copied.length > 0) lines.push(describeCopied(place.name, added.copied));
   if (added.created) lines.push("Its own AGENTS.md or README says how to set it up.");
   console.log(lines.join("\n") + note);
   return 0;
@@ -13196,7 +13543,7 @@ function formatRepos(here) {
   for (const repo of here.recorded)
     lines.push(`  ${repo.folder}  ${repo.remote}  on ${repo.branch}`);
   const cloned = here.cloned.filter((repo) => !inFolder.has(repo.key));
-  lines.push("", "Cloned on this machine:");
+  lines.push("", "Checked out in the root:");
   if (cloned.length === 0) lines.push("  none others");
   const about = new Map(here.described.map((repo) => [repo.key, repo.about]));
   for (const repo of cloned) {
@@ -13240,7 +13587,7 @@ async function runRepos(rest) {
 init_define_HERD_PACKAGE();
 init_src();
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 var SEND_HELP = `Usage: herd send <text>
        herd send -- <text that starts with a dash>
        herd send < reply.txt
@@ -13323,7 +13670,7 @@ function withAbsolutePaths(message, cwd = process.cwd()) {
   return {
     ...message,
     files: files.map(
-      (file) => file && typeof file === "object" && typeof file.path === "string" ? { ...file, path: resolve5(cwd, file.path) } : file
+      (file) => file && typeof file === "object" && typeof file.path === "string" ? { ...file, path: resolve6(cwd, file.path) } : file
     )
   };
 }
@@ -13960,7 +14307,7 @@ ${HELP4}`);
 // src/package-entry.ts
 var invoked = (() => {
   try {
-    return realpathSync9(process.argv[1] ?? "");
+    return realpathSync11(process.argv[1] ?? "");
   } catch {
     return "";
   }