@kybernesis/create 0.14.2 → 0.14.3

package/dist/agent-limits.d.ts

@@ -0,0 +1,30 @@
+/** Eve 0.49's root default when the compiled config omits the policy. */
+export declare const CERTIFIED_INHERITED_MAX_INPUT_TOKENS_PER_SESSION = 40000000;
+export type AgentInputLimit = {
+    kind: "explicit-numeric";
+    value: number;
+} | {
+    kind: "explicit-uncapped";
+} | {
+    kind: "inherited";
+    value: typeof CERTIFIED_INHERITED_MAX_INPUT_TOKENS_PER_SESSION;
+} | {
+    kind: "unresolved";
+    reason: string;
+};
+export interface EveInfoInspection {
+    diagnostics: {
+        errors: number;
+        warnings: number;
+    } | null;
+    status: string | null;
+    limit: AgentInputLimit;
+}
+/**
+ * Read the effective root policy from Eve's compiled artifact, never from
+ * authored TypeScript. The 40M fallback is certified only when that artifact
+ * truly omits maxInputTokensPerSession.
+ */
+export declare function parseEveInfoInspection(output: string, readText?: (path: string) => string): EveInfoInspection;
+/** Compile once through Eve's structured info contract and inspect its artifact. */
+export declare function inspectEveAgent(cwd: string, env?: Record<string, string>): EveInfoInspection | null;

package/dist/agent-limits.js

