@vincemakes/kiso-code 0.15.5 → 0.15.7

package/dist/attachments.d.ts

@@ -0,0 +1,41 @@
+/**
+ * REL-0152-D11 — an image reaches the model.
+ *
+ * The wire was already complete and nobody had noticed. The `user_input`
+ * event's content has been `string | ContentBlock[]` since the protocol
+ * was written; the projection passes it through untouched; the Anthropic
+ * adapter sends an `image` block and the OpenAI-compatible family sends
+ * `image_url` with a data URI. What was missing was at the two ends:
+ * `session.run()` narrowed its parameter to text, and the CLI never
+ * built a block — `grep 'type: "image"' apps/cli/src` came back empty.
+ *
+ * This module is the CLI end. A turn's text is scanned for references to
+ * image files and each one becomes an image block beside the words.
+ *
+ * The reference is a PATH, deliberately, because two things a user can
+ * already do produce one on any terminal with no clipboard involved:
+ * dragging a file into the window, which terminals answer by inserting
+ * its path, and typing or pasting a path. Clipboard image paste is a
+ * separate mechanism with a separate open question (see the finding);
+ * this one works today, everywhere, and is what that mechanism will
+ * hand its temp file to when it lands.
+ */
+import type { ContentBlock } from "@vincemakes/kiso-core";
+/** The four media types the protocol accepts, recognised by the file's
+ *  own leading bytes. A name is a claim; the bytes are the fact, and a
+ *  screenshot saved as `.jpg` is a very ordinary thing to have. */
+export declare function sniff(buf: Buffer): "image/png" | "image/jpeg" | "image/gif" | "image/webp" | null;
+/**
+ * The turn's content: the string itself when nothing was attached, or
+ * the blocks when something was.
+ *
+ * Returning the STRING unchanged in the common case is not an
+ * optimisation, it is the compatibility guarantee: a turn with no image
+ * produces exactly the bytes it produced before this module existed, so
+ * every request that is not about an image is unaffected by the feature.
+ *
+ * A path that is not there, or is not an image, or is too large, is left
+ * standing in the text. Silently dropping it would tell the model about
+ * a file it cannot see, which is worse than telling it nothing.
+ */
+export declare function attachImages(text: string): string | ContentBlock[];

package/dist/attachments.js

