vexp-cli 3.3.8 → 3.4.0

package/dist/forget.js

@@ -32,6 +32,7 @@ export const INDEX_ARTIFACTS = [
     "manifest.json",
     "coverage.json",
     "daemon.pid",
+    "daemon.lock",
     "daemon.pipe",
     "daemon.sock",
     "healthy",

package/dist/git-worktree.js

@@ -0,0 +1,136 @@
+import * as fs from "fs";
+import * as path from "path";
+import { isStateHome } from "./state-home.js";
+// Linked git worktrees, as the CLI sees them.
+//
+// Agent answers (agent-consent.ts) and the setup writers need to know when a
+// folder is a linked worktree of another checkout: the answers given in the
+// main checkout apply to its worktrees, and the files committed there are
+// checked out in every worktree, where a setup must not repin them (field
+// report, 2026-11-07). The rule is the one vexp-core (utils.rs
+// git_project_root / worktree_consent_source), vexp-mcp (daemon-client.ts)
+// and the extension (vexp-vscode src/git-worktree.ts) apply:
+// test/git-worktree.lockstep.test.ts runs the same fixtures through all
+// three ports.
+//
+// Detection is by the content of the worktree's .git FILE, never by a path
+// convention: harnesses put worktrees anywhere (.claude/worktrees/,
+// .worktrees/, a sibling folder).
+/**
+ * The main checkout of a linked git worktree, or null when `dir` is not
+ * one. A linked worktree has a `.git` FILE whose `gitdir:` line points into
+ * `<main>/.git/worktrees/<name>`; git 2.48's `worktree.useRelativePaths`
+ * writes that path relative to the worktree. A submodule's gitdir points at
+ * `<parent>/.git/modules/<name>`, or, inside a linked worktree, at
+ * `<main>/.git/worktrees/<wt>/modules/<name>`, and is its own project: null. Lockstep
+ * with vexp-core utils::git_project_root / is_linked_worktree and the
+ * extension's linkedWorktreeMain.
+ */
+export function linkedWorktreeMain(dir) {
+    let content;
+    try {
+        const dotGit = path.join(dir, ".git");
+        if (!fs.statSync(dotGit).isFile())
+            return null;
+        content = fs.readFileSync(dotGit, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const gitdir = content
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .find((l) => l.startsWith("gitdir:"))
+        ?.slice("gitdir:".length)
+        .trim()
+        .replace(/\\/g, "/");
+    const at = gitdir ? gitdir.indexOf("/.git/worktrees/") : -1;
+    if (!gitdir || at <= 0)
+        return null;
+    // A worktree's admin dir is one folder, <common>/.git/worktrees/<name>. A
+    // submodule checked out inside a linked worktree has its git dir under
+    // that admin dir (<main>/.git/worktrees/<wt>/modules/<path>): it is its
+    // own project, as a submodule of the main checkout is, and reading it as
+    // a worktree of <main> lent it <main>'s consent and a daemon. Lockstep
+    // with vexp-core utils::git_project_root.
+    const name = gitdir.slice(at + "/.git/worktrees/".length).replace(/\/+$/, "");
+    if (!name || name.includes("/"))
+        return null;
+    const main = path.resolve(dir, gitdir.slice(0, at));
+    // A gitdir naming the folder itself is not a link to another checkout.
+    return path.resolve(main) === path.resolve(dir) ? null : main;
+}
+/**
+ * Is `other` a checkout of the same repository as `root`, on this machine?
+ * A folder that is there, whose main checkout (the one a linked worktree's
+ * .git file names, else the folder itself) is `root`'s: a worktree's main
+ * checkout, a sibling worktree, the main checkout's live worktree. Not a
+ * folder that is missing here (a teammate's clone, a renamed or moved
+ * project, a removed worktree) and not an independent clone with its own
+ * .git. A committed file's pin or hook path is kept (W3) only for such a
+ * folder: kept for any other, a fresh clone or a moved repository got a
+ * vexp server pinned to a folder that does not exist, and a Codex hook that
+ * failed at every prompt, where 3.3.9 had pointed the file at the checkout
+ * (review, 2026-11-07). Filesystem only, no git. Lockstep with the
+ * extension's.
+ */
+export function sameRepositoryCheckout(other, root) {
+    try {
+        if (!fs.statSync(other).isDirectory())
+            return false;
+    }
+    catch {
+        return false;
+    }
+    const mainOf = (d) => linkedWorktreeMain(d) ?? d;
+    const key = (p) => {
+        const r = path.resolve(p).replace(/[\\/]+$/, "");
+        const k = r.length > 0 ? r : path.resolve(p);
+        return process.platform === "win32" ? k.toLowerCase() : k;
+    };
+    const a = mainOf(other);
+    const b = mainOf(root);
+    if (key(a) === key(b))
+        return true;
+    try {
+        return key(fs.realpathSync.native(a)) === key(fs.realpathSync.native(b));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The main checkout a linked worktree takes its consent from: set up with
+ * vexp (manifest.json or index.db in its .vexp/) and not a folder the engine
+ * refuses whatever it holds (the home directory, a filesystem root). null
+ * for anything that is not a linked worktree. Lockstep with vexp-core
+ * utils::worktree_consent_source, vexp-mcp worktreeConsentSource and the
+ * extension's worktreeConsentSource.
+ */
+export function worktreeConsentSource(dir) {
+    const main = linkedWorktreeMain(dir);
+    if (!main)
+        return null;
+    const resolved = path.resolve(main);
+    // VEXP_ALLOW_HOME_WORKSPACE=1 lifts both refusals, as in the extension's
+    // refusedWhateverItHolds (isStateHome already answers false then).
+    const fsRoot = process.env.VEXP_ALLOW_HOME_WORKSPACE !== "1" && path.dirname(resolved) === resolved;
+    if (isStateHome(resolved) || fsRoot)
+        return null;
+    const vexp = path.join(main, ".vexp");
+    return fs.existsSync(path.join(vexp, "manifest.json")) || fs.existsSync(path.join(vexp, "index.db")) ? main : null;
+}
+/**
+ * Does the vexp extension start this folder's daemon when a window opens on
+ * it? Lockstep with the extension's startsAtActivation (non-null): the
+ * folder has an index of its own (.vexp/index.db), or, not on Windows, it
+ * is a linked worktree of a checkout set up for vexp (worktreeConsentSource),
+ * whose first start builds its index. Not on Windows: a live daemon holds
+ * the worktree's index open, and Windows then refuses `git worktree remove`.
+ * What `vexp doctor` says about a daemon that is down: a fresh worktree of
+ * a set-up repository was told to press "Start Indexing", while opening its
+ * window is enough (review, 2026-11-07).
+ */
+export function extensionStartsOnOpen(root, platform = process.platform) {
+    return fs.existsSync(path.join(root, ".vexp", "index.db")) || (platform !== "win32" && worktreeConsentSource(root) !== null);
+}

package/dist/hook-scripts.js

@@ -0,0 +1,271 @@
+import * as fs from "fs";
+// Committed hook scripts (K1), as `vexp setup` sees them. Twin:
+// packages/vexp-vscode/src/providers/hook-scripts.ts, the same code and the
+// same line word for word (vexp-vscode test/hook-scripts-lockstep.test.ts).
+//
+// Why: every hook script vexp writes into a project bakes the absolute path
+// of the engine that wrote it (VEXP_BIN), because Claude Code and Codex run
+// the script with no vexp on PATH. A team that commits .claude/hooks/ and
+// .codex/ then saw every checkout rewrite them whenever that path changed:
+// an extension update (a new versioned folder), a teammate's machine, a
+// container with another HOME, and `vexp setup` against the extension's
+// copy (the extension adds an upgrade fallback the CLI does not). git status
+// showed them modified in every clone and worktree, and an agent's `git add
+// -A` committed the churn (field report, 2026-11-07). A committed script
+// whose text is exactly what this vexp writes, for the engine path it
+// bakes, and that still finds a working engine, is left as it is.
+/**
+ * The extension's upgrade fallback, inserted after the VEXP_BIN line of
+ * every sh hook script it writes (vexp-vscode agent-auto-config.ts
+ * bakeVexpBin, where the reasoning lives). The CLI does not write it: its
+ * own paths are version-stable. It recognizes it, so a committed script
+ * the extension wrote is not rewritten into the CLI's form. Byte for byte
+ * the extension's.
+ */
+export const VEXP_BIN_FALLBACK = `
+# An extension upgrade removes the versioned folder above; fall back to the
+# newest installed vexp extension binary. Managed by vexp.
+if [ ! -x "$VEXP_BIN" ]; then
+  case "$VEXP_BIN" in
+    */extensions/vexp.vexp-vscode-*)
+      _vexp_ext_root="\${VEXP_BIN%%/vexp.vexp-vscode-*}"
+      _vexp_latest="$(ls -d "$_vexp_ext_root"/vexp.vexp-vscode-*/binaries/*/vexp-core* 2>/dev/null | sort -V 2>/dev/null | tail -n 1)"
+      [ -n "$_vexp_latest" ] && [ -x "$_vexp_latest" ] && VEXP_BIN="$_vexp_latest"
+      ;;
+  esac
+fi`;
+/**
+ * `plain`, a sh hook script as the CLI bakes it, in the extension's form:
+ * VEXP_BIN_FALLBACK right after its `VEXP_BIN="..."` line, which is where
+ * bakeVexpBin puts it. undefined for a script with no such line (the
+ * Windows .cmd twin, the opencode / Kilo plugins): neither twin adds a
+ * fallback there.
+ */
+export function withExtensionFallback(plain) {
+    const m = /^VEXP_BIN="[^"\r\n]*"$/m.exec(plain);
+    if (!m)
+        return undefined;
+    const at = m.index + m[0].length;
+    return plain.slice(0, at) + VEXP_BIN_FALLBACK + plain.slice(at);
+}
+/**
+ * The engine path a hook script bakes: the sh scripts' `VEXP_BIN="..."`,
+ * the .cmd twin's `set "VEXP_BIN=..."`, the opencode / Kilo plugins'
+ * `const VEXP_BIN = "...";` and `const BIN = "...";`. The first such line;
+ * undefined when the text has none.
+ */
+export function bakedEnginePath(text) {
+    const patterns = [
+        /^VEXP_BIN="([^"\r\n]*)"\r?$/m,
+        /^set "VEXP_BIN=([^"\r\n]*)"\r?$/m,
+        /^const (?:VEXP_)?BIN = "([^"\r\n]*)";\r?$/m,
+    ];
+    for (const re of patterns) {
+        const m = re.exec(text);
+        if (m && m[1] !== "")
+            return m[1];
+    }
+    return undefined;
+}
+function executable(p) {
+    try {
+        fs.accessSync(p, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isFile(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function dirNames(dir) {
+    try {
+        return fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+const isDigit = (c) => c >= "0" && c <= "9";
+const isAlpha = (c) => (c >= "A" && c <= "Z") || (c >= "a" && c <= "z");
+/** gnulib filevercmp's file_prefixlen: the length of `s` without a suffix like `.tar.gz` or `.exe`. */
+function filePrefixLen(s) {
+    const n = s.length;
+    let prefixlen = 0;
+    for (let i = 0;;) {
+        if (i === n)
+            return prefixlen;
+        i++;
+        prefixlen = i;
+        while (i + 1 < n && s[i] === "." && (isAlpha(s[i + 1]) || s[i + 1] === "~")) {
+            for (i += 2; i < n && (isAlpha(s[i]) || isDigit(s[i]) || s[i] === "~"); i++) {
+                /* the suffix goes on */
+            }
+        }
+    }
+}
+/** gnulib filevercmp's order(): where the byte at `pos` sorts. */
+function order(s, pos, len) {
+    if (pos === len)
+        return -1;
+    const c = s[pos];
+    if (isDigit(c))
+        return 0;
+    if (isAlpha(c))
+        return c.charCodeAt(0);
+    if (c === "~")
+        return -2;
+    return c.charCodeAt(0) + 256;
+}
+/** gnulib filevercmp's verrevcmp, over the first `alen` and `blen` characters. */
+function verrevcmp(a, alen, b, blen) {
+    let i = 0;
+    let j = 0;
+    while (i < alen || j < blen) {
+        let firstDiff = 0;
+        while ((i < alen && !isDigit(a[i])) || (j < blen && !isDigit(b[j]))) {
+            const ac = order(a, i, alen);
+            const bc = order(b, j, blen);
+            if (ac !== bc)
+                return ac - bc;
+            i++;
+            j++;
+        }
+        while (i < alen && a[i] === "0")
+            i++;
+        while (j < blen && b[j] === "0")
+            j++;
+        while (i < alen && j < blen && isDigit(a[i]) && isDigit(b[j])) {
+            if (!firstDiff)
+                firstDiff = a.charCodeAt(i) - b.charCodeAt(j);
+            i++;
+            j++;
+        }
+        if (i < alen && isDigit(a[i]))
+            return 1;
+        if (j < blen && isDigit(b[j]))
+            return -1;
+        if (firstDiff)
+            return firstDiff;
+    }
+    return 0;
+}
+/**
+ * `sort -V` as GNU coreutils orders two lines (gnulib filevercmp, then the
+ * whole line byte by byte when they tie), which is what the fallback's
+ * `sort -V | tail -n 1` uses to pick the newest build: 3.3.10 after 3.3.9.
+ * Negative, zero or positive, like a comparator.
+ */
+export function versionSortCompare(a, b) {
+    const byVersion = (() => {
+        if (a === "" || b === "")
+            return (b === "" ? 1 : 0) - (a === "" ? 1 : 0);
+        if (a[0] === ".") {
+            if (b[0] !== ".")
+                return -1;
+            const adot = a.length === 1;
+            const bdot = b.length === 1;
+            if (adot || bdot)
+                return (bdot ? 1 : 0) - (adot ? 1 : 0);
+            const adotdot = a[1] === "." && a.length === 2;
+            const bdotdot = b[1] === "." && b.length === 2;
+            if (adotdot || bdotdot)
+                return (bdotdot ? 1 : 0) - (adotdot ? 1 : 0);
+        }
+        else if (b[0] === ".") {
+            return 1;
+        }
+        const ap = filePrefixLen(a);
+        const bp = filePrefixLen(b);
+        const onePass = ap === a.length && bp === b.length;
+        const r = verrevcmp(a, ap, b, bp);
+        return r || onePass ? r : verrevcmp(a, a.length, b, b.length);
+    })();
+    if (byVersion !== 0)
+        return byVersion;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * The build VEXP_BIN_FALLBACK runs for `bin`, by the rules of its sh code:
+ * only for a path inside a VS Code extensions folder
+ * (`*\/extensions/vexp.vexp-vscode-*`), the newest (`sort -V`) of
+ * `<that folder>/vexp.vexp-vscode-*\/binaries/*\/vexp-core*`, and only when
+ * it is executable. undefined when the fallback would pick none. The sh
+ * code does not run at all while `bin` itself is executable.
+ */
+export function extensionFallbackEngine(bin) {
+    if (!bin.includes("/extensions/vexp.vexp-vscode-"))
+        return undefined;
+    // ${VEXP_BIN%%/vexp.vexp-vscode-*}: everything before the first match.
+    const root = bin.slice(0, bin.indexOf("/vexp.vexp-vscode-"));
+    // The glob, as sh expands it: no name that starts with a dot under a `*`.
+    const found = [];
+    for (const build of dirNames(root || "/")) {
+        if (!build.startsWith("vexp.vexp-vscode-"))
+            continue;
+        const binaries = `${root}/${build}/binaries`;
+        for (const platform of dirNames(binaries)) {
+            if (platform.startsWith("."))
+                continue;
+            for (const name of dirNames(`${binaries}/${platform}`)) {
+                if (name.startsWith("vexp-core"))
+                    found.push(`${binaries}/${platform}/${name}`);
+            }
+        }
+    }
+    if (found.length === 0)
+        return undefined;
+    const newest = found.reduce((a, b) => (versionSortCompare(a, b) >= 0 ? a : b));
+    return executable(newest) && isFile(newest) ? newest : undefined;
+}
+/**
+ * Would a hook script that bakes `bin` run an engine right now? The sh
+ * scripts run `$VEXP_BIN` when it is executable (and an executable that is
+ * no file runs nothing); a script with the extension's fallback
+ * (`withFallback`) otherwise runs the build extensionFallbackEngine names.
+ */
+export function hookEngineWorks(bin, withFallback) {
+    if (executable(bin))
+        return isFile(bin);
+    return withFallback && extensionFallbackEngine(bin) !== undefined;
+}
+/**
+ * K1: may the hook script `text` (what is on disk) stay as it is? Yes when
+ * it is exactly what this vexp writes for the engine path it bakes
+ * (`plainFor(bin)`, the CLI's form, or that with the extension's fallback),
+ * that script would find a working engine now, and `tracked()` (git, asked
+ * last) says the file is committed. A script whose template changed, whose
+ * engine is gone with no fallback that finds one, or that git does not
+ * track is written as before.
+ */
+export function committedHookScriptStays(text, plainFor, tracked) {
+    const bin = bakedEnginePath(text);
+    if (bin === undefined)
+        return false;
+    const plain = plainFor(bin);
+    const extension = withExtensionFallback(plain);
+    if (text !== plain && text !== extension)
+        return false;
+    if (!hookEngineWorks(bin, text === extension))
+        return false;
+    return tracked();
+}
+/** Why a committed hook script was left as it is (K1). ASCII, word for word the extension's. */
+export function committedHookScriptLine(file) {
+    return `${file} is committed to this repository and its vexp engine path still works here; vexp left it as it is`;
+}
+/** The script on disk at `file`, or undefined when there is none to read. */
+export function readHookScript(file) {
+    try {
+        return fs.readFileSync(file, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/license-activate.js

@@ -11,6 +11,39 @@ export function planLabel(plan) {
 export function isLifetimePlan(plan) {
     return /^tier[1-4]$/.test(plan);
 }
+/**
+ * The tool counts `vexp license` states, as the servers define them. The
+ * line said "no (7/10)" from v1.2.16 on, long after the surface grew, and
+ * "shows 4 by default" for the native server alone. Held to the sources by
+ * test/license.tool-counts.test.ts: vexp-core's build_all_tool_defs,
+ * FREE_TOOLS and CORE_LISTED_TOOLS (mcp_stdio.rs), and the Node server's
+ * MINIMAL_TOOL_DEFINITIONS (vexp-mcp/src/index.ts).
+ */
+export const TOOL_COUNTS = {
+    /** Every tool vexp-core's MCP server defines. */
+    native: 15,
+    /** Those its tools/call serves on a plan without all_tools. */
+    nativeFree: 9,
+    /** What vexp-core lists by default. */
+    nativeListed: 4,
+    /** What the Node MCP server (mcp-server.cjs) lists by default: the same
+     *  four since it lists expand_vexp_ref too. */
+    nodeListed: 4,
+};
+/** The "All tools" lines of `vexp license` and the menu's status, unindented. */
+export function allToolsLines(allTools) {
+    const c = TOOL_COUNTS;
+    if (!allTools)
+        return [`All tools: no (the Free set: ${c.nativeFree} of vexp-core's ${c.native} tools)`];
+    // One number while both servers list as many; both, should they part again.
+    const shown = c.nodeListed === c.nativeListed
+        ? `${c.nativeListed} by default`
+        : `${c.nativeListed} by default, ${c.nodeListed} through the Node MCP server`;
+    return [
+        "All tools: yes",
+        `(the MCP tool list shows ${shown}, to keep the catalog small; every tool stays callable - VEXP_ALL_TOOLS=1 lists them all)`,
+    ];
+}
 /** "Last check-in: <date>" / "never", for `vexp license` and the menu. */
 export function lastCheckInText() {
     const at = lastCheckIn();

package/dist/serve.js

@@ -125,7 +125,7 @@ async function resurrectDaemon(workspaceRoot, socketPath) {
             child = spawn(binary, ["daemon", "--workspace", workspaceRoot, "--socket", socketPath], {
                 detached: true,
                 stdio: ["ignore", log, log],
-                env: binaryEnv(binary),
+                env: serveDaemonEnv(binary, workspaceRoot),
             });
         }
         finally {
@@ -143,6 +143,20 @@ async function resurrectDaemon(workspaceRoot, socketPath) {
         return false;
     }
 }
+/** The environment of a daemon brought back: one that was started for an
+ *  agent's session stays one, with its idle stop. Without this a crash made it
+ *  permanent, holding its slot of the plan's daemon cap. The role is in the
+ *  lock file it left (vexp-core index_lock.rs AGENT_DAEMON_ROLE). */
+export function serveDaemonEnv(binary, workspaceRoot) {
+    const env = binaryEnv(binary);
+    try {
+        const lock = JSON.parse(fs.readFileSync(path.join(workspaceRoot, ".vexp", "daemon.lock"), "utf-8"));
+        if (lock?.role === "agent daemon")
+            env.VEXP_DAEMON_OWNER = "agent";
+    }
+    catch { /* no lock, or held and unreadable: no owner */ }
+    return env;
+}
 /** True when `sock` is the canonical socket for `ws` itself (unix path or the
  *  win32 named pipe derived from `ws`). A registry row that FAILS this is a
  *  ROUTING entry: a connected secondary repo mapped to its parent workspace's
@@ -170,7 +184,8 @@ export function isOwnerEntry(ws, sock) {
  *  and took a 16-core host down: ~1,585% CPU, 2 GB/s of reads, hard reset
  *  (field incident, 2026-09-02, tier 3). Worktree daemons run on demand
  *  only; resurrection is for canonical workspaces. A submodule's gitdir
- *  points at `/.git/modules/` and is left alone. Mirrors vexp-core
+ *  points at `/.git/modules/` (or, inside a linked worktree,
+ *  `/.git/worktrees/<wt>/modules/`) and is left alone. Mirrors vexp-core
  *  utils::git_project_root. */
 export function isLinkedWorktree(ws) {
     try {
@@ -183,7 +198,11 @@ export function isLinkedWorktree(ws) {
             .find((l) => l.trim().startsWith("gitdir:"));
         if (!gitdir)
             return false;
-        return gitdir.replace(/\\/g, "/").includes("/.git/worktrees/");
+        // Only `<common>/.git/worktrees/<name>`, one folder deep: a submodule
+        // checked out inside a linked worktree (`.git/worktrees/<wt>/modules/
+        // <path>`) is its own project. Lockstep with linkedWorktreeMain
+        // (git-worktree.ts) and vexp-core utils::git_project_root.
+        return /\/\.git\/worktrees\/[^/]+\/?$/.test(gitdir.slice(gitdir.indexOf("gitdir:") + "gitdir:".length).replace(/\\/g, "/").trim());
     }
     catch {
         return false;
@@ -203,8 +222,40 @@ export function resurrectionVeto(ws) {
         return "no manifest";
     if (isLinkedWorktree(ws))
         return "linked git worktree — on-demand only, never resurrected";
+    if (indexesNothingUnsetUp(ws)) {
+        return "its manifest lists no file and it was never set up — the daemon refuses it unless it now holds sources, so on-demand only";
+    }
     return null;
 }
+/** The files a person writes to set a folder up on purpose
+ *  (vexp-core utils::SET_UP_ON_PURPOSE, held equal by a test there). */
+export const SET_UP_ON_PURPOSE = ["vexp.toml", "workspace.json"];
+/** A workspace whose manifest lists no file and that nobody set up on
+ *  purpose: what older versions of `vexp index` left in folders with no
+ *  source. The daemon refuses such a folder unless a walk finds a source
+ *  file in it (vexp-core utils::nothing_to_serve); a resurrection would be
+ *  a refused spawn a minute. No walk here: a row whose folder gained
+ *  sources is started again by the next launcher that needs it, and its
+ *  daemon then writes a manifest that lists them. A manifest that cannot
+ *  be read, or has no file_hashes at all (every manifest vexp writes has
+ *  one), is not "no file". */
+function indexesNothingUnsetUp(ws) {
+    if (SET_UP_ON_PURPOSE.some((f) => fs.existsSync(path.join(ws, ".vexp", f))))
+        return false;
+    try {
+        const manifest = path.join(ws, ".vexp", "manifest.json");
+        // One that lists nothing is a few hundred bytes; a real one is not
+        // worth parsing every minute to learn that it lists files.
+        if (fs.statSync(manifest).size > 64 * 1024)
+            return false;
+        const parsed = JSON.parse(fs.readFileSync(manifest, "utf-8"));
+        const files = parsed?.file_hashes;
+        return typeof files === "object" && files !== null && Object.keys(files).length === 0;
+    }
+    catch {
+        return false;
+    }
+}
 export function resurrectionPlan(reg) {
     const bySock = new Map();
     for (const [ws, sock] of Object.entries(reg)) {