@vincemakes/kiso-code 0.25.0 → 0.26.1

package/dist/chat.js

@@ -1182,17 +1182,28 @@ export async function chat(session, faux, input, autoCompact, nav) {
             return;
         dispatch("/compact", dispatchCtx);
     };
+    // CX-1 F5: a literal input (task-file mode) submits the turn directly —
+    // its bytes never meet the slash dispatcher.
+    const route = (line) => {
+        if (input.literal === true)
+            dispatchCtx.submitTurn(line);
+        else
+            dispatch(line, dispatchCtx);
+    };
     input.onLine((line) => {
         if (!replReady) {
             queuedLines.push(line);
             return;
         }
-        dispatch(line, dispatchCtx);
+        route(line);
     });
     // W15: the expand key — the editor forwards ctrl+o; dispatch runs the
     // chain action (the sentinel's control char marks the key, so a typed
     // "expand" turn is never intercepted).
     input.onExpand(() => dispatch("\x12expand", dispatchCtx));
+    // E1 §3 — ctrl+x and `/copy` are the same action reached two ways, so
+    // they are the same sentinel: one implementation, one behaviour.
+    input.onCopy(() => dispatch("\x18copy", dispatchCtx));
     // R3a — Shift+Tab: the approval-tier cycle (the /mode ring, in the
     // MODES order). The switch is the SAME live-extension flip /mode
     // performs; the status row repaints at once with a one-line notice.
