@cruxy/cli 0.29.0 → 0.29.3

package/dist/utils/child-tree.d.ts

@@ -1,9 +1,11 @@
 /**
- * Shared no-orphan machinery for long-lived child processes (C.12 LSP servers,
- * C.27 MCP servers). A child is spawned `detached` so it leads its own process
- * group; every kill here uses a **negative-PID** `SIGKILL` so the whole tree —
- * the child AND any grandchildren it forked (gopls's `go`, an MCP server's
- * helper) — dies together.
+ * The process-EXIT backstop for long-lived child trees (C.12 LSP servers, C.27
+ * MCP servers). The platform-aware spawn/kill primitives themselves now live in
+ * {@link ./process-tree.js} — {@link killTree} is re-exported here unchanged so
+ * existing LSP/MCP importers keep their import path, and so this backstop and
+ * those transports reap trees the SAME way on every platform (negative-PID
+ * `SIGKILL` on POSIX, `taskkill /T /F` on win32 — no more orphaned grandchildren
+ * on Windows).
  *
  * A per-session graceful shutdown covers the normal path, but a hard exit
  * (Ctrl-C, an uncaught throw) would otherwise orphan these trees. So every live
@@ -15,12 +17,8 @@
  * and MCP (newline-delimited JSON) share the SAME backstop, so `killTrackedTrees`
  * on exit reaps both and there is a single source of truth for "no orphans".
  */
-/**
- * Kill a process's entire group (POSIX negative-PID `SIGKILL`), falling back to
- * a direct kill when there is no group (or on win32). Swallows errors — the
- * process may already be gone.
- */
-export declare function killTree(pid: number | undefined): void;
+import { killTree } from "./process-tree.js";
+export { killTree };
 /**
  * Force-kill the process group of every tracked-but-not-yet-shut-down child,
  * then forget them. This is exactly what the `exit`/`SIGINT`/`SIGTERM`/`SIGHUP`

package/dist/utils/child-tree.js

@@ -1,9 +1,11 @@
 /**
- * Shared no-orphan machinery for long-lived child processes (C.12 LSP servers,
- * C.27 MCP servers). A child is spawned `detached` so it leads its own process
- * group; every kill here uses a **negative-PID** `SIGKILL` so the whole tree —
- * the child AND any grandchildren it forked (gopls's `go`, an MCP server's
- * helper) — dies together.
+ * The process-EXIT backstop for long-lived child trees (C.12 LSP servers, C.27
+ * MCP servers). The platform-aware spawn/kill primitives themselves now live in
+ * {@link ./process-tree.js} — {@link killTree} is re-exported here unchanged so
+ * existing LSP/MCP importers keep their import path, and so this backstop and
+ * those transports reap trees the SAME way on every platform (negative-PID
+ * `SIGKILL` on POSIX, `taskkill /T /F` on win32 — no more orphaned grandchildren
+ * on Windows).
  *
  * A per-session graceful shutdown covers the normal path, but a hard exit
  * (Ctrl-C, an uncaught throw) would otherwise orphan these trees. So every live
@@ -15,26 +17,10 @@
  * and MCP (newline-delimited JSON) share the SAME backstop, so `killTrackedTrees`
  * on exit reaps both and there is a single source of truth for "no orphans".
  */
-/**
- * Kill a process's entire group (POSIX negative-PID `SIGKILL`), falling back to
- * a direct kill when there is no group (or on win32). Swallows errors — the
- * process may already be gone.
- */
-export function killTree(pid) {
-    if (pid === undefined)
-        return;
-    try {
-        process.kill(-pid, "SIGKILL");
-    }
-    catch {
-        try {
-            process.kill(pid, "SIGKILL");
-        }
-        catch {
-            /* already exited */
-        }
-    }
-}
+import { killTree } from "./process-tree.js";
+// Re-exported so LSP/MCP transports (and their tests) keep importing `killTree`
+// from here; the implementation is the shared, platform-aware one.
+export { killTree };
 const livePids = new Set();
 let handlersInstalled = false;
 /**

package/dist/utils/process-tree.d.ts

@@ -0,0 +1,16 @@
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
+/**
+ * Spawn a child as the head of a killable process tree, applying the
+ * platform-correct grouping options on top of the caller's own (`shell`, `cwd`,
+ * `stdio`, `env`, …). Any `detached`/`windowsHide` the caller passes is
+ * overridden — grouping is this module's responsibility, not the call site's.
+ */
+export declare function spawnTree(command: string, args?: readonly string[], options?: SpawnOptions): ChildProcess;
+/**
+ * Kill a child's ENTIRE process tree — the child and every descendant it
+ * spawned. POSIX: negative-PID `SIGKILL` targets the process group created by
+ * {@link spawnTree}'s `detached`. win32: `taskkill /PID <pid> /T /F` walks the
+ * OS tree (`/T`) and force-terminates it (`/F`). Fire-and-forget and
+ * error-swallowing on both paths — the tree may already be gone.
+ */
+export declare function killTree(pid: number | undefined): void;

package/dist/utils/process-tree.js

