@vincemakes/kiso-code 0.24.5 → 0.26.0

package/dist/chat.js

@@ -1193,6 +1193,9 @@ export async function chat(session, faux, input, autoCompact, nav) {
     // 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.

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
@@ -82,51 +83,70 @@ export function dispatch(line, ctx) {
         return;
     }
     if (trimmed === "\x12expand") {
-        // W15: the expand key (ctrl+o) — /last aimed at a chosen cell.
-        // The TARGET is picked at press time: a LIVE tool cell toggles
-        // IMMEDIATELY in place (the compositor owns those rows and
-        // redraws them — the approval pause is exactly when the user
-        // reads a cut diff, and the key must answer then, never after
-        // the run). A COMMITTED cell can never toggle — history is never
-        // rewritten (ADR-0046) — so its expanded block and the empty
-        // answer queue on the chain like /last: the block lands as new
-        // content after any in-flight turn. The sentinel carries the
-        // control char so a typed "expand" turn is never intercepted.
-        const r = body.expandNext();
-        if (r.kind === "toggled") {
-            ctx.input.prompt(); // in place — the frame already repainted
-            return;
-        }
-        const land = async () => {
-            if (r.kind === "appended") {
-                // DC-51 — ONE CALL, because one call is ONE CELL.
-                //
-                // This was a loop, one `bodyLog` per line, and each call
-                // makes its own raw cell — so D1 put a blank between every
-                // pair and the expansion came out laced with unpainted
-                // rows, twice the height of the card it is meant to be.
-                // The owner saw it as stripes.
-                //
-                // It only became wrong when the block became RENDERED ROWS
-                // (0.24.2 ③). Before that the lines were a header and two
-                // multi-line payloads — four cells, and the payloads' own
-                // newlines kept their rows inside one cell each.
-                //
-                // `bodyLog` splits on newlines, and a rendered row may not
-                // contain one (invariant ①b throws on it), so joining is
-                // exactly reversible here.
-                bodyLog(r.lines.join("\n"));
+        // DC-50 / R14 — ONE SWITCH, AND THE SESSION IS PRINTED AGAIN.
+        //
+        // What stood here: the key picked a TARGET at press time. A live
+        // tool cell toggled in place; a committed one could not, because
+        // ADR-0046 §3 forbade rewriting history — so its body was
+        // APPENDED as new content, chained behind any in-flight turn,
+        // with a ring choosing which card was next, `#opened` keeping the
+        // ring from repeating, `#lastAppend` stopping a held key printing
+        // the same rows three times (DC-35), and a two-branch "nothing to
+        // expand" message for the two ways it could decline.
+        //
+        // Amendment 1 removes the premise the whole apparatus served: the
+        // terminal's scrollback is ours to erase, so a committed card can
+        // be re-rendered where it stands. The key flips one boolean and
+        // the session is reprinted; every settled card obeys it, running
+        // cards keep their own window (E2/DC-43).
+        //
+        // It no longer chains. There is no content to land after an
+        // in-flight turn — nothing is appended — so the repaint is
+        // immediate, exactly as the live-cell toggle always was.
+        body.toggleExpanded();
+        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 if (r.kind === "none") {
-                // DC-35: "nothing to expand" was said in two situations and
-                // was only true in one of them. A reader who pressed the key
-                // on a ring of one had something to open — they were already
-                // looking at it — and the old line told them the opposite.
-                bodyLog(r.why === "already-last" ? "[that expansion is already the last thing on screen — ctrl+r opens the transcript]" : "[nothing to expand]");
+            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();
-        };
-        ctx.chainRef.current = ctx.chainRef.current.then(land);
+        });
         return;
     }
     if (trimmed === "/rewrap") {

package/dist/index.js

@@ -84,6 +84,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 +168,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 +409,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 +601,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

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,
@@ -70,6 +74,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.24.5",
+	"version": "0.26.0",
 	"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.24.5",
-		"@vincemakes/kiso-core": "0.24.5",
-		"@vincemakes/kiso-evals": "0.24.5",
-		"@vincemakes/kiso-mcp-ext": "0.24.5",
-		"@vincemakes/kiso-provider-anthropic": "0.24.5",
-		"@vincemakes/kiso-provider-openai": "0.24.5",
-		"@vincemakes/kiso-runtime": "0.24.5",
-		"@vincemakes/kiso-skills-ext": "0.24.5",
-		"@vincemakes/kiso-subagent-ext": "0.24.5",
-		"@vincemakes/kiso-task-ext": "0.24.5",
-		"@vincemakes/kiso-tools-node": "0.24.5",
-		"@vincemakes/kiso-tui": "0.24.5",
-		"@vincemakes/kiso-tui-cells": "0.24.5"
+		"@vincemakes/kiso-ask-ext": "0.26.0",
+		"@vincemakes/kiso-core": "0.26.0",
+		"@vincemakes/kiso-evals": "0.26.0",
+		"@vincemakes/kiso-mcp-ext": "0.26.0",
+		"@vincemakes/kiso-provider-anthropic": "0.26.0",
+		"@vincemakes/kiso-provider-openai": "0.26.0",
+		"@vincemakes/kiso-runtime": "0.26.0",
+		"@vincemakes/kiso-skills-ext": "0.26.0",
+		"@vincemakes/kiso-subagent-ext": "0.26.0",
+		"@vincemakes/kiso-task-ext": "0.26.0",
+		"@vincemakes/kiso-tools-node": "0.26.0",
+		"@vincemakes/kiso-tui": "0.26.0",
+		"@vincemakes/kiso-tui-cells": "0.26.0"
 	},
 	"devDependencies": {
 		"@types/node": "^26.1.2",