kronk-cli 0.1.2 → 0.1.3

package/README.md

@@ -50,6 +50,16 @@ workflow run that produced it:
 gh attestation verify kronk-cli-*.tgz --repo BardiaN/kronk-cli
 ```
 
+The same attestation is attached to every release as a file, so it can be checked without
+GitHub's attestations API in the loop — `<tarball>.sigstore.json` for `gh attestation verify`
+and cosign, `<tarball>.intoto.jsonl` for SLSA tooling:
+
+```bash
+gh release download v0.1.3 --repo BardiaN/kronk-cli
+gh attestation verify kronk-cli-0.1.3.tgz --repo BardiaN/kronk-cli \
+  --bundle kronk-cli-0.1.3.tgz.sigstore.json
+```
+
 npm packages carry the same provenance, shown as a **Provenance** panel on the
 [package page](https://www.npmjs.com/package/kronk-cli), and verifiable locally:
 
@@ -315,6 +325,45 @@ kronk-cli --auto "make the tests pass"      # unattended, runs the whole task
 
 ---
 
+## Startup: the model is loaded before you type
+
+Kronk has no load command. It lists a model in `GET /v1/models` as soon as the
+server starts, but the weights only reach VRAM on the first inference request —
+so on a fresh server the first prompt you type pays a 10–30 s cold load, and
+looks like a hang.
+
+`kronk-cli` pays it at boot instead. It asks Kronk what is resident, and if the
+selected model is not, sends the cheapest completion there is — one token, no
+reasoning — to trigger admission:
+
+```console
+$ kronk-cli
+  loaded   unsloth/Qwen3.6-35B-A3B-UD-Q4_K_M/AGENT · 11.4s
+
+  ██ kronk-cli  · local agent, no network
+```
+
+A model already in the pool is left alone; nothing is sent. If the selected one
+cannot be admitted — it will not fit next to what is already resident — the
+fallback runs the same order the CLI uses when you name nothing: the configured
+default, then the best id Kronk is serving. Each is tried once, and a failure
+says why:
+
+```console
+$ kronk-cli -m Qwen3.6-27B
+  unsloth/Qwen3.6-27B-Q4_K_M failed to load — 507 /chat/completions — insufficient VRAM
+  loaded   unsloth/Qwen3.6-35B-A3B-UD-Q4_K_M/AGENT · 2.0s · fallback
+```
+
+If nothing loads, the original pick stands and the first turn reports the real
+error. A warm-up is a convenience, not a gate — it never decides whether the CLI
+starts.
+
+Skip it with `--no-warm` or `KRONK_WARM=false` and the first prompt pays the load,
+as before.
+
+---
+
 ## Command-line options
 
 | Flag | Default | |
@@ -323,6 +372,7 @@ kronk-cli --auto "make the tests pass"      # unattended, runs the whole task
 | `-l`, `--models`, `--list` | — | List the models Kronk is serving, then exit |
 | `--no-context` | off | Skip the startup scan of the working directory |
 | `--no-compact` | off | Never auto-compact; fail when the window fills instead |
+| `--no-warm` | off | Don't preload the model at startup; let the first prompt trigger the load |
 | `--mcp [names]` | off | Attach MCP servers — bare for all, or a comma list |
 | `--mcp-list` | — | Show configured MCP servers and their tools, then exit |
 | `-a`, `--auto` | off | Autonomous: auto-approve tools **and** run until the task is done. Implies `--yes` |
@@ -391,6 +441,7 @@ The per-turn usage line still prints after each response; this one is the runnin
 | `KRONK_SANDBOX_DENY` | — | Extra paths to hide from `bash`, comma or colon separated |
 | `KRONK_DISTILL` | `true` | `false` disables tool-output distillation |
 | `KRONK_DISTILL_AT` | `8000` | Characters of output that trigger distillation |
+| `KRONK_WARM` | `true` | `false` skips the boot-time model preload |
 | `KRONK_AUTO_COMPACT` | `true` | `false` disables automatic compaction |
 | `KRONK_COMPACT_AT` | `0.85` | Fraction of the window that triggers compaction |
 | `NO_COLOR` | — | Any value disables colour |
@@ -847,7 +898,7 @@ previous prompt prefix — watch `cached` climb in the usage line.
 |---|---|
 | `Cannot reach Kronk` | `kronk server start --detach` |
 | `Kronk is running but has no models` | `kronk model pull <id>` |
-| First response takes ~25 s | Cold model load. Keep it warm with `--pool-ttl 1h` on the server |
+| First response takes ~25 s | Cold model load, and you started with `--no-warm`. Drop the flag, or keep the model warm with `--pool-ttl 1h` on the server |
 | Long silence before text | The model is reasoning. `--no-think`, or `/thinking` to watch it |
 | `(model produced no answer)` | Reasoning consumed the whole budget. Raise `KRONK_MAX_TOKENS` or use `--no-think` |
 | `kronk-cli: command not found` after an nvm switch | Re-run `npm link`, or see [Using nvm?](#using-nvm) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kronk-cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A Claude-Code-style terminal agent for local models served by Kronk.",
   "license": "Apache-2.0",
   "type": "module",

package/src/boot.js

@@ -0,0 +1,59 @@
+import { config, DEFAULT_MODEL } from './config.js';
+import { listLoaded, warm } from './client.js';
+import { c, spinner } from './ui.js';
+
+/** Last resort when neither the flag nor DEFAULT_MODEL is being served. */
+export function pickDefault(ids) {
+  const chat = ids.filter((id) => !/embedding|rerank/i.test(id));
+  const agent = chat.filter((id) => id.endsWith('/AGENT'));
+  const pool = agent.length ? agent : chat;
+  return pool.sort((a, b) => b.length - a.length)[0] ?? null;
+}
+
+/**
+ * Get the chosen model resident before the first prompt.
+ *
+ * A freshly started Kronk serves model *ids* but holds nothing in VRAM — it
+ * admits a model on its first inference request, and there is no endpoint that
+ * does it sooner. Left alone, that 10–25 s cold load lands on the first thing
+ * you type, looking like a hang. Do it here, where a spinner explains the wait
+ * and where a model that will not fit can still fall back to one that will.
+ *
+ * Never fatal: if nothing warms, the original pick stands and the first turn
+ * reports the real error. A warm-up is a convenience, not a gate.
+ *
+ * Returns the id left in `config.model`.
+ */
+export async function ensureLoaded(ids, log = console.error) {
+  const loaded = await listLoaded();
+  const resident = new Set((Array.isArray(loaded) ? loaded : []).map((l) => l.id));
+  if (resident.has(config.model)) return config.model;
+
+  const chosen = config.model;
+  // chosen → configured default → best guess; each distinct id tried once.
+  const chain = [...new Set([
+    chosen,
+    ids.includes(DEFAULT_MODEL) ? DEFAULT_MODEL : null,
+    pickDefault(ids),
+  ])].filter(Boolean);
+
+  for (const id of chain) {
+    if (resident.has(id)) { config.model = id; return id; }
+    const t0 = Date.now();
+    const spin = spinner(`loading ${id.split('/').pop()} — first run takes 10-30s`);
+    try {
+      await warm(id);
+      spin.stop();
+      const how = `${((Date.now() - t0) / 1000).toFixed(1)}s${id === chosen ? '' : ' · fallback'}`;
+      log(c.grey(`  loaded   ${id} · ${how}`));
+      config.model = id;
+      return id;
+    } catch (e) {
+      spin.stop();
+      log(c.yellow(`  ${id} failed to load — ${e.message.split('\n')[0].slice(0, 160)}`));
+    }
+  }
+  // Nothing would load. Keep the original pick and let the first turn say why.
+  config.model = chosen;
+  return chosen;
+}

package/src/client.js

@@ -113,3 +113,25 @@ export async function* streamChat({ model, messages, tools, signal, maxTokens, n
 
   yield { type: 'done', calls: [...calls.values()], finish };
 }
+
+/**
+ * Load a model into the pool.
+ *
+ * Kronk has no explicit "load" endpoint — admission happens on the first
+ * inference request, so the cheapest possible completion *is* the load
+ * command. A 23 GB MoE takes ~10–25 s off disk. The reply is discarded;
+ * only whether it succeeded matters.
+ */
+export async function warm(id, signal) {
+  const res = await req('/chat/completions', {
+    method: 'POST',
+    signal,
+    body: JSON.stringify({
+      model: id,
+      messages: [{ role: 'user', content: 'hi' }],
+      max_completion_tokens: 1,
+      enable_thinking: false,
+    }),
+  });
+  await res.text();
+}

package/src/config.js

@@ -23,6 +23,9 @@ export const config = {
   maxSteps: Number(process.env.KRONK_MAX_STEPS ?? file.maxSteps ?? Infinity),
   showThinking: (process.env.KRONK_THINKING ?? String(file.showThinking ?? 'true')) !== 'false',
   noThink: (process.env.KRONK_NO_THINK ?? String(file.noThink ?? '')) === '1',
+  // Kronk admits a model on its first inference request, not at server start.
+  // Pay that cold load at boot rather than on the first typed prompt.
+  warm: (process.env.KRONK_WARM ?? String(file.warm ?? 'true')) !== 'false',
   autoCompact: (process.env.KRONK_AUTO_COMPACT ?? String(file.autoCompact ?? 'true')) !== 'false',
   compactAt: Number(process.env.KRONK_COMPACT_AT ?? file.compactAt ?? 0.85),
   // Large tool output is summarized in a throwaway context so the raw text

package/src/index.js

@@ -4,6 +4,7 @@ import { stdin, stdout } from 'node:process';
 import { readFile } from 'node:fs/promises';
 import { config, DEFAULT_MODEL, warnIfInsecure } from './config.js';
 import { listModels, listModelDetails, listLoaded, modelLimits, tokenize } from './client.js';
+import { pickDefault, ensureLoaded } from './boot.js';
 import { runTurn, SYSTEM, SYSTEM_AUTO } from './agent.js';
 import { c, banner, fmtContext, statusLine } from './ui.js';
 import { projectContext } from './context.js';
@@ -29,6 +30,7 @@ const SHOW_MODELS = flag('--models', '-l', '--list');
 const SHOW_MCP = flag('--mcp-list');
 const NO_CONTEXT = flag('--no-context');
 if (flag('--no-compact')) config.autoCompact = false;
+if (flag('--no-warm')) config.warm = false;
 
 if (flag('-h', '--help')) {
   console.log(`