@@ -0,0 +1,81 @@
+import { spawn, } from "node:child_process";
+/**
+ * The single platform-aware primitive for spawning a killable process tree and
+ * reaping it whole. Both halves — {@link spawnTree} and {@link killTree} — MUST
+ * come from here as a pair, because how a child is spawned decides how its tree
+ * can be killed, and the two differ by platform:
+ *
+ * - POSIX: spawn `detached` so the child leads its own process group, then kill
+ *   the whole group with a negative-PID `SIGKILL`. One signal reaps the shell
+ *   AND everything it forked (a `shell:true` grandchild, gopls's `go`, …).
+ * - win32: there is no process-group signalling to lean on. `detached` there
+ *   means "new console / new group" — the wrong semantics, and a flashing
+ *   window. So we DON'T detach (just `windowsHide`), and kill by walking the
+ *   real OS parent-PID tree with `taskkill /T /F`, which a negative-PID signal
+ *   could never do on Windows (it would kill only the direct child and orphan
+ *   the grandchildren).
+ *
+ * This module exists because that pairing used to be copy-pasted — three
+ * POSIX-only `killTree` variants (run_command, the test runner, the LSP/MCP
+ * backstop), each of which silently orphaned grandchildren on Windows. There is
+ * now one implementation; a change to the kill discipline changes every path.
+ */
+const isWindows = process.platform === "win32";
+/**
+ * Spawn a child as the head of a killable process tree, applying the
+ * platform-correct grouping options on top of the caller's own (`shell`, `cwd`,
+ * `stdio`, `env`, …). Any `detached`/`windowsHide` the caller passes is
+ * overridden — grouping is this module's responsibility, not the call site's.
+ */
+export function spawnTree(command, args = [], options = {}) {
+    const grouped = isWindows
+        ? { ...options, detached: false, windowsHide: true }
+        : { ...options, detached: true };
+    return spawn(command, args, grouped);
+}
+/**
+ * Kill a child's ENTIRE process tree — the child and every descendant it
+ * spawned. POSIX: negative-PID `SIGKILL` targets the process group created by
+ * {@link spawnTree}'s `detached`. win32: `taskkill /PID <pid> /T /F` walks the
+ * OS tree (`/T`) and force-terminates it (`/F`). Fire-and-forget and
+ * error-swallowing on both paths — the tree may already be gone.
+ */
+export function killTree(pid) {
+    if (pid === undefined)
+        return;
+    if (isWindows) {
+        killTreeWindows(pid);
+        return;
+    }
+    try {
+        // Negative PID = "the whole group led by `pid`", not just `pid`.
+        process.kill(-pid, "SIGKILL");
+    }
+    catch {
+        // Already exited, or no group — nothing to kill.
+    }
+}
+/**
+ * Reap `pid`'s tree via `taskkill`. The killer is itself a child process, so we
+ * reap IT too: `stdio: "ignore"` gives it nothing to block on, the `error`
+ * handler swallows a missing-`taskkill`/EPIPE rejection (an unhandled `error`
+ * event would otherwise crash the process), and `unref` keeps this short-lived
+ * helper from holding the event loop open. taskkill exits on its own; we neither
+ * wait for it nor let it leak.
+ */
+function killTreeWindows(pid) {
+    try {
+        const killer = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        killer.on("error", () => {
+            // taskkill unavailable (should not happen on win32) — nothing more to do.
+        });
+        killer.unref();
+    }
+    catch {
+        // Even the spawn attempt failed — the tree, if any, outlives us. Nothing
+        // more we can do from here.
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "0.29.0",
+  "version": "0.29.3",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {
@@ -29,7 +29,6 @@
     "directory": "packages/cli"
   },
   "dependencies": {
-    "better-sqlite3": "^12.11.1",
     "commander": "^12.1.0",
     "fastembed": "^2.1.0",
     "picocolors": "^1.1.1",
@@ -37,7 +36,10 @@
     "undici": "^6.21.0",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5",
-    "@cruxy/sdk": "0.2.0"
+    "@cruxy/sdk": "0.2.1"
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^12.11.1"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",

package/dist/subagent/budget.d.ts

@@ -1,34 +0,0 @@
-import type { Usage } from "@cruxy/sdk";
-import type { LoopBudget } from "../agent/loop.js";
-import type { BudgetLimits } from "./types.js";
-/**
- * The subagent budget (C.14): iteration + token + optional wall-clock caps,
- * checked by the agent loop before every model turn (see `LoopBudget`). A
- * tripped cap stops the run with a human-readable reason — the subagent
- * returns a partial result, it never runs unbounded.
- */
-/**
- * Resolve the effective limits for one spawn: start from the configured
- * ceilings and let overrides only *narrow* them. A request above a ceiling is
- * clamped down, not honored — "budget overrides within limits" by construction.
- */
-export declare function resolveBudget(defaults: BudgetLimits, overrides?: Partial<BudgetLimits>): BudgetLimits;
-/**
- * A live budget for one subagent run. The wall clock starts at construction
- * (spawn time); the clock source is injectable so tests never sleep.
- */
-export declare class Budget implements LoopBudget {
-    private readonly limits;
-    private readonly now;
-    private readonly startedAt;
-    constructor(limits: BudgetLimits, now?: () => number);
-    /**
-     * The reason to stop before the next model turn, or `null` to continue.
-     * Checked at iteration boundaries — the in-flight turn always completes, so
-     * overshoot is bounded by one turn.
-     */
-    exceeded(state: {
-        iterations: number;
-        usage: Usage;
-    }): string | null;
-}