@kybernesis/create 0.24.2 → 0.25.0

package/dist/capabilities.d.ts

@@ -1,13 +1,11 @@
 import { type HostKind } from "./templates.js";
 import type { ModelScaffoldConfig } from "./model-reach.js";
 /**
- * The registry items install the newest release of each third-party
- * extension, and those are built on a later eve than the certified one, which
- * eve then refuses at discovery ("has no compile or runtime usage") and the
- * agent never boots. These are the releases proven on the certified eve.
- * Move them with the eve certification, never on their own.
+ * The third-party extensions at the releases proven on the certified eve (see
+ * THIRD_PARTY_PINS): the registry items install the newest release, which eve
+ * refuses at discovery when it is built on a later eve.
  */
-export declare const ENGINEER_EXTENSION_PINS: readonly ["@agent-browser/eve@0.34.0", "@github-tools/eve-extension@0.8.0"];
+export declare const ENGINEER_EXTENSION_PINS: string[];
 /**
  * Agent-to-agent: the eve channel becomes the governed dispatch door (people
  * still come in through kybernesisAuth in the same walk) and granted peers
@@ -17,7 +15,7 @@ export declare const ENGINEER_EXTENSION_PINS: readonly ["@agent-browser/eve@0.34
 export declare function applyDispatch(dir: string): string[];
 /**
  * The engineer: a declared `builder` subagent with its own workshop sandbox,
- * memory and skills, plus the browser and GitHub tools at the root.
+ * memory and skills, plus the GitHub tools at the root.
  */
 export declare function applyEngineer(dir: string, host: HostKind, model: ModelScaffoldConfig): {
     files: string[];

package/dist/capabilities.js

@@ -2,6 +2,7 @@ import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node
 import { join } from "node:path";
 import { finalizeGithubToolsRegistryMount, wireArpAuth } from "./init.js";
 import { DISPATCH_DEP, dispatchEveChannelTs, dispatchPeersTs, engineerPlan } from "./templates.js";
+import { THIRD_PARTY_PINS } from "./line-hop.js";
 import { run, yellow } from "./util.js";
 /**
  * The capabilities every company agent carries, applied the same way by
@@ -11,16 +12,14 @@ import { run, yellow } from "./util.js";
 // Official eve-registry limbs installed with the engineer subagent.
 // connection/vercel is Vercel-Connect-backed, so it is VERCEL-HOST ONLY: on a
 // self-hosted agent it cannot get an OIDC token and the agent fails to boot.
-const ENGINEER_ITEMS_ALL = ["extension/agent-browser", "extension/github-tools"];
+const ENGINEER_ITEMS_ALL = ["extension/github-tools"];
 const ENGINEER_ITEMS_VERCEL = ["connection/vercel"];
 /**
- * The registry items install the newest release of each third-party
- * extension, and those are built on a later eve than the certified one, which
- * eve then refuses at discovery ("has no compile or runtime usage") and the
- * agent never boots. These are the releases proven on the certified eve.
- * Move them with the eve certification, never on their own.
+ * The third-party extensions at the releases proven on the certified eve (see
+ * THIRD_PARTY_PINS): the registry items install the newest release, which eve
+ * refuses at discovery when it is built on a later eve.
  */
-export const ENGINEER_EXTENSION_PINS = ["@agent-browser/eve@0.34.0", "@github-tools/eve-extension@0.8.0"];
+export const ENGINEER_EXTENSION_PINS = Object.entries(THIRD_PARTY_PINS).map(([name, version]) => `${name}@${version}`);
 function write(dir, path, content) {
     const full = join(dir, path);
     mkdirSync(join(full, ".."), { recursive: true });
@@ -43,7 +42,7 @@ export function applyDispatch(dir) {
 }
 /**
  * The engineer: a declared `builder` subagent with its own workshop sandbox,
- * memory and skills, plus the browser and GitHub tools at the root.
+ * memory and skills, plus the GitHub tools at the root.
  */
 export function applyEngineer(dir, host, model) {
     const plan = engineerPlan(host, model);
@@ -56,7 +55,7 @@ export function applyEngineer(dir, host, model) {
         if (!ok)
             console.log(yellow(`  ! ${item} did not install cleanly — re-run: npx eve add ${item}`));
     }
-    // --legacy-peer-deps: both declare peer ranges that trail the certified eve.
+    // --legacy-peer-deps: it declares a peer range that trails the certified eve.
     const pinned = run("npm", ["install", "--save-exact", "--legacy-peer-deps", ...ENGINEER_EXTENSION_PINS, "--no-audit", "--no-fund"], {
         cwd: dir,
         allowFail: true,

package/dist/doctor.d.ts

@@ -8,6 +8,11 @@ export interface Check {
 }
 /** Report the opt-in GitHub capability only when its mount is present. */
 export declare function githubToolsDoctorCheck(mountExists: boolean, env: Record<string, string | undefined>): Check | null;
+/**
+ * What the agent still carries from an older eve line: everything `kyb
+ * upgrade` would move (reported, not done), and what it leaves to a person.
+ */
+export declare function lineHopDoctorChecks(cwd: string): Check[];
 /** The shape @kybernesis/exe's inspector returns; declared here so create keeps zero runtime deps. */
 export interface DockerTemplateInspection {
     status: "skipped" | "present" | "failed";

package/dist/doctor.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { TEMPLATE_CONTAINER_PROBE, parseTemplateContainers, templateContainerDoctorChecks } from "./sandbox-orphans.js";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { bold, capture, dim, green, parseEnv, red, yellow } from "./util.js";
+import { EVE_VERSION, REGISTRY_URL, bold, capture, dim, green, parseEnv, red, yellow } from "./util.js";
 import { diagnoseManageRestart, findMatchingAgentServiceUnit } from "./systemd.js";
 import { inspectEveAgent } from "./agent-limits.js";
 import { classifyModelReach } from "./model-reach.js";
@@ -10,6 +10,7 @@ import { countAbandonedRuns } from "./run-store.js";
 import { describeStaleSidecar, newestPackageChange, staleSidecars } from "./stale-sidecar.js";
 import { checkSelfVersion } from "./self-version.js";
 import { envUrlProblems } from "./env-urls.js";
+import { migrateManifest, migrateSources } from "./line-hop.js";
 const MARK = {
     pass: green("✓"),
     warn: yellow("!"),
@@ -25,6 +26,38 @@ export function githubToolsDoctorCheck(mountExists, env) {
         detail: "set GITHUB_TOKEN in .env.local or the deployment environment, then rebuild and restart",
     };
 }
+/**
+ * What the agent still carries from an older eve line: everything `kyb
+ * upgrade` would move (reported, not done), and what it leaves to a person.
+ */
+export function lineHopDoctorChecks(cwd) {
+    const checks = [];
+    try {
+        const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+        const manifest = migrateManifest(pkg, REGISTRY_URL);
+        for (const move of manifest.moves) {
+            checks.push({
+                verdict: "warn",
+                label: move.to === null ? `${move.name} is installed` : `${move.name} is ${move.from}, not ${move.to}`,
+                detail: `${move.why}; kyb upgrade moves it`,
+            });
+        }
+        if (manifest.registry) {
+            checks.push({ verdict: "warn", label: "the @kybernesis registry is not the one for this eve line", detail: `kyb upgrade points it at ${manifest.registry.to}` });
+        }
+    }
+    catch {
+        /* no readable package.json: the dependency checks say so */
+    }
+    const sources = migrateSources(cwd, { write: false });
+    for (const file of sources.updated)
+        checks.push({ verdict: "warn", label: `${file} is written for an older eve`, detail: `kyb upgrade rewrites it for eve ${EVE_VERSION}` });
+    for (const file of sources.removed)
+        checks.push({ verdict: "warn", label: `${file} mounts an extension that does not run on eve ${EVE_VERSION}`, detail: "kyb upgrade removes it" });
+    for (const { file, action } of sources.manual)
+        checks.push({ verdict: "warn", label: `${file} needs a hand`, detail: action });
+    return checks;
+}
 export function dockerTemplateDoctorChecks(result) {
     if (result.status === "skipped")
         return [];
@@ -242,6 +275,8 @@ export async function doctor() {
     const githubCheck = githubToolsDoctorCheck(existsSync(join(cwd, "agent/extensions/github.ts")), env);
     if (githubCheck)
         add(githubCheck.verdict, githubCheck.label, githubCheck.detail);
+    for (const check of lineHopDoctorChecks(cwd))
+        add(check.verdict, check.label, check.detail);
     // ── arcana keys: validate every key↔workspace pair read-only ───────────
     const arcanaPairs = [];
     if (env.ARCANA_API_KEY && env.ARCANA_COMPANY_WORKSPACE)

package/dist/exe-claude-route.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Give every `exeModel({ …, createOpenAI })` call in an agent the Anthropic
+ * factory too.
+ *
+ * @remarks
+ * Claude on the exe gateway is served on its Messages API, not the OpenAI one.
+ * Older scaffolds wrote subagents such as the builder with only `createOpenAI`
+ * and a Claude default (`anthropic/claude-sonnet-5`). That never had a working
+ * route, and since exe 0.17 `exeModel` refuses it at load, so the agent's whole
+ * eval suite stops before the first case and an update is rolled back for a
+ * file nobody touched. Passing `createAnthropic` as well is harmless for a
+ * non-Claude id (exeModel only uses it for `anthropic/…`), so the repair is
+ * unconditional for any call that lacks it.
+ *
+ * Returns the agent-relative paths it changed.
+ */
+export declare function repairExeClaudeRoute(cwd: string): string[];
+/** The source with `createAnthropic` passed to each exeModel call that has only `createOpenAI`, and imported. */
+export declare function withAnthropicFactory(source: string): string;

package/dist/exe-claude-route.js

@@ -0,0 +1,69 @@
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+/**
+ * Give every `exeModel({ …, createOpenAI })` call in an agent the Anthropic
+ * factory too.
+ *
+ * @remarks
+ * Claude on the exe gateway is served on its Messages API, not the OpenAI one.
+ * Older scaffolds wrote subagents such as the builder with only `createOpenAI`
+ * and a Claude default (`anthropic/claude-sonnet-5`). That never had a working
+ * route, and since exe 0.17 `exeModel` refuses it at load, so the agent's whole
+ * eval suite stops before the first case and an update is rolled back for a
+ * file nobody touched. Passing `createAnthropic` as well is harmless for a
+ * non-Claude id (exeModel only uses it for `anthropic/…`), so the repair is
+ * unconditional for any call that lacks it.
+ *
+ * Returns the agent-relative paths it changed.
+ */
+export function repairExeClaudeRoute(cwd) {
+    const root = join(cwd, "agent");
+    if (!existsSync(root))
+        return [];
+    const changed = [];
+    for (const file of sourceFiles(root)) {
+        const source = readFileSync(file, "utf8");
+        const next = withAnthropicFactory(source);
+        if (next === source)
+            continue;
+        writeFileSync(file, next);
+        changed.push(relative(cwd, file));
+    }
+    return changed;
+}
+/** The source with `createAnthropic` passed to each exeModel call that has only `createOpenAI`, and imported. */
+export function withAnthropicFactory(source) {
+    if (!/\bexeModel\s*\(/.test(source))
+        return source;
+    let touched = false;
+    const next = source.replace(/\bexeModel\s*\(\s*\{([^{}]*)\}\s*\)/g, (call, body) => {
+        if (!/\bcreateOpenAI\b/.test(body) || /\bcreateAnthropic\b/.test(body))
+            return call;
+        touched = true;
+        return call.replace(/\bcreateOpenAI\b/, "createOpenAI, createAnthropic");
+    });
+    if (!touched)
+        return source;
+    if (/\bimport\s*\{[^}]*\bcreateAnthropic\b[^}]*\}\s*from\s*["']@ai-sdk\/anthropic["']/.test(next))
+        return next;
+    const openaiImport = /^import\s*\{[^}]*\bcreateOpenAI\b[^}]*\}\s*from\s*["']@ai-sdk\/openai["'];?[^\n]*\n/m.exec(next);
+    const line = 'import { createAnthropic } from "@ai-sdk/anthropic";\n';
+    if (openaiImport) {
+        const at = openaiImport.index + openaiImport[0].length;
+        return next.slice(0, at) + line + next.slice(at);
+    }
+    return line + next;
+}
+function sourceFiles(dir) {
+    const out = [];
+    for (const entry of readdirSync(dir)) {
+        if (entry === "node_modules" || entry.startsWith("."))
+            continue;
+        const full = join(dir, entry);
+        if (statSync(full).isDirectory())
+            out.push(...sourceFiles(full));
+        else if (/\.(ts|mts|js|mjs)$/.test(entry))
+            out.push(full);
+    }
+    return out;
+}

package/dist/line-hop.d.ts

@@ -0,0 +1,74 @@
+/**
+ * What an agent built on eve 0.68 needs to run on eve 0.81, beyond new package
+ * versions. Each step touches only what a Kybernesis scaffold or registry item
+ * wrote, in the exact form it wrote it; anything authored by hand is reported
+ * and left alone.
+ */
+/** Where `kyb init` pointed the @kybernesis registry before the registry served one copy per eve line. */
+export declare const UNVERSIONED_REGISTRY_URL = "https://registry.kybernesis.ai/r/{name}.json";
+/**
+ * Third-party extensions, at the releases proven on the certified eve. The
+ * registry items install their newest release, which is built on a later eve
+ * and refused at discovery. Move them with the eve certification, never on
+ * their own.
+ */
+export declare const THIRD_PARTY_PINS: Readonly<Record<string, string>>;
+/** Third-party extensions with no release that mounts on the certified eve, and why. */
+export declare const DROPPED_EXTENSIONS: Readonly<Record<string, string>>;
+/** eve 0.81.1 peers on ai ^7.0.137; an agent's own range for ai must allow it. */
+export declare const AI_FLOOR = "7.0.137";
+/** Exactly what `eve add extension/agent-browser` wrote. */
+export declare const AGENT_BROWSER_MOUNT = "import browser from \"@agent-browser/eve\";\n\nexport default browser({});\n";
+export interface DependencyMove {
+    name: string;
+    from: string;
+    /** null when the dependency is removed. */
+    to: string | null;
+    why: string;
+}
+export interface ManifestMigration {
+    moves: DependencyMove[];
+    registry: {
+        from: string;
+        to: string;
+    } | null;
+}
+/**
+ * The manifest half: third-party pins, dropped extensions, the ai floor and
+ * the registry namespace. Mutates `pkg` and says what moved; writing it is the
+ * caller's, so a dry run can read the answer without touching disk.
+ */
+export declare function migrateManifest(pkg: Record<string, unknown>, registryUrl: string): ManifestMigration;
+export interface SourceMigration {
+    /** Files changed, relative to the agent. */
+    updated: string[];
+    /** Files removed, relative to the agent. */
+    removed: string[];
+    /** Files that need a hand, with what to do. */
+    manual: Array<{
+        file: string;
+        action: string;
+    }>;
+}
+/**
+ * The source half: the judge, the browser mount, the ask tools, and old tool
+ * names in prose. With `write: false` it only says what it would do.
+ */
+export declare function migrateSources(cwd: string, { write }?: {
+    write?: boolean;
+}): SourceMigration;
+/** The conversation store. The first boot on eve 0.81 deletes one written by an older line. */
+export declare const WORKFLOW_STORE = ".eve/.workflow-data";
+/** Where the store from line `fromLine` (e.g. "0.68") is kept across a hop. */
+export declare function workflowStoreBackup(fromLine: string): string;
+/** Build caches from the old line that the new one must not reuse. */
+export declare const STALE_EVE_CACHES: string[];
+/**
+ * Copy the conversation store aside before anything on the new line boots
+ * (the eval gate's dev server shares it with production). An existing backup
+ * is never overwritten: it is the copy taken before the first attempt.
+ */
+export declare function backUpWorkflowStore(cwd: string, fromLine: string): "copied" | "kept" | "none";
+/** Put the backed-up store back, for an agent that is going back to its old line. */
+export declare function restoreWorkflowStore(cwd: string, fromLine: string): boolean;
+export declare function clearStaleEveCaches(cwd: string): string[];

package/dist/line-hop.js

@@ -0,0 +1,207 @@
+import { cpSync, existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+/**
+ * What an agent built on eve 0.68 needs to run on eve 0.81, beyond new package
+ * versions. Each step touches only what a Kybernesis scaffold or registry item
+ * wrote, in the exact form it wrote it; anything authored by hand is reported
+ * and left alone.
+ */
+/** Where `kyb init` pointed the @kybernesis registry before the registry served one copy per eve line. */
+export const UNVERSIONED_REGISTRY_URL = "https://registry.kybernesis.ai/r/{name}.json";
+/**
+ * Third-party extensions, at the releases proven on the certified eve. The
+ * registry items install their newest release, which is built on a later eve
+ * and refused at discovery. Move them with the eve certification, never on
+ * their own.
+ */
+export const THIRD_PARTY_PINS = { "@github-tools/eve-extension": "0.8.1" };
+/** Third-party extensions with no release that mounts on the certified eve, and why. */
+export const DROPPED_EXTENSIONS = {
+    "@agent-browser/eve": "no release mounts on eve 0.81; the agent reads pages on its own computer (open_browser)",
+};
+/** eve 0.81.1 peers on ai ^7.0.137; an agent's own range for ai must allow it. */
+export const AI_FLOOR = "7.0.137";
+/** Exactly what `eve add extension/agent-browser` wrote. */
+export const AGENT_BROWSER_MOUNT = `import browser from "@agent-browser/eve";\n\nexport default browser({});\n`;
+function floorBelow(range, floor) {
+    const match = /^[\^~]?(\d+)\.(\d+)\.(\d+)$/.exec(range.trim());
+    if (!match)
+        return false;
+    const want = floor.split(".").map(Number);
+    const have = match.slice(1, 4).map(Number);
+    if (have[0] !== want[0])
+        return false;
+    for (let i = 0; i < 3; i += 1)
+        if (have[i] !== want[i])
+            return have[i] < want[i];
+    return false;
+}
+/**
+ * The manifest half: third-party pins, dropped extensions, the ai floor and
+ * the registry namespace. Mutates `pkg` and says what moved; writing it is the
+ * caller's, so a dry run can read the answer without touching disk.
+ */
+export function migrateManifest(pkg, registryUrl) {
+    const moves = [];
+    for (const section of ["dependencies", "devDependencies"]) {
+        const deps = pkg[section];
+        if (!deps)
+            continue;
+        for (const [name, range] of Object.entries(deps)) {
+            if (name in DROPPED_EXTENSIONS) {
+                delete deps[name];
+                moves.push({ name, from: range, to: null, why: DROPPED_EXTENSIONS[name] });
+            }
+            else if (THIRD_PARTY_PINS[name] && range !== THIRD_PARTY_PINS[name]) {
+                deps[name] = THIRD_PARTY_PINS[name];
+                moves.push({ name, from: range, to: THIRD_PARTY_PINS[name], why: "the release proven on the certified eve" });
+            }
+            else if (name === "ai" && floorBelow(range, AI_FLOOR)) {
+                deps[name] = `^${AI_FLOOR}`;
+                moves.push({ name, from: range, to: `^${AI_FLOOR}`, why: "the certified eve needs it" });
+            }
+        }
+    }
+    const overrides = pkg.overrides;
+    if (overrides && typeof overrides.ai === "string" && floorBelow(overrides.ai, AI_FLOOR))
+        overrides.ai = `^${AI_FLOOR}`;
+    let registry = null;
+    const registries = pkg.registries;
+    if (registries?.["@kybernesis"] === UNVERSIONED_REGISTRY_URL && registryUrl !== UNVERSIONED_REGISTRY_URL) {
+        registries["@kybernesis"] = registryUrl;
+        registry = { from: UNVERSIONED_REGISTRY_URL, to: registryUrl };
+    }
+    return { moves, registry };
+}
+/**
+ * Registry-written workflow tools whose question must survive the person
+ * sending another message. On 0.69+ an `execute` tool's open question is
+ * withdrawn by one; a `task` keeps it open and hands the answer back later.
+ */
+const ASK_TOOLS = [
+    {
+        path: "agent/tools/request_vault_item.ts",
+        helper: "@kybernesis/vault/ask",
+        explain: (source) => source.replace("// Parks durably; ", "// Runs as a task: the question stays open through any other message the person\n" +
+            "// sends (an `execute` call's question is withdrawn by one), and the answer\n" +
+            "// reaches the model later in the conversation. Parks durably; "),
+    },
+    {
+        path: "agent/tools/approve_spend_request.ts",
+        helper: "@kybernesis/payments",
+        explain: (source) => source.replace("\nexport default defineWorkflowTool(", "\n// Runs as a task: the question stays open through any other message the person\n" +
+            "// sends (an `execute` call's question is withdrawn by one, which would cancel\n" +
+            "// the purchase), and the result reaches the model later in the conversation." +
+            "\nexport default defineWorkflowTool("),
+    },
+];
+const EXECUTE_WORKFLOW = /( {2})async execute\(input, ctx\) \{(\n\s*"use workflow";)/;
+function walk(dir, keep) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory())
+            return entry.name === "node_modules" ? [] : walk(path, keep);
+        return entry.isFile() && keep(entry.name) ? [path] : [];
+    });
+}
+/**
+ * The source half: the judge, the browser mount, the ask tools, and old tool
+ * names in prose. With `write: false` it only says what it would do.
+ */
+export function migrateSources(cwd, { write = true } = {}) {
+    const result = { updated: [], removed: [], manual: [] };
+    const rel = (path) => relative(cwd, path);
+    // eve 0.72 grades with a decision model; `.evaluationModel(` no longer compiles.
+    for (const path of [join(cwd, "evals/evals.config.ts"), join(cwd, "evals.config.ts")]) {
+        if (!existsSync(path))
+            continue;
+        const source = readFileSync(path, "utf8");
+        if (!source.includes(".evaluationModel("))
+            continue;
+        if (write)
+            writeFileSync(path, source.replaceAll(".evaluationModel(", ".decisionModel("));
+        result.updated.push(rel(path));
+    }
+    // The browser extension: remove the scaffold's mount, flag any other.
+    for (const path of walk(join(cwd, "agent"), (name) => /\.[cm]?[jt]s$/.test(name))) {
+        const source = readFileSync(path, "utf8");
+        if (!source.includes("@agent-browser/eve"))
+            continue;
+        if (source === AGENT_BROWSER_MOUNT) {
+            if (write)
+                rmSync(path);
+            result.removed.push(rel(path));
+        }
+        else {
+            result.manual.push({ file: rel(path), action: `remove it: @agent-browser/eve ${DROPPED_EXTENSIONS["@agent-browser/eve"]}` });
+        }
+    }
+    for (const tool of ASK_TOOLS) {
+        const path = join(cwd, tool.path);
+        if (!existsSync(path))
+            continue;
+        const source = readFileSync(path, "utf8");
+        if (!source.includes(tool.helper) || !EXECUTE_WORKFLOW.test(source))
+            continue;
+        const swapped = source.replace(EXECUTE_WORKFLOW, "$1async task(input, ctx) {$2");
+        if (write)
+            writeFileSync(path, swapped.includes("Runs as a task:") ? swapped : tool.explain(swapped));
+        result.updated.push(tool.path);
+    }
+    // Prose that names tools eve 0.81 no longer has: the model would look for them.
+    for (const path of walk(join(cwd, "agent"), (name) => /\.(md|ts)$/.test(name))) {
+        const source = readFileSync(path, "utf8");
+        const names = ["connection_search", "load_skill"].filter((name) => new RegExp(`\\b${name}\\b`).test(source));
+        if (names.length === 0)
+            continue;
+        result.manual.push({
+            file: rel(path),
+            action: `rewrite ${names.map((n) => `\`${n}\``).join(" and ")}: eve 0.81 finds tools with \`eve__search\`, calls them with \`eve__tool\`, and loads skills with \`eve__skill\``,
+        });
+    }
+    return result;
+}
+/** The conversation store. The first boot on eve 0.81 deletes one written by an older line. */
+export const WORKFLOW_STORE = ".eve/.workflow-data";
+/** Where the store from line `fromLine` (e.g. "0.68") is kept across a hop. */
+export function workflowStoreBackup(fromLine) {
+    return `${WORKFLOW_STORE}.eve-${fromLine}`;
+}
+/** Build caches from the old line that the new one must not reuse. */
+export const STALE_EVE_CACHES = [".eve/sandbox-cache", ".eve/dev-runtime"];
+/**
+ * Copy the conversation store aside before anything on the new line boots
+ * (the eval gate's dev server shares it with production). An existing backup
+ * is never overwritten: it is the copy taken before the first attempt.
+ */
+export function backUpWorkflowStore(cwd, fromLine) {
+    const store = join(cwd, WORKFLOW_STORE);
+    const backup = join(cwd, workflowStoreBackup(fromLine));
+    if (existsSync(backup))
+        return "kept";
+    if (!existsSync(store))
+        return "none";
+    cpSync(store, backup, { recursive: true, preserveTimestamps: true });
+    return "copied";
+}
+/** Put the backed-up store back, for an agent that is going back to its old line. */
+export function restoreWorkflowStore(cwd, fromLine) {
+    const backup = join(cwd, workflowStoreBackup(fromLine));
+    if (!existsSync(backup))
+        return false;
+    const store = join(cwd, WORKFLOW_STORE);
+    rmSync(store, { recursive: true, force: true });
+    cpSync(backup, store, { recursive: true, preserveTimestamps: true });
+    return true;
+}
+export function clearStaleEveCaches(cwd) {
+    return STALE_EVE_CACHES.filter((dir) => {
+        const path = join(cwd, dir);
+        if (!existsSync(path))
+            return false;
+        rmSync(path, { recursive: true, force: true });
+        return true;
+    });
+}

package/dist/templates.js

@@ -792,9 +792,10 @@ export { deliver as default } from "@kybernesis/engineer/tools";
 // that matters is host access, and the old wording blurred exactly the line
 // people read this comment to understand.
 //
-// The root DOES get a browser and GitHub tools — the engineer layer installs
-// extension/agent-browser and extension/github-tools at the root, deliberately,
-// because reading a page is not the same blast radius as running a command.
+// The root DOES get GitHub tools — the engineer layer installs
+// extension/github-tools at the root, deliberately, because reading a repo is
+// not the same blast radius as running a command. Pages are read on the
+// agent's own computer (open_browser).
 export { default } from "@kybernesis/engineer";
 `,
         },
@@ -860,8 +861,9 @@ 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.
-  // 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") },
+  // eve ≥0.72 grades with a DECISION model (an evaluation model from 0.62),
+  // not a language model instance.
+  judge: { model: exe.decisionModel(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,

package/dist/upgrade.js

@@ -11,8 +11,10 @@ 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 { repairExeClaudeRoute } from "./exe-claude-route.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 { EVE_VERSION, REGISTRY_URL, bold, capture, dim, green, parseEnv, red, run, yellow } from "./util.js";
+import { backUpWorkflowStore, clearStaleEveCaches, migrateManifest, migrateSources, restoreWorkflowStore, workflowStoreBackup, } from "./line-hop.js";
 import { inspectEveAgent } from "./agent-limits.js";
 import { remoteProjectPath, sshTarget } from "./deploy.js";
 import { classifyModelReach } from "./model-reach.js";
@@ -75,6 +77,25 @@ function repairLocalQueueTimeouts(cwd, deps) {
         `    ${dim("slower than 30s was redelivered and its steps re-run — the agent answered twice.")}\n` +
         `    ${dim("Takes effect on the next server restart.")}\n`);
 }
+/** Route Claude ids through the gateway's Messages API wherever an agent builds an exe model (see exe-claude-route.ts). */
+function repairExeClaudeRoutes(cwd, deps) {
+    if (!deps["@kybernesis/exe"])
+        return;
+    const changed = repairExeClaudeRoute(cwd);
+    if (changed.length === 0)
+        return;
+    if (!deps["@ai-sdk/anthropic"]) {
+        const added = commandResult("npm", ["install", "@ai-sdk/anthropic"], cwd);
+        if (added.status !== 0) {
+            console.log(red(`  ✗ could not install @ai-sdk/anthropic for the Claude route:\n${added.stderr.trim()}`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    console.log(`  ${green("+")} passed createAnthropic to exeModel in ${changed.join(", ")}\n` +
+        `    ${dim("Claude on the exe gateway is served on its Messages API; with only createOpenAI")}\n` +
+        `    ${dim("a Claude id has no route, and exe 0.17+ refuses it when the agent loads.")}\n`);
+}
 /**
  * Finish a Buzz install that a version bump alone leaves half-done.
  *
@@ -578,11 +599,14 @@ 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*(?:\.evaluationModel\s*)?\(/.exec(source)?.[1];
+    const judgeProvider = /judge\s*:\s*\{[\s\S]*?model\s*:\s*([A-Za-z_$][\w$]*)\s*(?:\.(?:decisionModel|evaluationModel)\s*)?\(/.exec(source)?.[1];
     if (!judgeProvider)
         return null;
     const escaped = judgeProvider.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const providerBody = new RegExp(`(?:const|let)\\s+${escaped}\\s*=\\s*create[A-Za-z]+\\s*\\(\\s*\\{([\\s\\S]*?)\\}\\s*\\)`).exec(source)?.[1];
+    // The provider may be made inline (`model: createAnthropic({ … }).decisionModel(…)`)
+    // as well as bound to a name first; both carry the base URL in the same object.
+    const inline = /judge\s*:\s*\{[\s\S]*?model\s*:\s*create[A-Za-z]+\s*\(\s*\{([\s\S]*?)\}\s*\)/.exec(source)?.[1];
+    const providerBody = inline ?? new RegExp(`(?:const|let)\\s+${escaped}\\s*=\\s*create[A-Za-z]+\\s*\\(\\s*\\{([\\s\\S]*?)\\}\\s*\\)`).exec(source)?.[1];
     if (!providerBody)
         return /EXE_LLM_URL|llm\.int\.exe\.xyz/.test(source) ? undefined : null;
     if (/EXE_LLM_URL/.test(providerBody))
@@ -642,7 +666,7 @@ async function runUpgradeEvalGate(cwd, host) {
         const target = sshTarget(cwd, typeof host === "string" && host.length > 0 ? host : undefined);
         if (!target) {
             reportEvalGateUnavailable(cwd, null, ["no ssh target is configured"]);
-            return;
+            return "unavailable";
         }
         console.log(bold(`\nRunning the eval gate on ${target} (${remoteProjectPath(cwd)}) — deploy only on green …\n`));
         const result = spawnSync("ssh", [target, `cd ${remoteProjectPath(cwd)} && npm run eval`], {
@@ -652,27 +676,26 @@ async function runUpgradeEvalGate(cwd, host) {
         });
         if (result.status === 0) {
             console.log(`\n${green("✓ Upgrade green.")} Deploy with: ${bold("npx eve deploy")}\n`);
+            return "green";
         }
-        else {
-            console.log(`\n${red("✗ Evals failed after upgrade.")} Do NOT deploy — inspect .eve/evals/ artifacts on the host.\n`);
-            process.exitCode = 1;
-        }
-        return;
+        console.log(`\n${red("✗ Evals failed after upgrade.")} Do NOT deploy — inspect .eve/evals/ artifacts on the host.\n`);
+        process.exitCode = 1;
+        return "failed";
     }
     const preflight = await preflightEvalGate(cwd);
     if (preflight.kind === "unavailable") {
         reportEvalGateUnavailable(cwd, sshTarget(cwd), preflight.reasons);
-        return;
+        return "unavailable";
     }
     console.log(bold("\nRunning the eval gate (npm run eval) — deploy only on green …\n"));
     const ok = run("npm", ["run", "eval"], { cwd, allowFail: true });
     if (ok) {
         console.log(`\n${green("✓ Upgrade green.")} Deploy with: ${bold("npx eve deploy")}\n`);
+        return "green";
     }
-    else {
-        console.log(`\n${red("✗ Evals failed after upgrade.")} Do NOT deploy — inspect .eve/evals/ artifacts.\n`);
-        process.exitCode = 1;
-    }
+    console.log(`\n${red("✗ Evals failed after upgrade.")} Do NOT deploy — inspect .eve/evals/ artifacts.\n`);
+    process.exitCode = 1;
+    return "failed";
 }
 function upgradeEnvironment(cwd) {
     const envPath = join(cwd, ".env.local");
@@ -867,6 +890,47 @@ function startStoppedBridge(cwd, unit) {
         `  systemctl status ${unit}`);
     return false;
 }
+/**
+ * A third-party extension whose declared peer range trails the certified
+ * eve (the Vercel-owned @github-tools/eve-extension does) makes npm's
+ * default resolver ERESOLVE before it will write a tree at all. That is not
+ * a reason to abort the upgrade: retry the same install with
+ * --legacy-peer-deps so the tree is written, then let assessPeerTree judge
+ * WHO actually objects. A @kybernesis or root conflict still stops
+ * everything; only a stale third-party edge is tolerated (same principle as
+ * the KYB-548 peer-tree gate). KYB-561.
+ */
+function npmInstall(cwd, args) {
+    let result = commandResult("npm", args, cwd);
+    if (result.status !== 0 && /ERESOLVE/i.test(`${result.stdout}\n${result.stderr}`)) {
+        console.log(yellow("\n  ! npm reported a peer conflict. Retrying with --legacy-peer-deps so the installed peer tree can be assessed."));
+        result = commandResult("npm", [...args, "--legacy-peer-deps"], cwd);
+    }
+    return result;
+}
+function manifestMoved(migration) {
+    return migration.moves.length > 0 || migration.registry !== null;
+}
+function reportManifestMigration(migration) {
+    for (const move of migration.moves) {
+        console.log(move.to === null
+            ? `  ${green("-")} ${move.name} removed ${dim(`(${move.why})`)}`
+            : `  ${yellow("↑")} ${move.name}: ${move.from} → ${move.to} ${dim(`(${move.why})`)}`);
+    }
+    if (migration.registry)
+        console.log(`  ${green("+")} @kybernesis registry → ${migration.registry.to} ${dim("(the items built for this eve line)")}`);
+}
+function reportSourceMigration(cwd) {
+    const result = migrateSources(cwd);
+    for (const file of result.updated)
+        console.log(`  ${green("+")} updated ${file} ${dim(`(for eve ${EVE_VERSION})`)}`);
+    for (const file of result.removed)
+        console.log(`  ${green("-")} removed ${file} ${dim("(mounted an extension that does not run on this eve)")}`);
+    for (const { file, action } of result.manual)
+        console.log(`  ${yellow("!")} ${file}: ${action}`);
+    if (result.updated.length || result.removed.length || result.manual.length)
+        console.log();
+}
 /** The one line `kyb upgrade --check` prints for a program to read; everything else it prints is for people. */
 export const UPGRADE_PLAN_PREFIX = "KYB_UPGRADE_PLAN ";
 function printPlan(plan) {
@@ -915,6 +979,21 @@ export async function upgrade(options = {}) {
         console.log(`    ${dim(selfVersion.fix)} ${dim("(continuing: --allow-stale)")}\n`);
     }
     reportAgentInputLimit(cwd);
+    // An agent already on a newer eve line than this kyb was certified on must
+    // be upgraded by that line's kyb: from here every @kybernesis package would
+    // be "upgraded" to a build for the older eve.
+    const eveNow = installedPackageValue(cwd, "eve", ".version");
+    const nowLine = eveNow ? majorMinor(eveNow) : null;
+    const ownLine = majorMinor(EVE_VERSION);
+    if (nowLine && ownLine && (nowLine[0] > ownLine[0] || (nowLine[0] === ownLine[0] && nowLine[1] > ownLine[1]))) {
+        if (options.check)
+            printPlan({ ok: false, unresolved: ["eve"], changes: [], resetsConversations: false });
+        fail(`This agent runs eve ${eveNow}, a newer line than this kyb is certified for (${EVE_VERSION}). ` +
+            `Run the kyb for its line:\n  npx --yes --package=@kybernesis/create@eve-${nowLine[0]}.${nowLine[1]} kyb upgrade\n` +
+            `Nothing was changed.`);
+        return;
+    }
+    const selfInstalled = "installed" in selfVersion ? selfVersion.installed : undefined;
     const entries = dependencyEntries(pkg);
     const installedVersions = new Map();
     const targetVersions = new Map();
@@ -933,11 +1012,16 @@ export async function upgrade(options = {}) {
         // that supports the eve this host will be running — NOT npm's `latest`,
         // which for a per-eve-line package is routinely a build for a different
         // line and installs without complaint.
+        // kyb itself declares no eve peer, so the newest published kyb can belong
+        // to another eve line. The project carries the kyb doing this upgrade (a
+        // stale one renewed itself above), never a newer one.
         const target = name === "eve"
             ? EVE_VERSION
-            : name.startsWith("@kybernesis/")
-                ? newestBuildForEve(name, EVE_VERSION)
-                : capture("npm", ["view", name, "version"])?.trim();
+            : name === "@kybernesis/create"
+                ? selfInstalled && versionLt(installed, selfInstalled) ? selfInstalled : installed
+                : name.startsWith("@kybernesis/")
+                    ? newestBuildForEve(name, EVE_VERSION)
+                    : capture("npm", ["view", name, "version"])?.trim();
         if (!target) {
             console.log(`  ${yellow("!")} ${name}: ` +
                 (name.startsWith("@kybernesis/")
@@ -1002,13 +1086,19 @@ export async function upgrade(options = {}) {
     const changed = [...new Set(targets
             .filter((target) => target.installedVersion !== target.targetVersion && !(target.name === "eve" && versionLt(target.targetVersion, target.installedVersion)))
             .map((target) => `${target.name}@${target.targetVersion}`))];
+    // Third-party pins, dropped extensions and the registry namespace for this
+    // eve line. pkg now carries them; it is written below with the rest.
+    const manifest = migrateManifest(pkg, REGISTRY_URL);
     if (options.check) {
         printPlan({
             ok: true,
             eve: { installed: eveInstalled ?? null, certified: EVE_VERSION },
-            changes: [...new Map(targets
+            changes: [
+                ...new Map(targets
                     .filter((target) => changed.includes(`${target.name}@${target.targetVersion}`))
-                    .map((target) => [target.name, { name: target.name, from: target.installedVersion, to: target.targetVersion }])).values()],
+                    .map((target) => [target.name, { name: target.name, from: target.installedVersion, to: target.targetVersion }])).values(),
+                ...manifest.moves.map((move) => ({ name: move.name, from: move.from, to: move.to ?? "removed" })),
+            ],
             resetsConversations: eveChanged,
         });
         return;
@@ -1019,6 +1109,15 @@ export async function upgrade(options = {}) {
     }
     repairLocalQueueTimeouts(cwd, deps);
     if (changed.length === 0) {
+        if (manifestMoved(manifest)) {
+            reportManifestMigration(manifest);
+            writeFileSync(packagePath, `${JSON.stringify(pkg, null, 2)}\n`);
+            const reinstalled = npmInstall(cwd, ["install"]);
+            if (reinstalled.status !== 0) {
+                fail("\nnpm install failed after the dependency moves above; package.json carries them, the tree may not.");
+                return;
+            }
+        }
         if (loosePin) {
             const pinned = commandResult("npm", ["install", "--save-exact", `eve@${eveTarget}`], cwd);
             if (pinned.status !== 0) {
@@ -1038,9 +1137,12 @@ export async function upgrade(options = {}) {
         repairNotifySetup(cwd, deps);
         repairReasoningSandboxes(cwd, deps);
         repairManageRestart(cwd, deps);
+        repairExeClaudeRoutes(cwd, deps);
+        reportSourceMigration(cwd);
         return;
     }
     console.log(bold(`\nInstalling: ${changed.join(", ")}\n`));
+    reportManifestMigration(manifest);
     let stoppedBridge = null;
     if (cleanInstall && deps["@kybernesis/buzz"]) {
         const stopped = stopActiveBridge(cwd, buzzBridgeUnit(cwd));
@@ -1048,6 +1150,18 @@ export async function upgrade(options = {}) {
             return;
         stoppedBridge = stopped;
     }
+    // A new eve line: keep the conversations aside before anything on it boots
+    // (its first boot deletes an older line's store, and the eval gate's dev
+    // server shares the store with production), and drop the old line's caches.
+    const storeLine = cleanInstall && installedMajorMinor ? installedMajorMinor.join(".") : null;
+    if (storeLine) {
+        const kept = backUpWorkflowStore(cwd, storeLine);
+        if (kept !== "none") {
+            console.log(`  ${green("+")} conversations from eve ${storeLine} kept at ${workflowStoreBackup(storeLine)}${kept === "kept" ? ` ${dim("(from an earlier attempt)")}` : ""}`);
+        }
+        for (const dir of clearStaleEveCaches(cwd))
+            console.log(`  ${green("-")} cleared ${dir} ${dim(`(built for eve ${storeLine})`)}`);
+    }
     if (cleanInstall) {
         rewriteManifest(cwd, pkg, targets);
         try {
@@ -1064,28 +1178,12 @@ export async function upgrade(options = {}) {
     // reason rewriteManifest pins it: npm would save a caret by default.
     const eveChange = changed.find((spec) => spec.startsWith("eve@")) ?? (loosePin ? `eve@${eveTarget}` : undefined);
     const others = changed.filter((spec) => spec !== eveChange);
-    /**
-     * A third-party extension whose declared peer range trails the certified
-     * eve (the Vercel-owned @github-tools/eve-extension and @agent-browser/eve
-     * both do) makes npm's default resolver ERESOLVE before it will write a
-     * tree at all. That is not a reason to abort the upgrade: retry the same
-     * install with --legacy-peer-deps so the tree is written, then let
-     * assessPeerTree below judge WHO actually objects. A @kybernesis or root
-     * conflict still stops everything; only a stale third-party edge is
-     * tolerated (same principle as the KYB-548 peer-tree gate). KYB-561.
-     */
-    const npmInstall = (args) => {
-        let result = commandResult("npm", args, cwd);
-        if (result.status !== 0 && /ERESOLVE/i.test(`${result.stdout}\n${result.stderr}`)) {
-            console.log(yellow("\n  ! npm reported a peer conflict. Retrying with --legacy-peer-deps so the installed peer tree can be assessed."));
-            result = commandResult("npm", [...args, "--legacy-peer-deps"], cwd);
-        }
-        return result;
-    };
+    if (!cleanInstall && manifestMoved(manifest))
+        writeFileSync(packagePath, `${JSON.stringify(pkg, null, 2)}\n`);
     const installArgs = cleanInstall ? ["install"] : ["install", ...others];
-    let installed = cleanInstall || others.length > 0 ? npmInstall(installArgs) : { status: 0, stdout: "", stderr: "" };
+    let installed = cleanInstall || others.length > 0 || manifestMoved(manifest) ? npmInstall(cwd, installArgs) : { status: 0, stdout: "", stderr: "" };
     if (installed.status === 0 && !cleanInstall && eveChange) {
-        installed = npmInstall(["install", "--save-exact", eveChange]);
+        installed = npmInstall(cwd, ["install", "--save-exact", eveChange]);
     }
     if (installed.status !== 0) {
         const output = `${installed.stdout}\n${installed.stderr}`;
@@ -1129,6 +1227,8 @@ export async function upgrade(options = {}) {
     repairNotifySetup(cwd, deps);
     repairReasoningSandboxes(cwd, deps);
     repairManageRestart(cwd, deps);
+    repairExeClaudeRoutes(cwd, deps);
+    reportSourceMigration(cwd);
     run("npm", ["run", "typecheck"], { cwd });
     if (eveChanged) {
         const infoOk = run("npx", ["eve", "info"], { cwd, allowFail: true, quiet: true });
@@ -1138,5 +1238,9 @@ export async function upgrade(options = {}) {
         console.log(yellow("\nEval gate SKIPPED (--skip-eval). Run `npm run eval` before deploying.\n"));
         return;
     }
-    await runUpgradeEvalGate(cwd, options.host);
+    const outcome = await runUpgradeEvalGate(cwd, options.host);
+    // Going back means the old line, and the old line needs its conversations.
+    if (outcome === "failed" && storeLine && restoreWorkflowStore(cwd, storeLine)) {
+        console.log(`  ${green("+")} conversations from eve ${storeLine} put back from ${workflowStoreBackup(storeLine)} ${dim("(for when the agent goes back to it)")}\n`);
+    }
 }

package/dist/util.d.ts

@@ -1,5 +1,6 @@
-export declare const EVE_VERSION = "0.68.0";
-export declare const REGISTRY_URL = "https://registry.kybernesis.ai/r/{name}.json";
+export declare const EVE_VERSION = "0.81.1";
+/** The registry items built for EVE_VERSION's line; every @kybernesis dep in them is tagged for it. */
+export declare const REGISTRY_URL = "https://registry.kybernesis.ai/r/eve-0.81/{name}.json";
 export declare const DEFAULT_ISSUER = "https://agent.kybernesis.ai";
 export declare const green: (s: string) => string;
 export declare const yellow: (s: string) => string;

package/dist/util.js

@@ -1,7 +1,8 @@
 import { spawnSync } from "node:child_process";
 import { createInterface } from "node:readline/promises";
-export const EVE_VERSION = "0.68.0";
-export const REGISTRY_URL = "https://registry.kybernesis.ai/r/{name}.json";
+export const EVE_VERSION = "0.81.1";
+/** The registry items built for EVE_VERSION's line; every @kybernesis dep in them is tagged for it. */
+export const REGISTRY_URL = "https://registry.kybernesis.ai/r/eve-0.81/{name}.json";
 export const DEFAULT_ISSUER = "https://agent.kybernesis.ai";
 const TTY = process.stdout.isTTY === true;
 export const green = (s) => (TTY ? `\x1b[32m${s}\x1b[0m` : s);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/create",
-  "version": "0.24.2",
+  "version": "0.25.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.",
   "license": "Apache-2.0",
   "type": "module",
@@ -39,14 +39,15 @@
   },
   "devDependencies": {
     "@types/node": "24.x",
-    "eve": "0.68.0",
+    "eve": "0.81.1",
     "typescript": "7.0.2"
   },
   "engines": {
     "node": ">=20"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "tag": "eve-0.81"
   },
   "peerDependencies": {}
 }

package/skills/eve-building/SKILL.md

@@ -72,7 +72,7 @@ Docs: `docs/connections/*`.
 
 ## Skills (agent/skills/)
 
-On-demand procedures (model calls `load_skill` when the description matches).
+On-demand procedures (model calls `eve__skill` when the description matches).
 Forms: flat `.md` (first line = routing description) → packaged dir with
 `SKILL.md` (+`references/`, description frontmatter required) → `defineSkill`
 (only for typed/generated content). The description is a ROUTING HINT — write
@@ -112,7 +112,7 @@ Instruct serial delegation ("one draft at a time, wait for each result").
 ## Test in eve dev
 
 `npx eve dev` boots the local runtime + chat TUI. Walk: identity → skill
-routing (watch load_skill) → delegation → memory round-trip → (engineer)
+routing (watch eve__skill) → delegation → memory round-trip → (engineer)
 screenshot turn. Local principal counts as a DM surface. Kill the dev server
 before `npm run eval`. The TUI is NOT the deployed agent — redeploy after
 every change.

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

@@ -77,7 +77,7 @@ exactly §§2, 5, 6, and 7 of this playbook:
 | --- | --- | --- |
 | `npm create @kybernesis <name>` | Day 1, once | Same as `kyb init <name>` without installing anything first |
 | `kyb init <name>` | Day 1, once | eve scaffold (pinned version) + registry + all four packages + generated departments + eval wiring + env template + checklist |
-| `kyb init <name> --engineer` | When the pilot includes building software | Everything above PLUS the engineer layer: workshop sandbox (Playwright baked into the template), the vision screenshot tool, build/ship skills, and the official limbs (agent-browser, github-tools, vercel connection) |
+| `kyb init <name> --engineer` | When the pilot includes building software | Everything above PLUS the engineer layer: workshop sandbox (Playwright baked into the template), the vision screenshot tool, build/ship skills, and the official limbs (github-tools, vercel connection) |
 | `kyb doctor` | **Constantly** — after every human step, before every deploy, whenever anything is weird | Live preflight: every Arcana key↔workspace pair validated against the API (with the specific fix per failure: wrong-key 403 vs missing-workspace 404), issuer JWKS reachability, `KYBERNESIS_AGENT`, Slack connector env, `eve info` discovery, port-2000 conflict. Exit 1 on failure → usable in CI |
 | `kyb upgrade` | Maintenance visits / after Kybernesis ships a package update | Compares installed `@kybernesis/*` against npm **and eve against the Kybernesis-certified version** (never blindly npm-latest — we certify eve releases in the platform repo first), installs what's behind, typechecks (+ `eve info` after a framework bump), then **runs the eval suite as the gate** — tells you to deploy only on green |
 | `kyb upgrade --skip-eval` | Never for production changes | Same, without the gate |
@@ -613,8 +613,10 @@ six build/ship skills + engineering-conduct instructions) and
 `agent/sandbox/sandbox.ts` (the **workshop**: Playwright + Chromium baked into
 the sandbox template, domain allowlist on deployed sessions). Pair it with the
 official limbs if not using `kyb init --engineer`:
-`npx eve add extension/agent-browser extension/github-tools connection/vercel`
-(run individually).
+`npx eve add extension/github-tools connection/vercel` (run individually), then
+pin `@github-tools/eve-extension` to the release in `kyb`'s THIRD_PARTY_PINS.
+(extension/agent-browser does not mount on eve 0.81; the agent reads pages on
+its own computer with `open_browser`.)
 
 **Wire the Vercel connection** (preview deploys + a clickable link for every
 build — proven live 2026-08-06). After `vercel link` in the agent dir:
@@ -866,7 +868,7 @@ reach for the connection at all. Write it like a capability, name the systems.
 ### 4.3e Skills — teach the client's procedures (and mine skills.sh)
 
 A skill is a markdown procedure the model loads **on demand** (eve advertises
-each skill's description; the model calls `load_skill` when a turn matches).
+each skill's description; the model calls `eve__skill` when a turn matches).
 Anything the client's team does "the same way every time" — their release
 checklist, escalation path, report format — is a skill, not an always-on
 instruction. Keep always-on for identity and rules; skills for procedures.
@@ -1018,7 +1020,7 @@ this order — each line catches a different class of wiring mistake:
 1. **Identity**: "who are you, what can you do?" — does the persona match
    identity.md, and does it write chat-length answers?
 2. **Skill routing**: ask something a skill covers *without naming the skill*
-   — watch for the `load_skill` call. If it doesn't fire, the skill's
+   — watch for the `eve__skill` call. If it doesn't fire, the skill's
    `description` isn't written as a triggering task.
 3. **Delegation**: ask a department question — watch the subagent call and
    check the answer came back briefed (§4.4's "pack everything" rule).