@@ -0,0 +1,122 @@
+/**
+ * REL-0152-D11 — an image reaches the model.
+ *
+ * The wire was already complete and nobody had noticed. The `user_input`
+ * event's content has been `string | ContentBlock[]` since the protocol
+ * was written; the projection passes it through untouched; the Anthropic
+ * adapter sends an `image` block and the OpenAI-compatible family sends
+ * `image_url` with a data URI. What was missing was at the two ends:
+ * `session.run()` narrowed its parameter to text, and the CLI never
+ * built a block — `grep 'type: "image"' apps/cli/src` came back empty.
+ *
+ * This module is the CLI end. A turn's text is scanned for references to
+ * image files and each one becomes an image block beside the words.
+ *
+ * The reference is a PATH, deliberately, because two things a user can
+ * already do produce one on any terminal with no clipboard involved:
+ * dragging a file into the window, which terminals answer by inserting
+ * its path, and typing or pasting a path. Clipboard image paste is a
+ * separate mechanism with a separate open question (see the finding);
+ * this one works today, everywhere, and is what that mechanism will
+ * hand its temp file to when it lands.
+ */
+import { readFileSync, statSync } from "node:fs";
+/**
+ * The size a single image may reach before it is refused.
+ *
+ * Providers cap image payloads and base64 inflates by a third, so a file
+ * near this bound is already near theirs. The refusal is deliberate and
+ * VISIBLE: the path stays in the text, so the model is told a file was
+ * named rather than being handed a request that the provider will reject
+ * with something the user cannot act on.
+ */
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+/** The four media types the protocol accepts, recognised by the file's
+ *  own leading bytes. A name is a claim; the bytes are the fact, and a
+ *  screenshot saved as `.jpg` is a very ordinary thing to have. */
+export function sniff(buf) {
+    if (buf.length >= 8 && buf.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex")))
+        return "image/png";
+    if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff)
+        return "image/jpeg";
+    if (buf.length >= 6 && (buf.subarray(0, 6).toString("latin1") === "GIF87a" || buf.subarray(0, 6).toString("latin1") === "GIF89a"))
+        return "image/gif";
+    if (buf.length >= 12 && buf.subarray(0, 4).toString("latin1") === "RIFF" && buf.subarray(8, 12).toString("latin1") === "WEBP")
+        return "image/webp";
+    return null;
+}
+/**
+ * Path-shaped runs in a line, longest first so a quoted path wins over
+ * the bare fragment inside it. Quoted forms come first because that is
+ * what a terminal inserts for a name containing a space.
+ */
+const CANDIDATES = [
+    /'([^']*\.(?:png|jpe?g|gif|webp))'/gi,
+    /"([^"]*\.(?:png|jpe?g|gif|webp))"/gi,
+    /(\S*\.(?:png|jpe?g|gif|webp))/gi,
+];
+function look(path) {
+    try {
+        const st = statSync(path);
+        if (!st.isFile() || st.size > MAX_IMAGE_BYTES || st.size === 0)
+            return null;
+        const buf = readFileSync(path);
+        const mediaType = sniff(buf);
+        if (mediaType === null)
+            return null;
+        return { mediaType, data: buf.toString("base64") };
+    }
+    catch {
+        return null; // not there, not readable, not ours to complain about
+    }
+}
+/**
+ * The turn's content: the string itself when nothing was attached, or
+ * the blocks when something was.
+ *
+ * Returning the STRING unchanged in the common case is not an
+ * optimisation, it is the compatibility guarantee: a turn with no image
+ * produces exactly the bytes it produced before this module existed, so
+ * every request that is not about an image is unaffected by the feature.
+ *
+ * A path that is not there, or is not an image, or is too large, is left
+ * standing in the text. Silently dropping it would tell the model about
+ * a file it cannot see, which is worse than telling it nothing.
+ */
+export function attachImages(text) {
+    const found = [];
+    const claimed = [];
+    for (const re of CANDIDATES) {
+        re.lastIndex = 0;
+        for (const m of text.matchAll(re)) {
+            const path = m[1];
+            const start = m.index;
+            const end = start + m[0].length;
+            if (claimed.some((c) => start < c.end && end > c.start))
+                continue;
+            const hit = look(path);
+            if (hit === null)
+                continue;
+            claimed.push({ start, end });
+            found.push({ start, end, block: { type: "image", sourceType: "base64", mediaType: hit.mediaType, data: hit.data } });
+        }
+    }
+    if (found.length === 0)
+        return text;
+    found.sort((a, b) => a.start - b.start);
+    // the words are kept and kept IN PLACE: a turn is "what is wrong
+    // here?" plus the screenshot, and the question is half of it.
+    const blocks = [];
+    let at = 0;
+    for (const f of found) {
+        const before = text.slice(at, f.start).trim();
+        if (before !== "")
+            blocks.push({ type: "text", text: before });
+        blocks.push(f.block);
+        at = f.end;
+    }
+    const tail = text.slice(at).trim();
+    if (tail !== "")
+        blocks.push({ type: "text", text: tail });
+    return blocks;
+}

package/dist/byte-trace.d.ts

@@ -0,0 +1,46 @@
+/**
+ * REL-0152-D12 — the byte trace: what kiso actually sent, and when.
+ *
+ * Three defects in this round are only decidable from the byte stream:
+ *
+ *   - REL-0152-D1, the stray `[` and `]` at the row edges. `[` is the
+ *     CSI introducer and `]` the OSC introducer, so a lost ESC prints
+ *     exactly those two characters and nothing else — but kiso emits no
+ *     OSC at all, and every CSI it writes carries more than its
+ *     introducer. Either the bytes leaving kiso already contain those
+ *     characters (ours) or they do not (the terminal's parser). Nobody
+ *     can tell from a screenshot, and three rounds have now tried.
+ *   - REL-0152-D7, content that appears late or not at all. The frame
+ *     that should have carried it either went out or did not.
+ *   - the paste latency. The editor is measured at 146KB in 6ms, so if
+ *     a paste still feels slow the time is being spent before kiso sees
+ *     the bytes — which the arrival timestamps show directly.
+ *
+ * Set KISO_TRACE_BYTES to a path and every byte in BOTH directions is
+ * recorded with a millisecond stamp, then the file answers the question
+ * instead of another round of inference.
+ *
+ *   KISO_TRACE_BYTES=/tmp/kiso-bytes.jsonl kiso chat
+ *
+ * One JSON object per line: {ms, dir, n, b} — the stamp relative to the
+ * trace's start, "out" or "in", the byte count, and the bytes as base64
+ * so no escape, control character or partial UTF-8 sequence is altered
+ * on the way to disk. Nothing is interpreted here; interpretation is
+ * what the trace exists to make possible.
+ *
+ * OFF unless the variable is set: zero cost, and it never turns itself
+ * on. What it records is the terminal traffic of one session — screen
+ * output and keystrokes — so it is a diagnostic a person switches on
+ * deliberately, for one run, when something is wrong.
+ */
+/**
+ * Arm the trace if KISO_TRACE_BYTES names a file. Call once, before the
+ * dock is entered, so the first frame is in the record too.
+ *
+ * stdout is wrapped rather than tapped because there is no other way to
+ * see every write: the compositor, the CLI's own logging and node's
+ * error paths all reach the terminal through it. stdin is TAPPED — an
+ * extra "data" listener, which every listener receives — so the editor's
+ * own reading is untouched and the trace cannot swallow a keystroke.
+ */
+export declare function armByteTrace(): void;

