@kybernesis/create 0.18.1 → 0.20.0

package/dist/doctor.d.ts

@@ -20,7 +20,7 @@ export interface DockerTemplateInspection {
     }[];
 }
 export declare function dockerTemplateDoctorChecks(result: DockerTemplateInspection): Check[];
-export declare function modelReachDoctorCheck(authoredSource: string | null, compiledRouting: CompiledModelRouting): Check;
+export declare function modelReachDoctorCheck(authoredSource: string | null, compiledRouting: CompiledModelRouting, env?: Record<string, string | undefined>): Check;
 export declare function agentInputLimitDoctorCheck(limit: AgentInputLimit): Check;
 export declare function diskUsageDoctorCheck(percent: number, dockerSummary: string | null): Check;
 /**

package/dist/doctor.js

@@ -47,8 +47,13 @@ export function dockerTemplateDoctorChecks(result) {
         detail: issue.detail,
     }));
 }
-export function modelReachDoctorCheck(authoredSource, compiledRouting) {
-    const reach = classifyModelReach(authoredSource, compiledRouting);
+export function modelReachDoctorCheck(authoredSource, compiledRouting, env = {}) {
+    const check = modelReachCheck(classifyModelReach(authoredSource, compiledRouting, env));
+    return authoredSource !== null && /\bexeModelReach\s*\(/.test(authoredSource)
+        ? { ...check, label: `${check.label} [KYB_MODEL_REACH switch]` }
+        : check;
+}
+function modelReachCheck(reach) {
     switch (reach.kind) {
         case "claude-sub":
             return { verdict: "pass", label: "Model reach: claude-sub (Claude subscription)" };
@@ -289,7 +294,10 @@ export async function doctor() {
     // iMessage or Telegram should never be told to create a Slack connector.
     const hasSlackChannel = existsSync(join(cwd, "agent/channels/slack.ts"));
     if (hasSlackChannel) {
-        if (env.SLACK_CONNECTOR_UID)
+        const slackSource = readFileSync(join(cwd, "agent/channels/slack.ts"), "utf8");
+        if (slackSource.includes("controlPlaneSlackCredentials"))
+            add("pass", "Slack via the control plane (this agent's own Slack app)", "the owner adds it from the Channels page");
+        else if (env.SLACK_CONNECTOR_UID)
             add("pass", `Slack connector uid: ${env.SLACK_CONNECTOR_UID}`, "verify trigger path /eve/v1/slack (vercel connect list)");
         else if (env.SLACK_BOT_TOKEN)
             add("pass", "Slack via portable credentials (SLACK_BOT_TOKEN)");
@@ -653,7 +661,7 @@ export async function doctor() {
         const reachCheck = modelReachDoctorCheck(rootAgentSource, {
             kind: "unresolved",
             reason: "eve info failed before compiled model routing could be inspected",
-        });
+        }, env);
         add(reachCheck.verdict, reachCheck.label, reachCheck.detail);
         add("warn", "Eve max input tokens/session: unresolved", "eve info failed before the compiled root policy could be inspected");
     }
@@ -663,7 +671,7 @@ export async function doctor() {
             add("pass", `eve discovery clean (${diag.warnings} warnings)`);
         else
             add("fail", `eve discovery: ${diag ? `${diag.errors} errors` : "unparsed"}`, "npx eve info --json");
-        const reachCheck = modelReachDoctorCheck(rootAgentSource, info.modelRouting);
+        const reachCheck = modelReachDoctorCheck(rootAgentSource, info.modelRouting, env);
         add(reachCheck.verdict, reachCheck.label, reachCheck.detail);
         const limitCheck = agentInputLimitDoctorCheck(info.limit);
         add(limitCheck.verdict, limitCheck.label, limitCheck.detail);

package/dist/init.js

@@ -132,17 +132,12 @@ export async function init(rawName, options = {}) {
     for (const item of CORE_ITEMS) {
         run("npx", ["eve", "add", `@kybernesis/${item}`, "--overwrite"], { cwd: dir });
     }
-    // Anthropic is always the exe eval judge and is also the claude-sub agent
-    // provider. OpenAI is needed only by the ordinary exeModel gateway route.
+    // 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.
     const extraDeps = [
         ...plan.deps,
-        ...(host === "exe"
-            ? [
-                "@kybernesis/exe",
-                ...(model.reach === "default" ? ["@ai-sdk/openai"] : []),
-                "@ai-sdk/anthropic",
-            ]
-            : []),
+        ...(host === "exe" ? ["@kybernesis/exe", "@ai-sdk/openai", "@ai-sdk/anthropic"] : []),
     ];
     if (extraDeps.length) {
         console.log(bold(`\n2b   Installing for ${channel}/${host}: ${extraDeps.join(", ")} …`));

package/dist/model-reach.d.ts

@@ -39,8 +39,15 @@ export declare function resolveModelScaffold(options: {
     envReach?: string;
     model?: string;
 }): ModelScaffoldConfig;
+/**
+ * The route an `exeModelReach` agent takes at boot: KYB_MODEL_REACH when it is
+ * one that can run, else the authored `reach`. The same rules as
+ * `resolveExeReach` in @kybernesis/exe (declared here so create keeps zero
+ * runtime deps); change both together.
+ */
+export declare function switchedModelReach(source: string, env: Record<string, string | undefined>): DoctorModelReach | null;
 /**
  * Classify the effective route from stable authored helpers first, then Eve's
  * compiled routing. Provider=anthropic alone is not evidence of a subscription.
  */
