volute 0.53.0 → 0.54.0

package/dist/chunk-OT5SXF7L.js

@@ -0,0 +1,904 @@
+#!/usr/bin/env node
+import {
+  isTemplateStale
+} from "./chunk-CV6BNGFK.js";
+import {
+  computeTemplateHash
+} from "./chunk-HTRSSOHY.js";
+import {
+  cleanupVariant
+} from "./chunk-OGPVJ53N.js";
+import {
+  getSleepManagerIfReady,
+  readSystemsConfig
+} from "./chunk-LGXVGIWN.js";
+import {
+  applyTemplateHomeFiles,
+  composeTemplate,
+  copyTemplateToDir,
+  findTemplatesRoot
+} from "./chunk-X67BDDZR.js";
+import {
+  getMindManager
+} from "./chunk-WHL6PKYP.js";
+import {
+  migrateSkillsToTemplate
+} from "./chunk-PPSN2MLC.js";
+import {
+  deliverEvent
+} from "./chunk-HKGYZVWN.js";
+import {
+  readVoluteConfig
+} from "./chunk-WCFSBH33.js";
+import {
+  chownMindDir,
+  exec,
+  gitExec,
+  isIsolationEnabled,
+  wrapForIsolation
+} from "./chunk-OIOW3FPT.js";
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+import {
+  findMind,
+  mindDir,
+  readRegistry,
+  setMindTemplate,
+  setMindTemplateHash
+} from "./chunk-H6X6CKDN.js";
+
+// packages/daemon/src/lib/mind/upgrade.ts
+import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync, rmSync } from "fs";
+import { resolve as resolve3 } from "path";
+
+// packages/daemon/src/lib/mind/npm-install.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var NPM_INSTALL_ARGS = [
+  "install",
+  "--no-audit",
+  "--no-fund",
+  "--prefer-offline",
+  "--loglevel=error"
+];
+function lowPriorityArgv(cmd, args, ionice) {
+  return ionice ? ["ionice", ["-c2", "-n7", "nice", "-n19", cmd, ...args]] : ["nice", ["-n19", cmd, ...args]];
+}
+function hasIonice() {
+  return process.platform === "linux" && (existsSync("/usr/bin/ionice") || existsSync("/bin/ionice"));
+}
+async function npmInstallAsMind(cwd, mindName) {
+  const [cmd, args] = lowPriorityArgv("npm", NPM_INSTALL_ARGS, hasIonice());
+  if (isIsolationEnabled()) {
+    const [wrappedCmd, wrappedArgs] = await wrapForIsolation(cmd, args, mindName);
+    await exec(wrappedCmd, wrappedArgs, {
+      cwd,
+      env: { ...process.env, HOME: resolve(cwd, "home") }
+    });
+  } else {
+    await exec(cmd, args, { cwd });
+  }
+}
+async function depsChangedSince(dir, fromRef) {
+  try {
+    await gitExec(["diff", "--quiet", fromRef, "HEAD", "--", "package.json", "package-lock.json"], {
+      cwd: dir
+    });
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function npmInstallNeeded(dir, preMergeRef) {
+  if (!existsSync(resolve(dir, "node_modules"))) return true;
+  return depsChangedSince(dir, preMergeRef);
+}
+
+// packages/daemon/src/lib/mind/variants.ts
+import { statSync } from "fs";
+import { resolve as resolve2 } from "path";
+var SAFE_BRANCH_RE = /^[a-zA-Z0-9._\-/]+$/;
+function validateBranchName(branch) {
+  if (!SAFE_BRANCH_RE.test(branch)) {
+    return `Invalid branch name: ${branch}. Only alphanumeric, '.', '_', '-', '/' allowed.`;
+  }
+  if (branch.includes("..")) {
+    return `Invalid branch name: ${branch}. '..' not allowed.`;
+  }
+  return null;
+}
+var MERGE_EXCLUDED_PATHS = ["home/MEMORY.md", "home/memory/journal/"];
+var MAX_DELTA_CHARS = 12e3;
+var NEVER_REPORT_PREFIXES = ["home/.claude/", "home/.pi/", "home/.agents/"];
+var MAX_LISTED_UNRESOLVED_FILES = 20;
+async function findUnresolvedHomeFiles(cwd) {
+  const raw = await gitExec(
+    ["ls-files", "--others", "--ignored", "--exclude-standard", "-z", "--", "home"],
+    { cwd }
+  );
+  const allPaths = raw.split("\0").filter((path) => path && !NEVER_REPORT_PREFIXES.some((prefix) => path.startsWith(prefix)));
+  const files = [];
+  let totalBytes = 0;
+  for (const path of allPaths) {
+    let bytes = -1;
+    try {
+      bytes = statSync(resolve2(cwd, path)).size;
+    } catch {
+    }
+    if (bytes > 0) totalBytes += bytes;
+    if (files.length < MAX_LISTED_UNRESOLVED_FILES) files.push({ path, bytes });
+  }
+  return { files, totalCount: allPaths.length, totalBytes };
+}
+function formatBytes(bytes) {
+  if (bytes < 0) return "size unknown";
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  for (const unit of units) {
+    if (value < 1024) return `${value.toFixed(1)} ${unit}`;
+    value /= 1024;
+  }
+  return `${value.toFixed(1)} PB`;
+}
+function formatUnresolvedHomeFilesMessage(variantName, result) {
+  const lines = result.files.map(
+    (f) => `  - ${f.path.replace(/^home\//, "")} (${formatBytes(f.bytes)})`
+  );
+  const remaining = result.totalCount - result.files.length;
+  if (remaining > 0) lines.push(`  ...and ${remaining} more`);
+  return `Cannot join variant "${variantName}": it has ${result.totalCount} untracked file${result.totalCount === 1 ? "" : "s"} under home/ that .gitignore is hiding from git \u2014 never committed, and joining would destroy them when the variant is cleaned up (total: ${formatBytes(result.totalBytes)}):
+
+${lines.join("\n")}
+
+Before retrying the join, resolve each file in the variant \u2014 one of:
+  1. Track it: git add -f -- <path> (then commit it, or let auto-commit pick it up next turn)
+  2. Copy it out of home/ to somewhere safe, then delete it
+  3. Delete it if it's disposable
+
+Once resolved, retry the join. To join anyway and discard everything listed above, pass discardUnresolved: true.`;
+}
+var RESTORE_PATH_CHUNK = 500;
+var RESTORE_DIFF_MAX_BUFFER = 64 * 1024 * 1024;
+async function restoreMergeDeletedHomeFiles(cwd, sourceCommit) {
+  const raw = await gitExec(
+    [
+      "diff",
+      "--name-only",
+      "--diff-filter=D",
+      "--no-renames",
+      "-z",
+      sourceCommit,
+      "HEAD",
+      "--",
+      "home/"
+    ],
+    { cwd, maxBuffer: RESTORE_DIFF_MAX_BUFFER }
+  );
+  const deleted = raw.split("\0").filter(Boolean);
+  if (deleted.length === 0) return [];
+  let paths = [];
+  try {
+    const ignoredRaw = await gitExec(["check-ignore", "--stdin", "-z"], {
+      cwd,
+      maxBuffer: RESTORE_DIFF_MAX_BUFFER,
+      stdin: deleted.join("\0")
+    });
+    paths = ignoredRaw.split("\0").filter(Boolean);
+  } catch (err) {
+    if (err.code !== 1) throw err;
+  }
+  if (paths.length === 0) return [];
+  for (let i = 0; i < paths.length; i += RESTORE_PATH_CHUNK) {
+    const pathspecs = paths.slice(i, i + RESTORE_PATH_CHUNK).map((p) => `:(literal)${p}`);
+    await gitExec(["restore", `--source=${sourceCommit}`, "--worktree", "--", ...pathspecs], {
+      cwd
+    });
+  }
+  return paths;
+}
+async function mergeVariantExcludingMemory(projectRoot, variantBranch) {
+  const opts = { cwd: projectRoot };
+  let memoryDelta = "";
+  try {
+    const base = (await gitExec(["merge-base", "HEAD", variantBranch], opts)).trim();
+    memoryDelta = (await gitExec(["diff", `${base}..${variantBranch}`, "--", ...MERGE_EXCLUDED_PATHS], opts)).trim();
+  } catch (err) {
+    logger_default.error(
+      `variant join: failed to compute memory delta for ${variantBranch}`,
+      logger_default.errorData(err)
+    );
+    memoryDelta = `(journal delta unavailable \u2014 ${err instanceof Error ? err.message : String(err)})`;
+  }
+  if (memoryDelta.length > MAX_DELTA_CHARS) {
+    memoryDelta = `${memoryDelta.slice(0, MAX_DELTA_CHARS)}
+\u2026 (delta truncated)`;
+  }
+  try {
+    await gitExec(["merge", "--no-ff", "--no-commit", variantBranch], opts).catch(() => {
+    });
+    await gitExec(["reset", "-q", "HEAD", "--", ...MERGE_EXCLUDED_PATHS], opts);
+    for (const path of MERGE_EXCLUDED_PATHS) {
+      await gitExec(["checkout", "--", path], opts).catch(() => {
+      });
+    }
+    await gitExec(["clean", "-fdq", "--", ...MERGE_EXCLUDED_PATHS], opts);
+    await assertExcludedPathsRestored(opts);
+    if (await mergeInProgress(opts)) {
+      await gitExec(["commit", "--no-edit"], opts);
+    }
+  } catch (err) {
+    const conflicts = await listConflicts(opts);
+    const abortFailed = await gitExec(["merge", "--abort"], opts).then(
+      () => false,
+      () => true
+    );
+    throw new VariantMergeError(
+      `variant join aborted: ${err instanceof Error ? err.message : String(err)}`,
+      conflicts,
+      abortFailed
+    );
+  }
+  return memoryDelta;
+}
+var VariantMergeError = class extends Error {
+  constructor(message, conflicts, abortFailed = false) {
+    super(message);
+    this.conflicts = conflicts;
+    this.abortFailed = abortFailed;
+    this.name = "VariantMergeError";
+  }
+};
+async function mergeInProgress(opts) {
+  return gitExec(["rev-parse", "-q", "--verify", "MERGE_HEAD"], opts).then(
+    () => true,
+    () => false
+  );
+}
+async function listConflicts(opts) {
+  try {
+    const out = (await gitExec(["diff", "--name-only", "--diff-filter=U"], opts)).trim();
+    return out ? out.split("\n") : [];
+  } catch {
+    return [];
+  }
+}
+async function assertExcludedPathsRestored(opts) {
+  await gitExec(["diff", "--cached", "--quiet", "HEAD", "--", ...MERGE_EXCLUDED_PATHS], opts);
+  await gitExec(["diff", "--quiet", "HEAD", "--", ...MERGE_EXCLUDED_PATHS], opts);
+  const untracked = (await gitExec(
+    ["ls-files", "--others", "--exclude-standard", "--", ...MERGE_EXCLUDED_PATHS],
+    opts
+  )).trim();
+  if (untracked) {
+    throw new Error(
+      `untracked memory files remain after restore: ${untracked.replace(/\n/g, ", ")}`
+    );
+  }
+}
+
+// packages/daemon/src/lib/mind/upgrade.ts
+var UpgradeInProgressError = class extends Error {
+  worktreeDir;
+  constructor(worktreeDir) {
+    super("Upgrade variant already exists. Use continue or delete it first.");
+    this.name = "UpgradeInProgressError";
+    this.worktreeDir = worktreeDir;
+  }
+};
+var TEMPLATE_BRANCH = "volute/template";
+var UPGRADE_BRANCH = "upgrade";
+var FINAL_MERGE_CONFLICTS_MESSAGE = "Merge conflicts detected at the final merge step. The mind's directory has been restored to its pre-merge state; the upgrade worktree has been left in place for manual resolution.";
+var upgradeLocks = /* @__PURE__ */ new Map();
+async function withUpgradeLock(mindName, fn) {
+  const prior = upgradeLocks.get(mindName) ?? Promise.resolve();
+  const run = prior.catch(() => {
+  }).then(fn);
+  upgradeLocks.set(
+    mindName,
+    run.catch(() => {
+    })
+  );
+  return run;
+}
+async function configureGitIdentity(mindName, opts) {
+  const systemsConfig = readSystemsConfig();
+  const system = systemsConfig?.system ?? "local";
+  await gitExec(["config", "user.name", mindName], opts);
+  await gitExec(["config", "user.email", `${mindName}.${system}@volute.systems`], opts);
+}
+async function updateTemplateBranch(projectRoot, template, mindName) {
+  const tempWorktree = resolve3(projectRoot, ".variants", "_template_update");
+  let branchExists = false;
+  try {
+    await gitExec(["rev-parse", "--verify", TEMPLATE_BRANCH], { cwd: projectRoot });
+    branchExists = true;
+  } catch {
+  }
+  try {
+    await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
+  } catch {
+  }
+  if (existsSync2(tempWorktree)) {
+    rmSync(tempWorktree, { recursive: true, force: true });
+  }
+  const templatesRoot = findTemplatesRoot();
+  const { composedDir, manifest } = composeTemplate(templatesRoot, template);
+  try {
+    if (branchExists) {
+      await gitExec(["worktree", "add", tempWorktree, TEMPLATE_BRANCH], {
+        cwd: projectRoot
+      });
+    } else {
+      await gitExec(["worktree", "add", "--detach", tempWorktree], { cwd: projectRoot });
+      await gitExec(["checkout", "--orphan", TEMPLATE_BRANCH], { cwd: tempWorktree });
+      await gitExec(["rm", "-rf", "--cached", "."], { cwd: tempWorktree });
+      await gitExec(["clean", "-fd"], { cwd: tempWorktree });
+    }
+    if (branchExists) {
+      await gitExec(["rm", "-rf", "."], { cwd: tempWorktree }).catch(() => {
+      });
+    }
+    copyTemplateToDir(composedDir, tempWorktree, mindName, manifest);
+    const initDir = resolve3(tempWorktree, ".init");
+    if (existsSync2(initDir)) {
+      rmSync(initDir, { recursive: true, force: true });
+    }
+    const homeDir = resolve3(tempWorktree, "home");
+    if (existsSync2(homeDir)) {
+      for (const entry of readdirSync(homeDir)) {
+        if (entry !== "VOLUTE.md") {
+          rmSync(resolve3(homeDir, entry), { recursive: true, force: true });
+        }
+      }
+    }
+    await gitExec(["add", "-A"], { cwd: tempWorktree });
+    try {
+      await gitExec(["diff", "--cached", "--quiet"], { cwd: tempWorktree });
+    } catch {
+      await gitExec(["commit", "-m", "template update"], { cwd: tempWorktree });
+    }
+  } finally {
+    try {
+      await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
+    } catch {
+    }
+    if (existsSync2(tempWorktree)) {
+      rmSync(tempWorktree, { recursive: true, force: true });
+    }
+    rmSync(composedDir, { recursive: true, force: true });
+  }
+}
+async function mergeTemplateBranch(worktreeDir) {
+  try {
+    await gitExec(
+      ["merge", TEMPLATE_BRANCH, "--allow-unrelated-histories", "-m", "merge template update"],
+      { cwd: worktreeDir }
+    );
+    return false;
+  } catch (e) {
+    try {
+      const status = await gitExec(["status", "--porcelain"], { cwd: worktreeDir });
+      const hasConflictMarkers = status.split("\n").some((line) => line.startsWith("UU") || line.startsWith("AA"));
+      if (hasConflictMarkers) return true;
+    } catch {
+    }
+    throw e;
+  }
+}
+async function mergeWithUntrackResolution(dir, branch) {
+  try {
+    await gitExec(["merge", branch], { cwd: dir });
+    return { merged: true };
+  } catch {
+  }
+  try {
+    const unmergedRaw = await gitExec(["diff", "--name-only", "--diff-filter=U"], { cwd: dir });
+    const unmerged = unmergedRaw.split("\n").filter(Boolean);
+    if (unmerged.length === 0) {
+      throw new Error(`git merge ${branch} failed without conflicts`);
+    }
+    const resolvable = [];
+    if (!unmerged.includes(".gitignore")) {
+      for (const file of unmerged) {
+        try {
+          await gitExec(["check-ignore", "--no-index", "-q", "--", file], { cwd: dir });
+          resolvable.push(file);
+        } catch {
+        }
+      }
+    }
+    const remaining = unmerged.filter((f) => !resolvable.includes(f));
+    if (remaining.length > 0) {
+      await gitExec(["merge", "--abort"], { cwd: dir });
+      return { merged: false, files: unmerged };
+    }
+    for (const file of resolvable) {
+      await gitExec(["checkout", "--ours", "--", file], { cwd: dir });
+      await gitExec(["rm", "--cached", "--", file], { cwd: dir });
+    }
+    await gitExec(["commit", "-m", "merge template update (auto-untrack ignored files)"], {
+      cwd: dir
+    });
+    return { merged: true };
+  } catch (err) {
+    await gitExec(["merge", "--abort"], { cwd: dir }).catch(() => {
+    });
+    throw err instanceof Error ? err : new Error(String(err));
+  }
+}
+async function mergeUpgradeAndRestart(mindName, dir, worktreeDir, upgradeVariantName2, upgradeBranch, template, oldTemplate, restart) {
+  const templateChanged = template !== oldTemplate;
+  const mainStatus = (await gitExec(["status", "--porcelain"], { cwd: dir })).trim();
+  if (mainStatus) {
+    await gitExec(["add", "-A"], { cwd: dir });
+    await gitExec(["commit", "-m", "Auto-commit before upgrade merge"], { cwd: dir });
+  }
+  const preMergeHead = (await gitExec(["rev-parse", "HEAD"], { cwd: dir })).trim();
+  const mergeResult = await mergeWithUntrackResolution(dir, upgradeBranch);
+  if (!mergeResult.merged) {
+    return { ok: false, conflicts: true, files: mergeResult.files };
+  }
+  let restoreWarning;
+  let restored = [];
+  try {
+    restored = await restoreMergeDeletedHomeFiles(dir, preMergeHead);
+    if (restored.length > 0) {
+      logger_default.info(
+        `restored ${restored.length} home files untracked by the allowlist migration for ${mindName}`
+      );
+    }
+  } catch (err) {
+    logger_default.error(`failed to restore merge-deleted home files for ${mindName}`, logger_default.errorData(err));
+    restoreWarning = `Upgrade merged but restoring home files the allowlist migration deleted failed: ${err instanceof Error ? err.message : String(err)}. Recover them manually: list them with \`git diff --name-only --diff-filter=D --no-renames ${preMergeHead} HEAD -- home/\`, then restore each with \`git restore --source=${preMergeHead} --worktree -- <path>\`.`;
+  }
+  if (restored.length > 0) {
+    try {
+      await chownMindDir(dir, mindName);
+    } catch (err) {
+      logger_default.warn(`failed to chown restored home files for ${mindName}`, logger_default.errorData(err));
+    }
+  }
+  const withRestoreWarning = (warning) => [restoreWarning, warning].filter(Boolean).join(" ") || void 0;
+  try {
+    await cleanupVariant(upgradeVariantName2, mindName, dir, worktreeDir, {
+      branch: UPGRADE_BRANCH
+    });
+  } catch (err) {
+    logger_default.warn(`failed to clean up upgrade worktree for ${mindName}`, logger_default.errorData(err));
+  }
+  try {
+    await gitExec(["branch", "-D", upgradeBranch], { cwd: dir });
+  } catch {
+  }
+  let switchWarning;
+  if (templateChanged) {
+    try {
+      applyTemplateHomeFiles(resolve3(dir, "home"), template);
+      const migratedSkills = migrateSkillsToTemplate(dir, oldTemplate, template);
+      await gitExec(["add", "home/"], { cwd: dir });
+      try {
+        await gitExec(["diff", "--cached", "--quiet"], { cwd: dir });
+      } catch {
+        await gitExec(["commit", "-m", `swap template-owned home files for ${template}`], {
+          cwd: dir
+        });
+      }
+      await chownMindDir(dir, mindName);
+      const skillNote = migratedSkills.length > 0 ? ` Migrated skills to the ${template} skills dir: ${migratedSkills.join(", ")}.` : "";
+      switchWarning = `Switched ${oldTemplate}\u2192${template}: config reset to ${template} defaults, mechanics doc replaced, conversation starts fresh (sessions aren't portable across runtimes).${skillNote}`;
+    } catch (err) {
+      logger_default.warn(`failed to swap template home files for ${mindName}`, logger_default.errorData(err));
+      return {
+        ok: true,
+        warning: withRestoreWarning(
+          `Upgrade merged but template switch ${oldTemplate}\u2192${template} failed: ${err instanceof Error ? err.message : String(err)}. The mind is still registered as ${oldTemplate}; re-run the switch or fix home/ manually.`
+        )
+      };
+    }
+  }
+  try {
+    await setMindTemplateHash(mindName, computeTemplateHash(template));
+    await setMindTemplate(mindName, template);
+  } catch (err) {
+    logger_default.warn(`failed to update template for ${mindName}`, logger_default.errorData(err));
+  }
+  if (await npmInstallNeeded(dir, preMergeHead)) {
+    try {
+      await npmInstallAsMind(dir, mindName);
+    } catch (err) {
+      logger_default.warn(`npm install failed after upgrade merge for ${mindName}`, logger_default.errorData(err));
+      return {
+        ok: true,
+        warning: withRestoreWarning(
+          `Upgrade merged but npm install failed: ${err instanceof Error ? err.message : String(err)}. You may need to run npm install manually.`
+        )
+      };
+    }
+  } else {
+    logger_default.info(`skipping npm install for ${mindName} \u2014 dependencies unchanged by upgrade`);
+  }
+  const manager = getMindManager();
+  if (!restart) {
+    manager.setPendingContext(mindName, { type: "upgraded" });
+    return { ok: true, warning: withRestoreWarning(switchWarning) };
+  }
+  try {
+    if (manager.isRunning(mindName)) {
+      await manager.stopMind(mindName);
+    }
+    manager.setPendingContext(mindName, { type: "upgraded" });
+    await manager.startMind(mindName, { healthTimeoutMs: 12e4 });
+  } catch (e) {
+    return {
+      ok: true,
+      warning: withRestoreWarning(
+        `Upgrade merged but mind restart failed: ${e instanceof Error ? e.message : String(e)}`
+      )
+    };
+  }
+  return { ok: true, warning: withRestoreWarning(switchWarning) };
+}
+function upgradeVariantName(mindName) {
+  return `${mindName}-upgrade`;
+}
+function upgradeWorktreeDir(dir) {
+  return resolve3(dir, ".variants", UPGRADE_BRANCH);
+}
+function upgradeInProgress(mindName) {
+  return existsSync2(upgradeWorktreeDir(mindDir(mindName)));
+}
+function upgradeMidResolution(worktreeDir) {
+  try {
+    const gitDirContent = readFileSync(resolve3(worktreeDir, ".git"), "utf-8").trim();
+    const gitDir = gitDirContent.replace("gitdir: ", "");
+    return existsSync2(resolve3(gitDir, "MERGE_HEAD"));
+  } catch {
+    return false;
+  }
+}
+async function upgradeDiff(mindName, template) {
+  const entry = await findMind(mindName);
+  if (!entry) throw new Error("Mind not found");
+  const dir = mindDir(mindName);
+  const tmpl = template ?? entry.template ?? "claude";
+  await updateTemplateBranch(dir, tmpl, mindName);
+  try {
+    return await gitExec(["diff", "HEAD...volute/template"], { cwd: dir });
+  } catch {
+    return await gitExec(["diff", "HEAD", "volute/template"], { cwd: dir });
+  }
+}
+async function runUpgrade(mindName, opts) {
+  return withUpgradeLock(mindName, () => runUpgradeCore(mindName, opts));
+}
+async function runUpgradeCore(mindName, opts) {
+  const entry = await findMind(mindName);
+  if (!entry) throw new Error("Mind not found");
+  const dir = mindDir(mindName);
+  const oldTemplate = entry.template ?? "claude";
+  const template = opts?.template ?? oldTemplate;
+  const restart = opts?.restart ?? true;
+  const variantName = upgradeVariantName(mindName);
+  const worktreeDir = upgradeWorktreeDir(dir);
+  if (existsSync2(worktreeDir)) {
+    if (upgradeMidResolution(worktreeDir)) {
+      throw new UpgradeInProgressError(worktreeDir);
+    }
+    logger_default.warn(`clearing stale orphaned upgrade worktree for ${mindName}`);
+    await abortUpgradeCore(mindName);
+  }
+  if (!existsSync2(resolve3(dir, ".git"))) {
+    try {
+      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve3(dir, "home") } : void 0;
+      await gitExec(["init"], { cwd: dir, mindName, env });
+      await configureGitIdentity(mindName, { cwd: dir, mindName, env });
+      await gitExec(["add", "-A"], { cwd: dir, mindName, env });
+      await gitExec(["commit", "-m", "initial commit"], { cwd: dir, mindName, env });
+      await chownMindDir(dir, mindName);
+    } catch (err) {
+      rmSync(resolve3(dir, ".git"), { recursive: true, force: true });
+      throw new Error(
+        `Git initialization failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  await gitExec(["worktree", "prune"], { cwd: dir });
+  try {
+    await gitExec(["branch", "-D", UPGRADE_BRANCH], { cwd: dir });
+  } catch {
+  }
+  await updateTemplateBranch(dir, template, mindName);
+  const parentDir = resolve3(dir, ".variants");
+  if (!existsSync2(parentDir)) {
+    mkdirSync(parentDir, { recursive: true });
+  }
+  await gitExec(["worktree", "add", "-b", UPGRADE_BRANCH, worktreeDir], { cwd: dir });
+  await gitExec(["rm", "-r", "--cached", "--ignore-unmatch", "home/"], {
+    cwd: worktreeDir
+  });
+  try {
+    await gitExec(["checkout", "HEAD", "--", "home/VOLUTE.md"], { cwd: worktreeDir });
+    await gitExec(["add", "home/VOLUTE.md"], { cwd: worktreeDir });
+  } catch (err) {
+    const msg = String(err?.message ?? err);
+    if (!msg.includes("did not match")) {
+      logger_default.warn(
+        `unexpected error restoring VOLUTE.md during upgrade for ${mindName}`,
+        logger_default.errorData(err)
+      );
+    }
+  }
+  try {
+    await gitExec(["diff", "--cached", "--quiet"], { cwd: worktreeDir });
+  } catch {
+    await gitExec(["commit", "-m", "prepare for home/ allowlist migration"], {
+      cwd: worktreeDir
+    });
+  }
+  const hasConflicts = await mergeTemplateBranch(worktreeDir);
+  if (!hasConflicts) {
+    try {
+      await gitExec(["add", "home/"], { cwd: worktreeDir });
+    } catch (err) {
+      logger_default.warn(`failed to re-add home files during upgrade for ${mindName}`, logger_default.errorData(err));
+    }
+    try {
+      await gitExec(["diff", "--cached", "--quiet"], { cwd: worktreeDir });
+    } catch {
+      await gitExec(["commit", "-m", "re-add allowlisted home files"], {
+        cwd: worktreeDir
+      });
+    }
+  }
+  await chownMindDir(dir, mindName);
+  if (hasConflicts) {
+    const filesRaw = await gitExec(["diff", "--name-only", "--diff-filter=U"], {
+      cwd: worktreeDir
+    });
+    const files = filesRaw.split("\n").map((f) => f.trim()).filter(Boolean);
+    return { status: "conflicts", worktreeDir, files };
+  }
+  try {
+    const result = await mergeUpgradeAndRestart(
+      mindName,
+      dir,
+      worktreeDir,
+      variantName,
+      UPGRADE_BRANCH,
+      template,
+      oldTemplate,
+      restart
+    );
+    if (!result.ok) {
+      return {
+        status: "conflicts",
+        worktreeDir,
+        files: result.files,
+        message: FINAL_MERGE_CONFLICTS_MESSAGE
+      };
+    }
+    return { status: "upgraded", warning: result.warning };
+  } catch (err) {
+    try {
+      await cleanupVariant(variantName, mindName, dir, worktreeDir, { branch: UPGRADE_BRANCH });
+    } catch (cleanupErr) {
+      logger_default.warn(`cleanup failed after upgrade error for ${mindName}`, logger_default.errorData(cleanupErr));
+    }
+    throw err instanceof Error ? err : new Error(String(err));
+  }
+}
+async function continueUpgrade(mindName, opts) {
+  return withUpgradeLock(mindName, () => continueUpgradeCore(mindName, opts));
+}
+async function continueUpgradeCore(mindName, opts) {
+  const entry = await findMind(mindName);
+  if (!entry) throw new Error("Mind not found");
+  const dir = mindDir(mindName);
+  const oldTemplate = entry.template ?? "claude";
+  const template = opts?.template ?? oldTemplate;
+  const restart = opts?.restart ?? true;
+  const variantName = upgradeVariantName(mindName);
+  const worktreeDir = upgradeWorktreeDir(dir);
+  if (!existsSync2(worktreeDir)) {
+    throw new Error("No upgrade in progress");
+  }
+  const status = await gitExec(["status", "--porcelain"], { cwd: worktreeDir });
+  const hasConflicts = status.split("\n").some((line) => line.startsWith("UU") || line.startsWith("AA"));
+  if (hasConflicts) {
+    throw new Error("Unresolved conflicts remain");
+  }
+  try {
+    await gitExec(["add", "-A"], { cwd: worktreeDir });
+    await gitExec(["commit", "-m", "merge template update"], { cwd: worktreeDir });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    const stderr = e?.stderr ?? "";
+    const stdout = e?.stdout ?? "";
+    if (!msg.includes("nothing to commit") && !stderr.includes("nothing to commit") && !stdout.includes("nothing to commit"))
+      throw e;
+  }
+  try {
+    await gitExec(["add", "home/"], { cwd: worktreeDir });
+  } catch (err) {
+    logger_default.warn(`failed to re-add home files during upgrade for ${mindName}`, logger_default.errorData(err));
+  }
+  try {
+    await gitExec(["diff", "--cached", "--quiet"], { cwd: worktreeDir });
+  } catch {
+    await gitExec(["commit", "-m", "re-add allowlisted home files"], {
+      cwd: worktreeDir
+    });
+  }
+  await chownMindDir(dir, mindName);
+  const result = await mergeUpgradeAndRestart(
+    mindName,
+    dir,
+    worktreeDir,
+    variantName,
+    UPGRADE_BRANCH,
+    template,
+    oldTemplate,
+    restart
+  );
+  if (!result.ok) {
+    return {
+      status: "conflicts",
+      worktreeDir,
+      files: result.files,
+      message: FINAL_MERGE_CONFLICTS_MESSAGE
+    };
+  }
+  return { status: "upgraded", warning: result.warning };
+}
+async function abortUpgrade(mindName) {
+  return withUpgradeLock(mindName, () => abortUpgradeCore(mindName));
+}
+async function abortUpgradeCore(mindName) {
+  const dir = mindDir(mindName);
+  const variantName = upgradeVariantName(mindName);
+  const worktreeDir = upgradeWorktreeDir(dir);
+  if (!existsSync2(worktreeDir)) {
+    throw new Error("No upgrade in progress");
+  }
+  if (upgradeMidResolution(worktreeDir)) {
+    await gitExec(["merge", "--abort"], { cwd: worktreeDir }).catch(() => {
+    });
+  }
+  await cleanupVariant(variantName, mindName, dir, worktreeDir, {
+    stop: true,
+    branch: UPGRADE_BRANCH
+  });
+}
+
+// packages/daemon/src/lib/daemon/auto-upgrade.ts
+var alog = logger_default.child("auto-upgrade");
+var RETRY_DELAY_MS = 5e3;
+var blocked = /* @__PURE__ */ new Map();
+function getUpgradeBlocked(name) {
+  return blocked.get(name);
+}
+function selectEligible(entries, deps) {
+  const eligible = entries.filter((entry) => {
+    if (entry.mindType !== "mind") return false;
+    if (entry.stage === "seed") return false;
+    if (entry.parent) return false;
+    if (!deps.isStale(entry)) return false;
+    if (deps.readConfig(entry.name)?.upgrades === "manual") return false;
+    return true;
+  });
+  return eligible.sort((a, b) => {
+    const aSleeping = deps.isSleeping(a.name) ? 0 : 1;
+    const bSleeping = deps.isSleeping(b.name) ? 0 : 1;
+    return aSleeping - bSleeping;
+  });
+}
+async function sleep(ms) {
+  await new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+var defaultAutoUpgradeOneDeps = {
+  isRunning: (name) => getMindManager().isRunning(name),
+  runUpgrade,
+  abortUpgrade,
+  deliverEvent: (name, input) => deliverEvent(name, input),
+  delay: sleep
+};
+function pruneBlocked(blockedMap, eligibleNames) {
+  for (const name of blockedMap.keys()) {
+    if (!eligibleNames.has(name)) blockedMap.delete(name);
+  }
+}
+async function autoUpgradeOne(entry, sleeping, deps = defaultAutoUpgradeOneDeps) {
+  const wasRunning = deps.isRunning(entry.name);
+  const restart = wasRunning && !sleeping;
+  const attempt = () => deps.runUpgrade(entry.name, { restart });
+  let outcome;
+  try {
+    outcome = await attempt();
+  } catch (err) {
+    if (err instanceof UpgradeInProgressError) {
+      blocked.set(entry.name, {
+        reason: "upgrade already in progress (mid conflict resolution)",
+        at: /* @__PURE__ */ new Date()
+      });
+      return;
+    }
+    await deps.delay(RETRY_DELAY_MS);
+    try {
+      outcome = await attempt();
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
+      alog.error(`auto-upgrade failed for ${entry.name} after retry`, logger_default.errorData(err2));
+      blocked.set(entry.name, { reason: message, at: /* @__PURE__ */ new Date() });
+      return;
+    }
+  }
+  if (outcome.status === "conflicts") {
+    await deps.abortUpgrade(entry.name).catch((err) => {
+      alog.warn(`failed to abort conflicted auto-upgrade for ${entry.name}`, logger_default.errorData(err));
+    });
+    const fileList = outcome.files.join(", ");
+    await deps.deliverEvent(entry.name, {
+      type: "notice",
+      body: `Auto-upgrade hit merge conflicts in: ${fileList}. Run \`volute mind upgrade ${entry.name}\` to resolve them manually (or set "upgrades": "manual" in home/.config/volute.json to stop auto attempts).`
+    });
+    blocked.set(entry.name, { reason: `merge conflicts: ${fileList}`, at: /* @__PURE__ */ new Date() });
+  }
+}
+async function runAutoUpgrades() {
+  let entries;
+  try {
+    entries = await readRegistry();
+  } catch (err) {
+    alog.error("failed to read registry for auto-upgrade pass", logger_default.errorData(err));
+    return;
+  }
+  const sleepManager = getSleepManagerIfReady();
+  const isSleeping = (name) => sleepManager?.isSleeping(name) ?? false;
+  const eligible = selectEligible(entries, {
+    isStale: (entry) => isTemplateStale(entry),
+    isSleeping,
+    readConfig: (name) => readVoluteConfig(mindDir(name))
+  });
+  pruneBlocked(blocked, new Set(eligible.map((e) => e.name)));
+  if (eligible.length === 0) return;
+  alog.info(`auto-upgrade pass starting for ${eligible.length} mind(s)`, {
+    minds: eligible.map((e) => e.name)
+  });
+  for (const entry of eligible) {
+    blocked.delete(entry.name);
+    try {
+      await autoUpgradeOne(entry, isSleeping(entry.name));
+    } catch (err) {
+      alog.error(`unexpected error auto-upgrading ${entry.name}`, logger_default.errorData(err));
+      blocked.set(entry.name, {
+        reason: err instanceof Error ? err.message : String(err),
+        at: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+}
+
+export {
+  npmInstallAsMind,
+  npmInstallNeeded,
+  validateBranchName,
+  findUnresolvedHomeFiles,
+  formatUnresolvedHomeFilesMessage,
+  mergeVariantExcludingMemory,
+  VariantMergeError,
+  UpgradeInProgressError,
+  TEMPLATE_BRANCH,
+  configureGitIdentity,
+  upgradeInProgress,
+  upgradeDiff,
+  runUpgrade,
+  continueUpgrade,
+  abortUpgrade,
+  getUpgradeBlocked,
+  selectEligible,
+  pruneBlocked,
+  autoUpgradeOne,
+  runAutoUpgrades
+};