@herdingchats/friday 0.1.613 → 0.1.623

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.613", gitHead: "81ca2a791596886d867b9d1da1ba8e0430bed3c4" };
+    define_HERD_PACKAGE_default = { version: "0.1.623", gitHead: "0c391f8523159d26c6e23d46eb803c56a4e7a9ec" };
   }
 });
 
@@ -1496,8 +1496,6 @@ var init_conversation_state = __esm({
       waiting: "eyes",
       working: "hourglass_flowing_sand",
       handled: "white_check_mark",
-      // Seen, and not meant for the bot, so it left the message alone.
-      passed: "ok_hand",
       stuck: "warning"
     };
     conversationStateSchema = z13.enum([
@@ -3206,9 +3204,9 @@ import { fileURLToPath as fileURLToPath3 } from "node:url";
 init_define_HERD_PACKAGE();
 init_src();
 import { spawn as spawn7 } from "node:child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname10, join as join14 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname10, join as join15 } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { z as z22 } from "zod";
 
@@ -5662,6 +5660,9 @@ StandardError=append:${context2.paths.supervisorLog}
 WantedBy=default.target
 `;
 }
+function makeLogFolder(context2) {
+  mkdirSync8(dirname8(context2.paths.supervisorLog), { recursive: true });
+}
 function writeIfChanged(path, text4) {
   if (existsSync7(path) && readFileSync7(path, "utf8") === text4) return false;
   mkdirSync8(dirname8(path), { recursive: true });
@@ -5675,7 +5676,10 @@ function launchd(context2) {
   const loaded = async () => (await context2.run("launchctl", ["print", target])).status === 0;
   return {
     kind: "launchd",
-    install: async () => writeIfChanged(plist, launchAgentPlist(context2)),
+    install: async () => {
+      makeLogFolder(context2);
+      return writeIfChanged(plist, launchAgentPlist(context2));
+    },
     async start(changed) {
       if (await loaded()) {
         if (!changed) return;
@@ -5703,7 +5707,10 @@ function systemd(context2) {
   };
   return {
     kind: "systemd",
-    install: async () => writeIfChanged(unit, systemdUnit(context2)),
+    install: async () => {
+      makeLogFolder(context2);
+      return writeIfChanged(unit, systemdUnit(context2));
+    },
     async start(changed) {
       if (changed) await systemctl("daemon-reload");
       await systemctl("enable", SYSTEMD_UNIT);
@@ -5775,87 +5782,30 @@ function serviceFor(kind, context2) {
 init_define_HERD_PACKAGE();
 init_src();
 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 existsSync8, readdirSync as readdirSync3, rmSync as rmSync8 } from "node:fs";
-import { userInfo as userInfo2 } from "node:os";
-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 = 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 = 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}`);
-  }
-  for (const pm2 of oldPm2s(paths)) {
-    const listed = await run4(process.execPath, [pm2, "jlist"]);
-    let names = [];
-    try {
-      names = JSON.parse(listed.stdout).map((app) => app.name ?? "");
-    } catch {
-      names = [];
-    }
-    const ours = OLD_APPS.filter((name) => names.includes(name));
-    if (ours.length === 0) continue;
-    for (const name of ours) await run4(process.execPath, [pm2, "delete", name]);
-    await run4(process.execPath, [pm2, "save", "--force"]);
-    removed.push(`pm2's ${ours.join(" and ")}`);
-  }
-  return removed;
-}
+import { join as join14, resolve as resolve3 } from "node:path";
 
-// src/friday/verbose.ts
+// src/package-manager.ts
 init_define_HERD_PACKAGE();