-export declare function classifyModelReach(authoredSource: string | null, compiledRouting: CompiledModelRouting): DoctorModelReach;
+export declare function classifyModelReach(authoredSource: string | null, compiledRouting: CompiledModelRouting, env?: Record<string, string | undefined>): DoctorModelReach;

package/dist/model-reach.js

@@ -27,12 +27,46 @@ export function resolveModelScaffold(options) {
     }
     return { reach, model };
 }
+/**
+ * The route an `exeModelReach` agent takes at boot: KYB_MODEL_REACH when it is
+ * one that can run, else the authored `reach`. The same rules as
+ * `resolveExeReach` in @kybernesis/exe (declared here so create keeps zero
+ * runtime deps); change both together.
+ */
+export function switchedModelReach(source, env) {
+    if (!/\bexeModelReach\s*\(/.test(source))
+        return null;
+    const authored = /\breach\s*:\s*["'](gateway|byok|claude-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] ?? "";
+    const route = (reach) => {
+        if (reach === "gateway")
+            return { kind: "exe" };
+        if (reach === "claude-sub")
+            return { kind: "claude-sub" };
+        if (reach !== "byok")
+            return null;
+        const provider = /^(anthropic|openai)\//.exec(model)?.[1];
+        if (!provider)
+            return null;
+        return env[provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY"]?.trim()
+            ? { kind: "direct-provider", provider }
+            : null;
+    };
+    const requested = env[MODEL_REACH_ENV]?.trim();
+    const chosen = requested ? route(requested) : null;
+    return chosen ?? route(authored) ?? { kind: "direct-provider", ...(/^(anthropic|openai)\//.exec(model) ? { provider: model.split("/")[0] } : {}) };
+}
 /**
  * Classify the effective route from stable authored helpers first, then Eve's
  * compiled routing. Provider=anthropic alone is not evidence of a subscription.
  */
-export function classifyModelReach(authoredSource, compiledRouting) {
+export function classifyModelReach(authoredSource, compiledRouting, env = {}) {
     if (authoredSource !== null) {
+        const switched = switchedModelReach(authoredSource, env);
+        if (switched)
+            return switched;
         const claudeSubscription = /\bclaudeSubscription\s*\(/.test(authoredSource);
         const exeModel = /\bexeModel\s*\(/.test(authoredSource);
         const grokSubscription = /\bgrokSubscription\s*\(/.test(authoredSource);

package/dist/templates.js

@@ -260,19 +260,23 @@ export function channelPlan(kind, name, host) {
             return {
                 file: "slack.ts",
                 content: onExe
-                    ? `import { multiplayerSlackChannel } from "@kybernesis/multiplayer/slack";
-import { forwardedSocketVerifier } from "@kybernesis/exe/slack";
-
-// Slack on a self-hosted (exe.dev) host.
-// Inbound: a forwarder holds the exe-brokered Socket Mode connection and POSTs
-// events here; the verifier authenticates them on SLACK_SOCKET_FORWARDING_SECRET.
-// Outbound: SLACK_BOT_TOKEN must be on the host — eve's SlackChannelCredentials
-// has no apiUrl, so calls can't route through the exe integration yet.
+                    ? `import { channelIdentity } from "@kybernesis/enterprise";
+import { controlPlaneSlackCredentials, multiplayerSlackChannel } from "@kybernesis/multiplayer/slack";
+
+// Slack as this agent's own Slack app: its own name, @handle and picture in the
+// customer's workspace. The control plane makes the app and keeps its signing
+// secret and bot token in the customer's org; this channel reads them with the
+// agent credential at call time, so installing or removing the app from the
+// Channels page needs no restart and nothing Slack-related lives on this host.
+//
+// Every sender is a control-plane person, never a bare Slack user: an unlinked
+// one gets a private DM with a one-time claim link and nothing else.
+const issuer = process.env.KYBERNESIS_ISSUER ?? "https://agent.kybernesis.ai";
+const credential = process.env.KYBERNESIS_AGENT_CREDENTIAL;
+
 export default multiplayerSlackChannel({
-  credentials: {
-    botToken: process.env.SLACK_BOT_TOKEN!,
-    webhookVerifier: forwardedSocketVerifier(),
-  },
+  credentials: controlPlaneSlackCredentials({ issuer, credential }),
+  identity: credential ? channelIdentity({ issuer, credential }) : null,
 });
 `
                     : `import { connectSlackCredentials } from "@vercel/connect/eve";
@@ -284,20 +288,13 @@ export default multiplayerSlackChannel({
   credentials: connectSlackCredentials(process.env.SLACK_CONNECTOR_UID!),
 });
 `,
-                deps: ["@kybernesis/multiplayer", ...(onExe ? ["@kybernesis/exe"] : ["@vercel/connect"])],
+                deps: onExe ? ["@kybernesis/multiplayer@^0.6.0", "@kybernesis/enterprise"] : ["@kybernesis/multiplayer", "@vercel/connect"],
                 registryItems: [],
-                env: onExe
-                    ? [
-                        `SLACK_BOT_TOKEN="xoxb-..."   # outbound; from Slack OAuth & Permissions`,
-                        `SLACK_SOCKET_FORWARDING_SECRET="$(openssl rand -hex 24)"`,
-                    ]
-                    : [`SLACK_CONNECTOR_UID="slack/${name}"`],
+                env: onExe ? [] : [`SLACK_CONNECTOR_UID="slack/${name}"`],
                 steps: onExe
                     ? [
-                        `Create a Slack app (Socket Mode on; scopes: app_mentions:read, chat:write, channels:history, groups:history, im:history, users:read)`,
-                        `Hold its tokens off-host: ssh exe.dev integrations add slack --name ${name} --bot-token=- --app-token=-`,
-                        `Run the forwarder (scripts/slack-forwarder.py in @kybernesis/exe) with EXE_SLACK_GW set`,
-                        `After ANY scope change, reinstall the app — a stale token silently stops receiving events`,
+                        `Make the host public so Slack can reach /eve/v1/slack (ssh exe.dev share set-public <vm>)`,
+                        `The control plane makes this agent's Slack app; the owner adds it to their workspace from the Channels page`,
                     ]
                     : [
                         `vercel connect create slack --triggers --name ${name}`,
@@ -305,40 +302,72 @@ export default multiplayerSlackChannel({
                     ],
             };
         case "imessage":
-            return {
-                file: "photon.ts",
-                content: `import { photonIMessageChannel } from "eve/channels/photon";
-${onExe ? `import { photonEnvCredentials } from "@kybernesis/exe/photon";\n` : ""}
+            return onExe
+                ? {
+                    file: "linq.ts",
+                    content: `import { channelIdentity } from "@kybernesis/enterprise";
+import { linqEnvCredentials, linqSenderIdentity } from "@kybernesis/exe/linq";
+import { linqChannel } from "eve/channels/linq";
+
+// iMessage and SMS via the customer's own Linq account. Inbound is a signed
+// webhook at /eve/v1/linq. The owner connects a line from the Channels page
+// (the manage linq.signup and linq.verify actions), which writes LINQ_API_KEY
+// and LINQ_WEBHOOK_SECRET and registers this host's webhook.
+//
+// A sender is a control-plane person, never a phone number: an unlinked number
+// gets one text with a claim link and nothing else.
+const issuer = process.env.KYBERNESIS_ISSUER ?? "https://agent.kybernesis.ai";
+const credential = process.env.KYBERNESIS_AGENT_CREDENTIAL;
+const agentName = process.env.KYBERNESIS_AGENT;
+
+export default linqChannel({
+  credentials: linqEnvCredentials(),
+  ...(agentName ? { userName: agentName } : {}),
+  onMessage: linqSenderIdentity({
+    issuer,
+    agentName,
+    identity: credential ? channelIdentity({ issuer, credential }) : null,
+  }),
+});
+`,
+                    deps: ["@kybernesis/exe", "@kybernesis/enterprise"],
+                    registryItems: [],
+                    env: [],
+                    steps: [
+                        `Make the host public so Linq can reach /eve/v1/linq (ssh exe.dev share set-public <vm>)`,
+                        `The owner connects a line from the Channels page; it signs up their own Linq account with their email`,
+                    ],
+                }
+                : {
+                    file: "photon.ts",
+                    content: `import { photonIMessageChannel } from "eve/channels/photon";
+
 // iMessage via Photon. Inbound is a plain webhook at /eve/v1/photon; the Photon
 // signing secret takes precedence over the default Vercel-OIDC verifier, so this
 // works on any host with a public HTTPS URL.
 export default photonIMessageChannel({
-${onExe
-                    ? `  credentials: photonEnvCredentials(),`
-                    : `  async credentials() {
+  async credentials() {
     const projectId = process.env.IMESSAGE_PROJECT_ID;
     const projectSecret = process.env.IMESSAGE_PROJECT_SECRET;
     if (!projectId || !projectSecret) throw new Error("Photon project credentials are required.");
     return { projectId, projectSecret };
-  },`}
+  },
   webhookSecret: process.env.IMESSAGE_WEBHOOK_SECRET,
 });
 `,
-                deps: onExe ? ["@kybernesis/exe"] : [],
-                registryItems: [],
-                env: [
-                    `IMESSAGE_PROJECT_ID="..."`,
-                    `IMESSAGE_PROJECT_SECRET="..."`,
-                    `IMESSAGE_WEBHOOK_SECRET="..."   # Photon webhook signing secret`,
-                ],
-                steps: [
-                    `Create a Photon project and register the phone number (npx eve add channel/photon-imessage walks it)`,
-                    onExe
-                        ? `Make the host public FIRST — webhooks need anonymous access:\n       ssh exe.dev share port <vm> 8000 && ssh exe.dev share set-public <vm>`
-                        : `Deploy so the public URL exists`,
-                    `Register a Photon webhook for https://<your-host>/eve/v1/photon and copy its signing secret to IMESSAGE_WEBHOOK_SECRET`,
-                ],
-            };
+                    deps: [],
+                    registryItems: [],
+                    env: [
+                        `IMESSAGE_PROJECT_ID="..."`,
+                        `IMESSAGE_PROJECT_SECRET="..."`,
+                        `IMESSAGE_WEBHOOK_SECRET="..."   # Photon webhook signing secret`,
+                    ],
+                    steps: [
+                        `Create a Photon project and register the phone number (npx eve add channel/photon-imessage walks it)`,
+                        `Deploy so the public URL exists`,
+                        `Register a Photon webhook for https://<your-host>/eve/v1/photon and copy its signing secret to IMESSAGE_WEBHOOK_SECRET`,
+                    ],
+                };
         case "telegram":
             return {
                 file: "telegram.ts",
@@ -392,36 +421,38 @@ export default discordChannel({ botToken: process.env.DISCORD_BOT_TOKEN! });
 }
 /** One renderer for every model-bearing generated agent, root or subagent. */
 function agentModelTemplate(host, config) {
-    if (config.reach === "claude-sub") {
-        if (host !== "exe")
-            throw new Error("claude-sub model templates require an exe host");
-        return {
-            imports: `import { createAnthropic } from "@ai-sdk/anthropic";\n` +
-                `import { CLAUDE_SUBSCRIPTION_CONTEXT_WINDOW, claudeSubscription } from "@kybernesis/exe";\n\n`,
-            fields: `  model: claudeSubscription({ model: ${JSON.stringify(config.model)}, createAnthropic }),\n` +
-                `  modelContextWindowTokens: CLAUDE_SUBSCRIPTION_CONTEXT_WINDOW,\n`,
-        };
-    }
+    if (config.reach === "claude-sub" && host !== "exe")
+        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
+         * exactly what this scaffold used to hard-code.
+         *
+         * The subscription scaffold still names a gateway id, used only if the
+         * agent is switched to the gateway or BYOK with no EXE_MODEL set.
+         */
+        const defaults = config.reach === "claude-sub"
+            ? `reach: "claude-sub", model: ${JSON.stringify(`anthropic/${config.model}`)}`
+            : `reach: "gateway", model: ${JSON.stringify(config.model)}`;
         return {
-            // createAnthropic: the gateway serves Claude on Messages only, so an
-            // anthropic/* EXE_MODEL through the OpenAI client answers 404.
             imports: `import { createAnthropic } from "@ai-sdk/anthropic";\n` +
                 `import { createOpenAI } from "@ai-sdk/openai";\n` +
-                `import { exeModel } from "@kybernesis/exe";\n\n`,
-            fields: `  model: exeModel({ model: process.env.EXE_MODEL ?? ${JSON.stringify(config.model)}, createOpenAI, createAnthropic }),\n` +
-                `  modelContextWindowTokens: 200_000,\n`,
+                `import { exeModelReach } from "@kybernesis/exe";\n\n`,
+            fields: `  ...exeModelReach({ ${defaults}, createOpenAI, createAnthropic }),\n`,
         };
     }
     return { imports: "", fields: `  model: ${JSON.stringify(config.model)},\n` };
 }
 export function hostAgentTs(host, model) {
     const rendered = agentModelTemplate(host, model);
-    const comment = model.reach === "claude-sub"
-        ? `// Claude subscription model through the loopback OAuth proxy — no API key or exe gateway.\n`
-        : host === "exe"
-            ? `// Model served by the exe.dev LLM integration — no provider key on the host.\n// exe injects the credential (managed gateway, your API key, or a connected\n// ChatGPT subscription) server-side.\n`
-            : "";
+    const comment = host !== "exe"
+        ? ""
+        : (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`;
     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` : ""}});

package/dist/upgrade.js

@@ -607,7 +607,7 @@ export async function preflightEvalGate(cwd) {
     const reach = classifyModelReach(authoredSource, inspection?.modelRouting ?? {
         kind: "unresolved",
         reason: "eve info failed before compiled model routing could be inspected",
-    });
+    }, env);
     const reasons = [];
     switch (reach.kind) {
         case "claude-sub":

package/package.json

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

@@ -82,8 +82,25 @@ then `eve add @kybernesis/<item>`). Each covers one axis:
 - **manage** — the other direction: `manageChannel()` lets Studio install
   capabilities and write schedules onto a running agent, and `routineTools()`
   turns "every morning at 8, brief me" into a real schedule file. This is how a
-  routine gets created from chat without anyone touching the repo.
-- **exe** — running off Vercel. `exeModel()` for exe.dev's LLM integration,
+  routine gets created from chat without anyone touching the repo. The registry
+  item writes `create_routine`, `list_routines` and `delete_routine` into
+  `agent/tools/` (sharing `agent/lib/routines.ts`, which reads the restart from
+  `agent/channels/kyb.ts`), so `kyb init --studio` agents have them. Since 0.11
+  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
+  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`,
+  `claude-sub`) for agents authored with exe's `exeModelReach()`, and status
+  reports the route that will boot (with `fallback` when the request can't run).
+- **exe** — running off Vercel. `exeModelReach()` (0.16+, what `kyb init
+  --host=exe` writes from create 0.19) picks gateway, BYOK or the Claude
+  subscription from `KYB_MODEL_REACH` at boot and falls back to the authored
+  default rather than fail to start. `exeModel()` for exe.dev's LLM integration,
   `grokSubscription()` / `readGrokCredential()` for a SuperGrok or X Premium+
   login (`grok login` → `~/.grok/auth.json`, a valid bearer for api.x.ai —
   same shape as eve's `experimental_chatgpt()`), `hostPreflight()`, Photon