@vincemakes/kiso-code 0.31.0 → 0.32.0

package/dist/trust-ui.js

@@ -162,17 +162,38 @@ export function askUi(input) {
 export async function addDontAskAgainRule(rule) {
     const dir = extensionsDir();
     const file = join(dir, "dont-ask-again.mjs");
-    const existed = existsSync(file);
+    // §2.5: the LIVE extension, found by name in the array the chain reads.
+    // This is the only handle on the rules that is guaranteed to be the one
+    // in force, and finding it also tells us whether this is a first rule.
+    const at = currentAgentExtensions.findIndex((e) => e.name === "dont-ask-again");
+    const live = at >= 0 ? currentAgentExtensions[at] : undefined;
+    // Every rule the session already grants, plus this one (RL-F2: the file
+    // used to be rewritten with ONLY the newest rule, so a second grant
+    // erased the first from disk — invisible in-session, because the
+    // in-memory Set kept both, and only discovered at the next start).
+    //
+    // RL-F5: a file generated BEFORE this change exports RULES and puts
+    // nothing on the extension, so `live.rules` is undefined for it and a
+    // union starting from nothing would rewrite the file with this grant
+    // alone — every rule the human gave under 0.31.x gone, in exactly the
+    // way RL-F2 was invisible. The rules come out of the file instead, and
+    // the migration costs one grant.
+    const existing = live?.rules !== undefined ? [...live.rules] : rulesInFile(file);
+    const rules = [...new Set([...existing, rule])].sort();
     const module = [
         "// generated by kiso — the \"2 Yes, don't ask again for <tool>\" rule.",
         "// HUMAN-EDITABLE and HUMAN-DELETABLE — this file IS the revocation path:",
         "// delete a rule from the set (or the whole file) to be asked again.",
         "// ALLOW-ONLY by design (R3): never emits deny or ask — the mode moat",
         "// and the safe-defaults moat keep their teeth.",
-        `export const RULES = new Set(${JSON.stringify([rule])});`,
+        `const RULES = new Set(${JSON.stringify(rules)});`,
         "",
         "export default {",
         '  name: "dont-ask-again",',
+        "  // the live handle: kiso mutates THIS set to make a new rule take",
+        "  // effect without a reload. It is the same object the decide below",
+        "  // closes over, which is the whole point.",
+        "  rules: RULES,",
         "  approvals: [",
         "    {",
         "      decide(call) {",
@@ -185,21 +206,57 @@ export async function addDontAskAgainRule(rule) {
     ].join("\n");
     mkdirSync(dir, { recursive: true });
     writeFileSync(file, module, "utf8");
-    // The live in-session effect: a file that existed at startup was
-    // imported by the loader — ONE namespace — so mutating the exported
-    // RULES Set is live NOW (the current run's chain reads the same Set).
-    const mod = (await import(pathToFileURL(file).href));
-    if (mod.RULES !== undefined && !mod.RULES.has(rule))
-        mod.RULES.add(rule);
-    // A FIRST-time rule (a file that did not exist at startup) is not yet
-    // in the current run's chain — the chain is fixed at a run's start —
-    // so the generated extension joins the NEXT run's policies (run.ts
-    // re-reads the session config's extensions array, shared by
-    // reference). The honest story: a new rule applies from the next run.
-    if (!existed && mod.default !== undefined) {
+    // The live in-session effect. This used to re-import the plain file URL
+    // and mutate the module's exported Set, on the stated assumption that a
+    // file the loader imported is ONE namespace. §2.5's loader appends a
+    // per-load nonce so `/reload` can pick up edited code, and that
+    // assumption died with it: the loader holds `file?load=N` and a plain
+    // import is the startup namespace. A rule granted after any reload
+    // would mutate a Set nothing reads — the human clicks don't-ask-again
+    // and is asked again on the very next identical call.
+    //
+    // So there is no second import. The rule is added THROUGH the live
+    // extension, which is one source of truth by construction.
+    if (live?.rules !== undefined) {
+        live.rules.add(rule);
+        return;
+    }
+    // Either a FIRST rule (no such extension loaded) or the RL-F5 migration
+    // (a legacy extension is loaded but has no live handle). The freshly
+    // written file is imported and joins the chain — REPLACING the legacy
+    // entry rather than sitting beside it, because two extensions of the
+    // same name in the chain is a second source of truth and the whole point
+    // of the handle is that there is one. The chain is fixed at a run's
+    // start, so a first rule applies from the NEXT run (run.ts re-reads the
+    // session config's extensions array, shared by reference).
+    //
+    // The nonce is the loader's own lesson applied here: a plain file URL is
+    // cached forever, so a second grant in one process would import the
+    // bytes of the first.
+    const mod = (await import(`${pathToFileURL(file).href}?grant=${(grantSerial += 1)}`));
+    if (mod.default === undefined)
+        return;
+    if (at >= 0)
+        currentAgentExtensions[at] = mod.default;
+    else
         currentAgentExtensions.push(mod.default);
+}
+/** RL-F5 — the rules a generated file already holds. The `new Set([...])`
+ *  literal is JSON, which is what makes reading it back honest rather than
+ *  a parser. An unreadable or hand-edited-past-recognition file yields
+ *  nothing, and the new rule stands alone — the file is documented as
+ *  human-editable, so kiso must not fail on what a human wrote there. */
+function rulesInFile(file) {
+    try {
+        const m = /new Set\((\[[^\]]*\])\)/.exec(readFileSync(file, "utf8"));
+        return m === null ? [] : JSON.parse(m[1]);
+    }
+    catch {
+        return [];
     }
 }
+/** RL-F5: distinguishes each grant's import of the generated file. */
+let grantSerial = 0;
 /**
  * W21 — the §3.5 fix-hint table: per speaker, the ONE-line path to stop
  * being asked. The hint names the FIX, never a bypass ("switch to
@@ -309,8 +366,24 @@ function readMcpConfig(path) {
 }
 /** Merge user-level + project-level mcp.json into one temp file and point
  *  KISO_MCP_CONFIG at it — the mcp extension reads it at load time. */
+/**
+ * RL-F4 — the user mcp.json as it was BEFORE any merge, and RL-F1's exact
+ * sibling one function up. `applyMcpMerge` read `KISO_MCP_CONFIG` and then
+ * assigned the merged file to it, so a second merge — which is what a
+ * reload is — took the first merged file as the user config. That file
+ * already holds the project's servers, so the "exists in both" check
+ * throws for every one of them and EVERY reload fails in exactly the
+ * projects that carry MCP servers.
+ *
+ * Found by the lead reviewing the commit that fixed RL-F1 in the function
+ * below. The lesson is the sibling, not the loop: a defect found in one
+ * function is a question to ask of every function beside it, and I fixed
+ * one merge without looking at the other.
+ */
+let originalUserMcpPath;
 function applyMcpMerge(root) {
-    const userPath = process.env.KISO_MCP_CONFIG ?? join(kisoHome(), "mcp.json");
+    originalUserMcpPath ??= process.env.KISO_MCP_CONFIG ?? join(kisoHome(), "mcp.json");
+    const userPath = originalUserMcpPath;
     const user = readMcpConfig(userPath);
     const project = readMcpConfig(join(root, "mcp.json"));
     const userServers = user.mcpServers ?? {};
@@ -323,17 +396,37 @@ function applyMcpMerge(root) {
         }
     }
     const merged = { mcpServers: { ...userServers, ...projectServers } };
-    const temp = join(tmpdir(), `kiso-mcp-merged-${process.pid}.json`);
+    // RL-F4, second half: the path used to be `kiso-mcp-merged-<pid>.json`,
+    // the SAME file on every merge in one process — so a reload's cleanup of
+    // the paths the previous set owned deleted the file the new set had just
+    // been merged into. One directory per merge, and the directory is what is
+    // recorded, so the cleanup removes exactly what that merge created.
+    const dir = mkdtempSync(join(tmpdir(), "kiso-mcp-"));
+    const temp = join(dir, "mcp.json");
     writeFileSync(temp, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
     process.env.KISO_MCP_CONFIG = temp;
-    mergedTempPaths.push(temp);
+    mergedTempPaths.push(dir);
 }
 /** Merge user-level + project-level skills into one temp scan dir (project
  *  skill dirs symlinked first; a name in both → project wins + a stderr
  *  note) and point KISO_SKILLS_DIR at it — the skills extension's existing
  *  scan reads it at load time and per read_skill call. */
+/**
+ * §2.5 — the user skills directory as it was BEFORE any merge.
+ *
+ * `applySkillsMerge` ends by pointing `KISO_SKILLS_DIR` at the merged
+ * directory it just made. Read twice — which is exactly what a reload
+ * does — that is a loop: the second merge takes the FIRST merge as its
+ * user directory. A skill deleted from the real user directory would
+ * survive forever, and each merge would produce a temp directory the
+ * previous one's symlinks depend on, so none of them could ever be
+ * removed. This tree has already lost an afternoon to 449,956 stale
+ * temp directories.
+ */
+let originalUserSkillsDir;
 function applySkillsMerge(root) {
-    const userDir = process.env.KISO_SKILLS_DIR ?? join(kisoHome(), "skills");
+    originalUserSkillsDir ??= process.env.KISO_SKILLS_DIR ?? join(kisoHome(), "skills");
+    const userDir = originalUserSkillsDir;
     const projectDir = join(root, "skills");
     const merged = mkdtempSync(join(tmpdir(), "kiso-skills-"));
     mergedTempPaths.push(merged);

package/dist/update-check.d.ts

@@ -32,8 +32,6 @@ export interface UpdateCache {
     readonly checkedAt: number;
     /** the latest version the registry reported, if the check succeeded */
     readonly latest?: string;
-    /** the version already mentioned to this human — never mentioned twice */
-    readonly told?: string;
 }
 /**
  * Semver-ish "is b newer than a", for the shapes this line ever sees:
@@ -44,7 +42,15 @@ export interface UpdateCache {
 export declare function isNewer(current: string, latest: string): boolean;
 /** The one line, when there is one. Words only — a human can read it,
  *  paste it, and nothing about it needs colour to be understood (§1.2). */
-export declare const updateLine: (latest: string) => string;
+export declare const CHANGELOG_URL = "https://github.com/vincemakes/kiso/releases";
+/** OR-9 (owner, 2026-09-09): the card under the banner, as WORDS — a
+ *  title, the version with the command that installs it, the changelog.
+ *  The CLI styles them at composition; nothing here needs colour. */
+export declare function updateCardLines(latest: string): readonly string[];
+/** OR-9: what the cache already knows, with NO request — the boot paints
+ *  it under the banner before any check runs. Same silences as the check
+ *  (opt-out, faux without a seam, a pipe); a merely-recent cache speaks. */
+export declare function knownUpdate(deps: UpdateCheckDeps): string | null;
 export interface UpdateCheckDeps {
     readonly kisoHome: string;
     readonly version: string;

package/dist/update-check.js

@@ -51,7 +51,6 @@ function readCache(kisoHome) {
         return {
             checkedAt: c.checkedAt,
             ...(typeof c.latest === "string" ? { latest: c.latest } : {}),
-            ...(typeof c.told === "string" ? { told: c.told } : {}),
         };
     }
     catch {
@@ -97,7 +96,23 @@ export function isNewer(current, latest) {
 }
 /** The one line, when there is one. Words only — a human can read it,
  *  paste it, and nothing about it needs colour to be understood (§1.2). */
-export const updateLine = (latest) => `${latest} is out · npm i -g @vincemakes/kiso-code@latest`;
+export const CHANGELOG_URL = "https://github.com/vincemakes/kiso/releases";
+/** OR-9 (owner, 2026-09-09): the card under the banner, as WORDS — a
+ *  title, the version with the command that installs it, the changelog.
+ *  The CLI styles them at composition; nothing here needs colour. */
+export function updateCardLines(latest) {
+    return ["Update available", `New version ${latest} is available. Run kiso update`, `Changelog: ${CHANGELOG_URL}`];
+}
+/** OR-9: what the cache already knows, with NO request — the boot paints
+ *  it under the banner before any check runs. Same silences as the check
+ *  (opt-out, faux without a seam, a pipe); a merely-recent cache speaks. */
+export function knownUpdate(deps) {
+    const why = reasonNotToCheck(deps);
+    if (why !== null && why !== "recent")
+        return null;
+    const cached = readCache(deps.kisoHome);
+    return cached?.latest !== undefined && isNewer(deps.version, cached.latest) ? cached.latest : null;
+}
 /**
  * Should this launch even ask? Pure, so the reasons are testable without
  * a network, a clock or a terminal.
@@ -142,21 +157,14 @@ function reasonNotToCheck({ kisoHome, isTTY, faux, now = Date.now() }) {
 export async function checkForUpdate(deps) {
     const { kisoHome, version, now = Date.now() } = deps;
     const why = reasonNotToCheck(deps);
-    if (why !== null) {
-        // ONLY a recent check may still speak. The other three reasons are
-        // about the LINE, not about the request, so the cache is no way
-        // around them — an opt-out that still got announced, or a piped
-        // run that gained a row of kiso's prose, would be the feature
-        // ignoring the answer it was given.
-        if (why !== "recent")
-            return null;
-        const cached = readCache(kisoHome);
-        if (cached?.latest !== undefined && cached.told !== cached.latest && isNewer(version, cached.latest)) {
-            writeCache(kisoHome, { ...cached, told: cached.latest });
-            return updateLine(cached.latest);
-        }
-        return null;
-    }
+    // ONLY a recent check may still speak from cache. The other three
+    // reasons are about the CARD, not the request, so the cache is no way
+    // around them. OR-9: no `told` gate — a newer version is known at
+    // EVERY start (the card is shown every start; the once-only rule of
+    // §7.10 is superseded by the owner's 2026-09-09 ruling), only the
+    // REQUEST stays at most once a day.
+    if (why !== null)
+        return why === "recent" ? knownUpdate(deps) : null;
     let latest;
     try {
         const ctl = new AbortController();
@@ -177,15 +185,6 @@ export async function checkForUpdate(deps) {
     catch {
         // every failure is silence — see the header
     }
-    const prev = readCache(kisoHome);
-    const show = latest !== undefined && isNewer(version, latest) && prev?.told !== latest;
-    // `told` survives a check that learned nothing: forgetting it would
-    // re-announce a version this human has already been told about.
-    const told = show ? latest : prev?.told;
-    writeCache(kisoHome, {
-        checkedAt: now,
-        ...(latest === undefined ? {} : { latest }),
-        ...(told === undefined ? {} : { told }),
-    });
-    return show && latest !== undefined ? updateLine(latest) : null;
+    writeCache(kisoHome, { checkedAt: now, ...(latest === undefined ? {} : { latest }) });
+    return latest !== undefined && isNewer(version, latest) ? latest : null;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@vincemakes/kiso-code",
-	"version": "0.31.0",
-	"description": "kiso CLI — the durable coding agent that survives kill -9: kiso chat / kiso resume / kiso sessions.",
+	"version": "0.32.0",
+	"description": "kiso-code — the coding agent on kiso, the durable runtime for AI agents: kiso chat / kiso resume / kiso sessions.",
 	"type": "module",
 	"license": "MIT",
 	"bin": {
@@ -18,20 +18,20 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-ask-ext": "0.31.0",
-		"@vincemakes/kiso-core": "0.31.0",
-		"@vincemakes/kiso-evals": "0.31.0",
-		"@vincemakes/kiso-mcp-ext": "0.31.0",
-		"@vincemakes/kiso-provider-anthropic": "0.31.0",
-		"@vincemakes/kiso-provider-openai": "0.31.0",
-		"@vincemakes/kiso-provider-openai-responses": "0.31.0",
-		"@vincemakes/kiso-runtime": "0.31.0",
-		"@vincemakes/kiso-skills-ext": "0.31.0",
-		"@vincemakes/kiso-subagent-ext": "0.31.0",
-		"@vincemakes/kiso-task-ext": "0.31.0",
-		"@vincemakes/kiso-tools-node": "0.31.0",
-		"@vincemakes/kiso-tui": "0.31.0",
-		"@vincemakes/kiso-tui-cells": "0.31.0"
+		"@vincemakes/kiso-ask-ext": "0.32.0",
+		"@vincemakes/kiso-core": "0.32.0",
+		"@vincemakes/kiso-evals": "0.32.0",
+		"@vincemakes/kiso-mcp-ext": "0.32.0",
+		"@vincemakes/kiso-provider-anthropic": "0.32.0",
+		"@vincemakes/kiso-provider-openai": "0.32.0",
+		"@vincemakes/kiso-provider-openai-responses": "0.32.0",
+		"@vincemakes/kiso-runtime": "0.32.0",
+		"@vincemakes/kiso-skills-ext": "0.32.0",
+		"@vincemakes/kiso-subagent-ext": "0.32.0",
+		"@vincemakes/kiso-task-ext": "0.32.0",
+		"@vincemakes/kiso-tools-node": "0.32.0",
+		"@vincemakes/kiso-tui": "0.32.0",
+		"@vincemakes/kiso-tui-cells": "0.32.0"
 	},
 	"devDependencies": {
 		"@types/node": "^26.1.2",

package/dist/diff.d.ts

@@ -1,32 +0,0 @@
-/**
- * v2e — the diff renderer: edit/write changes as inline ± lines, zero
- * dependencies, no syntax highlighting (the spec's scope line). Shown at
- * the approval moment ONLY — the frozen summary stays one line (v2d's
- * anti-leak principle), /last has the full data.
- *
- * edit_file diffs IN PLACE (the search→replace windows are known — no
- * general engine needed); write_file does a row-level LCS over the old
- * file (small files are the target). Context: 2 rows each side. The
- * RENDERER truncates (18 head + 18 tail + "… N lines"); the stats come
- * from the full diff.
- */
-/** The diff block's per-row kind. */
-export type DiffLine = {
-    kind: "-" | "+" | " ";
-    text: string;
-};
-export interface DiffResult {
-    /** The FULL diff (with context, not truncated) — the display truncates. */
-    lines: DiffLine[];
-    added: number;
-    removed: number;
-}
-/** The RENDERER's truncation: head + "… N lines (/last for full)" + tail. */
-export declare function truncateDiff(diff: DiffLine[]): DiffLine[];
-/** edit_file: the search→replace windows replace in place — the changed
- *  region is KNOWN, so the diff is the old window vs the new window,
- *  context from the surrounding file. */
-export declare function editFileDiff(oldContent: string, search: string, replace: string): DiffResult;
-/** write_file: a new file is all +; an existing file diffs row-level
- *  against its old content. */
-export declare function writeFileDiff(oldContent: string | null, newContent: string): DiffResult;

package/dist/diff.js

@@ -1,122 +0,0 @@
-/**
- * v2e — the diff renderer: edit/write changes as inline ± lines, zero
- * dependencies, no syntax highlighting (the spec's scope line). Shown at
- * the approval moment ONLY — the frozen summary stays one line (v2d's
- * anti-leak principle), /last has the full data.
- *
- * edit_file diffs IN PLACE (the search→replace windows are known — no
- * general engine needed); write_file does a row-level LCS over the old
- * file (small files are the target). Context: 2 rows each side. The
- * RENDERER truncates (18 head + 18 tail + "… N lines"); the stats come
- * from the full diff.
- */
-/** A line-level LCS diff — the classic two-row DP, ~small inputs. */
-function lcsDiff(oldLines, newLines) {
-    const n = oldLines.length;
-    const m = newLines.length;
-    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
-    for (let i = n - 1; i >= 0; i -= 1) {
-        for (let j = m - 1; j >= 0; j -= 1) {
-            dp[i][j] = oldLines[i] === newLines[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
-        }
-    }
-    const out = [];
-    let i = 0;
-    let j = 0;
-    while (i < n && j < m) {
-        if (oldLines[i] === newLines[j]) {
-            out.push({ kind: " ", text: oldLines[i] });
-            i += 1;
-            j += 1;
-        }
-        else if (dp[i + 1][j] >= dp[i][j + 1]) {
-            out.push({ kind: "-", text: oldLines[i] });
-            i += 1;
-        }
-        else {
-            out.push({ kind: "+", text: newLines[j] });
-            j += 1;
-        }
-    }
-    while (i < n) {
-        out.push({ kind: "-", text: oldLines[i] });
-        i += 1;
-    }
-    while (j < m) {
-        out.push({ kind: "+", text: newLines[j] });
-        j += 1;
-    }
-    return out;
-}
-/** Keep 2 context rows around each change — the unified-style window. */
-function withContext(diff) {
-    const out = [];
-    let lastAdded = -10;
-    for (let k = 0; k < diff.length; k += 1) {
-        if (diff[k].kind === " ")
-            continue;
-        const from = Math.max(0, k - 2);
-        const to = Math.min(diff.length - 1, k + 2);
-        for (let c = from; c <= to; c += 1) {
-            if (c > lastAdded) {
-                out.push(diff[c]);
-                lastAdded = c;
-            }
-        }
-        lastAdded = to;
-    }
-    return out;
-}
-const MAX_DIFF_LINES = 40; // the RENDERED cap
-const TRUNCATE_KEEP = 18;
-/** The RENDERER's truncation: head + "… N lines (/last for full)" + tail. */
-export function truncateDiff(diff) {
-    if (diff.length <= MAX_DIFF_LINES)
-        return diff;
-    const omitted = diff.length - 2 * TRUNCATE_KEEP;
-    return [
-        ...diff.slice(0, TRUNCATE_KEEP),
-        { kind: " ", text: `… ${omitted} lines (/last for full)` },
-        ...diff.slice(diff.length - TRUNCATE_KEEP),
-    ];
-}
-function stats(diff) {
-    let added = 0;
-    let removed = 0;
-    for (const d of diff) {
-        if (d.kind === "+")
-            added += 1;
-        else if (d.kind === "-")
-            removed += 1;
-    }
-    return { added, removed };
-}
-/** edit_file: the search→replace windows replace in place — the changed
- *  region is KNOWN, so the diff is the old window vs the new window,
- *  context from the surrounding file. */
-export function editFileDiff(oldContent, search, replace) {
-    const oldLines = oldContent.split("\n");
-    const searchLines = search.split("\n");
-    const replaceLines = replace.split("\n");
-    // Locate the search window (the first occurrence — the edit tool's own
-    // semantics); no occurrence → the whole file is the old side.
-    let at = -1;
-    for (let i = 0; i + searchLines.length <= oldLines.length; i += 1) {
-        if (oldLines.slice(i, i + searchLines.length).join("\n") === search) {
-            at = i;
-            break;
-        }
-    }
-    const lines = at < 0 ? withContext(lcsDiff(oldLines, replaceLines)) : withContext(lcsDiff(oldLines, [...oldLines.slice(0, at), ...replaceLines, ...oldLines.slice(at + searchLines.length)]));
-    return { lines, ...stats(lines) };
-}
-/** write_file: a new file is all +; an existing file diffs row-level
- *  against its old content. */
-export function writeFileDiff(oldContent, newContent) {
-    if (oldContent === null) {
-        const lines = newContent.split("\n").map((text) => ({ kind: "+", text }));
-        return { lines, added: lines.length, removed: 0 };
-    }
-    const lines = withContext(lcsDiff(oldContent.split("\n"), newContent.split("\n")));
-    return { lines, ...stats(lines) };
-}