@@ -1243,7 +1254,7 @@ export async function chat(session, faux, input, autoCompact, nav) {
     // chain BEFORE the appends and the replayed turns would never be
     // awaited (the F-group regression).
     for (const line of queuedLines) {
-        dispatch(line, dispatchCtx);
+        route(line);
     }
     queuedLines.length = 0;
     input.prompt();

package/dist/clipboard.d.ts

@@ -35,3 +35,55 @@
 export declare function clipboardImage(dir: string, run?: (cmd: string, args: readonly string[]) => {
     status: number | null;
 }): string | null;
+/**
+ * E1 §3 — THE LAST ANSWER, from the record rather than from the screen.
+ *
+ * The source is the session's PROJECTION (`session.projected()`), which
+ * is derived from committed events: a message a retry or an abort voided
+ * is already absent from it, and so is anything still streaming. Two
+ * things this deliberately is NOT:
+ *
+ *   - the rendered rows, which are folded, washed and cut — a paste of
+ *     those is a paste of the terminal's layout, not of the answer;
+ *   - a join of the trailing `text_delta` frames, which are a live
+ *     projection and not a record.
+ *
+ * Null when there is no complete answer yet, so the caller can say so
+ * rather than copying an empty string over whatever the user had.
+ */
+export declare function lastAnswer(messages: readonly import("@vincemakes/kiso-core").Message[]): string | null;
+/** What the clipboard route did, and the one sentence the status row may
+ *  say about it. The message is the product of this function because the
+ *  claim and the act must not be able to drift apart. */
+export interface ClipboardWrite {
+    readonly ok: boolean;
+    readonly message: string;
+}
+interface WriteEnv {
+    readonly platform: string;
+    readonly isTTY: boolean;
+    readonly run: (cmd: string, args: readonly string[], stdin?: string) => {
+        status: number | null;
+    };
+    readonly write: (s: string) => void;
+}
+/**
+ * E1 §3 — PUT TEXT ON THE CLIPBOARD, and say only what happened.
+ *
+ * Two routes, and they differ in what they can KNOW:
+ *
+ *   - **darwin, `pbcopy`**: a real process with a real exit status. When
+ *     it succeeds we can say `copied`. When it fails we say so.
+ *   - **everywhere else, OSC 52**: a REQUEST to the terminal. Most
+ *     terminals do not answer it and Apple Terminal does not implement
+ *     it at all, so there is no success to report — only that we asked.
+ *     The row says `asked the terminal to copy N chars`. An earlier
+ *     draft said `copied N chars (via the terminal)`, which still leads
+ *     with "copied"; a reader takes the first word.
+ *
+ * And a route that does not exist: **stdout that is not a TTY emits
+ * nothing**. An OSC written into a pipe is escape bytes in someone's
+ * data.
+ */
+export declare function clipboardWrite(text: string, env?: Partial<WriteEnv>): ClipboardWrite;
+export {};

package/dist/clipboard.js

@@ -68,3 +68,81 @@ export function clipboardImage(dir, run = defaultRun) {
 function defaultRun(cmd, args) {
     return spawnSync(cmd, [...args], { stdio: "ignore", timeout: 5000 });
 }
+/**
+ * E1 §3 — THE LAST ANSWER, from the record rather than from the screen.
+ *
+ * The source is the session's PROJECTION (`session.projected()`), which
+ * is derived from committed events: a message a retry or an abort voided
+ * is already absent from it, and so is anything still streaming. Two
+ * things this deliberately is NOT:
+ *
+ *   - the rendered rows, which are folded, washed and cut — a paste of
+ *     those is a paste of the terminal's layout, not of the answer;
+ *   - a join of the trailing `text_delta` frames, which are a live
+ *     projection and not a record.
+ *
+ * Null when there is no complete answer yet, so the caller can say so
+ * rather than copying an empty string over whatever the user had.
+ */
+export function lastAnswer(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const m = messages[i];
+        if (m.role !== "assistant")
+            continue;
+        // A turn that only called tools said nothing to copy. Its blocks
+        // are real, so `blocks.length > 0` is not the test — the test is
+        // whether any of them is TEXT.
+        const text = m.blocks
+            .filter((b) => b.type === "text")
+            .map((b) => b.text)
+            .join("\n\n");
+        if (text !== "")
+            return text;
+    }
+    return null;
+}
+/**
+ * E1 §3 — PUT TEXT ON THE CLIPBOARD, and say only what happened.
+ *
+ * Two routes, and they differ in what they can KNOW:
+ *
+ *   - **darwin, `pbcopy`**: a real process with a real exit status. When
+ *     it succeeds we can say `copied`. When it fails we say so.
+ *   - **everywhere else, OSC 52**: a REQUEST to the terminal. Most
+ *     terminals do not answer it and Apple Terminal does not implement
+ *     it at all, so there is no success to report — only that we asked.
+ *     The row says `asked the terminal to copy N chars`. An earlier
+ *     draft said `copied N chars (via the terminal)`, which still leads
+ *     with "copied"; a reader takes the first word.
+ *
+ * And a route that does not exist: **stdout that is not a TTY emits
+ * nothing**. An OSC written into a pipe is escape bytes in someone's
+ * data.
+ */
+export function clipboardWrite(text, env = {}) {
+    const platform = env.platform ?? process.platform;
+    const isTTY = env.isTTY ?? process.stdout.isTTY === true;
+    const run = env.run ?? ((cmd, args, stdin) => spawnSync(cmd, [...args], { input: stdin, stdio: ["pipe", "ignore", "ignore"], timeout: 5000 }));
+    const write = env.write ?? ((s) => process.stdout.write(s));
+    const n = [...text].length;
+    // NO TTY, NO COPY — and this is checked BEFORE the platform, which is
+    // the correction the pipe gate forced.
+    //
+    // The first build let darwin's `pbcopy` run regardless, on the
+    // reasoning that pbcopy is a process and not a terminal route so it
+    // works with stdout redirected. It does work — and that is the
+    // problem: a script running `kiso chat < input.txt` would silently
+    // overwrite whatever the human had on their clipboard. A side effect
+    // on the user's desktop is not something a pipe should be able to
+    // cause by accident.
+    if (!isTTY)
+        return { ok: false, message: "no terminal to copy to" };
+    if (platform === "darwin") {
+        const r = run("pbcopy", [], text);
+        return r.status === 0
+            ? { ok: true, message: `copied ${n} chars` }
+            : { ok: false, message: `could not copy — pbcopy exited ${r.status ?? "abnormally"}` };
+    }
+    write(`\x1b]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`);
+    return { ok: true, message: `asked the terminal to copy ${n} chars` };
+}

package/dist/dispatch.js

@@ -7,6 +7,7 @@ import { contextRows, contextUnavailableRows, displayVerb, escapeTerminal, helpR
 import { newSessionId } from "./session-id.js";
 import { buildAdapter, resolveContinuationScope, resolveReasoning } from "@vincemakes/kiso-runtime/internal";
 import { MODES, MODE_NOTE, getMode, setMode } from "./mode.js";
+import { clipboardWrite, lastAnswer } from "./clipboard.js";
 import { agentModel, body, bodyLog, configModels, dock, readContextLedger, sessionsDir, setAgentModel, setCurrentModelName, setLastBinding } from "./state.js";
 import { directWriteProfile, profileAvailable } from "./config.js";
 /** The ONE dispatcher — slash commands, exit, and turns. The recovery
@@ -106,6 +107,48 @@ export function dispatch(line, ctx) {
         ctx.input.prompt();
         return;
     }
+    if (trimmed === "\x18copy" || trimmed === "/copy") {
+        // E1 §3 — the last answer onto the clipboard, as RAW MARKDOWN.
+        //
+        // The source is the session's PROJECTION, which is derived from
+        // committed events: a message a retry or an abort voided is already
+        // absent from it, and anything still streaming has not landed in it
+        // yet. Deliberately NOT the rendered rows (folded, washed, cut —
+        // that is the terminal's layout, not the answer) and NOT a join of
+        // the trailing text_delta frames (a live projection, not a record).
+        //
+        // One implementation for the key and the command: they are the same
+        // action reached two ways, and two implementations would be two
+        // behaviours waiting to drift.
+        // IT CHAINS, like `/last` and unlike `ctrl+o`. The distinction is
+        // what the action DEPENDS ON: ctrl+o repaints what is already on
+        // screen and can answer at once, while a copy reads the last
+        // ANSWER — which may be the turn currently in flight.
+        //
+        // Found by the pipe gate: a pipe hands the CLI every line at once,
+        // so an unchained `/copy` typed after `go` ran BEFORE the turn and
+        // said "nothing to copy — no answer yet" above the answer it was
+        // asked to copy.
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            const answer = lastAnswer(ctx.session.projected());
+            if (answer === null) {
+                bodyLog("[nothing to copy — no answer yet]");
+            }
+            else {
+                const r = clipboardWrite(answer);
+                // The MESSAGE comes from clipboardWrite, never from here —
+                // the claim and the act must not be able to drift apart. On
+                // the dock it rides the W18 hint slot (gone at the next
+                // keypress); in a pipe it is a line like any other.
+                if (dock.active)
+                    dock.setStatus(r.message);
+                else
+                    bodyLog(`[${r.message}]`);
+            }
+            ctx.input.prompt();
+        });
+        return;
+    }
     if (trimmed === "/rewrap") {
         // R4 (C4d): re-print the recent PROSE at the CURRENT width, at the
         // bottom. kiso hard-folds every row before committing it (invariant

package/dist/index.js

@@ -26,6 +26,7 @@
 import { appendFileSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { newSessionId } from "./session-id.js";
 import { createInterface } from "node:readline";
+import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 import { join } from "node:path";
 import { Body, Editor, bannerLines, currentGround, resolveGround, setGround, escapeTerminal, extensionsBannerText, idColumn, idleStatus, interactivePrompt, palette, renderSessionLine, sessionListFooter, sessionListRow } from "@vincemakes/kiso-tui";
@@ -38,7 +39,7 @@ import { agentModel, atFiles, body, bodyLog, kisoHome, builtInExtensions, curren
 import { askUi, resolveProjectTrust } from "./trust-ui.js";
 import { isFirstRun, scaffoldFirstRun } from "./first-run.js";
 import { fauxSkip, readFauxScript } from "./faux-glue.js";
-import { autoCompactFromEnv, chat, contextWindowTokens, estimateCtxRatio } from "./chat.js";
+import { chat, contextWindowTokens, estimateCtxRatio } from "./chat.js";
 import { loadProjectConfig, loadUserConfig, mergeConfigs, resolveAutoCompact, resolveContextWindow, resolveModel } from "./config.js";
 import { checkForUpdate } from "./update-check.js";
 import { resume } from "./resume.js";
@@ -54,6 +55,22 @@ export { applyProjectMerges } from "./trust-ui.js";
  *  prompt. Only ever constructed when stdin is NOT a TTY. The rl starts
  *  consuming stdin at construction (main), so 'line' events are buffered
  *  until chat() wires the handler — pipe input must never be dropped. */
+/** CX-1 F5 (audit F5): the task-file input — the file's whole content is
+ *  ONE turn, delivered the moment the loop listens, and the input is
+ *  closed right after: chat still awaits the in-flight chain before it
+ *  exits, so the turn runs to its terminal and nothing else is read.
+ *  Built on an EMPTY readline so every other member keeps the pipe
+ *  path's exact semantics (auto-denied asks, no chips, no pops). */
+function taskFileInput(content) {
+    const base = readlineInput(createInterface({ input: Readable.from([]), output: process.stdout }));
+    return {
+        ...base,
+        literal: true,
+        onLine(cb) {
+            cb(content);
+        },
+    };
+}
 function readlineInput(rl) {
     let lineCb = null;
     const pending = [];
@@ -84,6 +101,10 @@ function readlineInput(rl) {
             /* readline has no ctrl+o binding — ignored (W15 rides the
              * editor path only). */
         },
+        onCopy() {
+            /* readline has no ctrl+x binding — ignored. `/copy` still
+             * works here: it is a typed command, not a key. */
+        },
         question(query, cb) {
             rl.question(query, cb);
         },
@@ -164,6 +185,9 @@ function editorInput(editor) {
         onExpand(cb) {
             editor.onExpand(cb);
         },
+        onCopy(cb) {
+            editor.onCopy(cb);
+        },
         // KC2 §2: the redirect gesture — the editor decides WHEN (the
         // same-chunk pair, the precedence gate); chat decides what it MEANS.
         onRedirect(cb) {
@@ -402,10 +426,26 @@ function extensionsBanner(resume = []) {
     // filesystem calls it.
     const home = homedir();
     const cwd = process.cwd();
+    /** DC-49: realpath, falling back to the raw path when it cannot be
+     *  resolved — an unresolvable path is not a match, and throwing here
+     *  would take the banner down over a cosmetic row. */
+    const realOf = (dir) => {
+        try {
+            return realpathSync(dir);
+        }
+        catch {
+            return dir;
+        }
+    };
     body.banner(VERSION, text.replace(/^ · /, ""), resume, {
         model: agentModel,
         mode: getMode() === "plan" ? "plan (read-only)" : getMode(),
         cwd: cwd.startsWith(home) ? `~${cwd.slice(home.length)}` : cwd,
+        // DC-49 — REALPATH on both sides. A symlinked HOME (or a symlinked
+        // cwd) compares unequal as raw strings while being the same
+        // directory, and the row would then be absent exactly where it is
+        // most needed.
+        homeWorkspace: realOf(cwd) === realOf(home),
     });
 }
 /**
@@ -578,7 +618,7 @@ async function makeAgent(sessionId, input, modelFlag) {
         store,
         // Area 5: the coding tools are bound to the workspace — every path
         // they touch is canonicalized inside cwd, escapes are refused.
-        tools: [...createCodingTools({ workspaceRoot: process.cwd() })],
+        tools: [...createCodingTools({ workspaceRoot: process.cwd(), excludeRoots: [kisoHome()] })], // DC-49
         // Modes: the five tiers ride the E1 policy chain (mode:<tier>
         // extensions, current tier first) — the old static PERMISSION_POLICY
         // is gone, its semantics live in the "default" tier. The banner
@@ -844,6 +884,25 @@ async function main() {
     else {
         setMode(modeFromEnv() ?? loadUserConfig()?.mode ?? "default");
     }
+    // CX-1 F5: --task-file <path> — the file is the ONE user turn (the
+    // structured child entry). Read BEFORE any session exists: an
+    // unreadable file is a usage error with nothing executed.
+    let taskFile;
+    {
+        const i = args.indexOf("--task-file");
+        if (i !== -1) {
+            const path = args[i + 1];
+            if (path === undefined)
+                throw new CliUsageError("--task-file needs a path");
+            try {
+                taskFile = readFileSync(path, "utf8");
+            }
+            catch (err) {
+                throw new CliUsageError(`--task-file: cannot read ${path}: ${err.message}`);
+            }
+            args.splice(i, 2);
+        }
+    }
     const [command, arg] = args;
     // round 8: faux mode is the keyless demo script — an exhausted script must
     // exit non-zero, never masquerade as a successful provider run. The
@@ -855,7 +914,7 @@ async function main() {
     // (entered here, dock-bound, trusted before any extension loads),
     // readline elsewhere. The trust question, chat, and resume all read
     // through it; main's finally closes it on every exit path.
-    const input = makeLineInput();
+    const input = taskFile !== undefined ? taskFileInput(taskFile) : makeLineInput();
     // R3a — cross-session input history: ~/.kiso/history, one line per
     // entry, appended on submit, tail-500 at load (truncated by REWRITE
     // at startup so the file never grows unbounded). Unreadable file =
@@ -1073,7 +1132,12 @@ async function main() {
                 agent = await makeAgent(id, input, modelFlag);
                 // finding E4-1's faux resolution rides chatLoop (currentFaux).
                 faux = currentFaux;
-                await chatLoop(agent, id, input, autoCompactFromEnv());
+                // CX-1 F9 (audit F9): the bare entry resolves autoCompact from
+                // the SAME merged config chat/resume use — the env override
+                // lives inside the resolver. It used to pass the env-only
+                // reader, so a user's config.json autoCompact worked on
+                // `kiso chat` and silently vanished on the default entry.
+                await chatLoop(agent, id, input, resolveAutoCompact(mergedConfig));
                 break;
             }
         }

package/dist/state.d.ts

@@ -55,6 +55,10 @@ export declare function readContextLedger(sessionId: string, window: number): im
  * the fuzzy filter sees one alphabet whichever branch ran.
  */
 export declare function atFiles(): readonly AtItem[];
+/** DC-49 — the walk, addressable for the gate. `atFiles` is driven by
+ *  `process.cwd()` and `kisoHome()`, neither of which a unit case can
+ *  set honestly; this is the same function with both supplied. */
+export declare function atWalkFor(root: string, excludeRoots: readonly string[]): readonly string[];
 /**
  * v2c — the interactive input source. TTYs use the raw-mode Editor (the
  * self-drawn input row — width-aware, the CJK-drift root cause retired,
@@ -63,6 +67,9 @@ export declare function atFiles(): readonly AtItem[];
  * source.
  */
 export interface LineInput {
+    /** CX-1 F5: task-file mode — every line delivered is a TURN, never a
+     *  command; the dispatcher is bypassed (a leading `/` is content). */
+    readonly literal?: boolean;
     onLine(cb: (line: string) => void): void;
     onSigint(cb: () => void): void;
     onEot(cb: () => void): void;
@@ -70,6 +77,10 @@ export interface LineInput {
     /** W15: the expand key (ctrl+o) — the chain-level action, never the
      *  editor's own interpretation. */
     onExpand(cb: () => void): void;
+    /** E1 §3: the copy key (ctrl+x) — the chain-level action, never the
+     *  composer's own. The readline input ignores it; `/copy` is the
+     *  route that works everywhere. */
+    onCopy(cb: () => void): void;
     /** KC2 §2: the redirect gesture (Alt+Enter / Ctrl+Enter) — the
      *  buffer's text arrives as a line at the same instant the run is told
      *  to stop. OPTIONAL: the pipe path has no raw keys and never wires

package/dist/state.js

@@ -6,7 +6,7 @@
  * the moved modules read and mutate at call time.
  */
 import { execFileSync } from "node:child_process";
-import { readdirSync, readFileSync } from "node:fs";
+import { readdirSync, readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -119,7 +119,8 @@ export function atFiles() {
         paths = execFileSync("git", ["ls-files", "-c", "-o", "--exclude-standard"], { cwd: process.cwd(), encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 1 << 24 }).split("\n").filter((p) => p !== "");
     }
     catch {
-        paths = atWalk(process.cwd(), "", []);
+        // DC-49: the fallback walk excludes kiso's own state directory.
+        paths = atWalk(process.cwd(), "", [], [kisoHome()]);
     }
     return paths.slice(0, AT_CAP + 1).map((path) => ({ path }));
 }
@@ -128,15 +129,26 @@ export function atFiles() {
  *  directory contributes nothing and ends nothing — the recursion's own
  *  try catches it at that level, so one locked subtree cannot stop a
  *  file picker from opening. */
-function atWalk(dir, prefix, out) {
+function atWalk(dir, prefix, out, excluded = []) {
     try {
         for (const e of readdirSync(dir, { withFileTypes: true })) {
             if (out.length > AT_CAP)
                 break;
             if (AT_SKIP.has(e.name))
                 continue;
-            if (e.isDirectory())
-                atWalk(`${dir}/${e.name}`, `${prefix}${e.name}/`, out);
+            const full = `${dir}/${e.name}`;
+            if (e.isDirectory()) {
+                // DC-49 — the picker does not DESCEND into an excluded root.
+                //
+                // `AT_SKIP` is a list of NAMES with no dot rule, so unlike
+                // tools-node's walk this one has never skipped `~/.kiso` at
+                // all: with the workspace at `~` and no git repo there, `@`
+                // lists the user's own session logs among their files. That
+                // is current behaviour, not a future risk.
+                if (excluded.length > 0 && isUnder(full, excluded))
+                    continue;
+                atWalk(full, `${prefix}${e.name}/`, out, excluded);
+            }
             else if (e.isFile())
                 out.push(`${prefix}${e.name}`);
         }
@@ -146,6 +158,34 @@ function atWalk(dir, prefix, out) {
     }
     return out;
 }
+/** DC-49 — realpath on BOTH sides. darwin's `/tmp` is a symlink to
+ *  `/private/tmp`, so a raw string compare is a check that passes on one
+ *  machine and not another. */
+function isUnder(dir, roots) {
+    let real;
+    try {
+        real = realpathSync(dir);
+    }
+    catch {
+        real = dir;
+    }
+    return roots.some((r) => {
+        let rr;
+        try {
+            rr = realpathSync(r);
+        }
+        catch {
+            rr = r;
+        }
+        return real === rr || real.startsWith(`${rr}/`);
+    });
+}
+/** DC-49 — the walk, addressable for the gate. `atFiles` is driven by
+ *  `process.cwd()` and `kisoHome()`, neither of which a unit case can
+ *  set honestly; this is the same function with both supplied. */
+export function atWalkFor(root, excludeRoots) {
+    return atWalk(root, "", [], excludeRoots);
+}
 /** v2b: the bottom-anchored UI — docked only on a color TTY; pipes and
  *  NO_COLOR stay the v2a line mode byte-for-byte. Created at load, like
  *  the pre-split module-scope const. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-code",
-	"version": "0.25.0",
+	"version": "0.26.1",
 	"description": "kiso CLI — 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.25.0",
-		"@vincemakes/kiso-core": "0.25.0",
-		"@vincemakes/kiso-evals": "0.25.0",
-		"@vincemakes/kiso-mcp-ext": "0.25.0",
-		"@vincemakes/kiso-provider-anthropic": "0.25.0",
-		"@vincemakes/kiso-provider-openai": "0.25.0",
-		"@vincemakes/kiso-runtime": "0.25.0",
-		"@vincemakes/kiso-skills-ext": "0.25.0",
-		"@vincemakes/kiso-subagent-ext": "0.25.0",
-		"@vincemakes/kiso-task-ext": "0.25.0",
-		"@vincemakes/kiso-tools-node": "0.25.0",
-		"@vincemakes/kiso-tui": "0.25.0",
-		"@vincemakes/kiso-tui-cells": "0.25.0"
+		"@vincemakes/kiso-ask-ext": "0.26.1",
+		"@vincemakes/kiso-core": "0.26.1",
+		"@vincemakes/kiso-evals": "0.26.1",
+		"@vincemakes/kiso-mcp-ext": "0.26.1",
+		"@vincemakes/kiso-provider-anthropic": "0.26.1",
+		"@vincemakes/kiso-provider-openai": "0.26.1",
+		"@vincemakes/kiso-runtime": "0.26.1",
+		"@vincemakes/kiso-skills-ext": "0.26.1",
+		"@vincemakes/kiso-subagent-ext": "0.26.1",
+		"@vincemakes/kiso-task-ext": "0.26.1",
+		"@vincemakes/kiso-tools-node": "0.26.1",
+		"@vincemakes/kiso-tui": "0.26.1",
+		"@vincemakes/kiso-tui-cells": "0.26.1"
 	},
 	"devDependencies": {
 		"@types/node": "^26.1.2",