@kybernesis/create 0.21.0 → 0.23.0

package/dist/add.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { bold, dim, green, red, run, yellow } from "./util.js";
 import { addBuzz } from "./buzz.js";
+import { applyDispatch, applyEngineer, modelConfigOf } from "./capabilities.js";
 import { CHANNEL_KINDS, arcanaMemorySlotTs, channelPlan } from "./templates.js";
 /**
  * `kyb add channel <kind>` — put another surface on an agent that already exists.
@@ -26,11 +27,15 @@ export async function add(what, rest) {
     // the provisioner and people naturally type, so both spellings land here.
     if (what === "buzz" || (what === "channel" && rest.find((a) => !a.startsWith("-")) === "buzz"))
         return addBuzz();
+    if (what === "dispatch" || what === "engineer")
+        return addCapability(what);
     if (what !== "channel") {
         console.error(red(`kyb add: don't know how to add "${what ?? ""}".`));
         console.log(dim(`  kyb add channel <${CHANNEL_KINDS.filter((k) => k !== "none").join("|")}>`));
         console.log(dim(`  kyb add memory   ${dim("— an eve 0.49 memory slot backed by Arcana (recall before every turn)")}`));
         console.log(dim(`  kyb add buzz     ${dim("— the agent's own Buzz identity, tools and bridge, ready for its owner's community")}`));
+        console.log(dim(`  kyb add dispatch ${dim("— call and be called by the agents the control plane allows (governed edges)")}`));
+        console.log(dim(`  kyb add engineer ${dim("— the builder subagent: workshop sandbox, vision dev loop, file delivery")}`));
         process.exitCode = 1;
         return;
     }
@@ -145,3 +150,35 @@ export function addMemory(cwd = resolve(process.cwd())) {
     console.log(dim(`    recall before every turn from ARCANA_COMPANY_WORKSPACE; capture off; ${extensionMounted ? "tools from the extension" : "remember/recall/search as memory__* tools"}`));
     console.log(dim("    needs eve >= 0.49 and @kybernesis/arcana >= 0.4 — kyb upgrade carries both. Then: npx eve info"));
 }
+/**
+ * `kyb add dispatch` / `kyb add engineer` — what `kyb init` now builds in, put
+ * on an agent scaffolded before it did. Same code path as init, so an added
+ * capability is the same files a new agent gets.
+ */
+function addCapability(what) {
+    const dir = resolve(process.cwd());
+    if (!existsSync(join(dir, "package.json")) || !existsSync(join(dir, "agent"))) {
+        console.error(red(`kyb add ${what}: run this inside an agent directory.`));
+        process.exitCode = 1;
+        return;
+    }
+    const host = existsSync(join(dir, "scripts/eve-server.sh")) ? "exe" : "vercel";
+    console.log(bold(`kyb add ${what}`));
+    console.log(dim(`  agent: ${agentNameOf(dir)}\n  host:  ${host}`));
+    if (what === "dispatch") {
+        for (const file of applyDispatch(dir))
+            console.log(green(`  + ${file}`));
+    }
+    else {
+        if (existsSync(join(dir, "agent/subagents/builder"))) {
+            console.log(yellow("  agent/subagents/builder already exists — leaving it alone."));
+            return;
+        }
+        const { files, steps } = applyEngineer(dir, host, modelConfigOf(dir));
+        for (const file of files)
+            console.log(green(`  + ${file}`));
+        if (steps.length)
+            console.log(`\n${bold("Then:")}\n${steps.map((s, i) => `  ${i + 1}. ${s}`).join("\n")}`);
+    }
+    console.log(dim("\n  Type-check, build and restart the agent for it to take effect."));
+}

package/dist/capabilities.d.ts

@@ -0,0 +1,22 @@
+import { type HostKind } from "./templates.js";
+import type { ModelScaffoldConfig } from "./model-reach.js";
+/**
+ * Agent-to-agent: the eve channel becomes the governed dispatch door (people
+ * still come in through kybernesisAuth in the same walk) and granted peers
+ * become tools. arpAuth is put back into the walk when the agent has the
+ * identity item, since the new channel replaces the file that carried it.
+ */
+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.
+ */
+export declare function applyEngineer(dir: string, host: HostKind, model: ModelScaffoldConfig): {
+    files: string[];
+    steps: string[];
+};
+/**
+ * The model config an existing agent was authored with, read back from its
+ * agent/agent.ts, so a builder added later runs the same route as its root.
+ */
+export declare function modelConfigOf(dir: string): ModelScaffoldConfig;

