@kybernesis/create 0.15.4 → 0.15.6

package/dist/doctor.js

@@ -6,6 +6,7 @@ import { 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";
+import { countAbandonedRuns } from "./run-store.js";
 import { checkSelfVersion } from "./self-version.js";
 const MARK = {
     pass: green("✓"),
@@ -125,6 +126,21 @@ export async function doctor() {
     if (selfVersion.kind === "stale") {
         add("warn", selfVersion.message, selfVersion.fix);
     }
+    /**
+     * Durable runs nothing will ever finish. They are replayed at every boot and
+     * eve removes none of them, so this only ever grows until something retires
+     * them. Reported rather than fixed: the remedy restarts the agent, which is
+     * not something a diagnostic should do behind someone's back.
+     */
+    const runs = countAbandonedRuns(cwd);
+    if (runs) {
+        if (runs.abandoned === 0) {
+            add("pass", `durable run store is clean (${runs.total} runs, ${runs.held} held by a hook)`);
+        }
+        else {
+            add("warn", `${runs.abandoned} abandoned durable run(s) of ${runs.total} — replayed at every boot, never removed`, "scripts/safe-restart.sh, or reclaimAbandonedRuns() from @kybernesis/exe. Runs a hook still holds (routine sessions) are never retired.");
+        }
+    }
     // ── project shape ──────────────────────────────────────────────────────
     if (!existsSync(join(cwd, "agent"))) {
         console.error(red("Not an eve agent project (no agent/ directory). Run inside the agent repo."));

package/dist/run-store.d.ts

@@ -0,0 +1,22 @@
+/**
+ * How many durable runs this host is carrying that nothing will ever finish
+ * (KYB-546).
+ *
+ * eve leaves a run in `running` when a session, turn or task is abandoned, and
+ * ships nothing that retires them. They accumulate — four figures per host after
+ * a month — and every one is replayed at boot. After a durable-runtime change
+ * those replays diverge, are declared CORRUPTED_EVENT_LOG, and the conversation
+ * is dead for good.
+ *
+ * Reimplemented here rather than imported from @kybernesis/exe: doctor runs in
+ * repos that do not depend on exe, and a diagnostic that cannot run where the
+ * problem is is not a diagnostic. It only counts — retiring is exe's job.
+ */
+export interface RunStoreCount {
+    abandoned: number;
+    /** Held by a hook token: routine sessions live here and must never be retired. */
+    held: number;
+    total: number;
+}
+/** Count abandoned runs under an agent's `.eve/.workflow-data`, or null when there is no store. */
+export declare function countAbandonedRuns(cwd: string, olderThanDays?: number, now?: Date): RunStoreCount | null;

package/dist/run-store.js

@@ -0,0 +1,63 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+/** Count abandoned runs under an agent's `.eve/.workflow-data`, or null when there is no store. */
+export function countAbandonedRuns(cwd, olderThanDays = 2, now = new Date()) {
+    const data = join(cwd, ".eve", ".workflow-data");
+    const runsDir = join(data, "runs");
+    let names;
+    try {
+        names = readdirSync(runsDir).filter((n) => n.endsWith(".json"));
+    }
+    catch {
+        return null;
+    }
+    const held = new Set();
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const full = join(dir, e.name);
+            if (e.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (!e.name.endsWith(".json"))
+                continue;
+            try {
+                const d = JSON.parse(readFileSync(full, "utf8"));
+                if (typeof d.runId === "string" && d.runId !== "")
+                    held.add(d.runId);
+            }
+            catch {
+                // Unreadable hook: count nothing rather than guess a run is unheld.
+            }
+        }
+    };
+    walk(join(data, "hooks"));
+    const threshold = olderThanDays * 86_400_000;
+    const out = { abandoned: 0, held: 0, total: names.length };
+    for (const name of names) {
+        let run;
+        try {
+            run = JSON.parse(readFileSync(join(runsDir, name), "utf8"));
+        }
+        catch {
+            continue;
+        }
+        if (run.status !== "running")
+            continue;
+        if (typeof run.runId === "string" && held.has(run.runId)) {
+            out.held += 1;
+            continue;
+        }
+        const updated = typeof run.updatedAt === "string" ? Date.parse(run.updatedAt) : NaN;
+        if (Number.isFinite(updated) && now.getTime() - updated >= threshold)
+            out.abandoned += 1;
+    }
+    return out;
+}

package/dist/upgrade.js

@@ -977,10 +977,28 @@ export async function upgrade(options = {}) {
     // reason rewriteManifest pins it: npm would save a caret by default.
     const eveChange = changed.find((spec) => spec.startsWith("eve@"));
     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;
+    };
     const installArgs = cleanInstall ? ["install"] : ["install", ...others];
-    let installed = cleanInstall || others.length > 0 ? commandResult("npm", installArgs, cwd) : { status: 0, stdout: "", stderr: "" };
+    let installed = cleanInstall || others.length > 0 ? npmInstall(installArgs) : { status: 0, stdout: "", stderr: "" };
     if (installed.status === 0 && !cleanInstall && eveChange) {
-        installed = commandResult("npm", ["install", "--save-exact", eveChange], cwd);
+        installed = npmInstall(["install", "--save-exact", eveChange]);
     }
     if (installed.status !== 0) {
         const output = `${installed.stdout}\n${installed.stderr}`;

package/package.json

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