@kybernesis/create 0.15.0 → 0.15.2

package/dist/templates.d.ts

@@ -80,3 +80,19 @@ export declare function arcanaMemorySlotTs(options: {
  * registry item, so the three can never disagree about what the file says.
  */
 export declare function notifyMountTs(): string;
+/**
+ * The sandbox source for a reasoning-only specialist. One source for the
+ * `kyb upgrade` repair and any future scaffold, so they cannot disagree.
+ *
+ * Every eve agent has exactly one sandbox, and a declared subagent that
+ * authors none gets the framework default — on a self-hosted host, a Docker
+ * container from an 840MB image. A specialist that reasons and remembers with
+ * its file tools disabled never touches a filesystem, yet still booted a
+ * container per call; on a small host those boots blow eve's command-hook
+ * wait, which reads as the specialist being unavailable. `justbash` is eve's
+ * pure-JS bash: a virtual filesystem, no daemon, no VM, no container, no
+ * image, available instantly.
+ */
+export declare function reasoningSandboxLibTs(): string;
+/** What each reasoning-only subagent's `sandbox.ts` re-exports. */
+export declare function reasoningSandboxReexportTs(): string;

package/dist/templates.js

@@ -733,3 +733,34 @@ export function notifyMountTs() {
 export { default } from "@kybernesis/notify/extension";
 `;
 }
+/**
+ * The sandbox source for a reasoning-only specialist. One source for the
+ * `kyb upgrade` repair and any future scaffold, so they cannot disagree.
+ *
+ * Every eve agent has exactly one sandbox, and a declared subagent that
+ * authors none gets the framework default — on a self-hosted host, a Docker
+ * container from an 840MB image. A specialist that reasons and remembers with
+ * its file tools disabled never touches a filesystem, yet still booted a
+ * container per call; on a small host those boots blow eve's command-hook
+ * wait, which reads as the specialist being unavailable. `justbash` is eve's
+ * pure-JS bash: a virtual filesystem, no daemon, no VM, no container, no
+ * image, available instantly.
+ */
+export function reasoningSandboxLibTs() {
+    return `import { defineSandbox } from "eve/sandbox";
+import { justbash } from "eve/sandbox/just-bash";
+
+// The sandbox for a reasoning-only specialist: an instant virtual filesystem,
+// no Docker container. See agent/subagents/<id>/sandbox.ts, which re-export
+// this. Only subagents that do real build/git/network work keep a docker()
+// sandbox of their own.
+export default defineSandbox({ backend: justbash() });
+`;
+}
+/** What each reasoning-only subagent's `sandbox.ts` re-exports. */
+export function reasoningSandboxReexportTs() {
+    return `// Reasoning-only specialist: no real filesystem, so no Docker container.
+// See agent/lib/reasoning-sandbox for why this exists and what it replaces.
+export { default } from "../../lib/reasoning-sandbox";
+`;
+}

package/dist/upgrade.d.ts

@@ -15,6 +15,10 @@ export declare function agentInputLimitUpgradeMessage(limit: AgentInputLimit): s
 export declare function needsNotify(deps: Record<string, string>): boolean;
 /** Write the notify mount if it is missing. Never touches a file that exists. */
 export declare function repairNotifyMount(cwd: string): "mounted" | "present";
+/** Reasoning-only subagents (disable all file tools) that have no sandbox of their own. */
+export declare function reasoningSubagentsNeedingSandbox(cwd: string): string[];
+/** Write the shared lib source and each specialist's re-export. Never touches a file that exists. */
+export declare function writeReasoningSandboxes(cwd: string, subagents: string[]): string[];
 export type GithubToolsMountRepair = {
     kind: "missing" | "current" | "updated" | "customized";
 } | {

package/dist/upgrade.js

@@ -1,4 +1,4 @@
-import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -15,7 +15,7 @@ import { inspectEveAgent } from "./agent-limits.js";
 import { remoteProjectPath, sshTarget } from "./deploy.js";
 import { classifyModelReach } from "./model-reach.js";
 import { checkSelfVersion, versionLt } from "./self-version.js";
-import { LEGACY_GITHUB_TOOLS_MOUNT, githubToolsMountTs, notifyMountTs } from "./templates.js";
+import { LEGACY_GITHUB_TOOLS_MOUNT, githubToolsMountTs, notifyMountTs, reasoningSandboxLibTs, reasoningSandboxReexportTs } from "./templates.js";
 import { confirmEveUpgrade, inspectBuzzSessions, inspectDurableRuns, reconcileEvalScript, } from "./upgrade-sessions.js";
 export function agentInputLimitUpgradeMessage(limit) {
     switch (limit.kind) {
@@ -210,6 +210,109 @@ function repairNotifySetup(cwd, deps) {
         console.log(`    ${dim("Takes effect after the next build and restart.")}\n`);
     }
 }
+/**
+ * A reasoning-only specialist that still boots a Docker container.
+ *
+ * Every eve agent has exactly one sandbox, and a declared subagent that
+ * authors none gets the framework default — on a self-hosted host, a Docker
+ * container from an 840MB image. A specialist whose `bash`, `read_file`, and
+ * `write_file` tools are all disabled reasons and remembers and never touches
+ * a filesystem, yet each still booted its own container per call. On a small
+ * host those boots contend and blow eve's ~120s command-hook wait, which reads
+ * as "the specialist is unavailable" and, under a scheduled fan-out, thrashes
+ * the host. Disabling the file tools never stopped the sandbox: it is a slot
+ * eve always fills, not a consequence of the tools.
+ *
+ * The signal is deliberately narrow and static: a subagent that disables all
+ * three file tools has declared it does no filesystem work, so `just-bash` —
+ * eve's containerless virtual filesystem — is safe and correct for it. A
+ * subagent that leaves those tools enabled is left alone; whether it needs a
+ * real sandbox is a judgment only a person can make.
+ */
+function disablesAllFileTools(dir) {
+    const tools = join(dir, "tools");
+    if (!existsSync(tools))
+        return false;
+    return ["bash", "read_file", "write_file"].every((name) => {
+        const file = join(tools, `${name}.ts`);
+        if (!existsSync(file))
+            return false;
+        try {
+            return /disableTool\s*\(/.test(readFileSync(file, "utf8"));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function hasAuthoredSandbox(dir) {
+    return existsSync(join(dir, "sandbox.ts")) || existsSync(join(dir, "sandbox"));
+}
+/** Reasoning-only subagents (disable all file tools) that have no sandbox of their own. */
+export function reasoningSubagentsNeedingSandbox(cwd) {
+    const root = join(cwd, "agent/subagents");
+    if (!existsSync(root))
+        return [];
+    const found = [];
+    for (const entry of readdirSync(root)) {
+        const dir = join(root, entry);
+        try {
+            if (!statSync(dir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        if (!existsSync(join(dir, "agent.ts")))
+            continue;
+        if (hasAuthoredSandbox(dir))
+            continue;
+        if (disablesAllFileTools(dir))
+            found.push(entry);
+    }
+    return found.sort();
+}
+/** Write the shared lib source and each specialist's re-export. Never touches a file that exists. */
+export function writeReasoningSandboxes(cwd, subagents) {
+    const wrote = [];
+    const lib = join(cwd, "agent/lib/reasoning-sandbox.ts");
+    if (!existsSync(lib)) {
+        mkdirSync(join(cwd, "agent/lib"), { recursive: true });
+        writeFileSync(lib, reasoningSandboxLibTs());
+        wrote.push("agent/lib/reasoning-sandbox.ts");
+    }
+    for (const name of subagents) {
+        const file = join(cwd, "agent/subagents", name, "sandbox.ts");
+        if (existsSync(file))
+            continue;
+        writeFileSync(file, reasoningSandboxReexportTs());
+        wrote.push(`agent/subagents/${name}/sandbox.ts`);
+    }
+    return wrote;
+}
+function repairReasoningSandboxes(cwd, deps) {
+    const needing = reasoningSubagentsNeedingSandbox(cwd);
+    if (needing.length === 0)
+        return;
+    const done = [];
+    if (!deps["just-bash"]) {
+        const ok = run("npm", ["install", "just-bash@^3.1.0", "--no-audit", "--no-fund"], { cwd, allowFail: true, quiet: true });
+        if (!ok) {
+            console.log(`  ${yellow("!")} ${needing.length} reasoning specialist(s) still boot a Docker container per call, but just-bash could not be installed.\n` +
+                `    Run: npm install just-bash@^3.1.0 && npx kyb upgrade`);
+            return;
+        }
+        deps["just-bash"] = "^3.1.0";
+        done.push("installed just-bash");
+    }
+    const wrote = writeReasoningSandboxes(cwd, needing);
+    if (wrote.length > 0)
+        done.push(`gave ${needing.join(", ")} an instant sandbox (${wrote.length} file${wrote.length === 1 ? "" : "s"})`);
+    if (done.length > 0) {
+        console.log(`  ${green("+")} Sandboxes: ${done.join("; ")} ${dim("— reasoning specialists no longer boot a Docker container")}`);
+        console.log(`    ${dim("Takes effect after the next build and restart.")}\n`);
+    }
+}
 /** Quote one argument for the manual shell commands printed after a failed repair. */
 function shellQuote(value) {
     return `'${value.replaceAll("'", `'"'"'`)}'`;
@@ -721,15 +824,6 @@ function startStoppedBridge(cwd, unit) {
 }
 export async function upgrade(options = {}) {
     console.log(bold("\nkyb upgrade — checking @kybernesis/* and eve against npm\n"));
-    const selfVersion = checkSelfVersion();
-    if (selfVersion.kind === "stale") {
-        console.log(`  ${yellow("!")} ${selfVersion.message}`);
-        console.log(`    ${dim(selfVersion.fix)}\n`);
-        if (!options.allowStale) {
-            process.exitCode = 1;
-            return;
-        }
-    }
     const cwd = process.cwd();
     const packagePath = join(cwd, "package.json");
     const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
@@ -737,6 +831,39 @@ export async function upgrade(options = {}) {
         ...(pkg.dependencies ?? {}),
         ...(pkg.devDependencies ?? {}),
     };
+    const selfVersion = checkSelfVersion();
+    if (selfVersion.kind === "stale" && !options.allowStale) {
+        /**
+         * A stale kyb that is the PROJECT's own dependency renews itself.
+         *
+         * On every self-hosted agent, kyb is in package.json and `npx kyb` runs
+         * that copy; a global install — the printed fix until now — changes
+         * nothing there, and the person who followed it was back at the same
+         * message. So when the project owns kyb, install the latest into the
+         * project and run the upgrade again from that copy. The re-run is marked
+         * so that a registry that has not caught up cannot make this loop.
+         */
+        if (deps["@kybernesis/create"] && process.env.KYB_UPGRADE_RENEWED !== "1") {
+            console.log(`  ${yellow("↑")} kyb ${selfVersion.installed} → ${selfVersion.latest} ${dim("(this project's own copy; renewing it first)")}`);
+            const renewed = run("npm", ["install", `@kybernesis/create@${selfVersion.latest}`, "--no-audit", "--no-fund"], { cwd, allowFail: true, quiet: true });
+            const cli = join(cwd, "node_modules/@kybernesis/create/dist/cli.js");
+            if (renewed && existsSync(cli)) {
+                const again = spawnSync(process.execPath, [cli, "upgrade", ...process.argv.slice(3)], {
+                    cwd, stdio: "inherit", env: { ...process.env, KYB_UPGRADE_RENEWED: "1" },
+                });
+                process.exitCode = again.status ?? 1;
+                return;
+            }
+        }
+        console.log(`  ${yellow("!")} ${selfVersion.message}`);
+        console.log(`    ${dim(deps["@kybernesis/create"] ? `npm install @kybernesis/create@latest && npx kyb upgrade` : selfVersion.fix)}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (selfVersion.kind === "stale") {
+        console.log(`  ${yellow("!")} ${selfVersion.message}`);
+        console.log(`    ${dim(selfVersion.fix)} ${dim("(continuing: --allow-stale)")}\n`);
+    }
     reportAgentInputLimit(cwd);
     const entries = dependencyEntries(pkg);
     const installedVersions = new Map();
@@ -822,6 +949,7 @@ export async function upgrade(options = {}) {
         repairHostArtifacts(cwd, deps);
         repairEvalCommand(cwd);
         repairNotifySetup(cwd, deps);
+        repairReasoningSandboxes(cwd, deps);
         repairManageRestart(cwd, deps);
         return;
     }
@@ -894,6 +1022,7 @@ export async function upgrade(options = {}) {
     repairHostArtifacts(cwd, deps);
     repairEvalCommand(cwd);
     repairNotifySetup(cwd, deps);
+    repairReasoningSandboxes(cwd, deps);
     repairManageRestart(cwd, deps);
     run("npm", ["run", "typecheck"], { cwd });
     if (eveChanged) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kybernesis/create",
-  "version": "0.15.0",
-  "description": "The Kybernesis agent scaffolder and FDE toolkit: one command to a governed, remembering, multiplayer, self-testing eve agent \u2014 plus doctor and upgrade.",
+  "version": "0.15.2",
+  "description": "The Kybernesis agent scaffolder and FDE toolkit: one command to a governed, remembering, multiplayer, self-testing eve agent — plus doctor and upgrade.",
   "license": "Apache-2.0",
   "type": "module",
   "homepage": "https://kybernesis.ai",