@@ -0,0 +1,86 @@
+import { readFileSync } from "node:fs";
+import { capture } from "./util.js";
+/** Eve 0.49's root default when the compiled config omits the policy. */
+export const CERTIFIED_INHERITED_MAX_INPUT_TOKENS_PER_SESSION = 40_000_000;
+/**
+ * Read the effective root policy from Eve's compiled artifact, never from
+ * authored TypeScript. The 40M fallback is certified only when that artifact
+ * truly omits maxInputTokensPerSession.
+ */
+export function parseEveInfoInspection(output, readText = (path) => readFileSync(path, "utf8")) {
+    let info;
+    try {
+        info = JSON.parse(output);
+    }
+    catch (error) {
+        return unresolved(`eve info --json was not valid JSON: ${error.message}`);
+    }
+    const diagnostics = parseDiagnostics(info.diagnostics);
+    const status = typeof info.status === "string" ? info.status : null;
+    const manifestPath = info.artifacts && typeof info.artifacts.compiledManifest === "string"
+        ? info.artifacts.compiledManifest
+        : null;
+    if (!manifestPath) {
+        return { diagnostics, status, limit: { kind: "unresolved", reason: "compiled manifest path was unavailable" } };
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(readText(manifestPath));
+    }
+    catch (error) {
+        return {
+            diagnostics,
+            status,
+            limit: { kind: "unresolved", reason: `compiled manifest could not be read: ${error.message}` },
+        };
+    }
+    if (!isRecord(manifest) || !isRecord(manifest.config)) {
+        return { diagnostics, status, limit: { kind: "unresolved", reason: "compiled root config was unavailable" } };
+    }
+    const limits = manifest.config.limits;
+    if (limits === undefined) {
+        return inherited(diagnostics, status);
+    }
+    if (!isRecord(limits)) {
+        return { diagnostics, status, limit: { kind: "unresolved", reason: "compiled root limits were malformed" } };
+    }
+    if (!Object.hasOwn(limits, "maxInputTokensPerSession")) {
+        return inherited(diagnostics, status);
+    }
+    const value = limits.maxInputTokensPerSession;
+    if (value === false)
+        return { diagnostics, status, limit: { kind: "explicit-uncapped" } };
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return { diagnostics, status, limit: { kind: "explicit-numeric", value } };
+    }
+    return {
+        diagnostics,
+        status,
+        limit: { kind: "unresolved", reason: "compiled maxInputTokensPerSession was neither a positive number nor false" },
+    };
+}
+/** Compile once through Eve's structured info contract and inspect its artifact. */
+export function inspectEveAgent(cwd, env) {
+    const output = capture("npx", ["eve", "info", "--json"], cwd, env);
+    return output === null ? null : parseEveInfoInspection(output);
+}
+function parseDiagnostics(value) {
+    if (!isRecord(value))
+        return null;
+    return typeof value.errors === "number" && typeof value.warnings === "number"
+        ? { errors: value.errors, warnings: value.warnings }
+        : null;
+}
+function inherited(diagnostics, status) {
+    return {
+        diagnostics,
+        status,
+        limit: { kind: "inherited", value: CERTIFIED_INHERITED_MAX_INPUT_TOKENS_PER_SESSION },
+    };
+}
+function unresolved(reason) {
+    return { diagnostics: null, status: null, limit: { kind: "unresolved", reason } };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/doctor.d.ts

@@ -1,3 +1,4 @@
+import { type AgentInputLimit } from "./agent-limits.js";
 type Verdict = "pass" | "warn" | "fail";
 export interface Check {
     verdict: Verdict;
@@ -16,6 +17,7 @@ export interface DockerTemplateInspection {
     }[];
 }
 export declare function dockerTemplateDoctorChecks(result: DockerTemplateInspection): Check[];
+export declare function agentInputLimitDoctorCheck(limit: AgentInputLimit): Check;
 /**
  * The inspector lives in @kybernesis/exe, next to the runtime that owns the
  * templates; create already resolves that package's scripts out of

package/dist/doctor.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { bold, capture, dim, green, parseEnv, red, yellow } from "./util.js";
 import { diagnoseManageRestart, findMatchingAgentServiceUnit } from "./systemd.js";
+import { inspectEveAgent } from "./agent-limits.js";
 const MARK = {
     pass: green("✓"),
     warn: yellow("!"),
@@ -30,6 +31,26 @@ export function dockerTemplateDoctorChecks(result) {
         detail: issue.detail,
     }));
 }
+export function agentInputLimitDoctorCheck(limit) {
+    switch (limit.kind) {
+        case "explicit-numeric":
+            return { verdict: "pass", label: `Eve max input tokens/session: ${limit.value.toLocaleString("en-US")} (explicit)` };
+        case "explicit-uncapped":
+            return { verdict: "pass", label: "Eve max input tokens/session: uncapped (explicit)" };
+        case "inherited":
+            return {
+                verdict: "warn",
+                label: `Eve max input tokens/session: ${limit.value.toLocaleString("en-US")} (inherited default)`,
+                detail: "set limits.maxInputTokensPerSession explicitly in the root agent; use false only when the host policy intentionally permits an uncapped session",
+            };
+        case "unresolved":
+            return {
+                verdict: "warn",
+                label: "Eve max input tokens/session: unresolved",
+                detail: limit.reason,
+            };
+    }
+}
 /**
  * The inspector lives in @kybernesis/exe, next to the runtime that owns the
  * templates; create already resolves that package's scripts out of
@@ -481,16 +502,19 @@ export async function doctor() {
      * `env` here is the same merged view every other check reads: .env.local
      * underneath, the real environment on top.
      */
-    const info = capture("npx", ["eve", "info"], cwd, env);
+    const info = inspectEveAgent(cwd, env);
     if (info === null) {
-        add("fail", "eve info failed", "run: set -a && . ./.env.local && set +a && npx eve info — the agent's own error is in that output");
+        add("fail", "eve info failed", "run: set -a && . ./.env.local && set +a && npx eve info --json — the agent's own error is in that output");
+        add("warn", "Eve max input tokens/session: unresolved", "eve info failed before the compiled root policy could be inspected");
     }
     else {
-        const diag = /Diagnostics\s+(\d+) errors?, (\d+) warnings?/.exec(info);
-        if (diag && diag[1] === "0")
-            add("pass", `eve discovery clean (${diag[2]} warnings)`);
+        const diag = info.diagnostics;
+        if (diag && diag.errors === 0)
+            add("pass", `eve discovery clean (${diag.warnings} warnings)`);
         else
-            add("fail", `eve discovery: ${diag ? `${diag[1]} errors` : "unparsed"}`, "npx eve info");
+            add("fail", `eve discovery: ${diag ? `${diag.errors} errors` : "unparsed"}`, "npx eve info --json");
+        const limitCheck = agentInputLimitDoctorCheck(info.limit);
+        add(limitCheck.verdict, limitCheck.label, limitCheck.detail);
     }
     const portBusy = capture("lsof", ["-ti", ":2000"]);
     if (portBusy && portBusy.trim())

package/dist/templates.js

@@ -366,6 +366,8 @@ import { exeModel } from "@kybernesis/exe";
 export default defineAgent({
   model: exeModel({ model: process.env.EXE_MODEL ?? ${JSON.stringify(model)}, createOpenAI }),
   modelContextWindowTokens: 200_000,
+  // This long-lived self-hosted process has no metered platform session ceiling.
+  limits: { maxInputTokensPerSession: false },
 });
 `;
     }

package/dist/upgrade.d.ts

@@ -1 +1,3 @@
+import { type AgentInputLimit } from "./agent-limits.js";
+export declare function agentInputLimitUpgradeMessage(limit: AgentInputLimit): string;
 export declare function upgrade(skipEval: boolean): Promise<void>;

package/dist/upgrade.js

@@ -5,7 +5,8 @@ import { reconcileHostArtifact } from "./host-artifacts.js";
 import { repairManageRestart } from "./systemd.js";
 import { repairTerminalSandboxCleanupHooks } from "./sandbox-cleanup.js";
 import { repairRemovedDefaultTools as repairRemovedDefaultTools_ } from "./removed-default-tools.js";
-import { EVE_VERSION, bold, capture, dim, green, red, run, yellow } from "./util.js";
+import { EVE_VERSION, bold, capture, dim, green, parseEnv, red, run, yellow } from "./util.js";
+import { inspectEveAgent } from "./agent-limits.js";
 /**
  * Which packages to upgrade: every `@kybernesis/*` this agent depends on.
  *
@@ -61,6 +62,32 @@ function warnIfStale() {
         `compiled into this tool, so an old kyb reports an old pin as current.`);
     console.log(`    ${dim("npm install -g @kybernesis/create@latest")}\n`);
 }
+export function agentInputLimitUpgradeMessage(limit) {
+    switch (limit.kind) {
+        case "explicit-numeric":
+            return `Eve max input tokens/session: ${limit.value.toLocaleString("en-US")} (explicit; unchanged)`;
+        case "explicit-uncapped":
+            return "Eve max input tokens/session: uncapped (explicit; unchanged)";
+        case "inherited":
+            return `Eve max input tokens/session: ${limit.value.toLocaleString("en-US")} inherited — set limits.maxInputTokensPerSession explicitly in agent/agent.ts; upgrade will not rewrite authored source`;
+        case "unresolved":
+            return `Eve max input tokens/session: unresolved (${limit.reason}); authored source was not changed`;
+    }
+}
+function reportAgentInputLimit(cwd) {
+    const envPath = join(cwd, ".env.local");
+    const env = {
+        ...(existsSync(envPath) ? parseEnv(readFileSync(envPath, "utf8")) : {}),
+        ...process.env,
+    };
+    const inspection = inspectEveAgent(cwd, env);
+    const limit = inspection?.limit ?? {
+        kind: "unresolved",
+        reason: "eve info --json failed",
+    };
+    const marker = limit.kind === "inherited" || limit.kind === "unresolved" ? yellow("!") : green("✓");
+    console.log(`  ${marker} ${agentInputLimitUpgradeMessage(limit)}`);
+}
 /**
  * Raise the local queue's delivery timeouts on an agent that already exists.
  *
@@ -309,6 +336,8 @@ export async function upgrade(skipEval) {
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     console.log(bold("\nkyb upgrade — checking @kybernesis/* and eve against npm\n"));
     warnIfStale();
+    // Read-only: report the compiled effective policy, never rewrite agent/agent.ts.
+    reportAgentInputLimit(cwd);
     // Env-only, so it is safe before anything is installed.
     repairLocalQueueTimeouts(cwd, deps);
     const toUpgrade = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/create",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "description": "The Kybernesis agent scaffolder and FDE toolkit: one command to a governed, remembering, multiplayer, self-testing eve agent — plus doctor and upgrade.",
   "license": "Apache-2.0",
   "type": "module",