@kybernesis/create 0.16.0 → 0.17.1

package/README.md

@@ -97,7 +97,7 @@ Before an eve version change, upgrade reads `.eve/.workflow-data/runs`, prints
 sessions when available, and requires explicit confirmation. Noninteractive
 runs fail closed unless `--yes` (or `-y`) is supplied. The warning is still printed with
 `--yes` and is not bypassed by `--skip-eval`. Existing direct `eve eval` scripts
-are migrated to `kyb-eval`; custom scripts are left untouched with a manual fix.
+are migrated to `kyb-eval` (shipped as a binary of this package from 0.17); custom scripts are left untouched with a manual fix.
 The wrapper counts corruption diagnostics beside the eval result and turns a
 nominally green eve exit into a failure when condemned durable state was seen.
 It also identifies failures from `judge.autoevals.*` assertions as judge

package/dist/agent-limits.js

@@ -10,7 +10,10 @@ export const CERTIFIED_INHERITED_MAX_INPUT_TOKENS_PER_SESSION = 40_000_000;
 export function parseEveInfoInspection(output, readText = (path) => readFileSync(path, "utf8")) {
     let info;
     try {
-        info = JSON.parse(output);
+        // eve ≥0.62 prints its terminal header ("☰eve  v0.68.0 …") ahead of the
+        // JSON even with --json, so parse from the first object literal.
+        const start = output.indexOf("{");
+        info = JSON.parse(start > 0 ? output.slice(start) : output);
     }
     catch (error) {
         return unresolved(`eve info --json was not valid JSON: ${error.message}`);

package/dist/cli.js

@@ -64,6 +64,7 @@ function initOptions(rest) {
     const subs = flag(rest, 'subagents');
     return {
         engineer: rest.includes('--engineer'),
+        computer: rest.includes('--computer'),
         studio: rest.includes('--studio'),
         channel: flag(rest, "channel"),
         host: flag(rest, "host"),
@@ -104,6 +105,7 @@ function usage(command) {
       --model-reach=<reach> ${dim("claude-sub (exe only; default: host route)")}
       --subagents=a,b       ${dim("department subagents")}
       --engineer            ${dim("add the engineer layer")}
+      --computer            ${dim("the agent's own desktop + Chrome (exe only)")}
       --studio              ${dim("wire KYBER Studio local/manage routes")}
       --yes, -y             ${dim("no prompts")}
 
@@ -228,6 +230,7 @@ ${dim("  npm i -g @kybernesis/create@latest")}
       --model=<id>      ${dim("provider/model-id; bare claude-opus-5 for claude-sub")}
       --model-reach=<r> ${dim("claude-sub (exe only); env: KYB_MODEL_REACH")}
       --engineer        ${dim("add the engineer layer: workshop sandbox + vision dev loop")}
+      --computer        ${dim("the agent's own computer: persistent desktop + Chrome you can watch (exe only)")}
       --studio          ${dim("wire for KYBER Studio: local execution + management routes")}
       --yes             ${dim("no prompts; take flags and defaults")}
   ${bold("kyb add channel <kind>")}

package/dist/doctor.d.ts

@@ -32,4 +32,21 @@ export declare function diskUsageDoctorCheck(percent: number, dockerSummary: str
  */
 export declare function inspectDockerTemplatesViaExe(cwd: string): Promise<DockerTemplateInspection | null>;
 export declare function doctor(): Promise<void>;
+export interface ComputerInspection {
+    /** agent/sandbox.ts imports @kybernesis/computer. */
+    configured: boolean;
+    /** COMPUTER_NAME from .env.local, or the default the sandbox file falls back to. */
+    name: string;
+    containerState: "running" | "stopped" | "missing" | "unknown";
+    /** The noVNC port is bound on loopback. */
+    screenBound: boolean | null;
+    vncPasswordSet: boolean;
+}
+/**
+ * A computer that is configured but not running is the quiet failure here:
+ * every session would try to start it and the first turn pays the whole boot,
+ * or fails if Docker is off. Missing before the first build is normal.
+ */
+export declare function computerDoctorChecks(c: ComputerInspection): Check[];
+export declare function inspectComputer(cwd: string): ComputerInspection | null;
 export {};

package/dist/doctor.js

@@ -313,7 +313,7 @@ export async function doctor() {
         const vercelConn = join(cwd, "agent/connections/vercel.ts");
         const selfHostedAgent = Boolean(deps["@kybernesis/exe"]) ||
             (existsSync(join(cwd, "agent/subagents/builder/sandbox/sandbox.ts")) &&
-                readFileSync(join(cwd, "agent/subagents/builder/sandbox/sandbox.ts"), "utf8").includes("docker("));
+                /docker\(|DockerSandbox/.test(readFileSync(join(cwd, "agent/subagents/builder/sandbox/sandbox.ts"), "utf8")));
         if (selfHostedAgent && !existsSync(vercelConn)) {
             add("pass", "no Vercel MCP connection (self-hosted)", "public deploys need the CLIENT's own Vercel token — Vercel Connect does not work off-Vercel");
         }
@@ -399,7 +399,7 @@ export async function doctor() {
     // deployment. None of them are theoretical.
     const selfHosted = Boolean(deps["@kybernesis/exe"]) ||
         existsSync(join(cwd, "agent/sandbox/sandbox.ts")) &&
-            readFileSync(join(cwd, "agent/sandbox/sandbox.ts"), "utf8").includes("docker(");
+            /docker\(|DockerSandbox/.test(readFileSync(join(cwd, "agent/sandbox/sandbox.ts"), "utf8"));
     const templateInspection = await inspectDockerTemplatesViaExe(cwd);
     for (const check of templateInspection ? dockerTemplateDoctorChecks(templateInspection) : []) {
         add(check.verdict, check.label, check.detail);
@@ -508,6 +508,10 @@ export async function doctor() {
             ]);
             const diskCheck = diskUsageDoctorCheck(percent, dockerSummary);
             add(diskCheck.verdict, diskCheck.label, diskCheck.detail);
+            const computer = inspectComputer(cwd);
+            if (computer)
+                for (const check of computerDoctorChecks(computer))
+                    checks.push(check);
         }
         /**
          * Instructions that name a tool the agent does not have.
@@ -679,3 +683,69 @@ export async function doctor() {
     console.log(`\n  ${fails ? red(`${fails} failing`) : green("0 failing")}, ${warns ? yellow(`${warns} warnings`) : "0 warnings"}\n`);
     process.exit(fails ? 1 : 0);
 }
+/**
+ * A computer that is configured but not running is the quiet failure here:
+ * every session would try to start it and the first turn pays the whole boot,
+ * or fails if Docker is off. Missing before the first build is normal.
+ */
+export function computerDoctorChecks(c) {
+    if (!c.configured)
+        return [];
+    const checks = [];
+    switch (c.containerState) {
+        case "running":
+            checks.push({ verdict: "pass", label: `the agent's computer "${c.name}" is running` });
+            break;
+        case "stopped":
+            checks.push({
+                verdict: "warn",
+                label: `the agent's computer "${c.name}" exists but is stopped`,
+                detail: "the next session restarts it and pays the boot; `docker start " + c.name + "` brings it back now",
+            });
+            break;
+        case "missing":
+            checks.push({
+                verdict: "warn",
+                label: `the agent's computer "${c.name}" has not been built yet`,
+                detail: "`eve build` creates and prepares it (eve's desktop stack + Chrome, ~5 minutes)",
+            });
+            break;
+        default:
+            checks.push({ verdict: "warn", label: "could not inspect the agent's computer", detail: "is Docker running on this host?" });
+    }
+    if (c.containerState === "running" && c.screenBound === false) {
+        checks.push({
+            verdict: "fail",
+            label: "the computer is running but its screen is not published on :6080",
+            detail: "the container was created without the noVNC port mapping; `docker rm -f " + c.name + "` and `eve build` to recreate it (volumes keep the home and /workspace)",
+        });
+    }
+    if (!c.vncPasswordSet) {
+        checks.push({
+            verdict: "warn",
+            label: "the computer's screen has no VNC password",
+            detail: "exe's port-proxy sign-in is the only gate; set COMPUTER_VNC_PASSWORD in .env.local and `docker rm -f " + c.name + "` + `eve build` to apply",
+        });
+    }
+    return checks;
+}
+export function inspectComputer(cwd) {
+    const sandboxPath = join(cwd, "agent/sandbox.ts");
+    if (!existsSync(sandboxPath) || !readFileSync(sandboxPath, "utf8").includes("@kybernesis/computer"))
+        return null;
+    const envPath = join(cwd, ".env.local");
+    const env = existsSync(envPath) ? parseEnv(readFileSync(envPath, "utf8")) : {};
+    const sandboxSource = readFileSync(sandboxPath, "utf8");
+    const fallback = /COMPUTER_NAME \?\? "([^"]+)"/.exec(sandboxSource)?.[1] ?? "agent-computer";
+    const name = env.COMPUTER_NAME?.trim() || fallback;
+    const state = capture("docker", ["inspect", "-f", "{{.State.Running}}", name]);
+    const containerState = state === null ? "unknown" : state.trim() === "true" ? "running" : state.trim() === "false" ? "stopped" : "missing";
+    const ports = containerState === "running" ? capture("docker", ["port", name, "6080"]) : null;
+    return {
+        configured: true,
+        name,
+        containerState,
+        screenBound: containerState === "running" ? Boolean(ports && ports.trim().length > 0) : null,
+        vncPasswordSet: Boolean(env.COMPUTER_VNC_PASSWORD?.trim()),
+    };
+}

package/dist/eval-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/eval-cli.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * `kyb-eval`: `eve eval` with the two checks eve's own exit code does not make.
+ *
+ * `kyb upgrade` migrates every agent's `scripts.eval` to this command and runs
+ * it as the deploy gate, and the README has described it since 0.14 — but no
+ * binary ever shipped, so a migrated agent's `npm run eval` failed with
+ * "command not found" and the gate reported red for the wrong reason.
+ *
+ * What it adds on top of `eve eval <args>`:
+ * - a nominally green run that logged condemned durable state
+ *   (`CORRUPTED_EVENT_LOG`, `REPLAY_DIVERGENCE`) exits 1 — those runs are
+ *   terminal and a suite that passed beside them proves less than it says;
+ * - a run whose failures are all judge errors (evaluation model unreachable,
+ *   HTTP failures from the judge provider) says so, rather than reading as the
+ *   agent under test failing.
+ */
+import { spawn } from "node:child_process";
+const CONDEMNED = /CORRUPTED_EVENT_LOG|REPLAY_DIVERGENCE/;
+const JUDGE_FAILURE = /judge[^\n]*(unreachable|ECONNREFUSED|fetch failed|HTTP \d{3}|Unauthenticated|no credentials|not valid)/i;
+function main() {
+    const args = process.argv.slice(2);
+    const child = spawn("npx", ["eve", "eval", ...args], { stdio: ["inherit", "pipe", "pipe"], env: process.env });
+    let condemned = 0;
+    let judgeFailures = 0;
+    const scan = (chunk, out) => {
+        const text = chunk.toString();
+        out.write(text);
+        for (const line of text.split("\n")) {
+            if (CONDEMNED.test(line))
+                condemned += 1;
+            if (JUDGE_FAILURE.test(line))
+                judgeFailures += 1;
+        }
+    };
+    child.stdout.on("data", (chunk) => scan(chunk, process.stdout));
+    child.stderr.on("data", (chunk) => scan(chunk, process.stderr));
+    child.on("error", (error) => {
+        console.error(`kyb-eval: could not start eve eval: ${error.message}`);
+        process.exit(2);
+    });
+    child.on("close", (code) => {
+        if (condemned > 0) {
+            console.error(`\nkyb-eval: ${condemned} condemned durable-state diagnostic(s) seen (CORRUPTED_EVENT_LOG / REPLAY_DIVERGENCE). ` +
+                "Those conversations are terminal; treating this run as red.");
+            process.exit(1);
+        }
+        if (code !== 0 && judgeFailures > 0) {
+            console.error(`\nkyb-eval: ${judgeFailures} judge failure(s) seen — the evaluation model was unreachable or refused, ` +
+                "which is a judge-reachability problem, not evidence that the agent under test failed. Fix the judge, then rerun.");
+        }
+        process.exit(code ?? 1);
+    });
+}
+main();

package/dist/init.d.ts

@@ -6,6 +6,8 @@ import { type ChannelKind, type HostKind } from "./templates.js";
 export declare function finalizeGithubToolsRegistryMount(cwd: string, registryAddSucceeded: boolean): boolean;
 export interface InitOptions {
     engineer?: boolean;
+    /** The agent's own computer: a persistent Docker desktop with Chrome (exe hosts only). */
+    computer?: boolean;
     /**
      * Wire this agent for KYBER Studio: local execution on the user's own machine,
      * and management routes so Studio can install capabilities and write routines.

package/dist/init.js

@@ -1,7 +1,7 @@
-import { chmodSync, copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, chmodSync, copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { DEFAULT_ISSUER, EVE_VERSION, REGISTRY_URL, ask, bold, closePrompts, dim, green, run, slug, red, yellow, } from "./util.js";
-import { CHANNEL_KINDS, channelPlan, engineerPlan, envExample, evalFileTs, exeEvalConfigTs, evalScript, hostAgentTs, hostSteps, githubToolsMountTs, identityMd, rootArcanaTs, subagentAgentTs, subagentArcanaTs, subagentInstructionsMd, } from "./templates.js";
+import { CHANNEL_KINDS, channelPlan, computerPlan, engineerPlan, envExample, evalFileTs, exeEvalConfigTs, evalScript, hostAgentTs, hostSteps, githubToolsMountTs, identityMd, rootArcanaTs, subagentAgentTs, subagentArcanaTs, subagentInstructionsMd, } from "./templates.js";
 import { suiteDir } from "./skills.js";
 import { configureArcana } from "./arcana.js";
 import { upsertEnv } from "./envfile.js";
@@ -36,6 +36,7 @@ export function finalizeGithubToolsRegistryMount(cwd, registryAddSucceeded) {
 }
 export async function init(rawName, options = {}) {
     const engineer = options.engineer === true;
+    const computer = options.computer === true;
     const studio = options.studio === true;
     const nonInteractive = options.yes === true;
     const name = slug(rawName ?? (await ask("Agent name (kebab-case)?", "acme-agent")));
@@ -187,6 +188,14 @@ export async function init(rawName, options = {}) {
                 console.log(yellow(`  ! ${item} did not install cleanly — re-run: npx eve add ${item}`));
         }
     }
+    const compPlan = computer && host === "exe" ? computerPlan(name) : null;
+    if (computer && host !== "exe") {
+        console.log(yellow("\n  ! --computer needs a Docker host (exe.dev); a Vercel function cannot keep a desktop alive. Skipped."));
+    }
+    if (compPlan) {
+        console.log(bold("\n2e   The agent's computer: persistent desktop + Chrome, sighted computer tool, browser guard …"));
+        run("npm", ["install", ...compPlan.deps, "--no-audit", "--no-fund"], { cwd: dir, allowFail: true });
+    }
     console.log(bold("\n2d   Seeding the FDE Claude Code skill suite (.claude/skills) …"));
     try {
         cpSync(suiteDir(), join(dir, ".claude/skills"), { recursive: true });
@@ -373,8 +382,17 @@ export async function init(rawName, options = {}) {
             writeFileSync(full, file.content);
         }
     }
+    if (compPlan) {
+        for (const file of compPlan.files) {
+            const full = join(dir, file.path);
+            mkdirSync(join(full, ".."), { recursive: true });
+            writeFileSync(full, file.content);
+        }
+    }
     console.log(bold("\n5/6  Env template + hermetic eval script …"));
     writeFileSync(join(dir, ".env.example"), envExample(name, depts, issuer, plan.env, host, model));
+    if (compPlan)
+        appendFileSync(join(dir, ".env.example"), compPlan.env);
     const pkgPath = join(dir, "package.json");
     const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
     pkg.scripts = { ...pkg.scripts, eval: evalScript(name, depts) };
@@ -394,6 +412,7 @@ export async function init(rawName, options = {}) {
         model.reach === "claude-sub" ? "Claude subscription reach" : null,
         studio ? "KYBER Studio (local execution + management routes)" : null,
         engineer ? "engineer subagent (workshop + vision loop)" : null,
+        compPlan ? "its own computer (desktop + Chrome, watch and take over)" : null,
         depts.length ? `${depts.length} dept subagent(s)` : null,
     ].filter(Boolean);
     const steps = [
@@ -401,6 +420,7 @@ export async function init(rawName, options = {}) {
         ...hostSteps(host, name, model),
         ...plan.steps,
         ...(engPlan?.steps ?? []),
+        ...(compPlan?.steps ?? []),
         `Control plane: register agent "${name}" at ${issuer}/agents + grant the pilot cohort`,
         `npm run eval → green → deploy → live smoke + the revoke demo`,
     ];

package/dist/removed-default-tools.d.ts

@@ -27,3 +27,15 @@ export interface RemovedDefaultToolsRepair {
     optedIn: string[];
 }
 export declare function repairRemovedDefaultTools(cwd: string): RemovedDefaultToolsRepair;
+/**
+ * eve 0.65 took `ask_question` out of the default tool set and made it an
+ * opt-in workflow tool (`eve add tool/ask_question`). An agent certified on an
+ * earlier line had it everywhere, and the notify hooks, the Buzz approval
+ * bridge and the Studio question cards all key on that tool name — so every
+ * scope that could ask keeps the tool, and a stale `disableTool()` file (a
+ * build error from 0.65) is removed.
+ */
+export declare const OPT_IN_TOOLS_SINCE: {
+    readonly ask_question: "0.65.0";
+};
+export declare function repairOptInTools(cwd: string, eveVersion: string): RemovedDefaultToolsRepair;

package/dist/removed-default-tools.js

@@ -84,3 +84,52 @@ export function repairRemovedDefaultTools(cwd) {
     }
     return { removed, optedIn };
 }
+/**
+ * eve 0.65 took `ask_question` out of the default tool set and made it an
+ * opt-in workflow tool (`eve add tool/ask_question`). An agent certified on an
+ * earlier line had it everywhere, and the notify hooks, the Buzz approval
+ * bridge and the Studio question cards all key on that tool name — so every
+ * scope that could ask keeps the tool, and a stale `disableTool()` file (a
+ * build error from 0.65) is removed.
+ */
+export const OPT_IN_TOOLS_SINCE = { ask_question: "0.65.0" };
+function askQuestionSource() {
+    return [
+        "// eve 0.65 made ask_question an opt-in tool. This agent asked people questions",
+        "// on the certified earlier line, so it keeps the tool (kyb upgrade wrote this).",
+        'import { askQuestion } from "eve/tools/ask_question";',
+        "",
+        "export default askQuestion();",
+        "",
+    ].join("\n");
+}
+export function repairOptInTools(cwd, eveVersion) {
+    const removed = [];
+    const optedIn = [];
+    if (versionAtLeast(eveVersion, OPT_IN_TOOLS_SINCE.ask_question)) {
+        for (const scope of agentScopes(cwd)) {
+            const tools = join(scope, "tools");
+            const file = join(tools, "ask_question.ts");
+            if (existsSync(file)) {
+                if (isDisableToolFile(file)) {
+                    unlinkSync(file);
+                    removed.push(relative(cwd, file));
+                }
+                continue;
+            }
+            mkdirSync(tools, { recursive: true });
+            writeFileSync(file, askQuestionSource());
+            optedIn.push(relative(cwd, file));
+        }
+    }
+    return { removed, optedIn };
+}
+function versionAtLeast(version, floor) {
+    const parse = (v) => v.replace(/^[^\d]*/, "").split("-")[0].split(".").map((n) => Number(n) || 0);
+    const a = parse(version), b = parse(floor);
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] ?? 0) !== (b[i] ?? 0))
+            return (a[i] ?? 0) > (b[i] ?? 0);
+    }
+    return true;
+}

package/dist/templates.d.ts

@@ -96,3 +96,21 @@ export declare function notifyMountTs(): string;
 export declare function reasoningSandboxLibTs(): string;
 /** What each reasoning-only subagent's `sandbox.ts` re-exports. */
 export declare function reasoningSandboxReexportTs(): string;
+export interface ComputerPlan {
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+    deps: string[];
+    steps: string[];
+    /** Lines appended to .env.example. */
+    env: string;
+}
+/**
+ * A persistent Docker desktop with Chrome that the person can watch and take
+ * over, as the agent's ROOT sandbox, plus the sighted computer tool, the
+ * guarded open_browser, and the surface ladder in instructions. The engineer
+ * workshop (a subagent sandbox) is untouched. Needs Docker, so it is an exe
+ * host feature: a Vercel function has no daemon to keep a container alive.
+ */
+export declare function computerPlan(name: string): ComputerPlan;

package/dist/templates.js

@@ -456,28 +456,26 @@ export function hostSteps(host, name, model) {
 function workshopSandbox(host) {
     if (host === "exe") {
         return `import { defineSandbox } from "eve/sandbox";
-import { docker } from "eve/sandbox/docker";
+import { DockerSandbox } from "eve/sandbox/docker";
 
 /**
  * The engineer workshop, self-hosted: pnpm + Playwright + Chromium baked into
- * the TEMPLATE so warm sessions run render→screenshot→vision in seconds.
+ * the ENVIRONMENT (prepared once at build, inherited by every session) so warm
+ * sessions run render→screenshot→vision in seconds.
  *
- * Docker rather than vercel(): the hosted backend needs Vercel OIDC, which does
- * not exist off-Vercel.
+ * Docker rather than Vercel Sandbox: the hosted provider needs Vercel OIDC,
+ * which does not exist off-Vercel.
  *
  * HOST PREREQUISITE: some images ship Docker disabled (exe.dev's exeuntu runs
  * \`systemctl disable docker.service\`). Run \`sudo systemctl enable --now docker\`
  * or every build fails with SandboxTemplateNotProvisionedError.
  *
  * NOTE: Docker sessions do not enforce a domain allowlist the way the hosted
- * backend does. Egress control is the HOST's responsibility here — a deliberate
+ * provider does. Egress control is the HOST's responsibility here — a deliberate
  * difference from the Vercel deployment, not an oversight.
  */
-export default defineSandbox({
-  backend: docker(),
-  revalidationKey: () => "kybernesis-workshop-v5-docker",
-  async bootstrap({ use }) {
-    const sandbox = await use();
+export const environment = DockerSandbox.environment({
+  prepare: async (sandbox) => {
     // Base image is Debian-family; refresh indexes before installing browser deps.
     await sandbox.run({ command: "apt-get update" });
     await sandbox.run({ command: "npm install -g pnpm" });
@@ -492,28 +490,49 @@ export default defineSandbox({
     });
   },
 });
+
+export default defineSandbox(() => environment.open());
 `;
     }
     return `import { defineSandbox } from "eve/sandbox";
-import { vercel } from "eve/sandbox/vercel";
+import { VercelSandbox } from "eve/sandbox/vercel";
 
 /**
  * The engineer workshop: a warm, safe cloud dev machine.
  *
- * TEMPLATE bootstrap (once, inherited by every session): pnpm + Playwright +
- * Chromium. Prewarm runs at deploy time, so a broken bootstrap fails the build
- * loudly and warm sessions run the full render→screenshot→vision loop in
- * seconds. Backend PINNED to Vercel Sandbox — hosted sandboxes even from local
- * dev (run \`vercel link\` + \`vercel env pull\` first), so evals exercise the
- * exact production backend. No Docker anywhere.
+ * ENVIRONMENT preparation (once at build, inherited by every session): pnpm +
+ * Playwright + Chromium. Preparation runs at deploy time, so a broken recipe
+ * fails the build loudly and warm sessions run the full render→screenshot→
+ * vision loop in seconds. Provider PINNED to Vercel Sandbox — hosted sandboxes
+ * even from local dev (run \`vercel link\` + \`vercel env pull\` first), so evals
+ * exercise the exact production provider. No Docker anywhere.
  *
  * All sessions run under a domain ALLOWLIST: an agent that installs arbitrary
  * npm packages must not have open egress. A blocked domain fails loudly;
  * treat every addition as a security decision.
  */
-export default defineSandbox({
-  backend: vercel({
-    resources: { vcpus: 4 },
+export const environment = VercelSandbox.environment({
+  resources: { vcpus: 4 },
+  prepare: async (sandbox) => {
+    // The egress proxy carries HTTPS only; apt defaults to http:// mirrors, so
+    // every index fetch silently fails. Rewrite to https first.
+    await sandbox.run({
+      command:
+        "find /etc/apt -type f \\\\( -name '*.list' -o -name '*.sources' \\\\) -exec sed -i 's|http://|https://|g' {} + && apt-get update",
+    });
+    await sandbox.run({ command: "npm install -g pnpm" });
+    await sandbox.run({
+      command:
+        "mkdir -p /workspace/.shot && cd /workspace/.shot && echo '{\\"name\\":\\"kyb-shot\\",\\"private\\":true}' > package.json && npm install playwright",
+    });
+    await sandbox.run({
+      command: "cd /workspace/.shot && npx playwright install --with-deps chromium",
+    });
+  },
+});
+
+export default defineSandbox(() =>
+  environment.open({
     networkPolicy: {
       allow: [
         "registry.npmjs.org",
@@ -541,25 +560,7 @@ export default defineSandbox({
       ],
     },
   }),
-  revalidationKey: () => "kybernesis-workshop-v5",
-  async bootstrap({ use }) {
-    const sandbox = await use();
-    // The egress proxy carries HTTPS only; apt defaults to http:// mirrors, so
-    // every index fetch silently fails. Rewrite to https first.
-    await sandbox.run({
-      command:
-        "find /etc/apt -type f \\\\( -name '*.list' -o -name '*.sources' \\\\) -exec sed -i 's|http://|https://|g' {} + && apt-get update",
-    });
-    await sandbox.run({ command: "npm install -g pnpm" });
-    await sandbox.run({
-      command:
-        "mkdir -p /workspace/.shot && cd /workspace/.shot && echo '{\\"name\\":\\"kyb-shot\\",\\"private\\":true}' > package.json && npm install playwright",
-    });
-    await sandbox.run({
-      command: "cd /workspace/.shot && npx playwright install --with-deps chromium",
-    });
-  },
-});
+);
 `;
 }
 export function engineerPlan(host, model) {
@@ -671,7 +672,8 @@ export default defineEvalConfig({
   // Verified against the exe integration rather than assumed: it validates model
   // names and refuses one it does not carry, so a stale default here fails the
   // whole suite at the judge rather than at anything the agent did.
-  judge: { model: exe(process.env.EXE_JUDGE_MODEL ?? "claude-sonnet-5") },
+  // eve ≥0.62 grades with an EVALUATION model, not a language model instance.
+  judge: { model: exe.evaluationModel(process.env.EXE_JUDGE_MODEL ?? "claude-sonnet-5") },
   // Real model and real memory on every turn: generous timeout, gentle concurrency.
   timeoutMs: 300_000,
   maxConcurrency: 1,
@@ -748,19 +750,120 @@ export { default } from "@kybernesis/notify/extension";
  */
 export function reasoningSandboxLibTs() {
     return `import { defineSandbox } from "eve/sandbox";
-import { justbash } from "eve/sandbox/just-bash";
+import { JustBashSandbox } 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()
+// this. Only subagents that do real build/git/network work keep a Docker
 // sandbox of their own.
-export default defineSandbox({ backend: justbash() });
+export const environment = JustBashSandbox.environment();
+
+export default defineSandbox(() => environment.open());
 `;
 }
 /** 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";
+export { default, environment } from "../../lib/reasoning-sandbox";
 `;
 }
+/**
+ * A persistent Docker desktop with Chrome that the person can watch and take
+ * over, as the agent's ROOT sandbox, plus the sighted computer tool, the
+ * guarded open_browser, and the surface ladder in instructions. The engineer
+ * workshop (a subagent sandbox) is untouched. Needs Docker, so it is an exe
+ * host feature: a Vercel function has no daemon to keep a container alive.
+ */
+export function computerPlan(name) {
+    const files = [
+        {
+            path: "agent/sandbox.ts",
+            content: `import { defineSandbox } from "eve/sandbox";
+import { DockerComputer, prepareComputer, startComputer } from "@kybernesis/computer";
+
+// The agent's own computer: ONE persistent container (home and /workspace are
+// volumes, so Chrome's logins survive sessions) with its screen shared over
+// VNC/noVNC on this host's loopback :6080 — reachable only through exe.dev's
+// signed-in port proxy or an SSH tunnel. A person watching can take over.
+// This is the ROOT sandbox; the builder subagent keeps its own workshop.
+export const environment = DockerComputer.environment({
+  name: process.env.COMPUTER_NAME ?? "${name}-computer",
+  vncPassword: process.env.COMPUTER_VNC_PASSWORD,
+  prepare: prepareComputer, // eve's desktop stack + Chrome + the launcher bar, once at \`eve build\`
+});
+
+export default defineSandbox(async () => {
+  const sandbox = await environment.open();
+  await startComputer(sandbox);
+  return sandbox;
+});
+`,
+        },
+        {
+            path: "agent/tools/computer.ts",
+            content: `import { computerTool } from "@kybernesis/computer";
+
+// eve's computer_use with eyes: every action returns the screenshot as an
+// image the model can see, not just a path.
+export default computerTool();
+`,
+        },
+        {
+            path: "agent/tools/open_browser.ts",
+            content: `import { openBrowserTool } from "@kybernesis/computer";
+
+// Open a site in the computer's Chrome. Guarded: a site that has a connector
+// parks for the person's approval unless the call states a legitimate
+// override — connector first, browser only when there isn't one.
+export default openBrowserTool();
+`,
+        },
+        {
+            path: "agent/tools/close_tabs.ts",
+            content: `import { closeTabsTool } from "@kybernesis/computer";
+
+// The computer shares memory with the agent host; stale tabs are the spender.
+export default closeTabsTool();
+`,
+        },
+        {
+            path: "agent/instructions/computer.ts",
+            content: `import { defineInstructions } from "eve/instructions";
+import { COMPUTER_INSTRUCTIONS } from "@kybernesis/computer";
+
+// The "which surface" rule: connected app, then a tool, then the agent's
+// browser, then the person's machine. One source for every agent.
+export default defineInstructions({ content: COMPUTER_INSTRUCTIONS });
+`,
+        },
+        {
+            path: "evals/computer.eval.ts",
+            content: `import { computerSuite } from "@kybernesis/evals";
+
+// Screen reading, file and cookie persistence across sessions, and the guard:
+// a Gmail question is not answered by browsing mail.google.com. Add
+// \`connected\` / \`disconnected\` once this agent has connectors to prove the
+// order on — see the computerSuite docs.
+export default computerSuite();
+`,
+        },
+    ];
+    return {
+        files,
+        deps: ["@kybernesis/computer"],
+        steps: [
+            "Enable Docker on the host (some images ship it disabled): sudo systemctl enable --now docker",
+            "Set COMPUTER_VNC_PASSWORD in .env.local (the second gate on the shared screen; exe's port-proxy sign-in is the first)",
+            "Watch the screen: https://<vm>.exe.xyz:6080/vnc.html (account-gated), or ssh -N -L 6080:localhost:6080 <vm> and open http://localhost:6080/vnc.html",
+            "First `eve build` prepares the computer (eve's desktop stack + Chrome): allow ~5 minutes and ~2 GB of memory for the container",
+        ],
+        env: `
+# The agent's own computer (@kybernesis/computer): a persistent Docker desktop
+# with Chrome whose screen is shared on this host's loopback :6080 (noVNC),
+# behind exe.dev's port-proxy sign-in. The VNC password is the second gate.
+COMPUTER_NAME="${name}-computer"
+COMPUTER_VNC_PASSWORD="..."
+`,
+    };
+}

package/dist/upgrade.js

@@ -10,7 +10,7 @@ import { dockerPruneCronArtifact } from "./docker-prune-cron.js";
 import { newestOnLine } from "./on-line-version.js";
 import { findMatchingAgentServiceUnit, repairManageRestart } from "./systemd.js";
 import { repairTerminalSandboxCleanupHooks } from "./sandbox-cleanup.js";
-import { repairRemovedDefaultTools as repairRemovedDefaultTools_ } from "./removed-default-tools.js";
+import { repairOptInTools, repairRemovedDefaultTools as repairRemovedDefaultTools_ } from "./removed-default-tools.js";
 import { EVE_VERSION, bold, capture, dim, green, parseEnv, red, run, yellow } from "./util.js";
 import { inspectEveAgent } from "./agent-limits.js";
 import { remoteProjectPath, sshTarget } from "./deploy.js";
@@ -332,7 +332,14 @@ function repairRemovedDefaultTools(cwd) {
     for (const file of optedIn) {
         console.log(`  ${green("+")} wrote ${file} ${dim("(keeps the tool this scope had on eve 0.38)")}`);
     }
-    if (removed.length || optedIn.length)
+    const optIn = repairOptInTools(cwd, EVE_VERSION);
+    for (const file of optIn.removed) {
+        console.log(`  ${green("-")} removed ${file} ${dim("(disabled a tool eve no longer provides by default; a compile error from eve 0.65)")}`);
+    }
+    for (const file of optIn.optedIn) {
+        console.log(`  ${green("+")} wrote ${file} ${dim("(ask_question is opt-in from eve 0.65; this scope keeps it)")}`);
+    }
+    if (removed.length || optedIn.length || optIn.removed.length || optIn.optedIn.length)
         console.log();
 }
 function repairSandboxCleanupHooks(cwd, deps) {
@@ -578,7 +585,7 @@ function exeJudgeUrl(cwd, env) {
     if (!path)
         return null;
     const source = readFileSync(path, "utf8");
-    const judgeProvider = /judge\s*:\s*\{[\s\S]*?model\s*:\s*([A-Za-z_$][\w$]*)\s*\(/.exec(source)?.[1];
+    const judgeProvider = /judge\s*:\s*\{[\s\S]*?model\s*:\s*([A-Za-z_$][\w$]*)\s*(?:\.evaluationModel\s*)?\(/.exec(source)?.[1];
     if (!judgeProvider)
         return null;
     const escaped = judgeProvider.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/dist/util.d.ts

@@ -1,4 +1,4 @@
-export declare const EVE_VERSION = "0.51.1";
+export declare const EVE_VERSION = "0.68.0";
 export declare const REGISTRY_URL = "https://registry.kybernesis.ai/r/{name}.json";
 export declare const DEFAULT_ISSUER = "https://agent.kybernesis.ai";
 export declare const green: (s: string) => string;

package/dist/util.js

@@ -1,6 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { createInterface } from "node:readline/promises";
-export const EVE_VERSION = "0.51.1";
+export const EVE_VERSION = "0.68.0";
 export const REGISTRY_URL = "https://registry.kybernesis.ai/r/{name}.json";
 export const DEFAULT_ISSUER = "https://agent.kybernesis.ai";
 const TTY = process.stdout.isTTY === true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/create",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "description": "The Kybernesis agent scaffolder and FDE toolkit: one command to a governed, remembering, multiplayer, self-testing eve agent \u2014 plus doctor and upgrade.",
   "license": "Apache-2.0",
   "type": "module",
@@ -24,7 +24,8 @@
     "NOTICE"
   ],
   "bin": {
-    "kyb": "./dist/cli.js"
+    "kyb": "./dist/cli.js",
+    "kyb-eval": "./dist/eval-cli.js"
   },
   "exports": {
     "./package.json": "./package.json"
@@ -38,7 +39,7 @@
   },
   "devDependencies": {
     "@types/node": "24.x",
-    "eve": "^0.51.1",
+    "eve": "0.68.0",
     "typescript": "7.0.2"
   },
   "engines": {

package/skills/fde-engagement/references/playbook.md

@@ -1989,7 +1989,7 @@ export default defineAgent({
 });
 ```
 
-Four things to know before you promise it:
+Five things to know before you promise it:
 
 - **The exe LLM integration also serves `anthropic/*` ids, and that is NOT this.**
   It reaches Anthropic through a gateway, which bills metered usage. Same model,
@@ -2000,9 +2000,18 @@ Four things to know before you promise it:
   provider-defined tools, which Anthropic validates by name, and the failure
   (`tools.N.web_search_20250305.name: Input should be 'web_search'`) reads like
   a bug in the agent's own tool definitions.
-- **The sign-in is per host and interactive** — a browser step, once, in the
-  container. It survives restarts because it lives in a named volume, but a new
-  VM needs its own.
+- **The sign-in is per host and interactive** — a browser step in the container.
+  It survives restarts because it lives in a named volume, but a new VM needs
+  its own.
+- **And it is not a one-off: the sign-in expires about every 28 days.** The
+  access token refreshes hourly and does so happily the whole time, which tells
+  you nothing — the refresh token underneath carries a fixed expiry that using
+  it does not extend. On expiry the proxy blanks the credential to empty strings
+  and every turn 401s; only `login` recovers it, never `reload` or a restart.
+  **Say this to the client before you promise the arrangement, and put the
+  re-login in someone's calendar** — it is the operational debt you take on in
+  exchange for not billing metered usage. Run `scripts/claude-subscription.sh
+  status` on a schedule: it now reports days remaining and escalates at 7 and 3.
 - **It is a process to keep alive.** If the container stops, every turn fails
   with a connection error from inside the model SDK, which reads like the model
   being down. `hostPreflight({ claudeProxyUrl })` asks about it at boot; the