@@ -43,6 +45,7 @@ if (flag('-h', '--help')) {
     -l, --models        list the models Kronk is serving, then exit
         --no-context    skip the startup scan of the working directory
         --no-compact    never auto-compact; fail instead when the window fills
+        --no-warm       don't preload the model; let the first prompt trigger it
         --mcp [names]   attach MCP servers; bare for all, or a comma list
         --mcp-list      show configured MCP servers and their tools, then exit
     -m, --model <id>    model to use; substring is enough, /AGENT profiles win
@@ -60,6 +63,7 @@ if (flag('-h', '--help')) {
     KRONK_MAX_TOKENS    output cap per response (default 8192)
     KRONK_MAX_STEPS     cap on tool calls per task (default unlimited)
     KRONK_NO_THINK      set to 1 to disable reasoning
+    KRONK_WARM          false to skip the boot-time model preload
     KRONK_AUTO_COMPACT  false to disable automatic compaction
     KRONK_COMPACT_AT    fraction of the window that triggers it (default 0.85)
 
@@ -96,14 +100,6 @@ let MCP_WANTED = null;
 const stepsArg = opt('--steps');
 if (stepsArg) config.maxSteps = /^(0|off|none|inf|unlimited)$/i.test(stepsArg) ? Infinity : Number(stepsArg);
 
-/** Last resort when neither the flag nor DEFAULT_MODEL is being served. */
-function pickDefault(ids) {
-  const chat = ids.filter((id) => !/embedding|rerank/i.test(id));
-  const agent = chat.filter((id) => id.endsWith('/AGENT'));
-  const pool = agent.length ? agent : chat;
-  return pool.sort((a, b) => b.length - a.length)[0] ?? null;
-}
-
 async function boot() {
   let ids;
   try {
@@ -139,6 +135,8 @@ async function boot() {
   }
   if (!config.model) config.model = pickDefault(ids);
 
+  if (config.warm) await ensureLoaded(ids);
+
   const { configured, native } = await modelLimits(config.model);
   config.contextWindow = configured;
   config.nativeContext = native;
@@ -343,7 +341,16 @@ async function main() {
   // Without one, stdin IS the prompt, so wait longer before giving up.
   const piped = await readStdin(inline ? 200 : 10_000);
   const oneShotPrompt = inline && piped ? `${inline}\n\n${piped}` : (inline || piped);
-  if (oneShotPrompt) { await oneShot(oneShotPrompt); return; }
+  if (oneShotPrompt) {
+    // stdin has given us everything it is going to. When it is a pipe the
+    // caller never closes — a script, an editor task, a CI step — the read
+    // above stays pending and its handle would keep the process alive long
+    // after the answer was printed. Let go of it before answering.
+    stdin.pause();
+    stdin.unref?.();
+    await oneShot(oneShotPrompt);
+    return;
+  }
 
   const rl = readline.createInterface({ input: stdin, output: stdout, historySize: 500 });
   await boot();