kritya 0.8.26-beta → 0.8.27-beta

package/README.md

@@ -55,7 +55,7 @@ review → fix` for building something new end-to-end
 
 ## Setup
 
-Requires Node.js >=22.
+Requires Node.js >=22.19.0.
 
 1. Get an API key from your chosen provider (click any
    model → "Get API Key").
@@ -170,7 +170,8 @@ In-session commands (type `/` to see them with autocomplete; letters filter the
 Custom `/commands` you define (see [docs/CONFIGURATION.md](docs/CONFIGURATION.md#custom-slash-commands)) also appear here.
 
 `Esc` cancels a running request. `↑/↓` recalls input history. `Ctrl+O` toggles
-full tool output. `Ctrl+K` is the kill switch (see below). `Ctrl+C` exits.
+full tool output. `Ctrl+E` opens the file the agent touched most recently in
+`$EDITOR`. `Ctrl+K` is the kill switch (see below). `Ctrl+C` exits.
 
 ### More features
 

package/dist/agent/skills.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { writeStderr } from "../stderr.js";
 import { pluginsDir, pluginSkillsRoots, scanPlugins, userPluginsDir } from "../plugins/discover.js";
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 const KEY_VALUE_RE = /^([A-Za-z0-9_-]+):\s*(.*)$/;
@@ -73,7 +74,7 @@ function unquote(value) {
     return value;
 }
 let warnSink = (message) => {
-    process.stderr.write(`kritya: ${message}\n`);
+    writeStderr(`kritya: ${message}\n`);
 };
 function warn(message) {
     warnSink(message);

package/dist/config/config.js

@@ -161,6 +161,8 @@ export function resolveProvider(config, override) {
         apiKey = merged.apiKey;
     if (!apiKey && name === "nvidia")
         apiKey = process.env.NVIDIA_API_KEY || config.apiKey;
+    if (apiKey)
+        apiKey = apiKey.trim();
     return {
         name,
         baseUrl,

package/dist/config/debug.js

@@ -1,3 +1,4 @@
+import { writeStderr } from "../stderr.js";
 /**
  * Most best-effort persistence (session/audit/telemetry writes, config and
  * trust-file reads, hook loading, …) deliberately swallows its own errors —
@@ -10,12 +11,7 @@ export function debugLog(context, err) {
     if ((process.env.KRITYA_DEBUG ?? "").toLowerCase() !== "1" && process.env.KRITYA_DEBUG !== "true")
         return;
     const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
-    try {
-        process.stderr.write(`[kritya debug] ${context}: ${message}\n`);
-    }
-    catch {
-        // stderr itself failing isn't something debug logging can do anything about
-    }
+    writeStderr(`[kritya debug] ${context}: ${message}\n`);
 }
 /**
  * For best-effort persistence that a user actually needs to know failed
@@ -39,12 +35,7 @@ export function warnUser(context, err) {
     }
     warnedContexts.add(context);
     const message = err instanceof Error ? err.message : String(err);
-    try {
-        process.stderr.write(`[kritya] warning: ${context} failed: ${message}\n`);
-    }
-    catch {
-        // stderr itself failing isn't something this can do anything about
-    }
+    writeStderr(`[kritya] warning: ${context} failed: ${message}\n`);
     debugLog(context, err);
 }
 /** Contexts currently warning via warnPersistenceFailure, in the order first seen. */

package/dist/config/models.js

@@ -45,6 +45,24 @@ export const CURATED_MODELS = [
         note: "strong agentic tool use",
         contextWindow: 256_000,
     },
+    {
+        id: "z-ai/glm-5.3",
+        label: "GLM 5.3",
+        note: "strong agentic tool use",
+        contextWindow: 1_048_576,
+    },
+    {
+        id: "z-ai/glm-5.3-flash",
+        label: "GLM 5.3 Flash",
+        note: "fast + cheap",
+        contextWindow: 1_048_576,
+    },
+    {
+        id: "deepseek-ai/deepseek-v4.1-flash",
+        label: "DeepSeek V4.1 Flash",
+        note: "fast + cheap",
+        contextWindow: 1_048_576,
+    },
 ];
 export const DEFAULT_MODEL = CURATED_MODELS[0].id;
 /**

package/dist/index.js

@@ -16,7 +16,7 @@ import { AuditLog } from "./audit/audit.js";
 import { runAuditCli } from "./audit/cli.js";
 import { runSkillsCli } from "./agent/skillsCli.js";
 import { createTracer, cleanupOldTelemetry } from "./telemetry/tracer.js";
-import { createMeter } from "./telemetry/metrics.js";
+import { createMeter, RENDER_BOUNDS_MS } from "./telemetry/metrics.js";
 import { retentionDaysFor } from "./config/retention.js";
 import { backgroundManager } from "./shell/background.js";
 import { defaultSandboxMode, sandboxAvailable, sandboxUnavailableReason } from "./shell/sandbox.js";
@@ -415,6 +415,17 @@ async function main() {
                     sessionMeter.flushAndWait(),
                     new Promise((resolve) => setTimeout(resolve, 2000).unref()),
                 ]);
+                // Hand the terminal back before leaving. Ink hides the cursor for the
+                // whole time it is rendering and only shows it again from its own
+                // teardown — which the process.exit() below skips, leaving the shell's
+                // prompt invisible until the user runs `reset`. unmount() is that
+                // teardown; it also finishes drawing the frame we are standing on.
+                try {
+                    ui.instance?.unmount();
+                }
+                catch {
+                    // Whatever brought us here may have been the UI itself. Exit anyway.
+                }
                 cleanup();
                 process.exit(code);
             })();
@@ -709,12 +720,24 @@ async function main() {
     // compaction — subagents (read-only or write) never do, even though they
     // run the same Agent class and can also trigger auto-compaction.
     agent.autoMemory = true;
+    // How long Ink takes to turn the React tree into a frame, per frame. This is
+    // the part of drawing a screen that grows with the size of the transcript, so
+    // it is the number that says whether the UI is getting sluggish — the
+    // terminal write it excludes is bounded by the terminal, not by us.
+    // `renderTime` excludes Ink's own throttling, so it is the raw cost of the
+    // frame rather than the interval between frames.
+    const renderHistogram = sessionMeter.histogram("kritya.render.duration_ms", RENDER_BOUNDS_MS);
     ui.instance = render(_jsx(App, { agent: agent, workspace: workspace, modelRef: modelRef, providerRef: providerRef, config: config, resumedCount: initialHistory.length, initialTasks: initialTasks, undoStack: undoStack, uiBridge: uiBridge, resumeSessions: resumeSessions.length ? resumeSessions : undefined, customCommands: loadCustomCommands(workspace, trustWorkspace, plugins), mcpToolCount: mcpTools.length, onSwitchClient: (newClient) => {
             client = newClient;
         }, onRequestPermissionReady: (fn) => {
             permissionRef.current = fn;
         }, onRequestElicitationReady: (fn) => {
             elicitationRef.current = fn;
-        }, privacyMode: privacyMode, firstLaunch: firstLaunch }));
+        }, privacyMode: privacyMode, firstLaunch: firstLaunch }), {
+        onRender: ({ renderTime }) => renderHistogram.record(renderTime),
+        // Repaint only the lines that changed instead of the whole frame:
+        // less flicker and less CPU while streaming. Ink 8 native.
+        incrementalRendering: true,
+    });
     markBannerSeen(workspace);
 }

package/dist/mcp/client.js

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { writeStderr } from "../stderr.js";
 import { VERSION } from "../version.js";
 import { NOOP_TRACER } from "../telemetry/tracer.js";
 import { McpAuthRequiredError } from "./oauth.js";
@@ -644,14 +645,14 @@ function exposedToolName(server, toolName) {
  * is registered on the transport so `tools/call` can mirror argument values
  * into `Mcp-Param-{Name}` headers later — see `ModernHttpTransport.
  * setToolHeaderMap`/`send`. Logged the same way other "skip with a warning"
- * MCP failures are (`process.stderr.write("kritya: ...")`).
+ * MCP failures are (`writeStderr("kritya: ...")`).
  */
 function filterHeaderAnnotatedTools(server, specs, transport) {
     const kept = [];
     for (const spec of specs) {
         const result = validateToolHeaders(spec.inputSchema);
         if (!result.ok) {
-            process.stderr.write(`kritya: MCP server "${server}" tool "${spec.name}" excluded — invalid x-mcp-header ` +
+            writeStderr(`kritya: MCP server "${server}" tool "${spec.name}" excluded — invalid x-mcp-header ` +
                 `annotation: ${result.reason}\n`);
             continue;
         }
@@ -675,7 +676,7 @@ function filterSchemaSafeTools(server, specs) {
     for (const spec of specs) {
         const result = checkSchemaSafety(spec.inputSchema);
         if (!result.ok) {
-            process.stderr.write(`kritya: MCP server "${server}" tool "${spec.name}" excluded — unsafe inputSchema: ` +
+            writeStderr(`kritya: MCP server "${server}" tool "${spec.name}" excluded — unsafe inputSchema: ` +
                 `${result.reason}\n`);
             continue;
         }
@@ -852,7 +853,7 @@ export async function connectServer(name, cfg, trace) {
         }
         else {
             status.error = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`kritya: MCP server "${name}" failed to start: ${status.error}\n`);
+            writeStderr(`kritya: MCP server "${name}" failed to start: ${status.error}\n`);
             span.setStatus("ERROR", status.error);
             // status.error comes from the (untrusted) server process's own error
             // output, which could echo back an env var or header value it was

package/dist/net/urlSafety.js

@@ -1,5 +1,5 @@
 import { lookup as dnsLookup } from "node:dns/promises";
-import { Agent } from "undici";
+import { Agent, Dispatcher1Wrapper } from "undici";
 /**
  * Shared "is this host on a private/internal network" check, used by both
  * fetch_url (src/tools/fetchUrl.ts) and the MCP HTTP transport guard
@@ -210,7 +210,7 @@ export function assertSafeUrl(label, url) {
  * it's safe to share across every call site that uses the same policy.
  */
 function createPinnedDispatcher(isBlockedAddress) {
-    return new Agent({
+    return new Dispatcher1Wrapper(new Agent({
         connect: {
             lookup(hostname, options, callback) {
                 dnsLookup(hostname, { all: true })
@@ -235,7 +235,7 @@ function createPinnedDispatcher(isBlockedAddress) {
                     .catch((err) => callback(err, []));
             },
         },
-    });
+    }));
 }
 /** For callers that never allow loopback either (fetch_url). */
 export const pinnedDispatcher = createPinnedDispatcher(isPrivateOrLoopbackHost);

package/dist/plugins/discover.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { writeStderr } from "../stderr.js";
 /**
  * Scans each root for `<name>/plugin.json` folders, in name order, and reports
  * both what loaded and why anything didn't. Roots that don't exist are
@@ -73,7 +74,7 @@ export function scanPluginsDetailed(roots) {
     return { loaded: [...seen.values()], skipped };
 }
 let warnSink = (message) => {
-    process.stderr.write(`kritya: ${message}\n`);
+    writeStderr(`kritya: ${message}\n`);
 };
 function warn(message) {
     warnSink(message);

package/dist/plugins/mcp.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { writeStderr } from "../stderr.js";
 function isServerConfig(v) {
     if (!v || typeof v !== "object")
         return false;
@@ -65,7 +66,7 @@ export function scanPluginMcpServers(plugins) {
  * map for labeling `/mcp` output. Skips are reported via `warn` (defaults to
  * stderr, like scanPlugins/scanSkills).
  */
-export function loadPluginMcpServers(plugins, warn = (m) => process.stderr.write(`kritya: ${m}\n`)) {
+export function loadPluginMcpServers(plugins, warn = (m) => writeStderr(`kritya: ${m}\n`)) {
     const { loaded, skipped } = scanPluginMcpServers(plugins);
     for (const s of skipped) {
         warn(`skipping mcp server "${s.name}" from plugin "${s.pluginName}": ${s.reason}`);

package/dist/repomap/repoMap.js

@@ -9,7 +9,7 @@
  */
 import fs from "node:fs/promises";
 import path from "node:path";
-import fg from "fast-glob";
+import { glob } from "tinyglobby";
 import { isPathSafe, resolveSafe } from "../tools/common.js";
 import { loadIgnorePatterns } from "../tools/ignore.js";
 import { CODE_EXTENSIONS, extractSymbols } from "./symbols.js";
@@ -88,13 +88,13 @@ export async function buildRepoMap(workspace, subdir = ".", options = {}) {
     const opts = { ...DEFAULTS, ...options };
     const root = resolveSafe(workspace, subdir || ".");
     const scopeLabel = path.relative(workspace, root) || "(workspace root)";
-    const found = await fg("**/*", {
+    const found = await glob("**/*", {
         cwd: root,
         dot: false,
         onlyFiles: true,
         followSymbolicLinks: false,
+        expandDirectories: false,
         ignore: ["**/node_modules/**", "**/.git/**", ...loadIgnorePatterns(workspace)],
-        suppressErrors: true,
     });
     // Keep only source files, then rank by path so the maxFiles cap (which bounds
     // how many files we actually read) retains the most important ones.

package/dist/stderr.js

@@ -0,0 +1,47 @@
+/**
+ * Where a warning goes while someone else owns the terminal.
+ *
+ * Ink owns the terminal for the whole time the UI is up. It keeps its frame in
+ * a known place, and anything that reaches the terminal *through* Ink is
+ * written between clearing that frame and repainting it — so the text lands
+ * above the UI and stays there. A raw `process.stderr.write` bypasses all of
+ * that: the bytes land wherever the cursor happened to be, in the middle of
+ * the frame, and the next repaint erases and redraws against a line count that
+ * no longer matches the screen. The warning comes out garbled and takes the
+ * frame with it.
+ *
+ * Ink patches `console` for exactly this reason, but `console.error` is not
+ * available to the plain module functions that raise these warnings — an agent
+ * loop, an MCP client, a plugin loader — and a hook (`useStderr`) cannot be
+ * called from one. So the UI registers a sink on mount and clears it on
+ * unmount, and everything else goes through `writeStderr`, which uses the sink
+ * when there is one and raw stderr when there is not: CLI subcommands, headless
+ * runs, and anything before the UI mounts or after it is torn down.
+ *
+ * Deliberately not used by `crash.ts`: by the time a crash handler runs, the
+ * UI is being torn down and its frame state is not trustworthy, so the crash
+ * report goes straight to stderr.
+ */
+let sink;
+/** Installed by the mounted UI. Pass `undefined` on unmount. */
+export function setStderrSink(fn) {
+    sink = fn;
+}
+/** Write a warning to stderr, through the UI when one is mounted. */
+export function writeStderr(text) {
+    if (sink) {
+        try {
+            sink(text);
+            return;
+        }
+        catch {
+            // A sink that throws must not cost us the warning itself.
+        }
+    }
+    try {
+        process.stderr.write(text);
+    }
+    catch {
+        // stderr is gone; there is nowhere left to put it.
+    }
+}

package/dist/telemetry/metrics.js

@@ -11,6 +11,17 @@ export const NOOP_METER = {
     stop() { },
 };
 export const DEFAULT_LATENCY_BOUNDS_MS = [10, 50, 100, 250, 500, 1000, 2500, 5000, 10000, 30000];
+/**
+ * Buckets for Ink's per-frame `onRender` timing.
+ *
+ * The default latency bounds are useless here: drawing a frame is a
+ * sub-millisecond to low-single-digit-millisecond affair, so every sample would
+ * land in the first bucket and the histogram would say nothing. These cluster
+ * below the frame budget instead, and 33ms is the edge that matters — Ink caps
+ * rendering at 30fps (1000 / 30 ≈ 33.3ms), so a sample past it is a frame the
+ * UI could not draw on time.
+ */
+export const RENDER_BOUNDS_MS = [0.25, 0.5, 1, 2, 4, 8, 16, 24, 33, 66, 133];
 function nowUnixNano() {
     return (BigInt(Date.now()) * 1000000n).toString();
 }

package/dist/telemetry/tracer.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { CONFIG_DIR } from "../config/config.js";
 import { hardenWindowsDir } from "../config/winAcl.js";
 import { debugLog, warnPersistenceFailure } from "../config/debug.js";
+import { writeStderr } from "../stderr.js";
 import { VERSION } from "../version.js";
 import { encodeSpan, postOtlp } from "./otlp.js";
 function nowUnixNano() {
@@ -164,12 +165,7 @@ function fileSink(file) {
 }
 function consoleSink() {
     return (span) => {
-        try {
-            process.stderr.write(`[otel] ${JSON.stringify(span)}\n`);
-        }
-        catch {
-            // best-effort
-        }
+        writeStderr(`[otel] ${JSON.stringify(span)}\n`);
     };
 }
 function resourceFor(sessionId) {

package/dist/tools/glob.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import fg from "fast-glob";
+import { glob } from "tinyglobby";
 import { isPathSafe, truncateResult, countLines } from "./common.js";
 import { loadIgnorePatterns } from "./ignore.js";
 export const globTool = {
@@ -17,14 +17,14 @@ export const globTool = {
     summarize: (args) => `Glob ${args.pattern}`,
     resultSummary: (output) => countLines(output, "match", "matches"),
     async execute(args, ctx) {
-        // Models on Windows sometimes emit backslash paths; fast-glob needs forward slashes.
-        const files = await fg(String(args.pattern).replaceAll("\\", "/"), {
+        // Models on Windows sometimes emit backslash paths; glob patterns need forward slashes.
+        const files = await glob(String(args.pattern).replaceAll("\\", "/"), {
             cwd: ctx.workspace,
             dot: false,
             onlyFiles: true,
             followSymbolicLinks: false,
+            expandDirectories: false,
             ignore: ["**/node_modules/**", "**/.git/**", ...loadIgnorePatterns(ctx.workspace)],
-            suppressErrors: true,
         });
         const safeFiles = files.filter((f) => isPathSafe(ctx.workspace, path.join(ctx.workspace, f)));
         const capped = safeFiles.sort().slice(0, 200);

package/dist/tools/grep.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import fg from "fast-glob";
+import { glob } from "tinyglobby";
 import { isPathSafe, resolveSafe, safeCompileRegex, truncateResult, meaningfulLines, } from "./common.js";
 import { loadIgnorePatterns } from "./ignore.js";
 const MAX_MATCHES = 200;
@@ -34,14 +34,14 @@ export const grepTool = {
     async execute(args, ctx) {
         const regex = safeCompileRegex(String(args.pattern));
         const searchRoot = resolveSafe(ctx.workspace, String(args.path ?? "."));
-        // Models on Windows sometimes emit backslash paths; fast-glob needs forward slashes.
-        const files = await fg(String(args.include ?? "**/*").replaceAll("\\", "/"), {
+        // Models on Windows sometimes emit backslash paths; glob patterns need forward slashes.
+        const files = await glob(String(args.include ?? "**/*").replaceAll("\\", "/"), {
             cwd: searchRoot,
             dot: false,
             onlyFiles: true,
             followSymbolicLinks: false,
+            expandDirectories: false,
             ignore: ["**/node_modules/**", "**/.git/**", ...loadIgnorePatterns(ctx.workspace)],
-            suppressErrors: true,
         });
         const matches = [];
         for (const file of files) {

package/dist/tools/ignore.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 const IGNORE_FILE = ".krityaignore";
-/** Converts one gitignore-style line into fast-glob ignore pattern(s). */
+/** Converts one gitignore-style line into glob ignore pattern(s). */
 function toGlobPatterns(line) {
     let pattern = line.trim();
     if (!pattern || pattern.startsWith("#") || pattern.startsWith("!"))
@@ -15,7 +15,7 @@ function toGlobPatterns(line) {
     const base = anchored ? pattern : `**/${pattern}`;
     return isDir ? [`${base}/**`] : [base, `${base}/**`];
 }
-/** Reads `<workspace>/.krityaignore` (gitignore-style, one pattern per line) as fast-glob ignore patterns. */
+/** Reads `<workspace>/.krityaignore` (gitignore-style, one pattern per line) as glob ignore patterns. */
 export function loadIgnorePatterns(workspace) {
     let raw;
     try {

package/dist/ui/ApiKeySetupPrompt.js

@@ -1,7 +1,7 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
 import { Box, Text, useInput } from "ink";
-import TextInput from "ink-text-input";
+import { TextInput } from "./TextInput.js";
 /**
  * Shown once, only when the active provider has no API key resolved, on the
  * interactive TTY path (never from headless — see runHeadless in