package/dist/byte-trace.js

@@ -0,0 +1,103 @@
+/**
+ * REL-0152-D12 — the byte trace: what kiso actually sent, and when.
+ *
+ * Three defects in this round are only decidable from the byte stream:
+ *
+ *   - REL-0152-D1, the stray `[` and `]` at the row edges. `[` is the
+ *     CSI introducer and `]` the OSC introducer, so a lost ESC prints
+ *     exactly those two characters and nothing else — but kiso emits no
+ *     OSC at all, and every CSI it writes carries more than its
+ *     introducer. Either the bytes leaving kiso already contain those
+ *     characters (ours) or they do not (the terminal's parser). Nobody
+ *     can tell from a screenshot, and three rounds have now tried.
+ *   - REL-0152-D7, content that appears late or not at all. The frame
+ *     that should have carried it either went out or did not.
+ *   - the paste latency. The editor is measured at 146KB in 6ms, so if
+ *     a paste still feels slow the time is being spent before kiso sees
+ *     the bytes — which the arrival timestamps show directly.
+ *
+ * Set KISO_TRACE_BYTES to a path and every byte in BOTH directions is
+ * recorded with a millisecond stamp, then the file answers the question
+ * instead of another round of inference.
+ *
+ *   KISO_TRACE_BYTES=/tmp/kiso-bytes.jsonl kiso chat
+ *
+ * One JSON object per line: {ms, dir, n, b} — the stamp relative to the
+ * trace's start, "out" or "in", the byte count, and the bytes as base64
+ * so no escape, control character or partial UTF-8 sequence is altered
+ * on the way to disk. Nothing is interpreted here; interpretation is
+ * what the trace exists to make possible.
+ *
+ * OFF unless the variable is set: zero cost, and it never turns itself
+ * on. What it records is the terminal traffic of one session — screen
+ * output and keystrokes — so it is a diagnostic a person switches on
+ * deliberately, for one run, when something is wrong.
+ */
+import { appendFileSync, writeFileSync } from "node:fs";
+let path = null;
+let start = 0;
+function line(dir, data) {
+    if (path === null)
+        return;
+    const buf = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+    try {
+        appendFileSync(path, `${JSON.stringify({ ms: Date.now() - start, dir, n: buf.length, b: buf.toString("base64") })}\n`);
+    }
+    catch {
+        // a trace that fails must never take the session with it
+        path = null;
+    }
+}
+/**
+ * Arm the trace if KISO_TRACE_BYTES names a file. Call once, before the
+ * dock is entered, so the first frame is in the record too.
+ *
+ * stdout is wrapped rather than tapped because there is no other way to
+ * see every write: the compositor, the CLI's own logging and node's
+ * error paths all reach the terminal through it. stdin is TAPPED — an
+ * extra "data" listener, which every listener receives — so the editor's
+ * own reading is untouched and the trace cannot swallow a keystroke.
+ */
+export function armByteTrace() {
+    const target = process.env.KISO_TRACE_BYTES;
+    if (target === undefined || target === "")
+        return;
+    path = target;
+    start = Date.now();
+    try {
+        writeFileSync(path, "");
+    }
+    catch {
+        path = null;
+        return;
+    }
+    const write = process.stdout.write.bind(process.stdout);
+    process.stdout.write = ((chunk, ...rest) => {
+        line("out", chunk);
+        return write(chunk, ...rest);
+    });
+    process.stdin.on("data", (chunk) => line("in", chunk));
+    // The environment goes in the record FIRST, because kiso emits
+    // DIFFERENT frame bytes per terminal — DEC 2026 synchronized output
+    // where it is supported, a cursor-hide degrade on Apple Terminal —
+    // so a capture that does not say which terminal made it cannot be
+    // compared against anything. Same for the size and the locale: a row
+    // is built to a width, and the ambiguous-width characters kiso uses
+    // in its own chrome (· … —) are one cell or two depending on how the
+    // terminal was told to treat them.
+    const env = {
+        TERM_PROGRAM: process.env.TERM_PROGRAM ?? null,
+        TERM_PROGRAM_VERSION: process.env.TERM_PROGRAM_VERSION ?? null,
+        TERM: process.env.TERM ?? null,
+        LANG: process.env.LANG ?? null,
+        LC_CTYPE: process.env.LC_CTYPE ?? null,
+        columns: process.stdout.columns ?? null,
+        rows: process.stdout.rows ?? null,
+    };
+    try {
+        appendFileSync(path, `${JSON.stringify({ ms: 0, dir: "env", n: 0, b: "", env })}\n`);
+    }
+    catch {
+        path = null;
+    }
+}

