vexp-cli 3.3.8 → 3.3.9

package/README.md

@@ -69,7 +69,7 @@ vexp runs one small daemon per project, started by your agent's first call. By d
 idle_timeout_minutes = 30
 ```
 
-The next tool call or prompt starts the daemon again. `VEXP_IDLE_TIMEOUT_MINUTES` sets it for one daemon. A daemon the VS Code extension started for a window stops when that window closes. `vexp daemons` lists what is running, with each daemon's memory, and `vexp doctor` shows whether the setting is on.
+The next tool call or prompt starts the daemon again. `VEXP_IDLE_TIMEOUT_MINUTES` sets it for one daemon. A daemon the VS Code extension started for a window stops when that window closes. Unset, a daemon an agent's session started (any agent) stops after 30 minutes without use and frees its slot of the plan's daemon cap; `idle_timeout_minutes = 0` turns that off, and `VEXP_NO_AUTOSTART=1` keeps sessions from starting one. `vexp daemons` lists what is running, with each daemon's memory, and `vexp doctor` shows whether the setting is on.
 
 ## Supported agents
 

package/dist/agent-config.js

@@ -2452,6 +2452,12 @@ function isUserManagedCodexSection(section) {
  *  them. `pinTo` is `vexp use --pin`, on purpose. The http section keeps its
  *  project: the URL routes to one workspace's daemon.
  *
+ *  `vexp-core mcp` starts the checkout's shared daemon when none runs, as the
+ *  Node server does. Unused for 30 minutes it stops and frees its slot of the
+ *  plan's daemon cap (vexp-core idle.rs; `idle_timeout_minutes` overrides it).
+ *  VEXP_NO_AUTOSTART=1, or a cap already full, leaves the session serving
+ *  in-process and taking no slot.
+ *
  *  BYTE-IDENTICAL with the extension's buildCodexSection, marker lines
  *  included, or the two rewrite this machine-wide file in turn. */
 function buildCodexSection(opts) {
@@ -2508,10 +2514,21 @@ Authorization = "Bearer ${opts.token}"
  * buildCodexSection), so one user entry serves every project.
  *
  * Default transport is `direct` (stdio: `vexp-core mcp`), which works with AND
- * without VS Code/daemon: `vexp-core mcp` auto-proxies to a running daemon when
- * reachable and otherwise runs an embedded in-process index. Override with the
+ * without VS Code: `vexp-core mcp` proxies to the project's daemon, starting it
+ * when none runs as the Node MCP server does, so every session on a checkout
+ * shares one daemon. It runs an embedded in-process index where it may not
+ * start one (VEXP_NO_AUTOSTART=1, the daily limit), where the plan's daemon cap
+ * refuses it, or where it does not answer in time. Override with the
  * VEXP_CODEX_TRANSPORT env var ("direct" | "http").
  *
+ * Every agent configured with `vexp-core mcp` directly runs that server and
+ * starts the daemon the same way: Cline, Continue, ZCode and the entries
+ * written where no Node runtime is found. In an editor with the vexp
+ * extension, such a server can start the daemon before the extension does.
+ * The extension then adopts it as a daemon it does not own, and the rule
+ * that ends a window's daemon with its window does not apply to it: it runs
+ * until `vexp stop`, the idle stop (`idle_timeout_minutes`) or a reboot.
+ *
  * `pin` is `vexp use <project> --pin`: the one way to name a project in the entry,
  * kept by every later setup until `vexp use` changes it. `unpin` is
  * `vexp use --unpin`. [mcp_servers.vexp.tools.*] tables (Codex's per-tool

package/dist/cli.js

@@ -46,7 +46,8 @@ Daemons:
     [daemon]
     idle_timeout_minutes = 30
 
-  VEXP_IDLE_TIMEOUT_MINUTES sets it for one daemon. A daemon an editor window started stops
+  VEXP_IDLE_TIMEOUT_MINUTES sets it for one daemon. Unset, a daemon an agent's session started
+  stops after 30 minutes without use (0 turns that off). A daemon an editor window started stops
   with that window instead. vexp daemons lists them; vexp doctor says whether the setting is on.
 `;
 program.addHelpText("after", IDLE_STOP_HELP);

package/dist/daemon-upgrade.js

@@ -187,8 +187,13 @@ export function parseEngineVersion(stdout) {
     return last ? last : undefined;
 }
 /**
- * The folder `daemon-cmd` works on when run in `dir`: the nearest one with a
- * `.git` at or above it, else `dir` itself (find_repo_root in vexp-core).
+ * The folder `daemon-cmd` works on when run in `dir` (daemon_cmd_root in
+ * vexp-core): the nearest one with a `.git` at or above it, unless that one
+ * was never set up for vexp and a folder between it and `dir` was, which
+ * is then the nearest such folder; with no `.git` above, `dir` itself. Set
+ * up is the engine's is_workspace_marker: one of its consent files in the
+ * folder's .vexp/, and neither the home directory nor a filesystem root
+ * (forbidden_workspace_reason refuses both).
  */
 export function daemonCmdRoot(dir) {
     let start = path.resolve(dir);
@@ -198,10 +203,16 @@ export function daemonCmdRoot(dir) {
     catch {
         /* not there: the spelling given */
     }
+    const setUp = (d) => (process.env.VEXP_ALLOW_HOME_WORKSPACE === "1" ||
+        (upgradeAttemptKey(d) !== upgradeAttemptKey(vexpHome()) && path.dirname(d) !== d)) &&
+        ["manifest.json", "vexp.toml", "workspace.json", "index.db"].some((f) => fs.existsSync(path.join(d, ".vexp", f)));
+    const below = [];
     let current = start;
     for (;;) {
-        if (fs.existsSync(path.join(current, ".git")))
-            return current;
+        if (fs.existsSync(path.join(current, ".git"))) {
+            return setUp(current) ? current : (below.find(setUp) ?? current);
+        }
+        below.push(current);
         const parent = path.dirname(current);
         if (parent === current)
             return start;
@@ -215,8 +226,10 @@ export function daemonCmdRoot(dir) {
  *
  *  - the stop half reads `<dir>/.vexp/daemon.pid`; with none there it stops
  *    nothing, and the start half then races the daemon that is still up;
- *  - `daemon-cmd` works on the git root at or above its cwd, so for a
- *    workspace below one it would start a daemon on the folder above;
+ *  - `daemon-cmd` works on the git root at or above its cwd unless a folder
+ *    below an unset-up root was set up on its own (daemonCmdRoot), so for
+ *    any other workspace below one it would start a daemon on the folder
+ *    above;
  *  - the engine refuses to start on the home directory, so a daemon an older
  *    build left there would be stopped and not come back.
  */

package/dist/doctor.js

@@ -3492,7 +3492,7 @@ async function doctorChecks(onWorkspace) {
                 // the cause can change between starts.
                 const why = typeof st.llm_inactive_reason === "string" ? st.llm_inactive_reason : undefined;
                 const restartIsPointless = why !== undefined &&
-                    /vanilla build|model load failed|incomplete|did not survive|worker did not start/i.test(why);
+                    /vanilla build|model load failed|incomplete|did not survive|worker did not start|needs a GPU/i.test(why);
                 // A daemon still running its startup sync has not REACHED the model
                 // yet. Restarting there is worse than useless: it starts the sync
                 // over, and the user never arrives.

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/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
@@ -203,8 +217,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)) {