@kybernesis/create 0.24.4 → 0.26.0

package/README.md

@@ -14,6 +14,10 @@ npx @kybernesis/create init acme-atlas
 
 `kyb init --host=exe` always installs the agent's computer (`@kybernesis/computer`: a persistent desktop with Chrome a person can watch and take over) and its vault (`@kybernesis/vault`: per-agent, per-person logins and cards it fills on that computer without seeing them). They are not options. A Vercel host gets neither, because a function cannot keep a desktop alive, and init says so.
 
+## Core on every Studio agent
+
+`kyb init --studio` (every agent the provisioner builds) also installs what a person sees beyond words in KYBER Studio and on the phone: cards under replies (`@kybernesis/cards` and the `show` tool from the `cards` registry item), artifacts (`@kybernesis/artifacts`: pages the agent makes and keeps, served by manage) and magic (`@kybernesis/magic`: proactive heads-ups, off until each person turns them on). On a Linq agent, magic delivers into the iMessage thread the person last used. `kyb upgrade` adds whichever of the three an agent with `@kybernesis/manage` is missing, lists them in `--check` so the owner's Update button shows, and holds the result to the eval gate even when no other package moved.
+
 ## `kyb init [name]`
 
 Scaffolds the full Kybernesis stack:

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,8 @@ 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";
+import { missingStudioCore } from "./studio-core.js";
 const MARK = {
     pass: green("✓"),
     warn: yellow("!"),
@@ -25,6 +27,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 [];
@@ -197,6 +231,10 @@ export async function doctor() {
         else
             add("warn", `${p} not installed`, `eve add @kybernesis/${p.split("/")[1]}`);
     }
+    // Core on every agent Studio manages; kyb upgrade adds whichever is missing.
+    for (const core of missingStudioCore(deps)) {
+        add("warn", `${core.pkg} not installed (${core.what})`, `npx kyb upgrade adds it, or npx eve add @kybernesis/${core.item}`);
+    }
     /**
      * multiplayer is conversation mechanics for a SHARED channel — threads with
      * per-speaker identity, the public/DM split. An agent reached only through
@@ -242,6 +280,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/init.js

@@ -9,6 +9,7 @@ import { upsertEnv } from "./envfile.js";
 import { systemdRestartCommand } from "./systemd.js";
 import { sandboxCleanupScaffoldFiles } from "./sandbox-cleanup.js";
 import { MODEL_REACH_ENV, resolveModelScaffold } from "./model-reach.js";
+import { STUDIO_CORE, ignoreMagicState, wireMagicLinq } from "./studio-core.js";
 /**
  * The always-installed core. Everything else — channels, subagents, engineer,
  * host bindings — is opt-in, because assuming them means the FDE deletes files
@@ -151,7 +152,7 @@ export async function init(rawName, options = {}) {
         // client change THIS AGENT — its dependencies and its source; `notify`
         // lets it reach the person's phone. Different blast radius, so an agent
         // can have one without the others.
-        console.log(bold("\n2b2  KYBER Studio: local execution + management routes + phone notifications …"));
+        console.log(bold("\n2b2  KYBER Studio: local execution + management routes + phone notifications + cards, artifacts, heads-ups …"));
         const studioFailures = [];
         for (const item of ["local", "manage", "notify"]) {
             // The @kybernesis/ prefix is load-bearing: a bare name resolves against
@@ -168,6 +169,20 @@ export async function init(rawName, options = {}) {
                 console.log(yellow(`  ! ${item} did not install — re-run: npx eve add @kybernesis/${item}`));
             }
         }
+        // What a person sees beyond words, on every agent Studio reaches: cards
+        // under replies, artifacts, and magic (off until each person opts in).
+        // After manage and notify on purpose: artifacts are served by manage's
+        // routes, and magic delivers into its conversation and rings the phone.
+        for (const core of STUDIO_CORE) {
+            const ok = run("npx", ["eve", "add", `@kybernesis/${core.item}`, "--overwrite"], { cwd: dir, allowFail: true });
+            if (!ok) {
+                studioFailures.push(core.item);
+                console.log(yellow(`  ! ${core.item} did not install — re-run: npx eve add @kybernesis/${core.item}`));
+            }
+            else if (core.item === "magic") {
+                ignoreMagicState(dir);
+            }
+        }
         // Said again, loudly, at the end. A warning printed sixty lines before a
         // green summary is a warning nobody reads — and the agent that results
         // looks correctly scaffolded right up until KYBER Studio refuses it.
@@ -351,6 +366,9 @@ export async function init(rawName, options = {}) {
     else {
         console.log(bold(`\n4/6  Channel: ${channel} (no channel file) …`));
     }
+    // A person who last texted the agent gets their heads-ups in that thread.
+    if (studio && wireMagicLinq(dir))
+        console.log(dim("     agent/lib/magic-surfaces.ts — heads-ups also land in iMessage threads"));
     if (depts.length) {
         console.log(bold(`\n4b   Generating ${depts.length} department subagent(s) …`));
         const skillsSource = join(dir, "node_modules/@kybernesis/arcana/dist/extension/skills");
@@ -403,6 +421,7 @@ export async function init(rawName, options = {}) {
         host === "exe" ? "exe.dev host" : null,
         model.reach === "claude-sub" ? "Claude subscription reach" : null,
         studio ? "KYBER Studio (local execution + management routes)" : null,
+        studio ? "cards, artifacts and heads-ups (each person opts in)" : null,
         engineer ? "engineer subagent (workshop + vision loop)" : null,
         compPlan ? "its own computer (desktop + Chrome, watch and take over)" : null,
         compPlan ? "its own vault (logins and cards it fills without seeing)" : null,

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/studio-core.d.ts

@@ -0,0 +1,68 @@
+/**
+ * What a person gets from an agent in KYBER Studio and on the phone beyond
+ * words: cards under a reply (the `show` tool), pages the agent makes and
+ * keeps (artifacts), and heads-ups it sends on its own (magic, off for each
+ * person until they turn it on). Core on every agent since 2026-10-23 (Ian:
+ * "they ship with every single agent").
+ *
+ * Keyed on @kybernesis/manage, like notify: manage serves the artifact pages
+ * and owns the conversation magic delivers into, so without it neither has
+ * anywhere to land. Every agent the provisioner builds has it (--studio).
+ *
+ * Each one's marker is its own package. An agent that already has it, added
+ * by hand or customised (Sid's own delivery map), is never touched.
+ */
+export declare const STUDIO_CORE: readonly [{
+    readonly item: "cards";
+    readonly pkg: "@kybernesis/cards";
+    readonly what: "cards under its replies";
+}, {
+    readonly item: "artifacts";
+    readonly pkg: "@kybernesis/artifacts";
+    readonly what: "pages it makes and keeps";
+}, {
+    readonly item: "magic";
+    readonly pkg: "@kybernesis/magic";
+    readonly what: "heads-ups, off until each person turns them on";
+}];
+export type StudioCoreItem = (typeof STUDIO_CORE)[number];
+/** The core items this agent is missing, in install order. None without manage. */
+export declare function missingStudioCore(deps: Record<string, string>): StudioCoreItem[];
+/**
+ * The additions an upgrade would make, for `kyb upgrade --check`.
+ *
+ * Without them the Update button stays hidden on an agent whose packages are
+ * all current, which is exactly the agent these were built after. `resolve`
+ * names the build that would install; one that resolves to nothing is left
+ * out, because nothing published runs on this eve.
+ */
+export declare function planStudioCore(deps: Record<string, string>, resolve: (pkg: string) => string | undefined): Array<{
+    name: string;
+    from: string;
+    to: string;
+}>;
+/**
+ * Where magic delivers on an agent that also answers on iMessage through Linq.
+ *
+ * The registry's map sends every heads-up into the conversation Studio and the
+ * phone share. A person who last texted the agent should get it in that same
+ * thread instead (Linq thread ids start with "linq:").
+ */
+export declare function magicSurfacesLinqTs(): string;
+/**
+ * Point magic at Linq when this agent has a Linq channel. Only ever called
+ * right after the registry wrote its default map, so nothing hand-made is lost.
+ */
+export declare function wireMagicLinq(cwd: string): boolean;
+/**
+ * Keep magic's per-person state out of git. `.kyb/magic/people/<id>/` holds
+ * what each person turned on and what they were told; it belongs to the host.
+ */
+export declare function ignoreMagicState(cwd: string): boolean;
+/**
+ * Install each missing core item from the agent's own @kybernesis registry,
+ * the same way `eve add` would by hand: its package and its files. Returns
+ * what was added; a failure is said and skipped, and the eval gate after it
+ * judges the agent as it stands.
+ */
+export declare function repairStudioCore(cwd: string, deps: Record<string, string>): StudioCoreItem[];

package/dist/studio-core.js

@@ -0,0 +1,124 @@
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { dim, green, run, yellow } from "./util.js";
+/**
+ * What a person gets from an agent in KYBER Studio and on the phone beyond
+ * words: cards under a reply (the `show` tool), pages the agent makes and
+ * keeps (artifacts), and heads-ups it sends on its own (magic, off for each
+ * person until they turn it on). Core on every agent since 2026-10-23 (Ian:
+ * "they ship with every single agent").
+ *
+ * Keyed on @kybernesis/manage, like notify: manage serves the artifact pages
+ * and owns the conversation magic delivers into, so without it neither has
+ * anywhere to land. Every agent the provisioner builds has it (--studio).
+ *
+ * Each one's marker is its own package. An agent that already has it, added
+ * by hand or customised (Sid's own delivery map), is never touched.
+ */
+export const STUDIO_CORE = [
+    { item: "cards", pkg: "@kybernesis/cards", what: "cards under its replies" },
+    { item: "artifacts", pkg: "@kybernesis/artifacts", what: "pages it makes and keeps" },
+    { item: "magic", pkg: "@kybernesis/magic", what: "heads-ups, off until each person turns them on" },
+];
+/** The core items this agent is missing, in install order. None without manage. */
+export function missingStudioCore(deps) {
+    if (!deps["@kybernesis/manage"])
+        return [];
+    return STUDIO_CORE.filter((core) => !deps[core.pkg]);
+}
+/**
+ * The additions an upgrade would make, for `kyb upgrade --check`.
+ *
+ * Without them the Update button stays hidden on an agent whose packages are
+ * all current, which is exactly the agent these were built after. `resolve`
+ * names the build that would install; one that resolves to nothing is left
+ * out, because nothing published runs on this eve.
+ */
+export function planStudioCore(deps, resolve) {
+    return missingStudioCore(deps).flatMap((core) => {
+        const version = resolve(core.pkg);
+        return version ? [{ name: core.pkg, from: "none", to: version }] : [];
+    });
+}
+/**
+ * Where magic delivers on an agent that also answers on iMessage through Linq.
+ *
+ * The registry's map sends every heads-up into the conversation Studio and the
+ * phone share. A person who last texted the agent should get it in that same
+ * thread instead (Linq thread ids start with "linq:").
+ */
+export function magicSurfacesLinqTs() {
+    return `import type { MagicDispatch } from "@kybernesis/magic";
+import type { ScheduleToFn } from "eve/schedules";
+import kyb from "../channels/kyb.js";
+import linq from "../channels/linq.js";
+
+/**
+ * Where a heads-up is delivered: the conversation the person last used.
+ *
+ * A person who last texted this agent gets it in that same iMessage thread
+ * (Linq thread ids start with "linq:"). Everyone else gets it in the
+ * conversation Studio and the phone app share, which rings their phone.
+ */
+export function deliver(to: ScheduleToFn, dispatch: MagicDispatch) {
+  const { surface, packet } = dispatch;
+  if (surface.token?.startsWith("linq:")) {
+    return to(linq, { threadId: surface.token }).send(packet, { auth: surface.auth });
+  }
+  return to(kyb, { routine: "magic" }).send(packet, { auth: surface.auth });
+}
+`;
+}
+/**
+ * Point magic at Linq when this agent has a Linq channel. Only ever called
+ * right after the registry wrote its default map, so nothing hand-made is lost.
+ */
+export function wireMagicLinq(cwd) {
+    if (!existsSync(join(cwd, "agent/channels/linq.ts")))
+        return false;
+    const surfaces = join(cwd, "agent/lib/magic-surfaces.ts");
+    if (!existsSync(surfaces))
+        return false;
+    writeFileSync(surfaces, magicSurfacesLinqTs());
+    return true;
+}
+/**
+ * Keep magic's per-person state out of git. `.kyb/magic/people/<id>/` holds
+ * what each person turned on and what they were told; it belongs to the host.
+ */
+export function ignoreMagicState(cwd) {
+    const path = join(cwd, ".gitignore");
+    const current = existsSync(path) ? readFileSync(path, "utf8") : "";
+    if (current.split("\n").some((line) => /^\/?\.kyb\/?$/.test(line.trim())))
+        return false;
+    appendFileSync(path, `${current && !current.endsWith("\n") ? "\n" : ""}.kyb\n`);
+    return true;
+}
+/**
+ * Install each missing core item from the agent's own @kybernesis registry,
+ * the same way `eve add` would by hand: its package and its files. Returns
+ * what was added; a failure is said and skipped, and the eval gate after it
+ * judges the agent as it stands.
+ */
+export function repairStudioCore(cwd, deps) {
+    const added = [];
+    for (const core of missingStudioCore(deps)) {
+        const ok = run("npx", ["eve", "add", `@kybernesis/${core.item}`, "--yes"], { cwd, allowFail: true, quiet: true });
+        if (!ok) {
+            console.log(`  ${yellow("!")} could not add ${core.pkg} (${core.what}). Run: npx eve add @kybernesis/${core.item}`);
+            continue;
+        }
+        deps[core.pkg] = "latest";
+        added.push(core);
+        if (core.item === "magic") {
+            ignoreMagicState(cwd);
+            if (wireMagicLinq(cwd))
+                console.log(`    ${dim("magic delivers into iMessage threads too (agent/lib/magic-surfaces.ts)")}`);
+        }
+    }
+    if (added.length > 0) {
+        console.log(`  ${green("+")} Added ${added.map((core) => `${core.pkg} ${dim(`(${core.what})`)}`).join(", ")}`);
+        console.log(`    ${dim("Takes effect after the next build and restart.")}\n`);
+    }
+    return added;
+}

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

@@ -12,8 +12,10 @@ 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 { planStudioCore, repairStudioCore } from "./studio-core.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";
@@ -598,11 +600,11 @@ 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, "\\$&");
-    // The provider may be made inline (`model: createAnthropic({ … }).evaluationModel(…)`)
+    // 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];
@@ -665,7 +667,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`], {
@@ -675,27 +677,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");
@@ -890,6 +891,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) {
@@ -1045,13 +1087,22 @@ 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" })),
+                // Packages every agent now ships with that this one predates: an
+                // upgrade adds them, so the Update button has to show them.
+                ...planStudioCore(deps, (name) => newestBuildForEve(name, EVE_VERSION)),
+            ],
             resetsConversations: eveChanged,
         });
         return;
@@ -1062,6 +1113,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) {
@@ -1079,12 +1139,24 @@ export async function upgrade(options = {}) {
         repairHostArtifacts(cwd, deps);
         repairEvalCommand(cwd);
         repairNotifySetup(cwd, deps);
+        const added = repairStudioCore(cwd, deps);
         repairReasoningSandboxes(cwd, deps);
         repairManageRestart(cwd, deps);
         repairExeClaudeRoutes(cwd, deps);
+        reportSourceMigration(cwd);
+        if (added.length === 0)
+            return;
+        // New tools and a schedule on a live agent: the same gate as any upgrade.
+        run("npm", ["run", "typecheck"], { cwd });
+        if (options.skipEval) {
+            console.log(yellow("\nEval gate SKIPPED (--skip-eval). Run `npm run eval` before deploying.\n"));
+            return;
+        }
+        await runUpgradeEvalGate(cwd, options.host);
         return;
     }
     console.log(bold(`\nInstalling: ${changed.join(", ")}\n`));
+    reportManifestMigration(manifest);
     let stoppedBridge = null;
     if (cleanInstall && deps["@kybernesis/buzz"]) {
         const stopped = stopActiveBridge(cwd, buzzBridgeUnit(cwd));
@@ -1092,6 +1164,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 {
@@ -1108,28 +1192,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}`;
@@ -1171,9 +1239,11 @@ export async function upgrade(options = {}) {
     repairHostArtifacts(cwd, deps);
     repairEvalCommand(cwd);
     repairNotifySetup(cwd, deps);
+    repairStudioCore(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 });
@@ -1183,5 +1253,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.4",
+  "version": "0.26.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,7 +39,7 @@
   },
   "devDependencies": {
     "@types/node": "24.x",
-    "eve": "0.68.0",
+    "eve": "0.81.1",
     "typescript": "7.0.2"
   },
   "engines": {

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).