@kernelonpanic/kitcode 1.4.3 → 1.4.6

package/dist/index.js

@@ -69,6 +69,7 @@ var diagnosticsSchema = z.object({
   autoRun: z.boolean().default(true),
   commands: z.array(z.string().trim().min(1).max(2e4)).max(8).default([])
 });
+var MAX_SYSTEM_PROMPT_CHARS = 2e4;
 var configSchema = z.object({
   version: z.literal(1).default(1),
   model: z.string().optional(),
@@ -81,6 +82,14 @@ var configSchema = z.object({
   // Manual override for the model's context window. Unset means the window
   // comes from the provider catalogue or the endpoint's model list.
   contextWindow: z.number().int().min(1e3).max(1e7).optional(),
+  // Extra instructions appended to the built-in system prompt on every turn.
+  systemPrompt: z.string().max(MAX_SYSTEM_PROMPT_CHARS).optional(),
+  // When false, systemPrompt is kept in the config but not sent to the model.
+  systemPromptEnabled: z.boolean().default(true),
+  // Hard cap on model calls in one turn. Higher values let large refactors
+  // finish; 0 disables the cap entirely (use with care — a runaway loop will
+  // keep burning tokens until you press Esc).
+  maxTurnSteps: z.number().int().min(0).max(1e3).default(256),
   maxTokens: z.number().int().positive().max(2e5).default(64e3),
   budget: budgetSchema.default({
     maxTokensPerTurn: 1e7,
@@ -1268,8 +1277,40 @@ function isSubsequence(needle, haystack) {
   return needle.length === 0;
 }
 
-// src/tools/jobs.ts
+// src/tools/kill-tree.ts
 import { spawn } from "child_process";
+function killTree(child) {
+  if (child.pid == null) return;
+  const fallback = () => {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  };
+  if (process.platform === "win32") {
+    try {
+      const killer = spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      killer.once("error", fallback);
+      killer.once("close", (code) => {
+        if (code !== 0) fallback();
+      });
+    } catch {
+      fallback();
+    }
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGKILL");
+  } catch {
+    fallback();
+  }
+}
+
+// src/tools/jobs.ts
+import { spawn as spawn2 } from "child_process";
 import { StringDecoder } from "string_decoder";
 var MAX_JOBS = 8;
 var MAX_JOB_OUTPUT = 1e5;
@@ -1285,7 +1326,7 @@ function startJob(command, cwd) {
   installExitCleanup();
   counter += 1;
   const id = `bg-${counter}`;
-  const child = spawn(command, {
+  const child = spawn2(command, {
     shell: true,
     cwd,
     detached: process.platform !== "win32",
@@ -1391,22 +1432,6 @@ function summary(job) {
     signal: job.signal
   };
 }
-function killTree(child) {
-  if (child.pid == null) return;
-  if (process.platform === "win32") {
-    try {
-      spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
-    } catch {
-      child.kill("SIGKILL");
-    }
-    return;
-  }
-  try {
-    process.kill(-child.pid, "SIGKILL");
-  } catch {
-    child.kill("SIGKILL");
-  }
-}
 
 // src/core/memory.ts
 import { createHash } from "crypto";
@@ -1884,11 +1909,116 @@ function validSessionId(id) {
   return /^[A-Za-z0-9_-]{1,240}$/.test(id);
 }
 
+// src/core/retry.ts
+var MAX_RETRIES2 = 9;
+var INITIAL_BACKOFF_MS = 1e3;
+async function* streamWithRetry(provider, request, signal) {
+  request = { ...request, signal };
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
+    if (signal.aborted) return;
+    let emittedOutput = false;
+    try {
+      const stream = provider.stream(request)[Symbol.asyncIterator]();
+      let cancel;
+      let cancelTimer;
+      const cancelled = new Promise((resolve3) => {
+        cancel = () => {
+          cancelTimer ??= setTimeout(() => resolve3({ done: true, value: void 0 }), 100);
+        };
+        signal.addEventListener("abort", cancel, { once: true });
+        if (signal.aborted) cancel();
+      });
+      try {
+        for (; ; ) {
+          const next = await Promise.race([stream.next(), cancelled]);
+          if (next.done) break;
+          if (!signal.aborted || next.value.type === "usage" || next.value.type === "done") {
+            if (next.value.type !== "rate_limits" && next.value.type !== "retrying") emittedOutput = true;
+            yield next.value;
+          }
+          if (next.value.type === "done") break;
+        }
+      } finally {
+        signal.removeEventListener("abort", cancel);
+        if (cancelTimer !== void 0) clearTimeout(cancelTimer);
+        void stream.return?.().catch(() => void 0);
+      }
+      return;
+    } catch (error) {
+      if (signal.aborted) return;
+      if (emittedOutput) throw error;
+      lastError = error;
+      if (attempt >= MAX_RETRIES2) break;
+      const waitMs = retryBackoffMs(error, attempt);
+      if (waitMs > 0) {
+        yield {
+          type: "retrying",
+          attempt: attempt + 2,
+          waitMs,
+          reason: error instanceof Error ? error.message : String(error)
+        };
+        try {
+          await sleep(waitMs, signal);
+        } catch (error2) {
+          if (signal.aborted) return;
+          throw error2;
+        }
+        continue;
+      }
+      break;
+    }
+  }
+  if (lastError) throw lastError;
+}
+function retryBackoffMs(error, attempt) {
+  if (!isRateLimitError(error)) return 0;
+  const serverWait = retryAfterFromError(error);
+  if (serverWait > 0) return Math.min(serverWait, 6e4);
+  return Math.min(INITIAL_BACKOFF_MS * 2 ** attempt, 3e4);
+}
+function isRateLimitError(error) {
+  if (!(error instanceof ProviderError)) return false;
+  return error.status === 429;
+}
+function retryAfterFromError(error) {
+  const cause = error?.cause;
+  const headers = cause?.headers;
+  if (headers && typeof headers.get === "function") {
+    const ms = Number(headers.get("retry-after-ms"));
+    if (Number.isFinite(ms) && ms > 0) return ms;
+    const raw = headers.get("retry-after");
+    if (raw) {
+      const s = Number(raw);
+      if (Number.isFinite(s) && s > 0) return s * 1e3;
+      const date = Date.parse(raw);
+      if (!Number.isFinite(s) && Number.isFinite(date)) return Math.max(0, date - Date.now());
+    }
+  }
+  return 0;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve3, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason ?? new Error("Aborted"));
+      return;
+    }
+    const finish = () => {
+      signal.removeEventListener("abort", onAbort);
+      resolve3();
+    };
+    const onAbort = () => {
+      clearTimeout(id);
+      reject(signal.reason ?? new Error("Aborted"));
+    };
+    const id = setTimeout(finish, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
 // src/core/agent.ts
 var MAX_PAUSE_RESUMES = 5;
-var MAX_RETRIES2 = 3;
-var INITIAL_BACKOFF_MS = 1e3;
-var MAX_TURN_STEPS = 64;
+var DEFAULT_MAX_TURN_STEPS = 256;
 function createExecutionLane() {
   let tail2 = Promise.resolve();
   return {
@@ -1900,6 +2030,8 @@ function createExecutionLane() {
   };
 }
 async function runTurn(cfg, history, hooks, signal) {
+  const maxTurnSteps = cfg.maxTurnSteps ?? DEFAULT_MAX_TURN_STEPS;
+  const hasStepCap = maxTurnSteps > 0;
   const permissionLane = cfg.permissionLane ?? createExecutionLane();
   const originalHooks = hooks;
   hooks = {
@@ -1914,11 +2046,12 @@ async function runTurn(cfg, history, hooks, signal) {
       hooks.onEvent({ type: "turn_end", stopReason: "aborted" });
       return sanitizeHistory(messages);
     }
-    if (++steps > MAX_TURN_STEPS) {
+    steps += 1;
+    if (hasStepCap && steps > maxTurnSteps) {
       hooks.onEvent({
         type: "notice",
         level: "warn",
-        text: `Stopped after ${MAX_TURN_STEPS} model calls without finishing, to avoid burning tokens in a loop. Ask again with a narrower request.`
+        text: `Stopped after ${maxTurnSteps} model calls without finishing, to avoid burning tokens in a loop. Ask again with a narrower request.`
       });
       hooks.onEvent({ type: "turn_end", stopReason: "max_tokens" });
       return messages;
@@ -1935,6 +2068,7 @@ async function runTurn(cfg, history, hooks, signal) {
       }
     }
     const request = async () => {
+      hooks.onHistory?.(sanitizeHistory(messages));
       if (signal.aborted) return { content: [], stopReason: "aborted" };
       const budgetDecision = cfg.budget?.beforeRequest({
         modelRef: cfg.modelRef,
@@ -1958,6 +2092,7 @@ async function runTurn(cfg, history, hooks, signal) {
     const outcome = await (cfg.modelRequestLane?.run(request) ?? request());
     if (!outcome) return messages;
     messages.push({ role: "assistant", content: outcome.content });
+    hooks.onHistory?.(sanitizeHistory(messages));
     if (outcome.stopReason === "aborted") {
       hooks.onEvent({ type: "turn_end", stopReason: "aborted" });
       return sanitizeHistory(messages);
@@ -1965,6 +2100,7 @@ async function runTurn(cfg, history, hooks, signal) {
     if (outcome.stopReason === "tool_use") {
       const results = await runToolCalls(cfg, outcome.content, hooks, signal);
       if (results.length > 0) messages.push({ role: "user", content: results });
+      hooks.onHistory?.(sanitizeHistory(messages));
       if (signal.aborted) {
         hooks.onEvent({ type: "turn_end", stopReason: "aborted" });
         return sanitizeHistory(messages);
@@ -2011,7 +2147,7 @@ async function consumeStream(cfg, messages, hooks, signal, maxTokens) {
   let outputTokens = 0;
   const startedAt = Date.now();
   let firstTokenAt;
-  for await (const event of streamWithRetry(cfg.provider, request, cfg.modelRef, signal)) {
+  for await (const event of streamWithRetry(cfg.provider, request, signal)) {
     switch (event.type) {
       case "text_delta":
         firstTokenAt ??= Date.now();
@@ -2033,6 +2169,13 @@ async function consumeStream(cfg, messages, hooks, signal, maxTokens) {
       case "rate_limits":
         hooks.onEvent({ type: "rate_limits", model: cfg.modelRef, limits: event.limits });
         break;
+      case "retrying":
+        hooks.onEvent({
+          type: "notice",
+          level: "warn",
+          text: `Rate limited; retrying the same request in ${Math.ceil(event.waitMs / 1e3)}s (attempt ${event.attempt}). The conversation keeps its progress.`
+        });
+        break;
       case "tool_call":
         break;
       case "done":
@@ -2057,96 +2200,6 @@ async function consumeStream(cfg, messages, hooks, signal, maxTokens) {
     `"${cfg.provider.id}" ended the stream without completing the turn \u2014 nothing was generated. The endpoint answered, but not with a usable ${cfg.provider.kind} response.`
   );
 }
-async function* streamWithRetry(provider, request, modelRef, signal) {
-  let lastError;
-  for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
-    if (signal.aborted) return;
-    try {
-      const stream = provider.stream(request)[Symbol.asyncIterator]();
-      let cancel;
-      let cancelTimer;
-      const cancelled = new Promise((resolve3) => {
-        cancel = () => {
-          cancelTimer ??= setTimeout(() => resolve3({ done: true, value: void 0 }), 100);
-        };
-        signal.addEventListener("abort", cancel, { once: true });
-        if (signal.aborted) cancel();
-      });
-      try {
-        for (; ; ) {
-          const next = await Promise.race([stream.next(), cancelled]);
-          if (next.done) break;
-          if (!signal.aborted || next.value.type === "usage" || next.value.type === "done") {
-            yield next.value;
-          }
-          if (next.value.type === "done") break;
-        }
-      } finally {
-        signal.removeEventListener("abort", cancel);
-        if (cancelTimer !== void 0) clearTimeout(cancelTimer);
-        void stream.return?.().catch(() => void 0);
-      }
-      return;
-    } catch (error) {
-      lastError = error;
-      if (attempt >= MAX_RETRIES2) break;
-      const waitMs = retryBackoffMs(error, attempt);
-      if (waitMs > 0) {
-        try {
-          await sleep(waitMs, signal);
-        } catch (error2) {
-          if (signal.aborted) return;
-          throw error2;
-        }
-        continue;
-      }
-      break;
-    }
-  }
-  if (lastError) throw lastError;
-}
-function retryBackoffMs(error, attempt) {
-  if (!isRateLimitError(error)) return 0;
-  const serverWait = retryAfterFromError(error);
-  if (serverWait > 0) return Math.min(serverWait, 6e4);
-  return Math.min(INITIAL_BACKOFF_MS * 2 ** attempt, 3e4);
-}
-function isRateLimitError(error) {
-  if (!(error instanceof ProviderError)) return false;
-  return error.status === 429;
-}
-function retryAfterFromError(error) {
-  const cause = error?.cause;
-  const headers = cause?.headers;
-  if (headers && typeof headers.get === "function") {
-    const ms = Number(headers.get("retry-after-ms"));
-    if (Number.isFinite(ms) && ms > 0) return ms;
-    const raw = headers.get("retry-after");
-    if (raw) {
-      const s = Number(raw);
-      if (Number.isFinite(s) && s > 0) return s * 1e3;
-    }
-  }
-  return 0;
-}
-function sleep(ms, signal) {
-  return new Promise((resolve3, reject) => {
-    if (signal.aborted) {
-      reject(signal.reason ?? new Error("Aborted"));
-      return;
-    }
-    const finish = () => {
-      signal.removeEventListener("abort", onAbort);
-      resolve3();
-    };
-    const onAbort = () => {
-      clearTimeout(id);
-      reject(signal.reason ?? new Error("Aborted"));
-    };
-    const id = setTimeout(finish, ms);
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
 var CHARS_PER_TOKEN = 4;
 function estimateRequestTokens(cfg, messages) {
   let characters3 = cfg.system.length;
@@ -2173,8 +2226,10 @@ async function runToolCalls(cfg, content, hooks, signal) {
     for (const call of calls) if (call.name !== "task") out.push(await run(call));
     return out;
   })();
-  const [settledOthers] = await Promise.allSettled([others]);
-  const settledTasks = await Promise.allSettled(tasks);
+  const [[settledOthers], settledTasks] = await Promise.all([
+    Promise.allSettled([others]),
+    Promise.allSettled(tasks)
+  ]);
   for (const result of [settledOthers, ...settledTasks]) {
     if (result.status === "rejected") throw result.reason;
   }
@@ -2752,7 +2807,7 @@ import { readFile as readFile6, stat as stat4 } from "fs/promises";
 import path7 from "path";
 
 // src/tools/bash.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { StringDecoder as StringDecoder2 } from "string_decoder";
 var DEFAULT_TIMEOUT = 12e4;
 var MAX_TIMEOUT = 6e5;
@@ -2814,7 +2869,7 @@ var bashTool = {
       });
     }
     return new Promise((settle) => {
-      const child = spawn2(command, {
+      const child = spawn3(command, {
         shell: true,
         cwd: ctx.cwd,
         detached: process.platform !== "win32",
@@ -2854,31 +2909,15 @@ var bashTool = {
       };
       child.stdout.on("data", collector());
       child.stderr.on("data", collector());
-      const killTree2 = () => {
-        if (child.pid == null) return;
-        if (process.platform === "win32") {
-          try {
-            spawn2("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
-          } catch {
-            child.kill("SIGKILL");
-          }
-          return;
-        }
-        try {
-          process.kill(-child.pid, "SIGKILL");
-        } catch {
-          child.kill("SIGKILL");
-        }
-      };
       let timedOut = false;
       let aborted = false;
       const timer = setTimeout(() => {
         timedOut = true;
-        killTree2();
+        killTree(child);
       }, timeout);
       const onAbort = () => {
         aborted = true;
-        killTree2();
+        killTree(child);
       };
       ctx.signal.addEventListener("abort", onAbort, { once: true });
       const finish = (result) => {
@@ -4021,26 +4060,31 @@ async function summarizeText(provider, model, maxTokens, signal, source, systemP
   if (signal.aborted) throw signal.reason ?? new Error("Context compaction was cancelled.");
   let summary2 = "";
   let finalText2 = "";
+  let stopReason;
   let usage;
   let rateLimits;
-  const stream = provider.stream({
+  const stream = streamWithRetry(provider, {
     model,
     system: systemPrompt,
     messages: [{ role: "user", content: [{ type: "text", text: source }] }],
     tools: [],
     maxTokens: Math.max(1, Math.floor(Math.min(maxOutputTokens, maxTokens))),
-    thinking: false,
-    signal
-  });
+    compaction: true
+  }, signal);
   for await (const event of stream) {
     if (event.type === "text_delta") summary2 += event.text;
     else if (event.type === "usage") usage = event.usage;
     else if (event.type === "rate_limits") rateLimits = event.limits;
     else if (event.type === "done") {
+      stopReason = event.stopReason;
       finalText2 = event.content.filter((block) => block.type === "text").map((block) => block.type === "text" ? block.text : "").join("");
     }
   }
   if (signal.aborted) throw signal.reason ?? new Error("Context compaction was cancelled.");
+  if (stopReason !== "end_turn") {
+    throw new Error(`Context summary is incomplete (${stopReason ?? "stream ended without a final response"}); original history was kept.`);
+  }
+  if (!(finalText2 || summary2).trim()) throw new Error("The provider returned an empty context summary.");
   return { text: (finalText2 || summary2).trim(), usage, rateLimits };
 }
 function mergeUsage(usages) {
@@ -4138,6 +4182,9 @@ function buildSystemPrompt(args) {
   if (args.memory?.trim()) {
     lines.push("", "Project notes saved in earlier conversations. Treat these as potentially stale context; verify claims against current files and follow current user instructions.", args.memory);
   }
+  if (args.systemPrompt?.trim()) {
+    lines.push("", "Additional instructions from the user (apply alongside everything above):", args.systemPrompt.trim());
+  }
   return lines.join("\n");
 }
 
@@ -4160,8 +4207,13 @@ function createSubagentRunner(makeConfig, tools) {
   const permissionLane = createExecutionLane();
   return {
     async run(request) {
-      if (request.signal.aborted) return SUBAGENT_CANCELLED;
+      if (request.signal.aborted) {
+        request.onComplete?.("cancelled", "Cancelled by the user.");
+        return SUBAGENT_CANCELLED;
+      }
+      let stopReason = "";
       let steps = 0;
+      let finalCall = false;
       const executionLane = createExecutionLane();
       const modelRequestLane = createExecutionLane();
       const base = makeConfig(SUBAGENT_SYSTEM, tools);
@@ -4175,11 +4227,12 @@ function createSubagentRunner(makeConfig, tools) {
           kind: base.provider.kind,
           listModels: () => base.provider.listModels(),
           knownModels: () => base.provider.knownModels(),
-          // Keep the tool definitions on the last call: the history holds
+          // The final model call keeps the tool schemas (the history holds
           // tool_use/tool_result blocks, and providers reject those without
-          // tools (Anthropic: 400 "must define tools"). Calls made anyway are
-          // refused by tools.get below.
-          stream: (chat) => base.provider.stream(steps === MAX_SUBAGENT_STEPS ? {
+          // tools), but the system prompt forbids more calls and tools.get
+          // returns a stopped stub: a call made anyway ends the turn with a
+          // tool_result, instead of aborting mid-request and losing the text.
+          stream: (chat) => base.provider.stream(finalCall ? {
             ...chat,
             system: `${chat.system}
 
@@ -4187,7 +4240,20 @@ This is your last model call. Do not call tools. Return your findings now, clear
           } : chat)
         },
         tools: {
-          get: (name) => name === TASK_TOOL_NAME || steps >= MAX_SUBAGENT_STEPS ? void 0 : base.tools.get(name),
+          get: (name) => {
+            if (name === TASK_TOOL_NAME) return void 0;
+            const tool = base.tools.get(name);
+            if (!tool) return void 0;
+            if (!finalCall) return tool;
+            return {
+              ...tool,
+              permission: () => "allow",
+              execute: () => Promise.resolve({
+                content: "Tool budget exhausted: this was your last model call. Write the final answer now from what you already gathered.",
+                isError: true
+              })
+            };
+          },
           schemas: () => base.tools.schemas().filter((schema) => schema.name !== TASK_TOOL_NAME)
         },
         system: `${SUBAGENT_SYSTEM}
@@ -4198,7 +4264,12 @@ Working directory: ${base.cwd}`
       const signal = AbortSignal.any([request.signal, limit.signal]);
       const hooks = {
         onEvent(event) {
-          if (event.type === "turn_start" && ++steps > MAX_SUBAGENT_STEPS) limit.abort();
+          if (event.type === "turn_end") stopReason = event.stopReason;
+          if (event.type === "turn_start") {
+            ++steps;
+            if (steps > MAX_SUBAGENT_STEPS + 1) limit.abort();
+            else if (steps >= MAX_SUBAGENT_STEPS) finalCall = true;
+          }
           if (event.type === "tool_start") request.onProgress(brief(event.summary, 80));
           if (event.type === "subagent_start" || event.type === "subagent_end" || event.type === "subagent_event") return;
           request.onEvent?.(event);
@@ -4218,11 +4289,22 @@ Working directory: ${base.cwd}`
         { role: "user", content: [{ type: "text", text: request.prompt }] }
       ];
       const text = finalText(await runTurn(cfg, history, hooks, signal));
-      if (!limit.signal.aborted) return text;
-      if (request.signal.aborted && text === SUBAGENT_NO_ANSWER) return SUBAGENT_CANCELLED;
-      return text === SUBAGENT_NO_ANSWER ? STEP_LIMIT_NOTE : `${text}
+      if (request.signal.aborted || stopReason === "aborted" && !limit.signal.aborted) {
+        request.onComplete?.("cancelled", "Cancelled before the task finished; any output is partial.");
+        return text === SUBAGENT_NO_ANSWER ? SUBAGENT_CANCELLED : text;
+      }
+      if (limit.signal.aborted || finalCall && (stopReason === "tool_use" || text === SUBAGENT_NO_ANSWER)) {
+        request.onComplete?.("incomplete", STEP_LIMIT_NOTE);
+        return text === SUBAGENT_NO_ANSWER ? STEP_LIMIT_NOTE : `${text}
 
 ${STEP_LIMIT_NOTE}`;
+      }
+      if (text === SUBAGENT_NO_ANSWER || stopReason === "max_tokens" || stopReason === "refusal" || stopReason === "pause_turn") {
+        request.onComplete?.("incomplete", text === SUBAGENT_NO_ANSWER ? SUBAGENT_NO_ANSWER : `Task stopped (${stopReason}); output may be partial.`);
+      } else {
+        request.onComplete?.("done");
+      }
+      return text;
     }
   };
 }
@@ -4413,7 +4495,7 @@ function clip(value) {
 // package.json
 var package_default = {
   name: "@kernelonpanic/kitcode",
-  version: "1.4.3",
+  version: "1.4.6",
   description: "Terminal coding agent with a config you never have to write by hand",
   type: "module",
   license: "MIT",
@@ -4481,7 +4563,7 @@ var package_default = {
 
 // src/version.ts
 var KITCODE_VERSION = package_default.version;
-var KITCODE_COMMIT = true ? "586eb4def64a8ef824bf2fe2f58a9f71e18090f0" : "development";
+var KITCODE_COMMIT = true ? "98093a63cea2a1e99b9477191baf72c1839c9c27" : "development";
 function kitcodeUserAgent(sdkUserAgent2) {
   return `KitCode/${KITCODE_VERSION} ${sdkUserAgent2}`.trim();
 }
@@ -5127,12 +5209,12 @@ async function* streamOnce(client, providerId, apiKey2, req, thinkingOn) {
     messages: toMessageParams(req.messages),
     tools: toToolParams(req.tools)
   };
-  if (thinkingOn) {
+  if (thinkingOn && !req.compaction) {
     const thinking2 = thinkingParam(req.model, req.maxTokens);
     if (thinking2) params.thinking = thinking2;
   }
   const effort = effectiveEffort("anthropic", req.model, req.effort, req.messages);
-  if (effort) params.output_config = { effort };
+  if (effort && !req.compaction) params.output_config = { effort };
   let thinking = "";
   let text = "";
   let events = 0;
@@ -5398,8 +5480,8 @@ async function* streamOnce2(client, providerId, apiKey2, req, effort, thinkingOf
       {
         model: req.model,
         [tokenField]: req.maxTokens,
-        ...effort ? { reasoning_effort: effort } : {},
-        ...thinkingOff,
+        ...effort && !req.compaction ? { reasoning_effort: effort } : {},
+        ...req.compaction ? {} : thinkingOff,
         messages: toChatMessages(req.system, req.messages),
         ...req.tools.length > 0 ? { tools: toChatTools(req.tools) } : {},
         stream: true,
@@ -7061,8 +7143,14 @@ function createTaskTool(runner) {
       const subagentId = `sa${randomBytes3(4).toString("hex")}`;
       const description = field(input, "description") || "subagent";
       ctx.onEvent?.({ type: "subagent_start", id: subagentId, description });
+      let status = "done";
+      let reason;
       try {
-        const content = await runner.run({
+        let content = await runner.run({
+          onComplete: (outcome, detail) => {
+            status = outcome;
+            reason = detail;
+          },
           prompt: instruction,
           description,
           signal: ctx.signal,
@@ -7071,10 +7159,19 @@ function createTaskTool(runner) {
           confirm: ctx.confirm,
           requestPermission: ctx.requestPermission
         });
-        ctx.onEvent?.({ type: "subagent_end", id: subagentId, result: content });
-        if (progress.length === 0) return { content };
+        if (ctx.signal.aborted) {
+          status = "cancelled";
+          reason = "Cancelled by the user; any output is partial.";
+        }
+        if (status !== "done" && reason) content = `${reason}
+
+${content}`;
+        ctx.onEvent?.({ type: "subagent_end", id: subagentId, result: content, status, reason });
+        const isError = status !== "done";
+        if (progress.length === 0) return { content, isError };
         return {
           content,
+          isError,
           display: {
             kind: "list",
             title: `task ${brief(field(input, "description"), 40)}`,
@@ -7082,9 +7179,11 @@ function createTaskTool(runner) {
           }
         };
       } catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        ctx.onEvent?.({ type: "subagent_end", id: subagentId, result: `The subagent failed: ${reason}` });
-        return { content: `The subagent failed: ${reason}`, isError: true };
+        const reason2 = error instanceof Error ? error.message : String(error);
+        const cancelled = ctx.signal.aborted;
+        const content = cancelled ? `The subagent was cancelled: ${reason2}` : `The subagent failed: ${reason2}`;
+        ctx.onEvent?.({ type: "subagent_end", id: subagentId, result: content, status: cancelled ? "cancelled" : "error", reason: reason2 });
+        return { content, isError: true };
       }
     }
   };
@@ -7292,7 +7391,8 @@ async function boot(options) {
     cwd: options.cwd,
     toolNames: tools.list().map((tool) => tool.name),
     skills: skillCatalogue,
-    memory: projectMemory
+    memory: projectMemory,
+    systemPrompt: config.systemPromptEnabled ? config.systemPrompt : void 0
   });
   let modelRef = session.model || config.model || "";
   if (options.modelRef) modelRef = options.modelRef;
@@ -7362,6 +7462,7 @@ async function boot(options) {
       maxTokens: config.maxTokens,
       effort: config.effort,
       thinking: config.thinking,
+      maxTurnSteps: config.maxTurnSteps,
       budget: activeBudget,
       checkpoint: activeCheckpoint,
       trimContext: (messages) => trimForWindow(resolved.provider.kind, messages)
@@ -7742,6 +7843,34 @@ async function boot(options) {
         draft.lang = lang;
       });
     },
+    getSystemPrompt: () => config.systemPrompt ?? "",
+    isSystemPromptEnabled: () => config.systemPromptEnabled && config.systemPrompt !== void 0 && config.systemPrompt.trim() !== "",
+    async setSystemPrompt(text) {
+      const trimmed = text.trim();
+      if (trimmed.length > MAX_SYSTEM_PROMPT_CHARS) {
+        throw new Error(`System prompt must be at most ${MAX_SYSTEM_PROMPT_CHARS.toLocaleString("en-US")} characters.`);
+      }
+      await persistConfig((draft) => {
+        if (trimmed === "") delete draft.systemPrompt;
+        else draft.systemPrompt = trimmed;
+      });
+    },
+    async setSystemPromptEnabled(enabled) {
+      await persistConfig((draft) => {
+        draft.systemPromptEnabled = enabled;
+      });
+    },
+    async loadSystemPromptFile(requestedPath) {
+      const { readFile: readFile15 } = await import("fs/promises");
+      const resolved = path15.resolve(options.cwd, requestedPath);
+      return readFile15(resolved, "utf8");
+    },
+    getMaxTurnSteps: () => config.maxTurnSteps,
+    async setMaxTurnSteps(steps) {
+      await persistConfig((draft) => {
+        draft.maxTurnSteps = steps;
+      });
+    },
     getAccent: () => config.theme.accent,
     async setAccent(value) {
       await persistConfig((draft) => {
@@ -8508,6 +8637,8 @@ var COMMANDS = [
   { name: "mcp", args: "[add|list|delete|enable|disable]" },
   { name: "attach", args: "<path|clipboard|clear>" },
   { name: "memory", args: "[show|set <text>|clear]" },
+  { name: "systemp", args: "[set <text>|clear]", ...BUSY_SAFE },
+  { name: "steps", args: "[count]", ...BUSY_SAFE },
   { name: "compact" },
   { name: "update" },
   { name: "checker", ...BUSY_SAFE },
@@ -8516,7 +8647,7 @@ var COMMANDS = [
   { name: "resume" },
   { name: "undo" },
   { name: "clear" },
-  { name: "subagents", ...BUSY_SAFE },
+  { name: "subagents", args: "[clear]", ...BUSY_SAFE },
   { name: "help", ...BUSY_SAFE },
   { name: "exit", ...BUSY_SAFE }
 ];
@@ -8803,6 +8934,13 @@ var en = {
   subagentsTitle: "Open a sub-agent chat",
   subagentRunning: "running",
   subagentDone: "done",
+  subagentCancelled: "cancelled",
+  subagentError: "error",
+  subagentIncomplete: "incomplete",
+  subagentsCleared: "Finished subagents cleared from the list.",
+  noFinishedSubagents: "No finished subagents to clear.",
+  subagentsClear: "Clear finished subagents",
+  confirmExit: "Press Ctrl+C again within 3 seconds to exit. Any other key cancels.",
   subagentWaiting: "waiting for the first step\u2026",
   subagentBack: "esc back",
   attachUsage: "Usage: /attach <image-or-text-file> \xB7 /attach clipboard \xB7 /attach clear",
@@ -8881,6 +9019,18 @@ ${url}`,
   memoryEmpty: "Project memory is empty.",
   memoryClearAsk: "Clear project memory?",
   memoryReplaceAsk: "Replace all project memory notes with this text?",
+  systemPromptTitle: "System prompt addition",
+  systemPromptUsage: "/systemp [show] \xB7 /systemp set <text> \xB7 /systemp clear",
+  systemPromptEmpty: "No extra system prompt. Set one with /systemp set <text>.",
+  systemPromptSet: "System prompt addition saved.",
+  systemPromptCleared: "System prompt addition cleared.",
+  systemPromptEnabled: "System prompt enabled.",
+  systemPromptDisabled: "System prompt disabled (kept in config).",
+  systemPromptTooLong: (max) => `System prompt must be at most ${max} characters.`,
+  stepsCurrent: (n) => n === 0 ? "Model calls per turn: unlimited" : `Model calls per turn: ${n}`,
+  stepsSet: (n) => `Model calls per turn set to ${n}`,
+  stepsUnlimited: "Model calls per turn: unlimited (0). The turn budget still applies.",
+  stepsInvalid: "Usage: /steps <0-1000> (0 = unlimited)",
   promptDeleted: (name) => `Deleted prompt "${name}"`,
   promptNotFound: (name) => `Prompt "${name}" not found.`,
   promptsEmpty: "No saved prompts. Use /prompt save <name>.",
@@ -8923,6 +9073,8 @@ ${url}`,
     theme: "change the accent colour",
     lang: "change the interface language",
     memory: "view, replace or clear project memory",
+    systemp: "view, set, load from file, or toggle the extra system prompt",
+    steps: "cap model calls per turn",
     prompt: "insert or save a prompt",
     "prompt save": "save the current or recent text as a prompt",
     "prompt delete": "delete a saved prompt",
@@ -9040,6 +9192,13 @@ var ru = {
   subagentsTitle: "\u041E\u0442\u043A\u0440\u044B\u0442\u044C \u0447\u0430\u0442 \u0441\u0443\u0431-\u0430\u0433\u0435\u043D\u0442\u0430",
   subagentRunning: "\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442",
   subagentDone: "\u0433\u043E\u0442\u043E\u0432\u043E",
+  subagentCancelled: "\u043E\u0442\u043C\u0435\u043D\u0435\u043D\u043E",
+  subagentError: "\u043E\u0448\u0438\u0431\u043A\u0430",
+  subagentIncomplete: "\u043D\u0435 \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u043E",
+  subagentsCleared: "\u0417\u0430\u0432\u0435\u0440\u0448\u0451\u043D\u043D\u044B\u0435 \u0441\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u044B \u0443\u0434\u0430\u043B\u0435\u043D\u044B \u0438\u0437 \u0441\u043F\u0438\u0441\u043A\u0430.",
+  noFinishedSubagents: "\u041D\u0435\u0442 \u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D\u043D\u044B\u0445 \u0441\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u043E\u0432 \u0434\u043B\u044F \u043E\u0447\u0438\u0441\u0442\u043A\u0438.",
+  subagentsClear: "\u041E\u0447\u0438\u0441\u0442\u0438\u0442\u044C \u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D\u043D\u044B\u0445 \u0441\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u043E\u0432",
+  confirmExit: "\u041D\u0430\u0436\u043C\u0438\u0442\u0435 Ctrl+C \u0435\u0449\u0451 \u0440\u0430\u0437 \u0432 \u0442\u0435\u0447\u0435\u043D\u0438\u0435 3 \u0441\u0435\u043A\u0443\u043D\u0434 \u0434\u043B\u044F \u0432\u044B\u0445\u043E\u0434\u0430. \u041B\u044E\u0431\u0430\u044F \u0434\u0440\u0443\u0433\u0430\u044F \u043A\u043B\u0430\u0432\u0438\u0448\u0430 \u043E\u0442\u043C\u0435\u043D\u044F\u0435\u0442 \u0432\u044B\u0445\u043E\u0434.",
   subagentWaiting: "\u0436\u0434\u0451\u043C \u043F\u0435\u0440\u0432\u044B\u0439 \u0448\u0430\u0433\u2026",
   subagentBack: "esc \u2014 \u043D\u0430\u0437\u0430\u0434",
   attachUsage: "\u0418\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435: /attach <\u043A\u0430\u0440\u0442\u0438\u043D\u043A\u0430-\u0438\u043B\u0438-\u0442\u0435\u043A\u0441\u0442\u043E\u0432\u044B\u0439-\u0444\u0430\u0439\u043B> \xB7 /attach clipboard \xB7 /attach clear",
@@ -9118,6 +9277,18 @@ ${url}`,
   memoryEmpty: "\u041F\u0430\u043C\u044F\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u043F\u0443\u0441\u0442\u0430.",
   memoryClearAsk: "\u041E\u0447\u0438\u0441\u0442\u0438\u0442\u044C \u043F\u0430\u043C\u044F\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442\u0430?",
   memoryReplaceAsk: "\u0417\u0430\u043C\u0435\u043D\u0438\u0442\u044C \u0432\u0441\u0435 \u0437\u0430\u043C\u0435\u0442\u043A\u0438 \u043F\u0430\u043C\u044F\u0442\u0438 \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u044D\u0442\u0438\u043C \u0442\u0435\u043A\u0441\u0442\u043E\u043C?",
+  systemPromptTitle: "\u0414\u043E\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0435 \u043A \u0441\u0438\u0441\u0442\u0435\u043C\u043D\u043E\u043C\u0443 \u043F\u0440\u043E\u043C\u043F\u0442\u0443",
+  systemPromptUsage: "/systemp [show] \xB7 /systemp set <\u0442\u0435\u043A\u0441\u0442> \xB7 /systemp clear",
+  systemPromptEmpty: "\u0414\u043E\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044F \u043A \u0441\u0438\u0441\u0442\u0435\u043C\u043D\u043E\u043C\u0443 \u043F\u0440\u043E\u043C\u043F\u0442\u0443 \u043D\u0435\u0442. \u0417\u0430\u0434\u0430\u0439 \u0447\u0435\u0440\u0435\u0437 /systemp set <\u0442\u0435\u043A\u0441\u0442>.",
+  systemPromptSet: "\u0414\u043E\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0435 \u043A \u0441\u0438\u0441\u0442\u0435\u043C\u043D\u043E\u043C\u0443 \u043F\u0440\u043E\u043C\u043F\u0442\u0443 \u0441\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u043E.",
+  systemPromptCleared: "\u0414\u043E\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0435 \u043A \u0441\u0438\u0441\u0442\u0435\u043C\u043D\u043E\u043C\u0443 \u043F\u0440\u043E\u043C\u043F\u0442\u0443 \u0443\u0434\u0430\u043B\u0435\u043D\u043E.",
+  systemPromptEnabled: "\u0414\u043E\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0435 \u043A \u0441\u0438\u0441\u0442\u0435\u043C\u043D\u043E\u043C\u0443 \u043F\u0440\u043E\u043C\u043F\u0442\u0443 \u0432\u043A\u043B\u044E\u0447\u0435\u043D\u043E.",
+  systemPromptDisabled: "\u0414\u043E\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0435 \u043A \u0441\u0438\u0441\u0442\u0435\u043C\u043D\u043E\u043C\u0443 \u043F\u0440\u043E\u043C\u043F\u0442\u0443 \u0432\u044B\u043A\u043B\u044E\u0447\u0435\u043D\u043E (\u0441\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u043E \u0432 \u043A\u043E\u043D\u0444\u0438\u0433\u0435).",
+  systemPromptTooLong: (max) => `\u0414\u043E\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0435 \u043A \u0441\u0438\u0441\u0442\u0435\u043C\u043D\u043E\u043C\u0443 \u043F\u0440\u043E\u043C\u043F\u0442\u0443 \u043D\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u0434\u043B\u0438\u043D\u043D\u0435\u0435 ${max} \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432.`,
+  stepsCurrent: (n) => n === 0 ? "\u0412\u044B\u0437\u043E\u0432\u043E\u0432 \u043C\u043E\u0434\u0435\u043B\u0438 \u0437\u0430 \u0445\u043E\u0434: \u0431\u0435\u0437 \u043B\u0438\u043C\u0438\u0442\u0430" : `\u0412\u044B\u0437\u043E\u0432\u043E\u0432 \u043C\u043E\u0434\u0435\u043B\u0438 \u0437\u0430 \u0445\u043E\u0434: ${n}`,
+  stepsSet: (n) => `\u0412\u044B\u0437\u043E\u0432\u043E\u0432 \u043C\u043E\u0434\u0435\u043B\u0438 \u0437\u0430 \u0445\u043E\u0434 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u043E: ${n}`,
+  stepsUnlimited: "\u0412\u044B\u0437\u043E\u0432\u043E\u0432 \u043C\u043E\u0434\u0435\u043B\u0438 \u0437\u0430 \u0445\u043E\u0434: \u0431\u0435\u0437 \u043B\u0438\u043C\u0438\u0442\u0430 (0). \u0411\u044E\u0434\u0436\u0435\u0442 \u0442\u043E\u043A\u0435\u043D\u043E\u0432 \u0432\u0441\u0451 \u0435\u0449\u0451 \u0434\u0435\u0439\u0441\u0442\u0432\u0443\u0435\u0442.",
+  stepsInvalid: "\u0418\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435: /steps <0-1000> (0 = \u0431\u0435\u0437 \u043B\u0438\u043C\u0438\u0442\u0430)",
   promptDeleted: (name) => `\u041F\u0440\u043E\u043C\u0442 \xAB${name}\xBB \u0443\u0434\u0430\u043B\u0451\u043D`,
   promptNotFound: (name) => `\u041F\u0440\u043E\u043C\u0442 \xAB${name}\xBB \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D.`,
   promptsEmpty: "\u0421\u043E\u0445\u0440\u0430\u043D\u0451\u043D\u043D\u044B\u0445 \u043F\u0440\u043E\u043C\u0442\u043E\u0432 \u043D\u0435\u0442. \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439 /prompt save <\u0438\u043C\u044F>.",
@@ -9160,6 +9331,8 @@ ${url}`,
     theme: "\u0441\u043C\u0435\u043D\u0438\u0442\u044C \u0446\u0432\u0435\u0442 \u0430\u043A\u0446\u0435\u043D\u0442\u0430",
     lang: "\u0441\u043C\u0435\u043D\u0438\u0442\u044C \u044F\u0437\u044B\u043A \u0438\u043D\u0442\u0435\u0440\u0444\u0435\u0439\u0441\u0430",
     memory: "\u043F\u043E\u043A\u0430\u0437\u0430\u0442\u044C, \u0437\u0430\u043C\u0435\u043D\u0438\u0442\u044C \u0438\u043B\u0438 \u043E\u0447\u0438\u0441\u0442\u0438\u0442\u044C \u043F\u0430\u043C\u044F\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442\u0430",
+    systemp: "\u043F\u043E\u043A\u0430\u0437\u0430\u0442\u044C, \u0437\u0430\u0434\u0430\u0442\u044C, \u0437\u0430\u0433\u0440\u0443\u0437\u0438\u0442\u044C \u0438\u0437 \u0444\u0430\u0439\u043B\u0430 \u0438\u043B\u0438 \u0432\u043A\u043B\u044E\u0447\u0438\u0442\u044C/\u0432\u044B\u043A\u043B\u044E\u0447\u0438\u0442\u044C \u0434\u043E\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0435 \u043A \u0441\u0438\u0441\u0442\u0435\u043C\u043D\u043E\u043C\u0443 \u043F\u0440\u043E\u043C\u043F\u0442\u0443",
+    steps: "\u043B\u0438\u043C\u0438\u0442 \u0432\u044B\u0437\u043E\u0432\u043E\u0432 \u043C\u043E\u0434\u0435\u043B\u0438 \u0437\u0430 \u0445\u043E\u0434",
     prompt: "\u0432\u0441\u0442\u0430\u0432\u0438\u0442\u044C \u0438\u043B\u0438 \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u043F\u0440\u043E\u043C\u0442",
     skills: "\u0441\u043F\u0438\u0441\u043E\u043A \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u043D\u044B\u0445 \u0441\u043A\u0438\u043B\u043B\u043E\u0432",
     "prompt delete": "\u0443\u0434\u0430\u043B\u0438\u0442\u044C \u0441\u043E\u0445\u0440\u0430\u043D\u0451\u043D\u043D\u044B\u0439 \u043F\u0440\u043E\u043C\u0442",
@@ -9205,6 +9378,7 @@ function Confirm({ title, body, danger, onAnswer }) {
   const theme = useTheme();
   const strings = useStrings();
   useTerminalInput((char, key) => {
+    if (key.ctrl || key.meta || key.super) return;
     const c = normalizeHotkey(char);
     if (c === "y") onAnswer(true);
     else if (c === "n" || key.escape || key.return) onAnswer(false);
@@ -9338,18 +9512,30 @@ function LanguagePicker({ onPick }) {
 }
 
 // src/ui/components/Onboarding.tsx
-import { Box as Box4, Text as Text4 } from "ink";
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
 import Spinner from "ink-spinner";
 import TextInput from "ink-text-input";
 import { useState as useState2 } from "react";
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-function Onboarding({ onSubmit }) {
+function Onboarding({
+  onSubmit,
+  onCancel
+}) {
   const theme = useTheme();
   const strings = useStrings();
   const [step, setStep] = useState2("url");
   const [url, setUrl] = useState2("");
   const [key, setKey] = useState2("");
   const [error, setError] = useState2("");
+  useInput2((_input, inputKey) => {
+    if (!inputKey.escape || step === "working") return;
+    if (step === "key") {
+      setError("");
+      setStep("url");
+    } else {
+      onCancel?.();
+    }
+  });
   const submitKey = async (value) => {
     if (value.trim() === "") return;
     setStep("working");
@@ -9575,6 +9761,7 @@ function PermissionPrompt({ request, onDecide }) {
     setSelected(dangerous ? options.length - 1 : 0);
   }, [request]);
   useTerminalInput((char, key) => {
+    if (key.ctrl || key.meta || key.super) return;
     const c = normalizeHotkey(char);
     if (key.upArrow) setSelected((index) => (index - 1 + options.length) % options.length);
     else if (key.downArrow || key.tab) setSelected((index) => (index + 1) % options.length);
@@ -10355,13 +10542,30 @@ function ContextMeter({
 }
 
 // src/ui/components/SubagentChat.tsx
-import { Box as Box12, Text as Text12, useInput as useInput2 } from "ink";
+import { Box as Box12, Text as Text12 } from "ink";
+
+// src/ui/subagent-status.ts
+function subagentStatusLabel(state, strings) {
+  switch (state) {
+    case "running":
+      return strings.subagentRunning;
+    case "done":
+      return strings.subagentDone;
+    case "cancelled":
+      return strings.subagentCancelled;
+    case "error":
+      return strings.subagentError;
+    case "incomplete":
+      return strings.subagentIncomplete;
+  }
+}
+
+// src/ui/components/SubagentChat.tsx
 import { useState as useState7 } from "react";
 
 // src/ui/components/Transcript.tsx
 import { Box as Box11, Static, Text as Text11 } from "ink";
 import { memo as memo2, useEffect as useEffect3, useMemo as useMemo5, useRef as useRef4, useState as useState6 } from "react";
-import Spinner2 from "ink-spinner";
 import stringWidth4 from "string-width";
 
 // src/ui/markdown.tsx
@@ -11251,17 +11455,17 @@ function AssistantView({ bubble: source, maxRows }) {
   return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginTop: 1, children: [
     frameThinking !== "" && /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", maxHeight: thinkingBudget, overflowY: "hidden", children: /* @__PURE__ */ jsx11(Markdown, { dim: true, children: frameThinking }) }),
     bubble.streaming ? /* @__PURE__ */ jsx11(Text11, { children: frameText }) : /* @__PURE__ */ jsx11(Markdown, { children: bubble.text }),
-    bubble.streaming && bubble.text === "" && /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
-      /* @__PURE__ */ jsx11(Spinner2, { type: "dots" }),
-      " thinking"
-    ] })
+    bubble.streaming && bubble.text === "" && /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "thinking\u2026" })
   ] });
 }
 function clipTextToRows(text, maxRows, columns) {
   if (text === "" || maxRows <= 0) return "";
   const width = Number.isFinite(columns) ? Math.max(1, Math.floor(columns)) : 80;
-  const rows = text.replace(/\r\n?/g, "\n").split("\n").flatMap((line) => wrapVisualLine(line, width));
-  if (rows.length <= maxRows) return rows.join("\n");
+  const bound = (maxRows + 1) * width;
+  const sliced = text.length > bound;
+  const source = sliced ? text.slice(text.length - bound) : text;
+  const rows = source.replace(/\r\n?/g, "\n").split("\n").flatMap((line) => wrapVisualLine(line, width));
+  if (!sliced && rows.length <= maxRows) return rows.join("\n");
   const tail2 = rows.slice(-Math.max(1, maxRows - 1));
   return maxRows === 1 ? tail2.at(-1) ?? "" : ["\u2026", ...tail2].join("\n");
 }
@@ -11364,6 +11568,13 @@ function previewLines(content) {
   return [...lines.slice(0, 6), `\u2026 ${lines.length - 6} more lines`];
 }
 var VISIBLE_SUBAGENTS = 3;
+var PROGRESS_TAIL_CHARS = 4e3;
+function progressTail(text) {
+  if (text.length <= PROGRESS_TAIL_CHARS) return text;
+  const cut = text.slice(text.length - PROGRESS_TAIL_CHARS);
+  const newline = cut.indexOf("\n");
+  return newline === -1 ? cut : cut.slice(newline + 1);
+}
 function SubagentSummary({ agents }) {
   const theme = useTheme();
   const running = agents.filter((agent) => agent.state === "running");
@@ -11372,12 +11583,14 @@ function SubagentSummary({ agents }) {
       "Subagents: ",
       running.length,
       " running \xB7 ",
-      agents.length - running.length,
-      " done"
+      agents.filter((agent) => agent.state === "done").length,
+      " done / ",
+      agents.filter((agent) => agent.state !== "running" && agent.state !== "done").length,
+      " stopped"
     ] }),
     running.slice(0, VISIBLE_SUBAGENTS).map((agent) => {
       const latest = agent.bubbles.at(-1);
-      const progress = latest?.kind === "tool" ? latest.summary : latest?.kind === "assistant" ? sanitizeThinkingText(latest.text || latest.thinking, latest.streaming) : "waiting";
+      const progress = latest?.kind === "tool" ? latest.summary : latest?.kind === "assistant" ? sanitizeThinkingText(progressTail(latest.text || latest.thinking), latest.streaming) : "waiting";
       return /* @__PURE__ */ jsxs11(Text11, { dimColor: true, wrap: "truncate-end", children: [
         agent.description,
         " \xB7 ",
@@ -11389,23 +11602,28 @@ function SubagentSummary({ agents }) {
 }
 function SubagentView({ bubble, maxRows }) {
   const theme = useTheme();
+  const strings = useStrings();
   const { columns } = useTerminalSize();
   const mark = bubble.state === "running" ? "\u25CC" : "\u25CF";
-  const color = bubble.state === "running" ? theme.warn : theme.ok;
+  const color = bubble.state === "error" ? theme.error : bubble.state === "done" ? theme.ok : theme.warn;
   const latest = bubble.bubbles.at(-1);
-  const progress = latest?.kind === "assistant" ? sanitizeThinkingText(latest.text || latest.thinking, latest.streaming) : latest?.kind === "tool" ? latest.summary : "";
+  const progress = latest?.kind === "assistant" ? sanitizeThinkingText(progressTail(latest.text || latest.thinking), latest.streaming) : latest?.kind === "tool" ? latest.summary : "";
   return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginTop: 1, minWidth: 0, children: [
     /* @__PURE__ */ jsxs11(Text11, { color, bold: true, wrap: "truncate-end", children: [
       mark,
       " subagent: ",
-      bubble.description
+      bubble.description,
+      " - ",
+      subagentStatusLabel(bubble.state, strings)
     ] }),
+    bubble.reason && /* @__PURE__ */ jsx11(Text11, { color: theme.warn, children: bubble.reason }),
     /* @__PURE__ */ jsx11(Box11, { marginLeft: 2, flexDirection: "column", minWidth: 0, children: bubble.state === "running" ? /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", maxHeight: Math.max(1, (maxRows ?? 6) - 2), overflowY: "hidden", children: /* @__PURE__ */ jsx11(Markdown, { children: clipTextToRows(progress, Math.max(1, (maxRows ?? 6) - 2), Math.max(1, columns - 2)) }) }) : bubble.result ? /* @__PURE__ */ jsx11(Markdown, { children: sanitizeThinkingText(bubble.result) }) : null })
   ] });
 }
 
 // src/ui/components/SubagentChat.tsx
 import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+var MAX_SHOWN_BUBBLES = 24;
 function SubagentChat({
   bubble,
   rows,
@@ -11415,7 +11633,7 @@ function SubagentChat({
   const strings = useStrings();
   const [offset, setOffset] = useState7(0);
   const total = bubble?.bubbles.length ?? 0;
-  useInput2((_input, key) => {
+  useTerminalInput((_input, key) => {
     if (key.escape) onClose();
     else if (key.upArrow) setOffset((value) => Math.min(Math.max(0, total - 1), value + 1));
     else if (key.downArrow) setOffset((value) => Math.max(0, value - 1));
@@ -11427,18 +11645,19 @@ function SubagentChat({
     ] });
   }
   const running = bubble.state === "running";
-  const shown = bubble.bubbles.slice(0, total - offset);
-  const bodyRows = Math.max(3, rows - 2);
+  const shown = bubble.bubbles.slice(Math.max(0, total - offset - MAX_SHOWN_BUBBLES), total - offset);
+  const bodyRows = Math.max(3, rows - (bubble.reason ? 3 : 2));
   return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", minWidth: 0, children: [
-    /* @__PURE__ */ jsxs12(Text12, { color: running ? theme.warn : theme.ok, bold: true, wrap: "truncate-end", children: [
+    /* @__PURE__ */ jsxs12(Text12, { color: running || bubble.state === "cancelled" || bubble.state === "incomplete" ? theme.warn : bubble.state === "error" ? theme.error : theme.ok, bold: true, wrap: "truncate-end", children: [
       running ? "\u25CC" : "\u25CF",
       " ",
       bubble.description,
       /* @__PURE__ */ jsxs12(Text12, { dimColor: true, bold: false, children: [
         " \xB7 ",
-        running ? strings.subagentRunning : strings.subagentDone
+        subagentStatusLabel(bubble.state, strings)
       ] })
     ] }),
+    bubble.reason && /* @__PURE__ */ jsx12(Text12, { color: theme.warn, wrap: "truncate-end", children: bubble.reason }),
     /* @__PURE__ */ jsxs12(
       Box12,
       {
@@ -11464,25 +11683,44 @@ function SubagentChat({
 
 // src/ui/components/TerminalViewport.tsx
 import { Box as Box13 } from "ink";
-import { jsx as jsx13 } from "react/jsx-runtime";
-var INTERACTIVE_CHROME_ROWS = 11;
+import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+var CHROME_ROWS = 16;
 var MAX_LIVE_ROWS = 11;
 var MIN_LIVE_ROWS = 4;
-function liveTranscriptRows(rows) {
+var BOTTOM_SLACK_ROWS = 3;
+function liveTranscriptRows(rows, chromeRows) {
   if (!Number.isFinite(rows)) return MAX_LIVE_ROWS;
-  return Math.max(MIN_LIVE_ROWS, Math.min(MAX_LIVE_ROWS, Math.floor(rows) - INTERACTIVE_CHROME_ROWS - 2));
+  const chrome = chromeRows ?? CHROME_ROWS;
+  const budget = Math.floor(rows) - chrome - BOTTOM_SLACK_ROWS - 1;
+  return Math.max(MIN_LIVE_ROWS, Math.min(MAX_LIVE_ROWS, budget));
 }
 function TerminalViewport({ children, rows }) {
   const { columns } = useTerminalSize();
-  return /* @__PURE__ */ jsx13(
+  const liveRows = liveTranscriptRows(rows);
+  const items = Array.isArray(children) ? children : [children];
+  const [transcript, ...chromeChildren] = items;
+  return /* @__PURE__ */ jsxs13(
     Box13,
     {
-      width: columns,
+      width: columns - 1,
       maxWidth: "100%",
       flexDirection: "column",
-      maxHeight: liveTranscriptRows(rows) + INTERACTIVE_CHROME_ROWS,
+      maxHeight: liveRows + CHROME_ROWS,
       overflowY: "hidden",
-      children
+      children: [
+        /* @__PURE__ */ jsx13(
+          Box13,
+          {
+            flexDirection: "column",
+            flexShrink: 1,
+            minHeight: 0,
+            maxHeight: liveRows,
+            overflowY: "hidden",
+            children: transcript
+          }
+        ),
+        /* @__PURE__ */ jsx13(Box13, { flexDirection: "column", flexShrink: 0, children: chromeChildren })
+      ]
     }
   );
 }
@@ -11571,7 +11809,7 @@ function applyEvent(state, event) {
       return {
         ...state,
         bubbles: state.bubbles.map(
-          (bubble) => bubble.kind === "subagent" && bubble.id === event.id ? { ...bubble, state: "done", result: sanitizeTerminalText(event.result) } : bubble
+          (bubble) => bubble.kind === "subagent" && bubble.id === event.id ? { ...bubble, state: event.status ?? "done", reason: event.reason ? sanitizeTerminalText(event.reason) : void 0, result: sanitizeTerminalText(event.result) } : bubble
         )
       };
     case "subagent_event": {
@@ -11603,6 +11841,10 @@ function applyEvent(state, event) {
 function applyEvents(state, events) {
   return coalesceDeltas(events).reduce(applyEvent, state);
 }
+function isStreamDelta(event) {
+  if (event.type === "text_delta" || event.type === "thinking_delta") return true;
+  return event.type === "subagent_event" && isStreamDelta(event.event);
+}
 function coalesceDeltas(events) {
   const out = [];
   for (const event of events) {
@@ -11740,7 +11982,7 @@ function safeSummary(summarize, name, input) {
 }
 
 // src/ui/App.tsx
-import { jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
+import { jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
 var EFFORTS = ["auto", "low", "medium", "high", "xhigh", "max"];
 var STREAM_FRAME_MS = 50;
 var CUSTOM_ACCENT = "__custom__";
@@ -11797,6 +12039,8 @@ function App({
   const [, forceRender] = useState8(0);
   const history = useRef5(initialHistory);
   const abort = useRef5(null);
+  const exitArmedAt = useRef5(null);
+  const [hiddenSubagents, setHiddenSubagents] = useState8(() => /* @__PURE__ */ new Set());
   const sessionStart = useRef5(Date.now());
   const turns = useRef5(0);
   const [turnStart, setTurnStart] = useState8(null);
@@ -11848,7 +12092,7 @@ function App({
     (event) => {
       recordSpeed(speedMeter.current, event);
       transcriptEvents.current.push(event);
-      if (event.type !== "text_delta" && event.type !== "thinking_delta") {
+      if (!isStreamDelta(event)) {
         flushTranscriptEvents();
         return;
       }
@@ -11926,6 +12170,9 @@ function App({
     turns.current += 1;
     const hooks = {
       onEvent: queueTranscriptEvent,
+      onHistory: (messages) => {
+        history.current = messages;
+      },
       requestPermission: (request) => new Promise((resolve3) => {
         let settled = false;
         const finish = (decision) => {
@@ -11959,10 +12206,12 @@ function App({
         notice("error", error instanceof Error ? error.message : String(error));
       }
       history.current = await runtime.run(history.current, hooks, controller.signal);
-      void runtime.persist(history.current).catch((error) => notice("error", error instanceof Error ? error.message : String(error)));
     } catch (error) {
       notice("error", error instanceof Error ? error.message : String(error));
     } finally {
+      await runtime.persist(history.current).catch(
+        (error) => notice("error", error instanceof Error ? error.message : String(error))
+      );
       if (!controller.signal.aborted && Date.now() - startedAt >= BELL_AFTER_MS) bell();
       flushTranscriptEvents();
       abort.current = null;
@@ -12022,6 +12271,7 @@ function App({
           });
           sessionStart.current = Date.now();
           turns.current = 0;
+          speedMeter.current = createSpeedMeter();
           void runtime.persist([]).catch(
             (error) => notice("error", error instanceof Error ? error.message : String(error))
           );
@@ -12665,8 +12915,24 @@ ${strings.mcpAddUsage}`
           return;
         }
         case "subagents": {
+          flushTranscriptEvents();
+          const clearFinished = () => {
+            const finished = transcriptRef.current.bubbles.filter(
+              (bubble) => bubble.kind === "subagent" && bubble.state !== "running" && !hiddenSubagents.has(bubble.id)
+            );
+            if (finished.length === 0) {
+              notice("info", strings.noFinishedSubagents);
+              return;
+            }
+            setHiddenSubagents((previous) => /* @__PURE__ */ new Set([...previous, ...finished.map((bubble) => bubble.id)]));
+            notice("info", strings.subagentsCleared);
+          };
+          if (rawRest === "clear") {
+            clearFinished();
+            return;
+          }
           const agents = transcriptRef.current.bubbles.filter(
-            (bubble) => bubble.kind === "subagent"
+            (bubble) => bubble.kind === "subagent" && !hiddenSubagents.has(bubble.id)
           );
           if (agents.length === 0) {
             notice("info", strings.noSubagents);
@@ -12679,13 +12945,14 @@ ${strings.mcpAddUsage}`
           const running = ordered.filter((agent) => agent.state === "running");
           const id = running.length === 1 && rawRest === "" ? running[0].id : await pick(
             strings.subagentsTitle,
-            ordered.slice(0, 20).map((agent) => ({
+            [...ordered.slice(0, 20).map((agent) => ({
               key: agent.id,
               label: agent.description || "subagent",
-              hint: agent.state === "running" ? strings.subagentRunning : strings.subagentDone
-            }))
+              hint: subagentStatusLabel(agent.state, strings)
+            })), ...ordered.some((agent) => agent.state !== "running") ? [{ key: "__clear_finished__", label: strings.subagentsClear, hint: "/subagents clear" }] : []]
           );
-          if (id) setOverlay({ kind: "subagent", id });
+          if (id === "__clear_finished__") clearFinished();
+          else if (id) setOverlay({ kind: "subagent", id });
           return;
         }
         case "checker":
@@ -12758,6 +13025,61 @@ ${strings.mcpAddUsage}`
           notice("info", runtime.readMemory() || strings.memoryEmpty);
           return;
         }
+        case "systemp": {
+          const sub = rest[0]?.toLowerCase();
+          if (sub === "set" || sub === "load") {
+            const argument = rawRest.replace(/^\S+\s*/, "").trim();
+            if (!argument && sub === "load") {
+              notice("warn", strings.systemPromptUsage);
+              return;
+            }
+            try {
+              const text = sub === "set" ? argument || // No inline text: fall back to a full-screen input prompt.
+              (await promptInput(strings.systemPromptTitle) ?? "").trim() : await runtime.loadSystemPromptFile(argument);
+              if (!text) return;
+              if (text.length > MAX_SYSTEM_PROMPT_CHARS) {
+                notice("error", strings.systemPromptTooLong(MAX_SYSTEM_PROMPT_CHARS.toLocaleString(lang ?? "en")));
+                return;
+              }
+              await runtime.setSystemPrompt(text);
+              notice("info", strings.systemPromptSet);
+            } catch (error) {
+              notice("error", error instanceof Error ? error.message : String(error));
+            }
+            return;
+          }
+          if (sub === "clear") {
+            if (!runtime.getSystemPrompt()) {
+              notice("info", strings.systemPromptEmpty);
+              return;
+            }
+            await runtime.setSystemPrompt("");
+            notice("info", strings.systemPromptCleared);
+            return;
+          }
+          if (sub === "on") {
+            await runtime.setSystemPromptEnabled(true);
+            notice("info", strings.systemPromptEnabled);
+            return;
+          }
+          if (sub === "off") {
+            await runtime.setSystemPromptEnabled(false);
+            notice("info", strings.systemPromptDisabled);
+            return;
+          }
+          if (sub !== void 0 && sub !== "" && sub !== "show") {
+            notice("warn", strings.systemPromptUsage);
+            return;
+          }
+          const current = runtime.getSystemPrompt();
+          if (!current) {
+            notice("info", strings.systemPromptEmpty);
+            return;
+          }
+          const enabled = runtime.isSystemPromptEnabled();
+          notice("info", (enabled ? "" : "[disabled] ") + current);
+          return;
+        }
         case "effort": {
           notice("info", runtime.effortDescription(history.current));
           const choice = EFFORTS.includes(rawRest) ? rawRest : await pick(
@@ -12770,6 +13092,21 @@ ${strings.mcpAddUsage}`
           forceRender((n) => n + 1);
           return;
         }
+        case "steps": {
+          const current = runtime.getMaxTurnSteps();
+          if (!rest[0]) {
+            notice("info", strings.stepsCurrent(current));
+            return;
+          }
+          const parsed = Number(rest[0]);
+          if (!Number.isInteger(parsed) || parsed < 0 || parsed > 1e3) {
+            notice("warn", strings.stepsInvalid);
+            return;
+          }
+          await runtime.setMaxTurnSteps(parsed);
+          notice("info", parsed === 0 ? strings.stepsUnlimited : strings.stepsSet(parsed));
+          return;
+        }
         case "budget": {
           const current = runtime.getMaxTokensPerTurn();
           if (rest[0]) {
@@ -12954,7 +13291,7 @@ ${strings.mcpAddUsage}`
         }
       }
     },
-    [applyAccent, appendAttachment, ask2, exit, notice, pick, replaceAttachments, runtime, strings]
+    [applyAccent, appendAttachment, ask2, exit, notice, pick, replaceAttachments, runtime, strings, hiddenSubagents, flushTranscriptEvents]
   );
   const runSlash = useCallback(
     (line) => {
@@ -13123,6 +13460,7 @@ ${strings.mcpAddUsage}`
       }
       const text = raw.trim();
       const submitSlash = () => {
+        setPromptHistory((state) => appendInputHistory(state, text));
         if (!detachedInput) setInput("");
         const command = text.slice(1).trim().split(/\s+/)[0]?.toLowerCase();
         if (busyRef.current && !commandRunsWhileBusy(command) || slashPendingRef.current > 0) {
@@ -13184,6 +13522,18 @@ ${strings.mcpAddUsage}`
     [replaceAttachments, runAgent, runSlash, tryQueueAutomaticAttachment]
   );
   useTerminalInput((_char, key) => {
+    if (key.ctrl && _char === "c") {
+      const now = Date.now();
+      if (exitArmedAt.current !== null && now - exitArmedAt.current < 3e3) {
+        abort.current?.abort();
+        exit();
+      } else {
+        exitArmedAt.current = now;
+        notice("warn", strings.confirmExit);
+      }
+      return;
+    }
+    exitArmedAt.current = null;
     if (key.tab && key.shift) {
       const next = runtime.cycleMode();
       notice("info", strings.modeChanged(strings.modeLabel[next] ?? next));
@@ -13191,7 +13541,7 @@ ${strings.mcpAddUsage}`
       return;
     }
     if (!key.escape) return;
-    if (overlay.kind === "subagent") return;
+    if (overlay.kind !== "none") return;
     if (checkedOut.current && overlay.kind === "none") {
       if (busyRef.current || slashPendingRef.current > 0) {
         putBackCheckedOut(input);
@@ -13217,21 +13567,6 @@ ${strings.mcpAddUsage}`
       if (clipboardPasteTask.current) clipboardPasteTask.current = null;
       return;
     }
-    if (overlay.kind === "permission") {
-      overlay.resolve("deny");
-      setOverlay({ kind: "none" });
-      return;
-    }
-    if (overlay.kind === "confirm") {
-      overlay.resolve(false);
-      setOverlay({ kind: "none" });
-      return;
-    }
-    if (overlay.kind === "picker") {
-      overlay.select("");
-      setOverlay({ kind: "none" });
-      return;
-    }
     setInput("");
   });
   const shell = (children) => /* @__PURE__ */ jsx14(ThemeContext.Provider, { value: theme, children: /* @__PURE__ */ jsx14(StringsContext.Provider, { value: strings, children }) });
@@ -13259,13 +13594,16 @@ ${strings.mcpAddUsage}`
             notice("info", `${summary2}
 ${strings.configAt(runtime.configPath())}`);
             return summary2;
+          },
+          onCancel: () => {
+            if (!runtime.needsSetup()) setSetup(false);
           }
         }
       )
     );
   }
   return shell(
-    /* @__PURE__ */ jsxs13(TerminalViewport, { rows, children: [
+    /* @__PURE__ */ jsxs14(TerminalViewport, { rows, children: [
       /* @__PURE__ */ jsx14(
         Transcript,
         {
@@ -13398,7 +13736,7 @@ function TextInputOverlay({
   useInput3((_input, key) => {
     if (key.escape) onCancel();
   });
-  return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", children: [
+  return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: title }),
     /* @__PURE__ */ jsx14(
       TextInput2,
@@ -13518,10 +13856,16 @@ function clearTerminal() {
   if (process.stdout.isTTY) process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
 }
 var TUI_RENDER_OPTIONS = {
-  // Keep unchanged streamed lines in place instead of clearing and redrawing
-  // the whole live region on every frame.
-  incrementalRendering: true,
-  maxFps: 30
+  // Incremental rendering is off: Ink's incremental diff races with its own
+  // <Static> commits and leaves stale rows behind (the prompt frame appears
+  // twice). Standard rendering clears the whole frame each time — a little
+  // more work, but no stale lines.
+  incrementalRendering: false,
+  exitOnCtrlC: false,
+  // Throttling defers writes; when a bubble closes into <Static> mid-stream,
+  // the deferred frame and the static write race and leave stale rows behind.
+  // Unthrottled renders cost a little CPU but keep every frame consistent.
+  maxFps: 0
 };
 async function startTui(options) {
   const { runtime, history, warnings, shutdown } = await boot({