package/dist/chat.js

@@ -12,6 +12,7 @@ import { canonicalizeUsage } from "@vincemakes/kiso-runtime";
 import { canonicalizeUsageForModel } from "@vincemakes/kiso-runtime/internal";
 import { dispatch } from "./dispatch.js";
 import { agentModel, body, bodyLog, configuredWindow, dock } from "./state.js";
+import { attachImages } from "./attachments.js";
 import { lookupModelMetadata } from "@vincemakes/kiso-runtime/internal";
 import { addDontAskAgainRule, askPanel, fixHintFor, pendingAsk, resolveUncertains } from "./trust-ui.js";
 import { FauxExhaustionError, failOnFauxExhaustion } from "./faux-glue.js";
@@ -822,7 +823,13 @@ export async function chat(session, faux, input, autoCompact, nav) {
     };
     const turn = (text, seedSource) => new Promise((resolve, reject) => {
         queued = Math.max(0, queued - 1); // a queued turn starts
-        const run = seedSource !== undefined ? session.run(text, { source: seedSource }) : session.run(text);
+        // REL-0152-D11: a turn that names an image file carries it. The
+        // scan returns the STRING unchanged when it finds nothing, so a
+        // turn without one is byte-identical to before the feature.
+        // Seeded turns are the product's own words and are never
+        // scanned — nothing it writes to itself is an attachment.
+        const content = seedSource !== undefined ? text : attachImages(text);
+        const run = seedSource !== undefined ? session.run(content, { source: seedSource }) : session.run(content);
         currentRun = run;
         turnNo += 1;
         const myTurn = turnNo;

package/dist/clipboard.d.ts

@@ -0,0 +1,37 @@
+/**
+ * REL-0152-D11 — reading an image off the clipboard.
+ *
+ * SPLIT from attachments.ts on purpose. The pty-manifest gate
+ * classifies a test by its resource-dependency CLOSURE, and a module
+ * that spawns drags every test that imports it into the serial pool.
+ * The path scanning and the block building are pure and belong in the
+ * fast pool; only this file needs a process, so only this file's tests
+ * pay for one. The gate found that out, which is what it is for.
+ */
+/**
+ * REL-0152-D11, the clipboard half.
+ *
+ * Pasting an image into a terminal sends NOTHING useful: the terminal
+ * has no way to put binary into a byte stream, so a bracketed paste
+ * arrives empty (or with a filename, depending on the source app). An
+ * empty paste is therefore the signal — the user pressed paste and the
+ * terminal had nothing to give us — and the image, if there is one, has
+ * to be fetched from the clipboard directly.
+ *
+ * macOS only for now, through `osascript`, which is present on every
+ * Mac and needs no dependency. The coercion `the clipboard as «class
+ * PNGf»` is the documented way to get PNG bytes out of the pasteboard.
+ *
+ * KNOWN UNRESOLVED, and stated here rather than discovered later: that
+ * coercion FAILS with error -1700 when osascript runs detached from the
+ * user's session, which is where this was developed. `clipboard info`
+ * correctly reports the PNG flavour is present, so it is not a
+ * permission wall — it has the shape of a promised (lazily rendered)
+ * flavour that the source app materialises only for a process in the
+ * right session context. kiso runs in the user's own terminal session,
+ * where it may simply work. This returns null on any failure and the
+ * caller says so out loud; nothing here guesses.
+ */
+export declare function clipboardImage(dir: string, run?: (cmd: string, args: readonly string[]) => {
+    status: number | null;
+}): string | null;

package/dist/clipboard.js

@@ -0,0 +1,70 @@
+/**
+ * REL-0152-D11 — reading an image off the clipboard.
+ *
+ * SPLIT from attachments.ts on purpose. The pty-manifest gate
+ * classifies a test by its resource-dependency CLOSURE, and a module
+ * that spawns drags every test that imports it into the serial pool.
+ * The path scanning and the block building are pure and belong in the
+ * fast pool; only this file needs a process, so only this file's tests
+ * pay for one. The gate found that out, which is what it is for.
+ */
+import { readFileSync, statSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { sniff } from "./attachments.js";
+/**
+ * REL-0152-D11, the clipboard half.
+ *
+ * Pasting an image into a terminal sends NOTHING useful: the terminal
+ * has no way to put binary into a byte stream, so a bracketed paste
+ * arrives empty (or with a filename, depending on the source app). An
+ * empty paste is therefore the signal — the user pressed paste and the
+ * terminal had nothing to give us — and the image, if there is one, has
+ * to be fetched from the clipboard directly.
+ *
+ * macOS only for now, through `osascript`, which is present on every
+ * Mac and needs no dependency. The coercion `the clipboard as «class
+ * PNGf»` is the documented way to get PNG bytes out of the pasteboard.
+ *
+ * KNOWN UNRESOLVED, and stated here rather than discovered later: that
+ * coercion FAILS with error -1700 when osascript runs detached from the
+ * user's session, which is where this was developed. `clipboard info`
+ * correctly reports the PNG flavour is present, so it is not a
+ * permission wall — it has the shape of a promised (lazily rendered)
+ * flavour that the source app materialises only for a process in the
+ * right session context. kiso runs in the user's own terminal session,
+ * where it may simply work. This returns null on any failure and the
+ * caller says so out loud; nothing here guesses.
+ */
+export function clipboardImage(dir, run = defaultRun) {
+    if (process.platform !== "darwin")
+        return null;
+    const target = join(dir, `paste-${process.pid}-${Date.now()}.png`);
+    const script = [
+        "set d to (the clipboard as «class PNGf»)",
+        `set f to open for access POSIX file ${JSON.stringify(target)} with write permission`,
+        "set eof f to 0",
+        "write d to f",
+        "close access f",
+    ].flatMap((line) => ["-e", line]);
+    try {
+        const r = run("osascript", script);
+        if (r.status !== 0)
+            return null;
+        // the file must be a real image by the SAME sniffer the path
+        // route uses — a zero-byte file from a half-failed coercion is
+        // exactly what this round already produced once
+        const st = statSync(target);
+        if (!st.isFile() || st.size === 0)
+            return null;
+        if (sniff(readFileSync(target)) === null)
+            return null;
+        return target;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultRun(cmd, args) {
+    return spawnSync(cmd, [...args], { stdio: "ignore", timeout: 5000 });
+}

package/dist/index.js

@@ -42,6 +42,9 @@ import { autoCompactFromEnv, chat, contextWindowTokens, estimateCtxRatio } from
 import { loadProjectConfig, loadUserConfig, mergeConfigs, resolveAutoCompact, resolveContextWindow, resolveModel } from "./config.js";
 import { resume } from "./resume.js";
 import { resumeTail } from "./resume-tail.js";
+import { armByteTrace } from "./byte-trace.js";
+import { tmpdir } from "node:os";
+import { clipboardImage } from "./clipboard.js";
 import { collectSessionCards, projectSessionCard } from "./session-cards.js";
 // The moved exports stay reachable from this entry — the test imports
 // (project-trust, coding-agent) never change (B4: zero assertion changes).
@@ -165,6 +168,9 @@ function editorInput(editor) {
         onRedirect(cb) {
             editor.onRedirect(cb);
         },
+        onEmptyPaste(cb) {
+            editor.onEmptyPaste(cb);
+        },
         question(query, cb) {
             editor.question(query, cb);
         },
@@ -630,6 +636,9 @@ async function main() {
     // swallows it — the standard "the stream may die under me" idiom.
     process.stdout.on("error", () => { });
     process.stderr.on("error", () => { });
+    // REL-0152-D12: armed only by KISO_TRACE_BYTES, and armed HERE so the
+    // banner and the first frame are in the record. Off by default.
+    armByteTrace();
     // Modes: --mode <name> wins over KISO_MODE — both applied before the
     // first makeAgent (the tier extensions read `current` live). The flag
     // is stripped from the positional args, so it works in any position.
@@ -755,6 +764,18 @@ async function main() {
         editCol: () => dock.editCol(),
         onDock: () => dock.redraw(), // v2d-B: the freeze scrolls the dock up — re-pin it
     }));
+    // REL-0152-D11: pasting an image sends no bytes, so an empty paste is
+    // the signal to go and look at the clipboard. What comes back is a
+    // PATH, which the turn's attachment scan then picks up exactly as it
+    // would a dragged-in file — one mechanism, two ways of naming a file.
+    input.onEmptyPaste?.(() => {
+        const shot = clipboardImage(tmpdir());
+        if (shot === null) {
+            bodyLog("[nothing on the clipboard that kiso can read as an image]");
+            return null;
+        }
+        return shot;
+    });
     try {
         // merge round B: the project config's mode applies AFTER the trust gate
         // (its verdict decides whether the project config exists at all) —

package/dist/state.d.ts

@@ -75,6 +75,11 @@ export interface LineInput {
      *  to stop. OPTIONAL: the pipe path has no raw keys and never wires
      *  it, so readline stays exactly as it was. */
     onRedirect?(cb: (line: string) => void): void;
+    /** REL-0152-D11: an empty bracketed paste is the image case — a
+     *  terminal cannot put binary in a byte stream, so pasting one sends
+     *  nothing. The callback returns text to insert (a path) or null.
+     *  Optional: the pipe path has no editor and no clipboard. */
+    onEmptyPaste?(cb: () => string | null): void;
     question(query: string, cb: (answer: string) => void): void;
     cancelQuestion(): void;
     /** W21: open the approval panel — the editor's state machine takes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-code",
-	"version": "0.15.5",
+	"version": "0.15.7",
 	"description": "kiso CLI \u2014 the durable coding agent that survives kill -9: kiso chat / kiso resume / kiso sessions.",
 	"type": "module",
 	"license": "MIT",
@@ -18,19 +18,19 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-ask-ext": "0.15.5",
-		"@vincemakes/kiso-core": "0.15.5",
-		"@vincemakes/kiso-evals": "0.15.5",
-		"@vincemakes/kiso-mcp-ext": "0.15.5",
-		"@vincemakes/kiso-provider-anthropic": "0.15.5",
-		"@vincemakes/kiso-provider-openai": "0.15.5",
-		"@vincemakes/kiso-runtime": "0.15.5",
-		"@vincemakes/kiso-skills-ext": "0.15.5",
-		"@vincemakes/kiso-subagent-ext": "0.15.5",
-		"@vincemakes/kiso-task-ext": "0.15.5",
-		"@vincemakes/kiso-tools-node": "0.15.5",
-		"@vincemakes/kiso-tui": "0.15.5",
-		"@vincemakes/kiso-tui-cells": "0.15.5"
+		"@vincemakes/kiso-ask-ext": "0.15.7",
+		"@vincemakes/kiso-core": "0.15.7",
+		"@vincemakes/kiso-evals": "0.15.7",
+		"@vincemakes/kiso-mcp-ext": "0.15.7",
+		"@vincemakes/kiso-provider-anthropic": "0.15.7",
+		"@vincemakes/kiso-provider-openai": "0.15.7",
+		"@vincemakes/kiso-runtime": "0.15.7",
+		"@vincemakes/kiso-skills-ext": "0.15.7",
+		"@vincemakes/kiso-subagent-ext": "0.15.7",
+		"@vincemakes/kiso-task-ext": "0.15.7",
+		"@vincemakes/kiso-tools-node": "0.15.7",
+		"@vincemakes/kiso-tui": "0.15.7",
+		"@vincemakes/kiso-tui-cells": "0.15.7"
 	},
 	"devDependencies": {
 		"@types/node": "^26.1.2",