-var VERBOSE_ENV = "HERD_VERBOSE";
-var began = Date.now();
-function verbose2(line2) {
-  if (!process.env[VERBOSE_ENV]) return;
-  const seconds = ((Date.now() - began) / 1e3).toFixed(1);
-  process.stderr.write(`[friday +${seconds}s] ${line2}
-`);
-}
-var tail = (text4) => text4.trim().split("\n").slice(-3).join(" | ");
-function verboseExec(run4) {
-  return async (command, args, options) => {
-    if (!process.env[VERBOSE_ENV]) return run4(command, args, options);
-    const shown = [command, ...args].join(" ");
-    verbose2(`running ${shown}`);
-    const started = Date.now();
-    const ran = await run4(command, args, options);
-    const took = `${Date.now() - started}ms`;
-    verbose2(
-      ran.status === 0 ? `ran ${shown} (${took})` : `${shown} exited ${ran.status} (${took})${ran.stderr.trim() ? `: ${tail(ran.stderr)}` : ""}`
-    );
-    return ran;
-  };
-}
+import { existsSync as existsSync9 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { basename as basename3, delimiter, dirname as dirname9, isAbsolute as isAbsolute2, join as join12 } from "node:path";
 
 // src/friday/versions.ts
 init_define_HERD_PACKAGE();
 import { spawn as spawn5 } from "node:child_process";
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync9,
-  readdirSync as readdirSync4,
+  readdirSync as readdirSync3,
   readFileSync as readFileSync8,
   readlinkSync,
   realpathSync as realpathSync3,
   renameSync as renameSync3,
-  rmSync as rmSync9,
+  rmSync as rmSync8,
   symlinkSync,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { basename as basename2, dirname as dirname9, join as join12 } from "node:path";
+import { basename as basename2, join as join11 } from "node:path";
 var exec = (command, args, options = {}) => new Promise((resolve7) => {
   let stdout = "";
   let stderr = "";
@@ -5876,10 +5826,6 @@ var exec = (command, args, options = {}) => new Promise((resolve7) => {
     resolve7({ status: status2 ?? 1, stdout, stderr });
   });
 });
-function npmCommand() {
-  const beside = join12(dirname9(process.execPath), "npm");
-  return existsSync9(beside) ? beside : "npm";
-}
 function currentVersion(paths) {
   try {
     return basename2(readlinkSync(paths.current));
@@ -5888,10 +5834,10 @@ function currentVersion(paths) {
   }
 }
 function installedVersions(paths) {
-  if (!existsSync9(paths.versions)) return [];
-  return readdirSync4(paths.versions).filter((name) => VERSION.test(name)).sort(compareVersions);
+  if (!existsSync8(paths.versions)) return [];
+  return readdirSync3(paths.versions).filter((name) => VERSION.test(name)).sort(compareVersions);
 }
-var binOf = (versionDir, bin) => join12(packageDir(versionDir), `${bin}.mjs`);
+var binOf = (versionDir, bin) => join11(packageDir(versionDir), `${bin}.mjs`);
 async function versionRuns(versionDir, version, run4 = exec) {
   const ran = await run4(process.execPath, [binOf(versionDir, "herd"), "--version"], {
     timeoutMs: 3e4
@@ -5903,12 +5849,19 @@ async function versionRuns(versionDir, version, run4 = exec) {
   return null;
 }
 function recordedIntegrity(dir) {
-  try {
-    const lock = JSON.parse(readFileSync8(join12(dir, "package-lock.json"), "utf8"));
-    return lock.packages?.[`node_modules/${PACKAGE_NAME}`]?.integrity ?? null;
-  } catch {
-    return null;
+  for (const manager of INSTALLERS) {
+    for (const file of LOCKFILES[manager]) {
+      let lock;
+      try {
+        lock = readFileSync8(join11(dir, file), "utf8");
+      } catch {
+        continue;
+      }
+      const found = lockedIntegrity(manager, lock, PACKAGE_NAME);
+      if (found) return found;
+    }
   }
+  return null;
 }
 function npmFreeEnv() {
   return Object.fromEntries(
@@ -5916,10 +5869,10 @@ function npmFreeEnv() {
   );
 }
 async function installVersion(paths, version, { spec, integrity, run: run4 = exec, env = {}, log = () => {
-} } = {}) {
+}, manager } = {}) {
   if (!VERSION.test(version)) return { ok: false, reason: `${version} isn't a version.` };
-  const dir = join12(paths.versions, version);
-  if (existsSync9(dir)) {
+  const dir = join11(paths.versions, version);
+  if (existsSync8(dir)) {
     const installed2 = recordedIntegrity(dir);
     if (integrity && installed2 !== integrity)
       return { ok: false, reason: `the installed ${version} doesn't have the integrity named.` };
@@ -5927,62 +5880,63 @@ async function installVersion(paths, version, { spec, integrity, run: run4 = exe
     if (!broken2) return { ok: true, dir };
     return { ok: false, reason: `the installed ${version} doesn't run: ${broken2}.` };
   }
+  const using = manager ?? await findPackageManager({ env: { ...process.env, ...env }, run: run4 });
+  if (!using)
+    return {
+      ok: false,
+      reason: "there's no package manager to install it with: herd looked for npm, pnpm and Yarn 1 beside Node, on the PATH and in their usual folders."
+    };
   sweepStaging(paths);
-  const named = join12(paths.versions, `.staging-${version}-${process.pid}`);
-  rmSync9(named, { recursive: true, force: true });
+  const named = join11(paths.versions, `.staging-${version}-${process.pid}`);
+  rmSync8(named, { recursive: true, force: true });
   mkdirSync9(named, { recursive: true });
   const staging = realpathSync3(named);
   writeFileSync8(
-    join12(staging, "package.json"),
-    `${JSON.stringify({ private: true, allowScripts: { "node-pty": true } }, null, 2)}
+    join11(staging, "package.json"),
+    `${JSON.stringify(allowScriptsManifest(["node-pty"]), null, 2)}
 `
   );
+  if (using.name === "pnpm")
+    writeFileSync8(join11(staging, "pnpm-workspace.yaml"), allowScriptsWorkspace(["node-pty"]));
   const fail = (reason) => {
-    rmSync9(staging, { recursive: true, force: true });
+    rmSync8(staging, { recursive: true, force: true });
     return { ok: false, reason };
   };
-  log(`Installing ${PACKAGE_NAME}@${version}.`);
+  log(`Installing ${PACKAGE_NAME}@${version} with ${using.name} ${using.version}.`);
   const installed = await run4(
-    npmCommand(),
-    [
-      "install",
-      "--prefix",
-      staging,
-      spec ?? `${PACKAGE_NAME}@${version}`,
-      "--no-audit",
-      "--no-fund",
-      "--no-update-notifier",
-      "--save-exact"
-    ],
+    using.command,
+    addArgs(using.name, staging, spec ?? `${PACKAGE_NAME}@${version}`),
     // From inside the folder, so a workspace around wherever this ran isn't taken for its project.
     { cwd: staging, env: { ...npmFreeEnv(), ...env }, timeoutMs: 10 * 6e4 }
   );
   if (installed.status !== 0)
-    return fail(`npm couldn't install it: ${installed.stderr.trim().slice(-500)}`);
+    return fail(
+      `${using.name} couldn't install it: ${(installed.stderr || installed.stdout).trim().slice(-500)}`
+    );
   if (integrity) {
     const got = recordedIntegrity(staging);
     if (got !== integrity)
       return fail(
-        `its integrity doesn't match the release: npm served ${got ?? "nothing"}, and herd named ${integrity}`
+        `its integrity doesn't match the release: ${using.name} recorded ${got ?? "nothing"}, and herd named ${integrity}`
       );
   }
   const broken = await versionRuns(staging, version, run4);
   if (broken) return fail(broken);
-  renameSync3(staging, join12(realpathSync3(paths.versions), version));
+  renameSync3(staging, join11(realpathSync3(paths.versions), version));
   return { ok: true, dir };
 }
 function sweepStaging(paths) {
-  if (!existsSync9(paths.versions)) return;
-  for (const name of readdirSync4(paths.versions)) {
+  if (!existsSync8(paths.versions)) return;
+  for (const name of readdirSync3(paths.versions)) {
     const match = /^\.staging-.+-(\d+)$/.exec(name);
     if (match && !alive2(Number(match[1])))
-      rmSync9(join12(paths.versions, name), { recursive: true, force: true });
+      rmSync8(join11(paths.versions, name), { recursive: true, force: true });
   }
 }
 function activate(paths, version) {
   const next = `${paths.current}.next-${process.pid}`;
-  rmSync9(next, { force: true });
-  symlinkSync(join12("versions", version), next);
+  rmSync8(next, { force: true });
+  symlinkSync(join11("versions", version), next);
   renameSync3(next, paths.current);
 }
 function pruneVersions(paths, { inUse = [], keep = 3 } = {}) {
@@ -5997,7 +5951,7 @@ function pruneVersions(paths, { inUse = [], keep = 3 } = {}) {
   const removed = [];
   for (const version of versions) {
     if (kept.has(version)) continue;
-    rmSync9(join12(paths.versions, version), { recursive: true, force: true });
+    rmSync8(join11(paths.versions, version), { recursive: true, force: true });
     removed.push(version);
   }
   return removed;
@@ -6021,6 +5975,271 @@ async function hostVersions(paths, run4 = exec) {
   return [...found].filter(Boolean);
 }
 
+// src/package-manager.ts
+var MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+var INSTALLERS = ["npm", "pnpm", "yarn"];
+var MANAGER_ENV = "HERD_PACKAGE_MANAGER";
+var nameOf = (command) => {
+  const name = basename3(command).replace(/\.(cmd|exe|ps1)$/i, "");
+  return MANAGERS.includes(name) ? name : null;
+};
+function homesOf(name, env, home) {
+  const common = [join12(home, ".volta", "bin"), join12(home, ".local", "bin")];
+  switch (name) {
+    case "pnpm":
+      return [
+        ...env.PNPM_HOME ? [env.PNPM_HOME] : [],
+        join12(home, "Library", "pnpm"),
+        join12(home, ".local", "share", "pnpm"),
+        ...common
+      ];
+    case "bun":
+      return [join12(env.BUN_INSTALL || join12(home, ".bun"), "bin"), ...common];
+    case "yarn":
+      return [join12(home, ".yarn", "bin"), ...common];
+    case "npm":
+      return common;
+  }
+}
+function candidatePaths(name, {
+  env = process.env,
+  execPath = process.execPath,
+  home = homedir4(),
+  platform: platform2 = process.platform
+} = {}) {
+  const path = (env.PATH ?? env.Path ?? "").split(platform2 === "win32" ? ";" : delimiter);
+  const dirs = [
+    dirname9(execPath),
+    ...path,
+    ...homesOf(name, env, home),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin"
+  ];
+  const files = platform2 === "win32" ? [`${name}.cmd`, `${name}.exe`] : [name];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of dirs.filter(Boolean)) {
+    for (const file of files) seen.add(join12(dir, file));
+  }
+  return [...seen];
+}
+async function versionOf(command, run4, env) {
+  const ran = await run4(command, ["--version"], {
+    // A corepack shim would otherwise ask before downloading the manager it stands in for.
+    env: { ...env, COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" },
+    timeoutMs: 2e4
+  });
+  const version = ran.stdout.trim().split("\n").at(-1)?.trim() ?? "";
+  return ran.status === 0 && /^\d+\.\d+/.test(version) ? version : null;
+}
+var installs = (name, version) => name !== "yarn" || Number(version.split(".")[0]) < 2;
+async function findPackageManager(options = {}) {
+  const env = options.env ?? process.env;
+  const exists = options.exists ?? existsSync9;
+  const run4 = options.run ?? exec;
+  const only = options.only ?? INSTALLERS;
+  const accept = options.accept ?? installs;
+  const tried = /* @__PURE__ */ new Set();
+  const attempt = async (name, command) => {
+    if (tried.has(command)) return null;
+    tried.add(command);
+    if (isAbsolute2(command) && !exists(command)) return null;
+    const version = await versionOf(command, run4, env);
+    return version && accept(name, version) ? { name, command, version } : null;
+  };
+  const override = env[MANAGER_ENV]?.trim();
+  if (override) {
+    const name = nameOf(override);
+    if (name && only.includes(name)) {
+      const paths = isAbsolute2(override) ? [override] : candidatePaths(name, options);
+      for (const path of paths) {
+        const found = await attempt(name, path);
+        if (found) return found;
+      }
+    }
+  }
+  for (const name of only) {
+    for (const path of candidatePaths(name, options)) {
+      const found = await attempt(name, path);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function addArgs(manager, dir, spec) {
+  if (manager === "bun") throw new Error("Bun doesn't install Friday's versions.");
+  switch (manager) {
+    case "npm":
+      return [
+        "install",
+        "--prefix",
+        dir,
+        spec,
+        "--no-audit",
+        "--no-fund",
+        "--no-update-notifier",
+        "--save-exact"
+      ];
+    case "pnpm":
+      return ["add", spec, "--dir", dir, "--save-exact", "--config.update-notifier=false"];
+    case "yarn":
+      return ["add", spec, "--cwd", dir, "--exact", "--no-progress", "--non-interactive"];
+  }
+}
+var LOCKFILES = {
+  npm: ["package-lock.json", "npm-shrinkwrap.json"],
+  pnpm: ["pnpm-lock.yaml"],
+  bun: ["bun.lock", "bun.lockb"],
+  yarn: ["yarn.lock"]
+};
+var escapeRegExp = (text4) => text4.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+function lockedIntegrity(manager, lock, name) {
+  const integrity = /sha512-[A-Za-z0-9+/]+=*/;
+  switch (manager) {
+    case "npm": {
+      try {
+        const parsed = JSON.parse(lock);
+        return parsed.packages?.[`node_modules/${name}`]?.integrity ?? null;
+      } catch {
+        return null;
+      }
+    }
+    case "bun":
+      return null;
+    case "pnpm":
+    case "yarn": {
+      const lines = lock.split("\n");
+      const key = new RegExp(`^(\\s*)["']?${escapeRegExp(name)}@[^\\n]*:\\s*$`);
+      for (let i = 0; i < lines.length; i++) {
+        const match = key.exec(lines[i] ?? "");
+        if (!match) continue;
+        const indent = match[1]?.length ?? 0;
+        for (let j = i + 1; j < lines.length; j++) {
+          const line2 = lines[j] ?? "";
+          if (line2.trim() === "") continue;
+          if (line2.length - line2.trimStart().length <= indent) break;
+          const found = integrity.exec(line2);
+          if (found) return found[0];
+        }
+      }
+      return null;
+    }
+  }
+}
+function allowScriptsManifest(packages) {
+  return {
+    private: true,
+    // npm's.
+    allowScripts: Object.fromEntries(packages.map((name) => [name, true])),
+    // pnpm's, before pnpm-workspace.yaml held them.
+    pnpm: { onlyBuiltDependencies: packages }
+  };
+}
+var allowScriptsWorkspace = (packages) => `onlyBuiltDependencies:
+${packages.map((name) => `  - ${name}`).join("\n")}
+allowBuilds:
+${packages.map((name) => `  ${name}: true`).join("\n")}
+`;
+function managerOfCheckout(packageManagerField, hasFile) {
+  const declared = packageManagerField ? /^(npm|pnpm|bun|yarn)@(\d+)/.exec(packageManagerField) : null;
+  const lockOf = (name) => LOCKFILES[name].find(hasFile) ?? null;
+  if (declared) {
+    const name = declared[1];
+    return { name, lockfile: lockOf(name), major: Number(declared[2]) };
+  }
+  for (const name of MANAGERS) {
+    const lockfile = lockOf(name);
+    if (lockfile) return { name, lockfile, major: null };
+  }
+  return null;
+}
+function frozenInstallArgs(name, { offline, yarnMajor }) {
+  switch (name) {
+    case "npm":
+      return [
+        "ci",
+        offline ? "--offline" : "--prefer-offline",
+        "--no-audit",
+        "--no-fund",
+        "--no-update-notifier"
+      ];
+    case "pnpm":
+      return ["install", "--frozen-lockfile", offline ? "--offline" : "--prefer-offline"];
+    case "bun":
+      return ["install", "--frozen-lockfile", "--no-progress"];
+    case "yarn":
+      return (yarnMajor ?? 1) >= 2 ? ["install", "--immutable"] : [
+        "install",
+        "--frozen-lockfile",
+        "--non-interactive",
+        ...offline ? ["--offline"] : ["--prefer-offline"]
+      ];
+  }
+}
+
+// src/friday/legacy.ts
+init_define_HERD_PACKAGE();
+import { existsSync as existsSync10, readdirSync as readdirSync4, rmSync as rmSync9 } from "node:fs";
+import { userInfo as userInfo2 } from "node:os";
+import { join as join13 } from "node:path";
+var OLD_LAUNCH_AGENT = "com.herdingchats.herd";
+var OLD_APPS = ["herd-daemon", "herd-updater"];
+function oldPm2s(paths) {
+  const dir = join13(paths.herdHome, "daemon");
+  if (!existsSync10(dir)) return [];
+  return readdirSync4(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join13(dir, entry.name, "node_modules", "pm2", "bin", "pm2")).filter((pm2) => existsSync10(pm2));
+}
+async function retireOldDaemon(paths, { home, run: run4 }) {
+  const removed = [];
+  const plist = join13(home, "Library", "LaunchAgents", `${OLD_LAUNCH_AGENT}.plist`);
+  if (existsSync10(plist)) {
+    await run4("launchctl", ["bootout", `gui/${userInfo2().uid}/${OLD_LAUNCH_AGENT}`]);
+    rmSync9(plist, { force: true });
+    removed.push(`the login item ${OLD_LAUNCH_AGENT}`);
+  }
+  for (const pm2 of oldPm2s(paths)) {
+    const listed = await run4(process.execPath, [pm2, "jlist"]);
+    let names = [];
+    try {
+      names = JSON.parse(listed.stdout).map((app) => app.name ?? "");
+    } catch {
+      names = [];
+    }
+    const ours = OLD_APPS.filter((name) => names.includes(name));
+    if (ours.length === 0) continue;
+    for (const name of ours) await run4(process.execPath, [pm2, "delete", name]);
+    await run4(process.execPath, [pm2, "save", "--force"]);
+    removed.push(`pm2's ${ours.join(" and ")}`);
+  }
+  return removed;
+}
+
+// src/friday/verbose.ts
+init_define_HERD_PACKAGE();
+var VERBOSE_ENV = "HERD_VERBOSE";
+var began = Date.now();
+function verbose2(line2) {
+  if (!process.env[VERBOSE_ENV]) return;
+  const seconds = ((Date.now() - began) / 1e3).toFixed(1);
+  process.stderr.write(`[friday +${seconds}s] ${line2}
+`);
+}
+var tail = (text4) => text4.trim().split("\n").slice(-3).join(" | ");
+function verboseExec(run4) {
+  return async (command, args, options) => {
+    if (!process.env[VERBOSE_ENV]) return run4(command, args, options);
+    const shown = [command, ...args].join(" ");
+    verbose2(`running ${shown}`);
+    const started = Date.now();
+    const ran = await run4(command, args, options);
+    const took = `${Date.now() - started}ms`;
+    verbose2(
+      ran.status === 0 ? `ran ${shown} (${took})` : `${shown} exited ${ran.status} (${took})${ran.stderr.trim() ? `: ${tail(ran.stderr)}` : ""}`
+    );
+    return ran;
+  };
+}
+
 // src/friday/start.ts
 var MIN_NODE = [22, 18];
 var SETUP_WAIT_MS = 2e4;
@@ -6051,7 +6270,7 @@ var real = (path) => {
   }
 };
 function chooseRoot(cwd, home) {
-  return real(cwd) === real(home) ? join13(home, "friday") : resolve3(cwd);
+  return real(cwd) === real(home) ? join14(home, "friday") : resolve3(cwd);
 }
 async function runStart(options) {
   const { paths, run: run4 } = options;
@@ -6116,9 +6335,15 @@ async function runStart(options) {
     print(
       `Stopped the old daemon: removed ${retired.join(" and ")}. Its checkout is left as it was.`
     );
-  await ensureInstalled(options, print);
+  const manager = options.install?.manager ?? await findPackageManager({ run: run4 });
+  if (!manager)
+    throw new StartError(
+      "Friday installs and updates itself with npm, pnpm or Yarn 1, and herd found none of them that runs, beside Node, on your PATH or in their usual folders. Install one, or set HERD_PACKAGE_MANAGER to the path of one, then run this again."
+    );
+  verbose2(`installing with ${manager.name} ${manager.version}, at ${manager.command}`);
+  await ensureInstalled({ ...options, install: { ...options.install, manager } }, print);
   const command = [process.execPath, binOf(paths.current, "friday"), "supervise"];
-  const env = { HERD_HOME: paths.herdHome, ...options.env };
+  const env = { HERD_HOME: paths.herdHome, [MANAGER_ENV]: manager.command, ...options.env };
   const service = (options.service ?? defaultService(options))(command, env);
   if (moving && running) {
     print(`Stopping Friday at ${existing} to start it again from ${root}.`);
@@ -6224,7 +6449,7 @@ init_src();
 import { spawn as spawn6 } from "node:child_process";
 import {
   closeSync as closeSync3,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync as mkdirSync11,
   openSync as openSync4,
   readFileSync as readFileSync9,
@@ -6309,7 +6534,7 @@ var Supervisor = class {
     const { daemonLog, logs } = this.options.paths;
     mkdirSync11(logs, { recursive: true });
     try {
-      if (existsSync10(daemonLog) && statSync6(daemonLog).size > MAX_LOG_BYTES2)
+      if (existsSync11(daemonLog) && statSync6(daemonLog).size > MAX_LOG_BYTES2)
         renameSync4(daemonLog, `${daemonLog}.1`);
     } catch {
     }
@@ -6462,9 +6687,9 @@ Usage: ${FRIDAY_COMMAND} <command>
 
 Agents use the herd command, which comes with this one. herd setup shows what's left to set up.`;
 function defaults() {
-  const home = homedir4();
+  const home = homedir5();
   return {
-    paths: fridayPaths(process.env.HERD_HOME ?? join14(home, ".herd")),
+    paths: fridayPaths(process.env.HERD_HOME ?? join15(home, ".herd")),
     home,
     cwd: process.cwd(),
     run: exec,
@@ -6536,7 +6761,7 @@ async function friday(args, deps = defaults()) {
           agents: {
             // The choice lives in herd.config.ts, so it's asked for only before there is one, or
             // with --config.
-            ask: rest.includes("--config") || !existsSync11(herdConfigIn(deps.paths.herdHome)),
+            ask: rest.includes("--config") || !existsSync12(herdConfigIn(deps.paths.herdHome)),
             installed: async () => {
               verbose2("looking for installed agents");
               const found = installedAgents();
@@ -6595,7 +6820,7 @@ function agentsFlag(args) {
   return parsed.shares;
 }
 function attachTo(paths, terminal) {
-  const herd = existsSync11(binOf(paths.current, "herd")) ? binOf(paths.current, "herd") : join14(dirname10(process.argv[1] ?? ""), "herd.mjs");
+  const herd = existsSync12(binOf(paths.current, "herd")) ? binOf(paths.current, "herd") : join15(dirname10(process.argv[1] ?? ""), "herd.mjs");
   const child = spawn7(process.execPath, [herd, "attach", terminal], {
     stdio: "inherit",
     env: { ...process.env, HERD_HOME: paths.herdHome }
@@ -6659,14 +6884,14 @@ function runStatus(deps) {
 function readMissingFolder(herdHome2) {
   try {
     return folderUnavailableSchema.parse(
-      JSON.parse(readFileSync10(join14(herdHome2, "folder-unavailable.json"), "utf8"))
+      JSON.parse(readFileSync10(join15(herdHome2, "folder-unavailable.json"), "utf8"))
     );
   } catch {
     return null;
   }
 }
 function tail2(path, count) {
-  if (!existsSync11(path)) return [];
+  if (!existsSync12(path)) return [];
   const lines = readFileSync10(path, "utf8").split("\n");
   if (lines.at(-1) === "") lines.pop();
   return lines.slice(-count);
@@ -6674,7 +6899,7 @@ function tail2(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) => existsSync11(file));
+  const files = [paths.supervisorLog, paths.daemonLog].filter((file) => existsSync12(file));
   if (files.length === 0) {
     print(`There are no logs in ${paths.logs} yet.`);
     return 0;
@@ -6724,7 +6949,7 @@ init_define_HERD_PACKAGE();
 init_define_HERD_PACKAGE();
 import { spawn as spawn8 } from "node:child_process";
 import { appendFileSync, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname11, join as join15 } from "node:path";
+import { dirname as dirname11, join as join16 } from "node:path";
 var DEPLOY_HOSTS = ["api.cloudflare.com", "api.github.com", "registry.npmjs.org"];
 function buildPolicy(input) {
   const platform2 = input.platform ?? process.platform;
@@ -6771,7 +6996,7 @@ async function runSandboxed(args) {
     return 3;
   }
   await SandboxManager.initialize(policy, void 0, true);
-  const blocked = join15(process.env.HOME ?? ".", BLOCKED_LOG);
+  const blocked = join16(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);
@@ -7272,8 +7497,8 @@ init_define_HERD_PACKAGE();
 // src/build-runner-key.ts
 init_define_HERD_PACKAGE();
 init_src();
-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 { chmodSync as chmodSync3, existsSync as existsSync13, mkdirSync as mkdirSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join17 } from "node:path";
 import { z as z24 } from "zod";
 var BUILDS_URL = "https://builds.herdingchats.com";
 var runnerKeySchema = z24.object({
@@ -7281,10 +7506,10 @@ var runnerKeySchema = z24.object({
   key: z24.string().min(20),
   url: z24.string().url()
 });
-var runnerKeyPath = () => join16(herdHome(), "build-runner.json");
+var runnerKeyPath = () => join17(herdHome(), "build-runner.json");
 function readRunnerKey() {
   const path = runnerKeyPath();
-  if (!existsSync12(path)) return null;
+  if (!existsSync13(path)) return null;
   try {
     return runnerKeySchema.parse(JSON.parse(readFileSync13(path, "utf8")));
   } catch {
@@ -7463,7 +7688,7 @@ function formatSpeed(report) {
 // src/builds-admin.ts
 init_define_HERD_PACKAGE();
 import { mkdirSync as mkdirSync13, readFileSync as readFileSync14, rmSync as rmSync10, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } 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);
@@ -7471,13 +7696,13 @@ async function isAdmin(fetch2) {
   const body = await response.json().catch(() => ({}));
   return body.admin === true;
 }
-var refusalPath = () => join17(herdHome(), "builds", "refused.json");
+var refusalPath = () => join18(herdHome(), "builds", "refused.json");
 function writeBuildsRefusal(reason) {
   if (!reason) {
     rmSync10(refusalPath(), { force: true });
     return;
   }
-  mkdirSync13(join17(herdHome(), "builds"), { recursive: true });
+  mkdirSync13(join18(herdHome(), "builds"), { recursive: true });
   writeFileSync10(refusalPath(), JSON.stringify({ reason }));
 }
 function readBuildsRefusal() {
@@ -7641,7 +7866,7 @@ async function runConversations(rest) {
 init_define_HERD_PACKAGE();
 init_src();
 import { availableParallelism, totalmem } from "node:os";
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 
 // src/agent.ts
 init_define_HERD_PACKAGE();
@@ -7750,20 +7975,20 @@ function readClaudeScreen(raw) {
 
 // src/worktrees.ts
 init_define_HERD_PACKAGE();
-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");
+import { existsSync as existsSync14, realpathSync as realpathSync6 } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join19, relative } from "node:path";
+var worktreesRoot = () => join19(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 = (convos, conversationId) => join18(convos, conversationPrefix(conversationId));
+var conversationFolder = (convos, conversationId) => join19(convos, conversationPrefix(conversationId));
 function folderForConversation(root, conversationId) {
   const earlier = conversationFolder(legacyConvosDir(root), conversationId);
-  return existsSync13(earlier) ? earlier : conversationFolder(convosHome(root), conversationId);
+  return existsSync14(earlier) ? earlier : conversationFolder(convosHome(root), conversationId);
 }
 var within = (dir, path) => {
   const between = relative(dir, path);
-  return between !== "" && !between.startsWith("..") && !isAbsolute2(between);
+  return between !== "" && !between.startsWith("..") && !isAbsolute3(between);
 };
 var real2 = (path) => {
   try {
@@ -8062,8 +8287,8 @@ function readAgyScreen(raw) {
 // src/agy-settings.ts
 init_define_HERD_PACKAGE();
 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");
+import { join as join20, sep } from "node:path";
+var AGY_SETTINGS_FILE = join20(".herd", "agy-settings.json");
 var AGY_HOOK_EVENTS = ["SessionStart", "PreInvocation", "Stop"];
 var agyHookCommand = (event2, herd) => `${herd} hook agy ${event2} || true`;
 function agyHooks(herd) {
@@ -8080,7 +8305,7 @@ function agySettings(herd) {
   return { statusLine: { type: "command", command: `${herd} statusline agy` } };
 }
 function ownFolder(worktree, name) {
-  const folder = join19(worktree, name);
+  const folder = join20(worktree, name);
   if (lstatSync2(folder, { throwIfNoEntry: false })?.isSymbolicLink()) {
     throw new Error(`${name} in the worktree is a link`);
   }
@@ -8092,13 +8317,13 @@ function ownFolder(worktree, name) {
 }
 function writeAgyFiles(worktree, herd) {
   const agents = ownFolder(worktree, ".agents");
-  writeFileSync11(join19(agents, "hooks.json"), `${JSON.stringify(agyHooks(herd), null, 2)}
+  writeFileSync11(join20(agents, "hooks.json"), `${JSON.stringify(agyHooks(herd), null, 2)}
 `);
-  writeFileSync11(join19(agents, ".gitignore"), "*\n");
+  writeFileSync11(join20(agents, ".gitignore"), "*\n");
   const herdFolder = ownFolder(worktree, ".herd");
-  writeFileSync11(join19(herdFolder, ".gitignore"), "*\n");
+  writeFileSync11(join20(herdFolder, ".gitignore"), "*\n");
   writeFileSync11(
-    join19(worktree, AGY_SETTINGS_FILE),
+    join20(worktree, AGY_SETTINGS_FILE),
     `${JSON.stringify(agySettings(herd), null, 2)}
 `
   );
@@ -8253,15 +8478,15 @@ 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";
+import { existsSync as existsSync15, mkdirSync as mkdirSync15, readdirSync as readdirSync5, renameSync as renameSync5, rmSync as rmSync11, statSync as statSync7 } from "node:fs";
+import { dirname as dirname12, join as join21 } 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`);
+  return join21(dir, `${key}.git`);
 }
 async function ensureBareClone(store, remote, env) {
-  if (existsSync14(store)) {
+  if (existsSync15(store)) {
     let fetchFailed = null;
     try {
       await git(env, store, "fetch", "--quiet", "--prune", "origin");
@@ -8302,7 +8527,7 @@ function bareClones(dir) {
       return;
     }
     for (const name of entries.sort()) {
-      const path = join20(at, name);
+      const path = join21(at, name);
       if (name.endsWith(".git")) {
         try {
           const remote = gitSync(path, "config", "--get", "remote.origin.url");
@@ -8483,7 +8708,7 @@ init_define_HERD_PACKAGE();
 import { execFile as execFile2, execFileSync as execFileSync5, spawn as spawn9 } from "node:child_process";
 import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync17,
   mkdtempSync,
   readdirSync as readdirSync7,
@@ -8492,16 +8717,16 @@ import {
   rmSync as rmSync13,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { homedir as homedir6, tmpdir } from "node:os";
-import { join as join22 } from "node:path";
+import { homedir as homedir7, tmpdir } from "node:os";
+import { join as join23 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // src/check-registry.ts
 init_define_HERD_PACKAGE();
 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 join21 } from "node:path";
-var checkRegistryDir = () => process.env.HERDINGCHATS_CHECK_RUNNING ?? join21(homedir5(), ".cache", "herdingchats", "check", "running");
+import { homedir as homedir6 } from "node:os";
+import { join as join22 } from "node:path";
+var checkRegistryDir = () => process.env.HERDINGCHATS_CHECK_RUNNING ?? join22(homedir6(), ".cache", "herdingchats", "check", "running");
 var RESERVED_MB = 6 * 1024;
 var MIN_MEMORY_MB = 1024;
 var alive3 = (pid) => {
@@ -8514,7 +8739,7 @@ var alive3 = (pid) => {
 };
 function registerCheck(dir, pid, startedAt = Date.now()) {
   mkdirSync16(dir, { recursive: true });
-  const file = join21(dir, `${pid}.json`);
+  const file = join22(dir, `${pid}.json`);
   writeFileSync12(file, JSON.stringify({ pid, startedAt }));
   return () => rmSync12(file, { force: true });
 }
@@ -8530,12 +8755,12 @@ function runningChecks(dir, isAlive = alive3) {
     const pid = Number(name.slice(0, -".json".length));
     let entry = null;
     try {
-      entry = JSON.parse(readFileSync15(join21(dir, name), "utf8"));
+      entry = JSON.parse(readFileSync15(join22(dir, name), "utf8"));
     } catch {
       continue;
     }
     if (entry?.pid === pid && isAlive(pid)) count += 1;
-    else rmSync12(join21(dir, name), { force: true });
+    else rmSync12(join22(dir, name), { force: true });
   }
   return count;
 }
@@ -8543,9 +8768,9 @@ var memoryShareOf = (totalMb, running) => Math.max(MIN_MEMORY_MB, Math.floor((to
 
 // src/builds.ts
 init_self();
-var sandboxStatusPath = () => join22(herdHome(), "builds", "sandbox.json");
+var sandboxStatusPath = () => join23(herdHome(), "builds", "sandbox.json");
 function writeSandboxStatus(status2, now = Date.now()) {
-  mkdirSync17(join22(herdHome(), "builds"), { recursive: true });
+  mkdirSync17(join23(herdHome(), "builds"), { recursive: true });
   writeFileSync13(sandboxStatusPath(), JSON.stringify({ ...status2, at: now }));
 }
 function readSandboxStatus() {
@@ -8577,7 +8802,7 @@ var real3 = (path) => {
   }
 };
 function worktreeOf(dir, store) {
-  if (!existsSync15(join22(dir, ".git"))) return false;
+  if (!existsSync16(join23(dir, ".git"))) return false;
   try {
     return real3(git2(dir, "rev-parse", "--path-format=absolute", "--git-common-dir")) === real3(store);
   } catch {
@@ -8589,36 +8814,54 @@ function cloneFolder(from, to) {
   execFileSync5("cp", [...args, from, to]);
 }
 function moduleFolders(dir) {
-  const found = existsSync15(join22(dir, "node_modules")) ? ["node_modules"] : [];
+  const found = existsSync16(join23(dir, "node_modules")) ? ["node_modules"] : [];
   for (const entry of readdirSync7(dir, { withFileTypes: true })) {
     if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-      if (existsSync15(join22(dir, entry.name, "node_modules")))
-        found.push(join22(entry.name, "node_modules"));
+      if (existsSync16(join23(dir, entry.name, "node_modules")))
+        found.push(join23(entry.name, "node_modules"));
     }
   }
   return found;
 }
+function checkoutManager(dir) {
+  let field;
+  try {
+    const pkg = JSON.parse(readFileSync16(join23(dir, "package.json"), "utf8"));
+    if (typeof pkg.packageManager === "string") field = pkg.packageManager;
+  } catch {
+  }
+  const found = managerOfCheckout(field, (name) => existsSync16(join23(dir, name)));
+  if (!found?.lockfile)
+    throw new Error(
+      `${dir} has no lockfile to install node_modules from: herd looked for ${Object.values(LOCKFILES).flat().join(", ")}.`
+    );
+  return { ...found, lockfile: found.lockfile };
+}
 function lockHash(dir) {
-  const lock = readFileSync16(join22(dir, "package-lock.json"));
+  const lock = readFileSync16(join23(dir, checkoutManager(dir).lockfile));
   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((resolve7, reject) => {
-  const network = insideBuildSandbox() ? ["--offline"] : ["--prefer-offline"];
-  const child = spawn9(
-    "npm",
-    ["ci", ...network, "--no-audit", "--no-fund", "--no-update-notifier"],
-    {
+var frozenInstall = (gitEnv) => async (dir) => {
+  const { name, major } = checkoutManager(dir);
+  const env = gitEnv?.() ?? process.env;
+  const manager = await findPackageManager({ env, only: [name], accept: () => true });
+  if (!manager)
+    throw new Error(`${dir} installs with ${name}, which isn't on this machine, or doesn't run.`);
+  const args = frozenInstallArgs(name, { offline: insideBuildSandbox(), yarnMajor: major });
+  await new Promise((resolve7, reject) => {
+    const child = spawn9(manager.command, args, {
       cwd: dir,
+      env: { ...env, COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" },
       stdio: "ignore"
-    }
-  );
-  child.on("error", reject);
-  child.on(
-    "close",
-    (code) => code === 0 ? resolve7() : reject(new Error(`npm ci exited with ${code}`))
-  );
-});
+    });
+    child.on("error", reject);
+    child.on(
+      "close",
+      (code) => code === 0 ? resolve7() : reject(new Error(`${name} ${args[0]} exited with ${code}`))
+    );
+  });
+};
 var BuildRunner = class _BuildRunner {
   constructor(options) {
     this.options = options;
@@ -8626,11 +8869,11 @@ var BuildRunner = class _BuildRunner {
   options;
   running = /* @__PURE__ */ new Map();
   home() {
-    return this.options.home ?? join22(herdHome(), "builds");
+    return this.options.home ?? join23(herdHome(), "builds");
   }
   /** Where builds' own bare clones are, apart from the root's checkouts. */
   clonesDir() {
-    return join22(this.home(), "clones");
+    return join23(this.home(), "clones");
   }
   /** Herd's bare clone of a build's repo, for builds, whether or not it's there yet. */
   storeFor(build) {
@@ -8651,8 +8894,8 @@ var BuildRunner = class _BuildRunner {
     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 = join22(this.home(), name, String(slot));
-    mkdirSync17(join22(this.home(), name), { recursive: true });
+    const dir = join23(this.home(), name, String(slot));
+    mkdirSync17(join23(this.home(), name), { recursive: true });
     await withStoreLock(
       store,
       async () => {
@@ -8691,30 +8934,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 = join22(dir, "node_modules", ".herd-lock");
-    if (existsSync15(marker) && readFileSync16(marker, "utf8") === wanted) return;
-    const cache = join22(this.home(), "node_modules", wanted);
+    const marker = join23(dir, "node_modules", ".herd-lock");
+    if (existsSync16(marker) && readFileSync16(marker, "utf8") === wanted) return;
+    const cache = join23(this.home(), "node_modules", wanted);
     for (const folder of moduleFolders(dir))
-      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));
+      rmSync13(join23(dir, folder), { recursive: true, force: true });
+    if (existsSync16(join23(cache, ".complete"))) {
+      for (const folder of readFileSync16(join23(cache, ".complete"), "utf8").split("\n").filter(Boolean)) {
+        cloneFolder(join23(cache, folder), join23(dir, folder));
       }
     } else {
       this.options.log?.(`Installing node_modules for lockfile ${wanted.slice(0, 8)}.`);
-      await (this.options.install ?? npmCi)(dir);
-      const staging = mkdtempSync(join22(this.home(), "node_modules-"));
+      await (this.options.install ?? frozenInstall(this.options.gitEnv))(dir);
+      const staging = mkdtempSync(join23(this.home(), "node_modules-"));
       const folders = moduleFolders(dir);
       for (const folder of folders) {
-        mkdirSync17(join22(staging, folder, ".."), { recursive: true });
-        cloneFolder(join22(dir, folder), join22(staging, folder));
+        mkdirSync17(join23(staging, folder, ".."), { recursive: true });
+        cloneFolder(join23(dir, folder), join23(staging, folder));
       }
-      writeFileSync13(join22(staging, ".complete"), folders.join("\n"));
-      mkdirSync17(join22(this.home(), "node_modules"), { recursive: true });
+      writeFileSync13(join23(staging, ".complete"), folders.join("\n"));
+      mkdirSync17(join23(this.home(), "node_modules"), { recursive: true });
       rmSync13(cache, { recursive: true, force: true });
       execFileSync5("mv", [staging, cache]);
     }
-    mkdirSync17(join22(dir, "node_modules"), { recursive: true });
+    mkdirSync17(join23(dir, "node_modules"), { recursive: true });
     writeFileSync13(marker, wanted);
   }
   /**
@@ -8725,7 +8968,7 @@ var BuildRunner = class _BuildRunner {
     const env = {
       PATH: process.env.PATH ?? "/usr/bin:/bin",
       HOME: home,
-      TMPDIR: join22(home, "tmp"),
+      TMPDIR: join23(home, "tmp"),
       LANG: process.env.LANG ?? "en_US.UTF-8",
       HERD_BUILD_ID: build.id,
       HERD_BUILD_SECRET: build.secret,
@@ -8737,7 +8980,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: join22(home, "tmp")
+      CLAUDE_CODE_TMPDIR: join23(home, "tmp")
     };
     return env;
   }
@@ -8748,8 +8991,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(join22(this.options.scratch ?? scratchRoot(), "hb-"));
-    mkdirSync17(join22(home, "tmp"), { recursive: true });
+    const home = mkdtempSync(join23(this.options.scratch ?? scratchRoot(), "hb-"));
+    mkdirSync17(join23(home, "tmp"), { recursive: true });
     const run4 = randomUUID4();
     const env = {
       ..._BuildRunner.environment(build, home),
@@ -8759,11 +9002,11 @@ 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, join22(dir, "scripts", "build.mjs")];
+    let command = [process.execPath, join23(dir, "scripts", "build.mjs")];
     let policyPath = null;
     if (this.sandboxed()) {
       const policy = buildPolicy({
-        ownerHome: this.options.ownerHome ?? homedir6(),
+        ownerHome: this.options.ownerHome ?? homedir7(),
         root: this.options.root(),
         convos: convosHome(this.options.root()),
         worktree: dir,
@@ -8774,8 +9017,8 @@ var BuildRunner = class _BuildRunner {
         main: build.main,
         buildsUrl: build.url
       });
-      mkdirSync17(join22(this.home(), "policies"), { recursive: true });
-      policyPath = join22(this.home(), "policies", `${build.id}.json`);
+      mkdirSync17(join23(this.home(), "policies"), { recursive: true });
+      policyPath = join23(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];
@@ -8824,7 +9067,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 = join22(herdHome(), "builds"), list = listProcesses) {
+  static async sweep(home = join23(herdHome(), "builds"), list = listProcesses) {
     const left = buildProcesses(list(), null, home);
     await stopPids(left);
     return left.length;
@@ -8836,37 +9079,37 @@ var BuildRunner = class _BuildRunner {
    */
   static async probe(options = { buildsUrl: "" }) {
     if (insideBuildSandbox()) return { ok: true };
-    const herd = options.home ?? join22(herdHome(), "builds");
-    const dir = mkdtempSync(join22(scratchRoot(), "hp-"));
-    const secret = join22(dir, "owner", "secret");
+    const herd = options.home ?? join23(herdHome(), "builds");
+    const dir = mkdtempSync(join23(scratchRoot(), "hp-"));
+    const secret = join23(dir, "owner", "secret");
     try {
       mkdirSync17(herd, { recursive: true });
-      for (const sub of ["work", "git", "home", "owner"]) mkdirSync17(join22(dir, sub));
+      for (const sub of ["work", "git", "home", "owner"]) mkdirSync17(join23(dir, sub));
       writeFileSync13(secret, "probe");
       const policy = buildPolicy({
-        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"),
+        ownerHome: join23(dir, "owner"),
+        root: join23(dir, "owner"),
+        convos: join23(dir, "owner"),
+        worktree: join23(dir, "work"),
+        store: join23(dir, "git"),
+        worktreeGitDir: join23(dir, "git"),
+        home: join23(dir, "home"),
         nodePrefix: nodePrefix(),
         main: false,
         buildsUrl: options.buildsUrl || "https://builds.herdingchats.com"
       });
-      const policyPath = join22(herd, "probe-policy.json");
+      const policyPath = join23(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(join22(dir, "home", "ok"))}, "ok");`
+        `fs.writeFileSync(${JSON.stringify(join23(dir, "home", "ok"))}, "ok");`
       ].join(" ");
       const child = spawn9(
         process.execPath,
         [HERD_BIN, "build-sandbox", policyPath, "--", process.execPath, "-e", script],
         {
-          env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: join22(dir, "home") },
+          env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: join23(dir, "home") },
           stdio: ["ignore", "ignore", "pipe"]
         }
       );
@@ -8880,7 +9123,7 @@ var BuildRunner = class _BuildRunner {
       clearTimeout(timer);
       if (status2 === 10)
         return { ok: false, reason: "the sandbox let a build read the owner's files" };
-      if (status2 !== 0 || !existsSync15(join22(dir, "home", "ok"))) {
+      if (status2 !== 0 || !existsSync16(join23(dir, "home", "ok"))) {
         const why = stderr.trim().split("\n").at(-1) || `the probe exited with ${status2}`;
         return { ok: false, reason: why.slice(0, 300) };
       }
@@ -9235,7 +9478,7 @@ var CodexDriver = class {
 
 // src/daemon.ts
 init_define_HERD_PACKAGE();
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 
 // src/dispatch-connection.ts
 init_define_HERD_PACKAGE();
@@ -9339,7 +9582,7 @@ var DispatchConnection = class {
 
 // src/daemon.ts
 var CONFIG_POLL_MS = 2e3;
-var daemonSocketPath = () => join23(herdHome(), "daemon.sock");
+var daemonSocketPath = () => join24(herdHome(), "daemon.sock");
 var Daemon = class {
   constructor(options) {
     this.options = options;
@@ -9551,7 +9794,7 @@ 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 { existsSync as existsSync17, 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;
@@ -9563,7 +9806,7 @@ function linkOf(path) {
     return null;
   }
 }
-function missingFolder(path, required, { exists = existsSync16, linkTarget = linkOf } = {}) {
+function missingFolder(path, required, { exists = existsSync17, linkTarget = linkOf } = {}) {
   if (exists(path)) return null;
   const target = linkTarget(path);
   if (target) return { path, target };
@@ -9766,23 +10009,23 @@ init_define_HERD_PACKAGE();
 import { execFileSync as execFileSync6 } from "node:child_process";
 import {
   appendFileSync as appendFileSync2,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync18,
   readFileSync as readFileSync17,
   renameSync as renameSync6,
   writeFileSync as writeFileSync15
 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join24 } from "node:path";
-var LOCAL_SETTINGS = join24(".claude", "settings.local.json");
+import { isAbsolute as isAbsolute4, join as join25 } from "node:path";
+var LOCAL_SETTINGS = join25(".claude", "settings.local.json");
 var git3 = (cwd, ...args) => execFileSync6("git", ["-C", cwd, ...args], {
   encoding: "utf8",
   stdio: ["ignore", "pipe", "pipe"]
 }).trim();
 var shellQuote2 = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
 function writeWorktreeSettings(worktree, settings, ownCommand) {
-  const path = join24(worktree, LOCAL_SETTINGS);
+  const path = join25(worktree, LOCAL_SETTINGS);
   let current = {};
-  if (existsSync17(path)) {
+  if (existsSync18(path)) {
     try {
       const parsed = JSON.parse(readFileSync17(path, "utf8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
@@ -9804,7 +10047,7 @@ function writeWorktreeSettings(worktree, settings, ownCommand) {
     }
     next.hooks = hooks;
   }
-  mkdirSync18(join24(worktree, ".claude"), { recursive: true });
+  mkdirSync18(join25(worktree, ".claude"), { recursive: true });
   const temporary = `${path}.herd-${process.pid}`;
   writeFileSync15(temporary, `${JSON.stringify(next, null, 2)}
 `);
@@ -9824,10 +10067,10 @@ function ignoreLocalSettings(worktree) {
   } catch {
     return;
   }
-  const info = join24(isAbsolute3(common) ? common : join24(worktree, common), "info");
-  const exclude = join24(info, "exclude");
+  const info = join25(isAbsolute4(common) ? common : join25(worktree, common), "info");
+  const exclude = join25(info, "exclude");
   const line2 = "/.claude/settings.local.json";
-  const existing = existsSync17(exclude) ? readFileSync17(exclude, "utf8") : "";
+  const existing = existsSync18(exclude) ? readFileSync17(exclude, "utf8") : "";
   if (existing.split("\n").includes(line2)) return;
   mkdirSync18(info, { recursive: true });
   appendFileSync2(exclude, `${existing && !existing.endsWith("\n") ? "\n" : ""}${line2}
@@ -9872,7 +10115,7 @@ function loginShellEnv() {
 
 // src/machine-checks.ts
 init_define_HERD_PACKAGE();
-import { existsSync as existsSync18, rmSync as rmSync15 } from "node:fs";
+import { existsSync as existsSync19, rmSync as rmSync15 } from "node:fs";
 var REQUEST_POLL_MS = 2e3;
 var MachineChecks = class {
   constructor(options) {
@@ -9918,7 +10161,7 @@ var MachineChecks = class {
   /** `friday start` asked for every agent to be activated again. */
   takeRequest() {
     const path = activationRequestPath(this.options.herdHome);
-    if (!existsSync18(path)) return;
+    if (!existsSync19(path)) return;
     rmSync15(path, { force: true });
     this.activateChosen(true);
   }
@@ -9970,15 +10213,15 @@ init_define_HERD_PACKAGE();
 import { spawn as spawn11 } 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 join25 } from "node:path";
+import { join as join26 } from "node:path";
 init_self();
 import {
   HOST_PROTOCOL,
   hostVersion
 } from "./terminal-host.mjs";
-var hostsDir = () => join25(herdHome(), "terminals");
-var legacyHostSocketPath = () => join25(herdHome(), "terminals.sock");
-var currentHostSocketPath = (version = hostVersion()) => join25(hostsDir(), `${version}.sock`);
+var hostsDir = () => join26(herdHome(), "terminals");
+var legacyHostSocketPath = () => join26(herdHome(), "terminals.sock");
+var currentHostSocketPath = (version = hostVersion()) => join26(hostsDir(), `${version}.sock`);
 var speaksProtocol = (protocol) => protocol === HOST_PROTOCOL || protocol === HOST_PROTOCOL - 1;
 var sleep6 = (ms2) => new Promise((resolve7) => setTimeout(resolve7, ms2));
 function askHost(path, request) {
@@ -10029,7 +10272,7 @@ var HostTerminals = class {
       names = readdirSync8(dir).filter((name) => name.endsWith(".sock"));
     } catch {
     }
-    const paths = [legacyHostSocketPath(), ...names.map((name) => join25(dir, name))];
+    const paths = [legacyHostSocketPath(), ...names.map((name) => join26(dir, name))];
     const found = [];
     for (const path of paths) {
       try {
@@ -10268,7 +10511,7 @@ var UsageReporter = class {
 init_define_HERD_PACKAGE();
 init_src();
 import { mkdirSync as mkdirSync23, readFileSync as readFileSync18, writeFileSync as writeFileSync18 } from "node:fs";
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 
 // src/workspaces/codex.ts
 init_define_HERD_PACKAGE();
@@ -10280,7 +10523,7 @@ init_define_HERD_PACKAGE();
 init_define_HERD_PACKAGE();
 init_src();
 init_self();
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 import { z as z26 } from "zod";
 function hasThread(events) {
   return events.some(
@@ -10315,7 +10558,7 @@ function filesByMessage(events) {
   }
   return files;
 }
-var FILES_FOLDER = join26(".herd", "files");
+var FILES_FOLDER = join27(".herd", "files");
 function safeFileName(name) {
   const chars = Array.from(name.replace(/[/\\\p{Cc}]/gu, "_").trim());
   while (Buffer.byteLength(chars.join("")) > 200) chars.shift();
@@ -10548,11 +10791,11 @@ async function claimChange(ws, workspace, change) {
 // src/workspaces/delivery.ts
 init_define_HERD_PACKAGE();
 import { randomBytes as randomBytes6, randomUUID as randomUUID6 } from "node:crypto";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 
 // src/workspaces/repos.ts
 init_define_HERD_PACKAGE();
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 var rootOf = (ws) => ws.options.root?.() ?? ws.options.config().root ?? defaultRoot();
 var gitEnvOf = (ws) => ws.options.gitEnv?.() ?? loginShellEnv();
 function knownRemotes(ws) {
@@ -10664,7 +10907,7 @@ async function addHints(ws, workspace, hints, handedOff) {
       const added = await addWorktree({
         root,
         remote: cloneSource(hint.remote, knownRemotes(ws)),
-        path: join27(workspace.folder, place.name),
+        path: join28(workspace.folder, place.name),
         branch,
         ...handedOff ? { continueFrom: hint.branch ?? branch } : {},
         env: gitEnvOf(ws),
@@ -10716,14 +10959,14 @@ function handoffRepos(workspace) {
   return workspace.worktrees.map((repo) => ({
     folder: repo.folder,
     branch: repo.branch,
-    unpushed: hasUnpushed(join27(workspace.folder, repo.folder))
+    unpushed: hasUnpushed(join28(workspace.folder, repo.folder))
   }));
 }
 
 // src/workspaces/setup.ts
 init_define_HERD_PACKAGE();
 import { chmodSync as chmodSync4, mkdirSync as mkdirSync20, writeFileSync as writeFileSync16 } from "node:fs";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 
 // src/hooks.ts
 init_define_HERD_PACKAGE();
@@ -10756,7 +10999,7 @@ function configureClaude(ws, workspace) {
   configureClaudeIn(workspace.folder, (line2) => ws.log(`${workspace.conversationId}: ${line2}`));
 }
 function configureClaudeIn(folder, log) {
-  const herd = shellQuote2(join28(herdPathDir(), "herd"));
+  const herd = shellQuote2(join29(herdPathDir(), "herd"));
   try {
     const written = writeWorktreeSettings(
       folder,
@@ -10781,9 +11024,9 @@ function configureClaudeIn(folder, log) {
   }
 }
 function herdPathDir() {
-  const dir = join28(herdHome(), "bin");
+  const dir = join29(herdHome(), "bin");
   mkdirSync20(dir, { recursive: true, mode: 448 });
-  const shim = join28(dir, "herd");
+  const shim = join29(dir, "herd");
   writeFileSync16(shim, `#!/bin/sh
 exec "${process.execPath}" "${herdBin}" "$@"
 `);
@@ -10969,7 +11212,7 @@ async function followCheckIn(ws, workspace, reading) {
 init_define_HERD_PACKAGE();
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync21 } from "node:fs";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 function needsInvestigator(ws, workspace, reading) {
   const allowed = ws.options.canInvestigate ? ws.options.canInvestigate() : workspace.agent === "claude-code";
   if (!allowed || !reading || workspace.investigation) return false;
@@ -11134,9 +11377,9 @@ async function followInvestigation(ws, workspace) {
 }
 function saveScreen(ws, conversationId, screen, key) {
   try {
-    const dir = join29(herdHome(), "dialogs");
+    const dir = join30(herdHome(), "dialogs");
     mkdirSync21(dir, { recursive: true });
-    const file = join29(dir, `${conversationId}-${Date.now()}.txt`);
+    const file = join30(dir, `${conversationId}-${Date.now()}.txt`);
     appendFileSync3(file, `${screen.join("\n")}
 
 Way out: ${key}
@@ -11341,7 +11584,7 @@ async function deliver(ws, conversationId, delivery) {
     await ensureLeadTerminal(ws, workspace);
     const codex = workspace.agent === "codex";
     if (workspace.agent === "agy") {
-      writeAgyFiles(workspace.folder, shellQuote2(join30(herdPathDir(), "herd")));
+      writeAgyFiles(workspace.folder, shellQuote2(join31(herdPathDir(), "herd")));
     } else if (!codex) configureClaude(ws, workspace);
     const ownId = codex || workspace.agent === "agy";
     if (!workspace.started) {
@@ -11489,7 +11732,7 @@ import {
   statSync as statSync9,
   writeFileSync as writeFileSync17
 } from "node:fs";
-import { dirname as dirname14, join as join31, sep as sep2 } from "node:path";
+import { dirname as dirname14, join as join32, sep as sep2 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 
@@ -11503,7 +11746,7 @@ import { readFile } from "node:fs/promises";
 init_define_HERD_PACKAGE();
 init_src();
 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";
+import { basename as basename4, extname, isAbsolute as isAbsolute5, relative as relative2, resolve as resolve5 } from "node:path";
 var TYPES = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -11528,7 +11771,7 @@ var TYPES = {
 var mediaTypeFor = (path) => TYPES[extname(path).toLowerCase()] ?? "application/octet-stream";
 function isInside(root, path) {
   const between = relative2(root, path);
-  return between === "" || !between.startsWith("..") && !isAbsolute4(between);
+  return between === "" || !between.startsWith("..") && !isAbsolute5(between);
 }
 function resolveAttachments(worktree, files) {
   let root;
@@ -11558,7 +11801,7 @@ function resolveAttachments(worktree, files) {
     }
     resolved.push({
       path: real4,
-      name: basename3(file.path),
+      name: basename4(file.path),
       type: mediaTypeFor(real4),
       size: stats.size,
       ...file.title ? { title: file.title } : {},
@@ -12491,10 +12734,10 @@ async function bringIn(ws, workspace, files) {
   return listed;
 }
 async function download(ws, workspace, file) {
-  const path = join31(FILES_FOLDER, safeFileName(file.id), safeFileName(file.name));
-  const target = join31(workspace.folder, path);
+  const path = join32(FILES_FOLDER, safeFileName(file.id), safeFileName(file.name));
+  const target = join32(workspace.folder, path);
   if (statSync9(target, { throwIfNoEntry: false })?.size === file.size) return path;
-  const herd = join31(workspace.folder, ".herd");
+  const herd = join32(workspace.folder, ".herd");
   if (lstatSync4(herd, { throwIfNoEntry: false })?.isSymbolicLink()) {
     throw new Error("its folder leads outside the worktree");
   }
@@ -12502,7 +12745,7 @@ async function download(ws, workspace, file) {
   if (!realpathSync10(dirname14(target)).startsWith(realpathSync10(workspace.folder) + sep2)) {
     throw new Error("its folder leads outside the worktree");
   }
-  writeFileSync17(join31(herd, ".gitignore"), "*\n");
+  writeFileSync17(join32(herd, ".gitignore"), "*\n");
   const response = await ws.api(
     `${ws.conversationPath(workspace.conversationId)}/files/${encodeURIComponent(file.id)}`
   );
@@ -12792,7 +13035,7 @@ var Workspaces = class {
     return this.driver;
   }
   // ---- State, kept on disk so a restarted daemon picks up where it was.
-  statePath = () => join32(herdHome(), "state.json");
+  statePath = () => join33(herdHome(), "state.json");
   load() {
     try {
       return stateSchema.parse(JSON.parse(readFileSync18(this.statePath(), "utf8"))).workspaces;
@@ -13021,7 +13264,7 @@ async function runDaemon(args) {
   const folders = new FolderWatch({
     check: () => machineFolderProblem(machineRoot(), convosPath(machineRoot())),
     initial: missing,
-    statusPath: join33(herdHome(), "folder-unavailable.json"),
+    statusPath: join34(herdHome(), "folder-unavailable.json"),
     ...process.env.HERD_FOLDER_CHECK_MS ? { everyMs: Number(process.env.HERD_FOLDER_CHECK_MS) } : {},
     onChange: () => daemon?.foldersChanged()
   });
@@ -13121,7 +13364,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(join33(herdPathDir(), "herd")));
+      if (agent === "agy") writeAgyFiles(folder, shellQuote2(join34(herdPathDir(), "herd")));
       else if (agent === "claude-code") configureClaudeIn(folder, log);
     },
     ...shellCommand ? { shellCommand } : {},
@@ -13209,7 +13452,7 @@ async function runDaemon(args) {
       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),
+      repos: () => bareClones(join34(herdHome(), "builds", "clones")).map((repo) => repo.key).filter((key) => key.length <= 300).slice(0, 100),
       runner: new BuildRunner({
         root: () => machineRoot(),
         gitEnv,
@@ -13267,10 +13510,10 @@ init_define_HERD_PACKAGE();
 // src/agy-hooks.ts
 init_define_HERD_PACKAGE();
 import { readFileSync as readFileSync20 } from "node:fs";
-import { basename as basename4 } from "node:path";
+import { basename as basename5 } from "node:path";
 var text3 = (value) => typeof value === "string" ? value : "";
 function lastResponse(transcriptPath) {
-  if (!/^transcript.*\.jsonl$/.test(basename4(transcriptPath))) return "";
+  if (!/^transcript.*\.jsonl$/.test(basename5(transcriptPath))) return "";
   let lines;
   try {
     lines = readFileSync20(transcriptPath, "utf8").split("\n");
@@ -13396,8 +13639,8 @@ init_define_HERD_PACKAGE();
 import { spawn as spawn12 } 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 join34 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { join as join35 } from "node:path";
 var MAX_INPUT = 64 * 1024;
 var REPORT_TIMEOUT_MS = 300;
 var OWN_COMMAND_TIMEOUT_MS = 5e3;
@@ -13431,10 +13674,10 @@ function agyStateFrom(input) {
   const state = input?.agent_state;
   return state === "working" || state === "idle" ? state : null;
 }
-function ownAgyStatusLine(home = homedir7()) {
+function ownAgyStatusLine(home = homedir8()) {
   try {
     const settings = JSON.parse(
-      readFileSync21(join34(home, ".gemini", "antigravity-cli", "settings.json"), "utf8")
+      readFileSync21(join35(home, ".gemini", "antigravity-cli", "settings.json"), "utf8")
     );
     const command = settings.statusLine?.command;
     if (typeof command !== "string" || !command.trim()) return null;
@@ -13453,8 +13696,8 @@ function commandIn(path) {
     return null;
   }
 }
-function ownStatusLine(projectDir, home = homedir7()) {
-  return commandIn(join34(projectDir, ".claude", "settings.json")) ?? commandIn(join34(home, ".claude", "settings.json"));
+function ownStatusLine(projectDir, home = homedir8()) {
+  return commandIn(join35(projectDir, ".claude", "settings.json")) ?? commandIn(join35(home, ".claude", "settings.json"));
 }
 function runOwnCommand(command, input, cwd, timeoutMs = OWN_COMMAND_TIMEOUT_MS) {
   return new Promise((resolve7) => {
@@ -13876,7 +14119,7 @@ async function runTerminalHost(rest) {
 
 // src/commands/repo.ts
 init_define_HERD_PACKAGE();
-import { join as join35 } from "node:path";
+import { join as join36 } from "node:path";
 import { z as z33 } from "zod";
 var REPO_HELP = `Usage: herd repo <url or owner/name> [folder]
 
@@ -13964,7 +14207,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 = join35(here.folder, place.name);
+  const path = join36(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;