package/dist/capabilities.js

@@ -0,0 +1,73 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { finalizeGithubToolsRegistryMount, wireArpAuth } from "./init.js";
+import { DISPATCH_DEP, dispatchEveChannelTs, dispatchPeersTs, engineerPlan } from "./templates.js";
+import { run, yellow } from "./util.js";
+/**
+ * The capabilities every company agent carries, applied the same way by
+ * `kyb init` and by `kyb add` on an agent built before they were standard.
+ * Each returns what it wrote, so `add` can report it.
+ */
+// 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_VERCEL = ["connection/vercel"];
+function write(dir, path, content) {
+    const full = join(dir, path);
+    mkdirSync(join(full, ".."), { recursive: true });
+    writeFileSync(full, content);
+}
+/**
+ * Agent-to-agent: the eve channel becomes the governed dispatch door (people
+ * still come in through kybernesisAuth in the same walk) and granted peers
+ * become tools. arpAuth is put back into the walk when the agent has the
+ * identity item, since the new channel replaces the file that carried it.
+ */
+export function applyDispatch(dir) {
+    run("npm", ["install", DISPATCH_DEP, "--no-audit", "--no-fund"], { cwd: dir, allowFail: true });
+    let channel = dispatchEveChannelTs();
+    if (existsSync(join(dir, "agent/channels/arp.ts")))
+        channel = wireArpAuth(channel) ?? channel;
+    write(dir, "agent/channels/eve.ts", channel);
+    write(dir, "agent/tools/peers.ts", dispatchPeersTs());
+    return ["agent/channels/eve.ts", "agent/tools/peers.ts"];
+}
+/**
+ * The engineer: a declared `builder` subagent with its own workshop sandbox,
+ * memory and skills, plus the browser and GitHub tools at the root.
+ */
+export function applyEngineer(dir, host, model) {
+    const plan = engineerPlan(host, model);
+    run("npm", ["install", ...plan.deps, "--no-audit", "--no-fund"], { cwd: dir, allowFail: true });
+    const items = [...ENGINEER_ITEMS_ALL, ...(host === "vercel" ? ENGINEER_ITEMS_VERCEL : [])];
+    for (const item of items) {
+        const ok = run("npx", ["eve", "add", item, "--overwrite"], { cwd: dir, allowFail: true });
+        if (item === "extension/github-tools")
+            finalizeGithubToolsRegistryMount(dir, ok);
+        if (!ok)
+            console.log(yellow(`  ! ${item} did not install cleanly — re-run: npx eve add ${item}`));
+    }
+    for (const file of plan.files)
+        write(dir, file.path, file.content);
+    // A declared subagent sees none of the root's skills, so the memory skills
+    // its instructions name are copied in beside it.
+    const skills = join(dir, "node_modules/@kybernesis/arcana/dist/extension/skills");
+    if (existsSync(skills))
+        cpSync(skills, join(dir, "agent/subagents/builder/skills"), { recursive: true });
+    else
+        console.log(yellow(`  ! arcana skills not found at ${skills} — copy them into agent/subagents/builder/skills`));
+    return { files: plan.files.map((f) => f.path), steps: plan.steps };
+}
+/**
+ * The model config an existing agent was authored with, read back from its
+ * agent/agent.ts, so a builder added later runs the same route as its root.
+ */
+export function modelConfigOf(dir) {
+    const source = existsSync(join(dir, "agent/agent.ts")) ? readFileSync(join(dir, "agent/agent.ts"), "utf8") : "";
+    const reach = /\breach\s*:\s*["']([a-z-]+)["']/.exec(source)?.[1];
+    const model = /\bmodel\s*:\s*["']([^"']+)["']/.exec(source)?.[1];
+    if (reach === "claude-sub")
+        return { reach: "claude-sub", model: (model ?? "claude-opus-5").replace(/^anthropic\//, "") };
+    return { reach: "default", model: model ?? "anthropic/claude-sonnet-5" };
+}

package/dist/cli.js

@@ -222,7 +222,7 @@ ${bold("kyb")} ${dim(VERSION)} — Kybernesis agent scaffolder & FDE toolkit
 ${dim("  Every command below exists in this build. If one is missing, the install is older than the docs:")}
 ${dim("  npm i -g @kybernesis/create@latest")}
 
-  ${bold("kyb init [name]")}     scaffold a Kybernesis eve agent (core: enterprise + arcana + evals)
+  ${bold("kyb init [name]")}     scaffold a Kybernesis eve agent (core: enterprise + arcana + dispatch + evals)
       --channel=<kind>  ${dim("none|slack|imessage|telegram|discord|web  (default: none)")}
       --host=<kind>     ${dim("vercel|exe                                (default: vercel)")}
       --subagents=a,b   ${dim("department subagents                      (default: none)")}
@@ -235,6 +235,8 @@ ${dim("  npm i -g @kybernesis/create@latest")}
       ${dim("slack|imessage|telegram|discord|web — writes the channel, deps and env")}
   ${bold("kyb add buzz")}        ${dim("the agent's own Buzz identity, tools and bridge (connected from the Channels page)")}
   ${bold("kyb add memory")}      ${dim("eve 0.49 memory slot backed by Arcana: recall before every turn")}
+  ${bold("kyb add dispatch")}    ${dim("agent-to-agent: governed door + control-plane peers as tools")}
+  ${bold("kyb add engineer")}    ${dim("the builder subagent: workshop sandbox, vision dev loop, delivery")}
   ${bold("kyb doctor")}          preflight checks (keys, issuer, envs, discovery)
   ${bold("kyb skills")}          install/refresh the FDE skill suite for Claude Code
       --global          ${dim("install to ~/.claude/skills instead of this repo")}

package/dist/doctor.js

@@ -61,6 +61,8 @@ function modelReachCheck(reach) {
             return { verdict: "pass", label: "Model reach: exe (host LLM integration)" };
         case "grok-sub":
             return { verdict: "pass", label: "Model reach: grok-sub (direct xAI subscription credential)" };
+        case "chatgpt-sub":
+            return { verdict: "pass", label: "Model reach: chatgpt-sub (ChatGPT subscription through Codex)" };
         case "gateway":
             return { verdict: "pass", label: "Model reach: gateway" };
         case "direct-provider":

package/dist/init.js

@@ -1,8 +1,9 @@
 import { appendFileSync, chmodSync, copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { DEFAULT_ISSUER, EVE_VERSION, REGISTRY_URL, ask, bold, closePrompts, dim, green, run, slug, red, yellow, } from "./util.js";
-import { CHANNEL_KINDS, channelPlan, computerPlan, engineerPlan, envExample, evalFileTs, exeEvalConfigTs, evalScript, hostAgentTs, hostSteps, githubToolsMountTs, identityMd, rootArcanaTs, subagentAgentTs, subagentArcanaTs, subagentInstructionsMd, } from "./templates.js";
+import { CHANNEL_KINDS, channelPlan, computerPlan, envExample, evalFileTs, exeEvalConfigTs, evalScript, hostAgentTs, hostSteps, githubToolsMountTs, identityMd, rootArcanaTs, subagentAgentTs, subagentArcanaTs, subagentInstructionsMd, } from "./templates.js";
 import { suiteDir } from "./skills.js";
+import { applyDispatch, applyEngineer } from "./capabilities.js";
 import { configureArcana } from "./arcana.js";
 import { upsertEnv } from "./envfile.js";
 import { systemdRestartCommand } from "./systemd.js";
@@ -21,11 +22,6 @@ const CORE_ITEMS = ["enterprise", "arcana", "evals", "identity"];
 // Vercel function cannot keep a desktop alive, so there — and only there —
 // both are skipped, and init says so out loud.
 const CORE_EXE_ITEMS = ["vault"];
-// 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_VERCEL = ["connection/vercel"];
 /**
  * Replace Eve's freshly installed registry mount with the Kybernesis-managed
  * token-aware form. A failed registry add must not create a capability file.
@@ -132,6 +128,9 @@ export async function init(rawName, options = {}) {
     for (const item of CORE_ITEMS) {
         run("npx", ["eve", "add", `@kybernesis/${item}`, "--overwrite"], { cwd: dir });
     }
+    // Core too: other agents the company allows can call this one, and it can
+    // call them, governed by edges granted in the control plane.
+    applyDispatch(dir);
     // Anthropic is always the exe eval judge. Both providers are installed on
     // every exe agent: exeModelReach can be switched to any route at boot, and
     // between them the routes call both.
@@ -177,18 +176,10 @@ export async function init(rawName, options = {}) {
                 `    This agent cannot be connected to a desktop until they install.`));
         }
     }
-    const engPlan = engineer ? engineerPlan(host, model) : null;
-    if (engPlan) {
+    let engSteps = [];
+    if (engineer) {
         console.log(bold("\n2c   Engineer subagent: workshop sandbox + vision dev loop …"));
-        run("npm", ["install", ...engPlan.deps, "--no-audit", "--no-fund"], { cwd: dir, allowFail: true });
-        const engItems = [...ENGINEER_ITEMS_ALL, ...(host === "vercel" ? ENGINEER_ITEMS_VERCEL : [])];
-        for (const item of engItems) {
-            const ok = run("npx", ["eve", "add", item, "--overwrite"], { cwd: dir, allowFail: true });
-            if (item === "extension/github-tools")
-                finalizeGithubToolsRegistryMount(dir, ok);
-            if (!ok)
-                console.log(yellow(`  ! ${item} did not install cleanly — re-run: npx eve add ${item}`));
-        }
+        engSteps = applyEngineer(dir, host, model).steps;
     }
     const compPlan = host === "exe" ? computerPlan(name) : null;
     if (host !== "exe") {
@@ -382,13 +373,6 @@ export async function init(rawName, options = {}) {
         mkdirSync(join(full, ".."), { recursive: true });
         writeFileSync(full, file.content);
     }
-    if (engPlan) {
-        for (const file of engPlan.files) {
-            const full = join(dir, file.path);
-            mkdirSync(join(full, ".."), { recursive: true });
-            writeFileSync(full, file.content);
-        }
-    }
     if (compPlan) {
         for (const file of compPlan.files) {
             const full = join(dir, file.path);
@@ -412,6 +396,7 @@ export async function init(rawName, options = {}) {
         : yellow("  ! verify manually: npm run typecheck && npx eve info"));
     const parts = [
         "governed (enterprise)",
+        "agent-to-agent (dispatch)",
         "remembering (arcana)",
         "self-testing (evals)",
         channel === "none" ? null : `${channel} channel`,
@@ -427,7 +412,7 @@ export async function init(rawName, options = {}) {
         `Arcana: create workspaces (${name}-company, ${name}-eval${depts.map((d) => `, ${name}-${d}`).join("")}) + scoped kb_ keys; fill .env.local from .env.example`,
         ...hostSteps(host, name, model),
         ...plan.steps,
-        ...(engPlan?.steps ?? []),
+        ...engSteps,
         ...(compPlan?.steps ?? []),
         `Control plane: register agent "${name}" at ${issuer}/agents + grant the pilot cohort`,
         `npm run eval → green → deploy → live smoke + the revoke demo`,

package/dist/model-reach.d.ts

@@ -21,6 +21,8 @@ export type DoctorModelReach = {
     kind: "exe";
 } | {
     kind: "grok-sub";
+} | {
+    kind: "chatgpt-sub";
 } | {
     kind: "gateway";
 } | {

package/dist/model-reach.js

@@ -1,3 +1,6 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 export const MODEL_REACH_ENV = "KYB_MODEL_REACH";
 export const CLAUDE_SUBSCRIPTION_MODEL = "claude-opus-5";
 /** Resolve the one-shot scaffold selector. An explicit CLI value wins over Factory env. */
@@ -36,7 +39,7 @@ export function resolveModelScaffold(options) {
 export function switchedModelReach(source, env) {
     if (!/\bexeModelReach\s*\(/.test(source))
         return null;
-    const authored = /\breach\s*:\s*["'](gateway|byok|claude-sub)["']/.exec(source)?.[1];
+    const authored = /\breach\s*:\s*["'](gateway|byok|claude-sub|grok-sub|chatgpt-sub)["']/.exec(source)?.[1];
     if (!authored)
         return { kind: "unresolved", reason: "exeModelReach has no literal default reach to read" };
     const model = env.EXE_MODEL ?? /\bmodel\s*:\s*["']([^"']+)["']/.exec(source)?.[1] ?? "";
@@ -45,6 +48,18 @@ export function switchedModelReach(source, env) {
             return { kind: "exe" };
         if (reach === "claude-sub")
             return { kind: "claude-sub" };
+        // Runs only once `grok login` has left a credential; the agent falls back otherwise.
+        if (reach === "grok-sub") {
+            const auth = env.GROK_AUTH_PATH?.trim() || join(homedir(), ".grok", "auth.json");
+            return existsSync(auth) ? { kind: "grok-sub" } : null;
+        }
+        // Needs eve's chatgpt passed in, and a Codex sign-in on the host.
+        if (reach === "chatgpt-sub") {
+            if (!/\bchatgpt\s*[,}]/.test(source))
+                return null;
+            const auth = join(env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "auth.json");
+            return existsSync(auth) ? { kind: "chatgpt-sub" } : null;
+        }
         if (reach !== "byok")
             return null;
         const provider = /^(anthropic|openai)\//.exec(model)?.[1];

package/dist/templates.d.ts

@@ -41,6 +41,12 @@ export declare function channelPlan(kind: ChannelKind, name: string, host: HostK
 export type HostKind = "vercel" | "exe";
 export declare function hostAgentTs(host: HostKind, model: ModelScaffoldConfig): string;
 export declare function hostSteps(host: HostKind, name: string, model: ModelScaffoldConfig): string[];
+/** agent/channels/eve.ts: people, granted agents, and the local eval runner, through one door. */
+export declare function dispatchEveChannelTs(): string;
+/** agent/tools/peers.ts: every agent this one may call, as tools, resolved per turn. */
+export declare function dispatchPeersTs(): string;
+/** Pinned to the eve line the scaffold certifies, like every other @kybernesis dep it installs. */
+export declare const DISPATCH_DEP = "@kybernesis/dispatch@^0.7.0";
 export interface EngineerPlan {
     files: Array<{
         path: string;
@@ -49,6 +55,20 @@ export interface EngineerPlan {
     deps: string[];
     steps: string[];
 }
+/**
+ * What the builder is told. A declared subagent inherits nothing from the
+ * root, instructions included, so without this it builds with no idea it is
+ * briefed second-hand, that it remembers, or where its authority stops.
+ * Agent-facing prose: no agent or company names, it ships to every customer.
+ */
+export declare function builderInstructionsMd(): string;
+/**
+ * The builder's memory: the company brain the root uses, not a workspace of
+ * its own. A company agent has one brain, and the agent that builds was the one
+ * remembering nothing about what it built. ARCANA_BUILDER_WORKSPACE splits it
+ * off for an agent that wants a separate one.
+ */
+export declare function builderArcanaTs(): string;
 export declare function engineerPlan(host: HostKind, model: ModelScaffoldConfig): EngineerPlan;
 /**
  * The eval judge, for an exe.dev host.

package/dist/templates.js

@@ -425,9 +425,10 @@ function agentModelTemplate(host, config) {
         throw new Error("claude-sub model templates require an exe host");
     if (host === "exe") {
         /**
-         * Every exe agent takes the runtime switch: KYB_MODEL_REACH (gateway, byok
-         * or claude-sub) picks the route at boot, so the setup route can change it
-         * by writing env. `reach` here is what runs while it is unset, which is
+         * Every exe agent takes the runtime switch: KYB_MODEL_REACH (gateway, byok,
+         * claude-sub, grok-sub or chatgpt-sub) picks the route at boot, so the
+         * setup route can change it by writing env. `chatgpt` is passed so the
+         * ChatGPT subscription is one of those routes; nothing calls it until then. `reach` here is what runs while it is unset, which is
          * exactly what this scaffold used to hard-code.
          *
          * The subscription scaffold still names a gateway id, used only if the
@@ -439,8 +440,9 @@ function agentModelTemplate(host, config) {
         return {
             imports: `import { createAnthropic } from "@ai-sdk/anthropic";\n` +
                 `import { createOpenAI } from "@ai-sdk/openai";\n` +
+                `import { chatgpt } from "eve/models/openai";\n` +
                 `import { exeModelReach } from "@kybernesis/exe";\n\n`,
-            fields: `  ...exeModelReach({ ${defaults}, createOpenAI, createAnthropic }),\n`,
+            fields: `  ...exeModelReach({ ${defaults}, createOpenAI, createAnthropic, chatgpt }),\n`,
         };
     }
     return { imports: "", fields: `  model: ${JSON.stringify(config.model)},\n` };
@@ -452,7 +454,7 @@ export function hostAgentTs(host, model) {
         : (model.reach === "claude-sub"
             ? `// By default a Claude subscription through the loopback OAuth proxy — no API key or exe gateway.\n`
             : `// By default the exe.dev LLM integration — no provider key on the host; exe\n// injects the credential (managed gateway, your API key, or a connected\n// ChatGPT subscription) server-side.\n`) +
-            `// KYB_MODEL_REACH (gateway | byok | claude-sub) switches the route at boot\n// without editing this file; EXE_MODEL names the gateway or BYOK model.\n`;
+            `// KYB_MODEL_REACH (gateway | byok | claude-sub | grok-sub | chatgpt-sub) switches the route at boot\n// without editing this file; EXE_MODEL names the gateway or BYOK model.\n`;
     return `import { defineAgent } from "eve";
 ${rendered.imports}${comment}export default defineAgent({
 ${rendered.fields}${host === "exe" ? `  // This long-lived self-hosted process has no metered platform session ceiling.\n  limits: { maxInputTokensPerSession: false },\n` : ""}});
@@ -486,6 +488,62 @@ export function hostSteps(host, name, model) {
         `npx eve deploy`,
     ];
 }
+// ── Agent-to-agent (dispatch) ───────────────────────────────────────────
+// Every agent is reachable by the agents its company allows, and can call
+// them, with nothing named in code: the edge is granted in the control plane.
+// The receiving side is the eve channel itself, so it REPLACES the plain
+// governed channel the enterprise item writes; people still come in through
+// kybernesisAuth in the same walk.
+/** agent/channels/eve.ts: people, granted agents, and the local eval runner, through one door. */
+export function dispatchEveChannelTs() {
+    return `import { localDev } from "eve/channels/auth";
+import { dispatchChannel } from "@kybernesis/dispatch";
+import { kybernesisAuth } from "@kybernesis/enterprise";
+
+// One door, three kinds of caller, each its own decision:
+// - people, through KYBER Studio, the phone and the web app: kybernesisAuth
+//   admits only an identity session holding a grant on this agent;
+// - other agents: dispatchChannel's governed walk admits a short-lived A2A
+//   token minted for an edge granted in the control plane naming this agent
+//   as callee. Nothing is listed here; the grant lives in the control plane;
+// - the eval runner: localDev() accepts loopback only and is inert in
+//   production. Local evals send no credentials at all.
+//
+// KYBERNESIS_AGENT must match the control-plane registration exactly,
+// including case: the mint checks the callee by name.
+export default dispatchChannel({
+  governed: {
+    issuer: process.env.KYBERNESIS_ISSUER ?? "https://agent.kybernesis.ai",
+    agent: process.env.KYBERNESIS_AGENT!,
+  },
+  extraAuth: [
+    kybernesisAuth({
+      issuer: process.env.KYBERNESIS_ISSUER ?? "https://agent.kybernesis.ai",
+      agent: process.env.KYBERNESIS_AGENT!,
+    }),
+    localDev(),
+  ],
+});
+`;
+}
+/** agent/tools/peers.ts: every agent this one may call, as tools, resolved per turn. */
+export function dispatchPeersTs() {
+    return `import { governedPeers } from "@kybernesis/dispatch";
+
+// Every agent this one is ALLOWED to call, as tools, resolved from the control
+// plane at the start of each turn. Granting an edge there is the whole job:
+// the tool appears on the next turn and goes when the edge is revoked, with no
+// file to write and no redeploy.
+//
+// These calls carry THIS agent's identity. Where a peer holds personal data and
+// should answer as the person instead, declare it with remotePeer() under
+// agent/subagents/ (it forwards the principal) and list its name in
+// \`declared\` here so it is not offered twice.
+export default governedPeers();
+`;
+}
+/** Pinned to the eve line the scaffold certifies, like every other @kybernesis dep it installs. */
+export const DISPATCH_DEP = "@kybernesis/dispatch@^0.7.0";
 /** The workshop sandbox, per host. Same recipe; different backend. */
 function workshopSandbox(host) {
     if (host === "exe") {
@@ -597,6 +655,100 @@ export default defineSandbox(() =>
 );
 `;
 }
+/**
+ * What the builder is told. A declared subagent inherits nothing from the
+ * root, instructions included, so without this it builds with no idea it is
+ * briefed second-hand, that it remembers, or where its authority stops.
+ * Agent-facing prose: no agent or company names, it ships to every customer.
+ */
+export function builderInstructionsMd() {
+    return `# Identity
+
+You are the builder. You write and ship software: prototypes, deliverables,
+internal tools and fixes. You have the workshop: a sandbox with a shell, a
+filesystem, a browser you can see through, and file delivery.
+
+You receive fully briefed tasks from the agent you work for and never see the
+original conversation. Treat the message as the whole brief.
+
+# How you work
+
+Verify by looking. You can screenshot what you built. A page you have not
+looked at is a page you have not finished.
+
+Start dev servers detached. A foreground server blocks the turn and hangs the
+whole task.
+
+Say what you actually ran: commands, versions, what passed. "Should work" is not
+a report.
+
+Deliver, don't describe. When the output is a file, deliver it and give the
+plain URL. Markdown around a link breaks it in some chat apps.
+
+Stop at production. Preview deploys are yours; promoting to production is
+always a person's decision.
+
+# Memory
+
+You share the company's long-term memory (Arcana) through the \`arcana\`
+connection: recall, search, timeline, remember and brain notes.
+
+- Look it up before you start. Never claim something is unknown without
+  searching; an empty entity recall is not enough, so escalate to search.
+- Record what you built, what you tried that failed, and the decisions behind a
+  stack choice. A project shipped and forgotten teaches nobody.
+- Long-form material goes in a brain note: \`arcana_brain_write\` and
+  \`arcana_brain_add\`, always both, or nothing can find it.
+- Load the \`recall\`, \`remember\` or \`brain-note\` skill when the task
+  is more than one obvious call.
+
+# When the brief is thin
+
+Build anyway. You cannot ask anyone; the person who asked is one step removed.
+Take the most reasonable reading, say plainly what you assumed at the top, and
+build what that reading deserves.
+`;
+}
+/**
+ * The builder's memory: the company brain the root uses, not a workspace of
+ * its own. A company agent has one brain, and the agent that builds was the one
+ * remembering nothing about what it built. ARCANA_BUILDER_WORKSPACE splits it
+ * off for an agent that wants a separate one.
+ */
+export function builderArcanaTs() {
+    return `import { defineMcpClientConnection } from "eve/connections";
+
+// The company brain, shared with the root agent by design: knowing and doing
+// are different jobs, the memory is not. No placeholder: a builder quietly
+// addressing a workspace nobody owns is amnesia that looks like a model
+// problem. Set it with \`kyb arcana\`.
+const workspace = process.env.ARCANA_BUILDER_WORKSPACE ?? process.env.ARCANA_COMPANY_WORKSPACE;
+if (!workspace) {
+  throw new Error("ARCANA_COMPANY_WORKSPACE is not set — run \`kyb arcana\` to set the workspace and its key.");
+}
+
+export default defineMcpClientConnection({
+  url: "https://mcp.arcana.kybernesis.ai/mcp",
+  description:
+    "The company's long-term memory (Arcana), shared with the agent you work for: what was built, what was tried, what failed, and the decisions behind it.",
+  auth: {
+    getToken: async () => {
+      // The eval brain is a different workspace with its own key (Arcana keys
+      // answer 403 outside their own workspace), recognised by name.
+      const evalWorkspace = process.env.ARCANA_EVAL_WORKSPACE;
+      const isEval = evalWorkspace ? workspace === evalWorkspace : workspace.endsWith("-eval");
+      const token =
+        (isEval ? process.env.ARCANA_EVAL_API_KEY : undefined) ??
+        process.env.ARCANA_BUILDER_API_KEY ??
+        process.env.ARCANA_API_KEY;
+      if (!token) throw new Error("ARCANA_API_KEY is not set.");
+      return { token };
+    },
+  },
+  headers: { "X-Kyberagent-Agent": async () => workspace },
+});
+`;
+}
 export function engineerPlan(host, model) {
     const onExe = host === "exe";
     const renderedModel = agentModelTemplate(host, model);
@@ -650,6 +802,8 @@ export { default } from "@kybernesis/engineer";
             path: "agent/subagents/builder/sandbox/sandbox.ts",
             content: workshopSandbox(host),
         },
+        { path: "agent/subagents/builder/instructions.md", content: builderInstructionsMd() },
+        { path: "agent/subagents/builder/connections/arcana.ts", content: builderArcanaTs() },
     ];
     if (onExe) {
         files.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/create",
-  "version": "0.21.0",
+  "version": "0.23.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",

package/skills/kybernesis-packages/SKILL.md

@@ -89,9 +89,11 @@ then `eve add @kybernesis/<item>`). Each covers one axis:
   it also carries the owner's setup routes (`GET /eve/v1/kyb/setup`,
   `POST .../setup/env`, `POST .../setup/action`): a `manage` grant only;
   allowlisted env (`EXE_MODEL`, `EXE_LLM_URL`, `ANTHROPIC_API_KEY`,
-  `OPENAI_API_KEY`, `SLACK_BOT_TOKEN`, `SLACK_SIGNING_SECRET`) and the actions
-  `claude.login` (link, then the code on stdin), `linq.signup`/`linq.verify`,
-  `link.login` and `vnc.password`. Every change applies at one restart that
+  `OPENAI_API_KEY`, `SLACK_BOT_TOKEN`, `SLACK_SIGNING_SECRET`, and since 0.20
+  `KYBERNESIS_VOICE_OPENAI_KEY`, the owner's key for voice calls, with a `voice`
+  setup item shown when @kybernesis/voice is installed) and the actions
+  `claude.login` (link, then the code on stdin), `linq.signup`/`linq.verify`, `linq.contacts`/`linq.contact.add`/`linq.contact.remove` (who can text a shared line, 0.15),
+  `link.login`/`link.logout`, `wallet.add` (0.16: adds the payments item to an agent with a computer, rebuilds, rolls back on a failed build, restarts only after a good one), `linq.add` (0.18: the same for the iMessage channel, offered while `agent/channels/linq.ts` is missing, so an agent built without iMessage can answer the line it signs up), `slack.add` (0.19: the control-plane Slack channel via `kyb add channel slack`, offered to a registered agent on its own host with no Slack channel; the client then asks the control plane to make the agent's Slack app), `buzz.add` (0.19: `kyb add buzz` plus a build, answered 202 at once because the Buzz CLI build takes minutes; the `buzz` item reports `busy`, then the Buzz card or why it failed) and `vnc.password`. Every change applies at one restart that
   waits until no conversation is in flight (deploy.sh's count). A BYOK key only
   takes effect when `agent/agent.ts` uses that provider; status says so.
   Since 0.12 it also takes `KYB_MODEL_REACH` (`gateway`, `byok`,
@@ -129,7 +131,12 @@ then `eve add @kybernesis/<item>`). Each covers one axis:
   token, grants the person who ran it, idempotent by name),
   `deploy` (copy + install + restart + PROVE it; `eve deploy` on Vercel),
   `doctor`, `upgrade` (carries eve to the Kybernesis-CERTIFIED pin, never
-  blind latest), `skills`. Ships THIS skill suite.
+  blind latest), `skills`. Ships THIS skill suite. Since 0.23 every `init`
+  carries dispatch (the governed `agent/channels/eve.ts` plus
+  `agent/tools/peers.ts` = `governedPeers()`), and `--engineer` writes a
+  declared `builder` subagent with its own instructions, the company Arcana
+  connection and the memory skills. `kyb add dispatch` and `kyb add engineer`
+  retrofit an agent built before that.
 
 ## Gotchas that each cost a real debugging session