@kernelonpanic/kitcode 1.1.1 → 1.2.0

package/dist/index.js

@@ -9,6 +9,14 @@ import { existsSync } from "fs";
 
 // src/config/schema.ts
 import { z } from "zod";
+var reservedRecordKeys = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var safeRecordKeySchema = z.string().min(1).max(256).refine((value) => !reservedRecordKeys.has(value) && !/[\0-\x1f\x7f]/.test(value), {
+  message: "contains a reserved or unsafe key"
+});
+var providerIdSchema = safeRecordKeySchema.regex(
+  /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/,
+  "must start with a letter or digit and contain only letters, digits, dots, underscores, or dashes"
+);
 function isAllowedEndpointUrl(value) {
   try {
     const url = new URL(value);
@@ -79,11 +87,11 @@ var configSchema = z.object({
   }),
   diagnostics: diagnosticsSchema.default({ autoRun: true, commands: [] }),
   updates: updatesSchema.default({ checkOnStart: false }),
-  providers: z.record(z.string(), providerConfigSchema).default({}),
-  permissions: z.record(z.string(), permissionModeSchema).default({}),
-  mcp: z.record(z.string(), mcpServerSchema).default({})
+  providers: z.record(providerIdSchema, providerConfigSchema).default({}),
+  permissions: z.record(safeRecordKeySchema, permissionModeSchema).default({}),
+  mcp: z.record(safeRecordKeySchema, mcpServerSchema).default({})
 });
-var authSchema = z.record(z.string(), z.string());
+var authSchema = z.record(providerIdSchema, z.string());
 function defaultConfig() {
   return configSchema.parse({});
 }
@@ -380,8 +388,9 @@ function perMillion(value) {
 }
 function positiveInt(value) {
   const parsed = toNumber(value);
-  if (parsed === void 0 || parsed <= 0) return void 0;
-  return Math.trunc(parsed);
+  if (parsed === void 0) return void 0;
+  const integer = Math.trunc(parsed);
+  return integer >= 1 ? integer : void 0;
 }
 function toNumber(value) {
   if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
@@ -401,7 +410,12 @@ async function detectProvider(rawUrl, apiKey2, opts = {}) {
   if (!isAllowedEndpointUrl(baseUrl)) {
     throw new Error("API URL must use https; plain http is only allowed for localhost or 127.0.0.1.");
   }
-  const id = opts.name ?? providerIdFromUrl(baseUrl);
+  const candidateId = opts.name ?? providerIdFromUrl(baseUrl);
+  const parsedId = providerIdSchema.safeParse(candidateId);
+  if (!parsedId.success) {
+    throw new Error(`Invalid provider name "${candidateId}": ${parsedId.error.issues[0]?.message ?? "invalid name"}`);
+  }
+  const id = parsedId.data;
   if (hostname(baseUrl) === anthropicHost) {
     const probed = await probe(
       fetchImpl,
@@ -453,7 +467,8 @@ function providerIdFromUrl(url) {
   }
   const labels = host.split(".");
   const label = labels.find((part) => part !== "api" && part !== "") ?? "provider";
-  return label.replace(/[^a-z0-9-]/g, "-");
+  const candidate = label.replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "") || "provider";
+  return providerIdSchema.safeParse(candidate).success ? candidate : `provider-${candidate}`;
 }
 function isAddressLiteral(host) {
   return host === "localhost" || /^[0-9.]+$/.test(host) || host.includes(":");
@@ -651,7 +666,7 @@ async function isFile(file) {
 
 // src/config/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { chmod as chmod2, readFile as readFile2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import path3 from "path";
 
 // src/config/trust.ts
@@ -671,23 +686,30 @@ async function isWorkspaceTrusted(cwd) {
 }
 async function trustWorkspace(cwd) {
   const workspace = await canonicalWorkspace(cwd);
-  const trust = await loadTrust();
-  if (!trust.workspaces.includes(workspace)) {
-    trust.workspaces.push(workspace);
-    trust.workspaces.sort();
-    await saveTrust(trust);
-  }
+  await withTrustLock(async () => {
+    const trust = await readTrust();
+    if (!trust.workspaces.includes(workspace)) {
+      trust.workspaces.push(workspace);
+      trust.workspaces.sort();
+      await writeTrust(trust);
+    }
+  });
   return workspace;
 }
 async function revokeWorkspaceTrust(cwd) {
   const workspace = await canonicalWorkspace(cwd);
-  const trust = await loadTrust();
-  const workspaces = trust.workspaces.filter((entry) => entry !== workspace);
-  if (workspaces.length !== trust.workspaces.length) await saveTrust({ version: 1, workspaces });
+  await withTrustLock(async () => {
+    const trust = await readTrust();
+    const workspaces = trust.workspaces.filter((entry) => entry !== workspace);
+    if (workspaces.length !== trust.workspaces.length) await writeTrust({ version: 1, workspaces });
+  });
   return workspace;
 }
 async function loadTrust() {
   await trustLock;
+  return readTrust();
+}
+async function readTrust() {
   let parsed;
   try {
     parsed = JSON.parse(await readFile(trustPath, "utf8"));
@@ -703,26 +725,29 @@ async function loadTrust() {
     workspaces: value.workspaces.filter((entry) => typeof entry === "string")
   };
 }
-async function saveTrust(value) {
-  const release = trustLock;
-  let resolveLock;
+async function writeTrust(value) {
+  await ensureDir(path2.dirname(trustPath));
+  const temp = `${trustPath}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temp, `${JSON.stringify(value, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+    await rename(temp, trustPath);
+  } catch (error) {
+    await rm(temp, { force: true });
+    throw error;
+  }
+}
+async function withTrustLock(action) {
+  const previous = trustLock;
+  let release;
   trustLock = new Promise((resolve3) => {
-    resolveLock = resolve3;
+    release = resolve3;
   });
-  await release;
+  await previous;
   try {
-    await ensureDir(path2.dirname(trustPath));
-    const temp = `${trustPath}.${randomUUID()}.tmp`;
-    try {
-      await writeFile(temp, `${JSON.stringify(value, null, 2)}
-`, { encoding: "utf8", mode: 384 });
-      await rename(temp, trustPath);
-    } catch (error) {
-      await rm(temp, { force: true });
-      throw error;
-    }
+    return await action();
   } finally {
-    resolveLock();
+    release();
   }
 }
 
@@ -754,7 +779,7 @@ async function loadConfigAt(location) {
 }
 async function saveConfig(config) {
   const location = await configLocation();
-  await writeJsonAtomic(location.path, config);
+  await writeJsonAtomic(location.path, config, location.scope === "project" ? void 0 : 384);
 }
 async function initProjectConfig(dir) {
   const location = { path: projectConfigPath(dir), scope: "project" };
@@ -817,17 +842,24 @@ async function readJson(file) {
   }
 }
 async function writeJsonAtomic(file, value, mode) {
-  await ensureDir(path3.dirname(file));
+  const parent = path3.dirname(file);
+  if (isInside(homeDir, parent)) await ensureDir(parent);
+  else await mkdir2(parent, { recursive: true });
   const temp = `${file}.${randomUUID2()}.tmp`;
   try {
     await writeFile2(temp, `${JSON.stringify(value, null, 2)}
 `, { encoding: "utf8", mode });
     await rename2(temp, file);
+    if (mode !== void 0) await chmod2(file, mode);
   } catch (error) {
     await rm2(temp, { force: true });
     throw error;
   }
 }
+function isInside(root, candidate) {
+  const relative2 = path3.relative(path3.resolve(root), path3.resolve(candidate));
+  return relative2 === "" || !path3.isAbsolute(relative2) && relative2.split(path3.sep)[0] !== "..";
+}
 function formatIssues(file, error) {
   const lines = error.issues.map(
     (issue) => `  ${issue.path.join(".") || "(root)"}: ${issue.message}`
@@ -856,6 +888,8 @@ async function addProvider(url, key, options = {}) {
   }
   const config = options.local ? await loadProjectConfig(cwd) : (await loadRuntimeConfig(cwd)).config;
   const auth = await loadAuth();
+  const configBefore = structuredClone(config);
+  const authBefore = { ...auth };
   config.providers[detected.id] = detected.config;
   auth[detected.id] = key;
   const models = detected.models;
@@ -863,8 +897,16 @@ async function addProvider(url, key, options = {}) {
     const chosen = pickDefault(models);
     if (chosen) config.model = formatModelRef(detected.id, chosen);
   }
-  await saveConfig(config);
-  await saveAuth(auth);
+  try {
+    await saveConfig(config);
+    await saveAuth(auth);
+  } catch (error) {
+    Object.assign(config, configBefore);
+    for (const id of Object.keys(auth)) delete auth[id];
+    Object.assign(auth, authBefore);
+    await Promise.allSettled([saveConfig(config), saveAuth(auth)]);
+    throw error;
+  }
   const location = await configLocation();
   const protocol = detected.config.type === "anthropic" ? "Anthropic" : "OpenAI-compatible";
   const rows = [
@@ -971,7 +1013,7 @@ function skipControlString(text, from, bellTerminates) {
 
 // src/app/runtime.ts
 import path13 from "path";
-import { mkdir as mkdir5 } from "fs/promises";
+import { mkdir as mkdir6 } from "fs/promises";
 
 // src/core/session.ts
 import { randomBytes } from "crypto";
@@ -997,8 +1039,13 @@ async function saveSession(state) {
   await ensureDir(sessionsDir);
   const file = path4.join(sessionsDir, `${state.id}.json`);
   const temp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
-  await writeFile3(temp, JSON.stringify(state), { encoding: "utf8", mode: 384 });
-  await atomicRename(temp, file);
+  try {
+    await writeFile3(temp, JSON.stringify(state), { encoding: "utf8", mode: 384 });
+    await atomicRename(temp, file);
+  } catch (error) {
+    await unlink(temp).catch(() => void 0);
+    throw error;
+  }
 }
 async function atomicRename(from, to, retries = 5) {
   for (let attempt = 0; attempt < retries; attempt++) {
@@ -1172,7 +1219,9 @@ function readState(raw) {
   }
   if (typeof parsed !== "object" || parsed === null) return null;
   const state = parsed;
-  if (typeof state.id !== "string" || !Array.isArray(state.messages)) return null;
+  if (typeof state.id !== "string" || !validSessionId(state.id)) return null;
+  const messages = readMessages(state.messages);
+  if (!messages) return null;
   return {
     id: state.id,
     title: typeof state.title === "string" ? state.title.slice(0, 120) : void 0,
@@ -1180,11 +1229,59 @@ function readState(raw) {
     createdAt: typeof state.createdAt === "string" ? state.createdAt : "",
     updatedAt: typeof state.updatedAt === "string" ? state.updatedAt : "",
     model: typeof state.model === "string" ? state.model : "",
-    messages: state.messages,
-    usage: Array.isArray(state.usage) ? state.usage : [],
+    messages,
+    usage: readUsageEntries(state.usage),
     context: readContextUsage(state.context)
   };
 }
+function readMessages(value) {
+  if (!Array.isArray(value)) return null;
+  const messages = [];
+  for (const item of value) {
+    if (typeof item !== "object" || item === null) return null;
+    const candidate = item;
+    if (candidate.role !== "user" && candidate.role !== "assistant") return null;
+    if (!Array.isArray(candidate.content)) return null;
+    const content = [];
+    for (const block of candidate.content) {
+      if (!validContentBlock(block)) return null;
+      content.push(block);
+    }
+    messages.push({ role: candidate.role, content });
+  }
+  return messages;
+}
+function validContentBlock(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const block = value;
+  switch (block.type) {
+    case "text":
+    case "thinking":
+      return typeof block.text === "string";
+    case "tool_use":
+      return typeof block.id === "string" && typeof block.name === "string";
+    case "tool_result":
+      return typeof block.toolUseId === "string" && typeof block.content === "string" && (block.isError === void 0 || typeof block.isError === "boolean");
+    case "image":
+      return typeof block.name === "string" && typeof block.data === "string" && block.data.length <= MAX_SESSION_BYTES * 2 && ["image/jpeg", "image/png", "image/gif", "image/webp"].includes(String(block.mediaType));
+    case "file":
+      return typeof block.name === "string" && typeof block.mediaType === "string" && typeof block.text === "string";
+    default:
+      return false;
+  }
+}
+function readUsageEntries(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (typeof item !== "object" || item === null) return [];
+    const candidate = item;
+    const usage = readUsage(candidate.usage);
+    if (typeof candidate.model !== "string" || !usage || !Number.isInteger(candidate.requests) || candidate.requests < 0) {
+      return [];
+    }
+    return [{ model: candidate.model, usage, requests: candidate.requests, costUsd: null }];
+  });
+}
 async function resolveExportTarget(destination, state) {
   const resolved = path4.resolve(destination);
   const info = await stat2(resolved).catch(() => null);
@@ -1245,7 +1342,9 @@ function readUsage(value) {
   if (typeof value !== "object" || value === null) return void 0;
   const usage = value;
   const fields = ["input", "output", "cacheWrite", "cacheRead"];
-  if (fields.some((field2) => typeof usage[field2] !== "number" || !Number.isFinite(usage[field2]))) {
+  if (fields.some(
+    (field2) => typeof usage[field2] !== "number" || !Number.isFinite(usage[field2]) || usage[field2] < 0
+  )) {
     return void 0;
   }
   return {
@@ -1276,10 +1375,13 @@ async function resolveSessionId(query) {
   );
 }
 function assertSessionId(id) {
-  if (!/^[A-Za-z0-9_-]{1,240}$/.test(id)) {
+  if (!validSessionId(id)) {
     throw new Error(`Invalid session id: ${id}`);
   }
 }
+function validSessionId(id) {
+  return /^[A-Za-z0-9_-]{1,240}$/.test(id);
+}
 
 // src/core/agent.ts
 var MAX_PAUSE_RESUMES = 5;
@@ -1455,11 +1557,20 @@ function retryAfterFromError(error) {
 }
 function sleep(ms, signal) {
   return new Promise((resolve3, reject) => {
-    const id = setTimeout(resolve3, ms);
-    signal.addEventListener("abort", () => {
+    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"));
-    }, { once: true });
+    };
+    const id = setTimeout(finish, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
   });
 }
 function estimateRequestTokens(cfg, messages) {
@@ -1478,9 +1589,7 @@ function estimateRequestTokens(cfg, messages) {
 async function runToolCalls(cfg, content, hooks, signal) {
   const calls = content.filter((block) => block.type === "tool_use");
   const results = [];
-  for (const call of calls) {
-    results.push(await runOneCall(cfg, call, hooks, signal));
-  }
+  for (const call of calls) results.push(await runOneCall(cfg, call, hooks, signal));
   return results;
 }
 async function runOneCall(cfg, call, hooks, signal) {
@@ -1608,6 +1717,7 @@ function costOf(usage, pricing) {
 }
 
 // src/core/budget.ts
+var UNKNOWN_MODEL_PRICING = { input: 3, output: 15 };
 function createTurnBudget(limits, resolvePricing = pricingFor) {
   let usage = emptyUsage();
   let costUsd = 0;
@@ -1645,7 +1755,7 @@ function createTurnBudget(limits, resolvePricing = pricingFor) {
       const pricing = resolvePricing(request.modelRef);
       if (current.costUsd !== null) {
         const remainingUsd = limits.maxCostUsdPerTurn - current.costUsd;
-        const effectivePricing = pricing ?? { input: 3e-3, output: 0.015 };
+        const effectivePricing = pricing ?? UNKNOWN_MODEL_PRICING;
         const inputUsd = estimatedInput * effectivePricing.input / 1e6;
         const affordableOutput = Math.floor(
           (remainingUsd - inputUsd) * 1e6 / effectivePricing.output
@@ -1661,9 +1771,10 @@ function createTurnBudget(limits, resolvePricing = pricingFor) {
       return { allowed: true, maxOutputTokens: Math.floor(outputLimit) };
     },
     record(modelRef, next) {
-      usage = addUsage(usage, normalizeUsage(next));
-      const priced = costOf(usage, resolvePricing(modelRef));
-      costUsd = priced;
+      const normalized = normalizeUsage(next);
+      usage = addUsage(usage, normalized);
+      const priced = costOf(normalized, resolvePricing(modelRef) ?? UNKNOWN_MODEL_PRICING);
+      costUsd = (costUsd ?? 0) + (priced ?? 0);
     },
     snapshot
   };
@@ -1686,7 +1797,7 @@ import { createReadStream } from "fs";
 import {
   chmod as chmod3,
   lstat,
-  mkdir as mkdir2,
+  mkdir as mkdir3,
   readFile as readFile4,
   readdir as readdir2,
   rename as rename4,
@@ -1928,7 +2039,7 @@ async function restoreFile(root, relativePath, snapshot, expected) {
   const safe = resolveInside(root, relativePath);
   if (!safe.ok || safe.relative !== relativePath) throw new Error("The restore path changed.");
   const data = decodeSnapshot(snapshot);
-  await mkdir2(path5.dirname(safe.path), { recursive: true });
+  await mkdir3(path5.dirname(safe.path), { recursive: true });
   const rechecked = resolveInside(root, relativePath);
   if (!rechecked.ok || rechecked.path !== safe.path || rechecked.relative !== relativePath) {
     throw new Error("The restore path changed while preparing its parent directory.");
@@ -2372,17 +2483,15 @@ async function loadAttachment(cwd, requestedPath) {
 }
 async function loadAutomaticAttachment(cwd, requestedPath) {
   if (!looksLikeAttachmentPath(requestedPath)) return null;
-  const resolved = resolveAttachmentPath(cwd, requestedPath);
+  const requested = resolveAttachmentPath(cwd, requestedPath);
+  const safe = resolveInside(cwd, requested);
+  if (!safe.ok || safe.relative === "") return null;
+  const resolved = safe.path;
   if (isSensitiveAutomaticPath(resolved)) {
     throw new Error(
       `For safety, sensitive-looking files must be attached explicitly with /attach: ${path7.basename(resolved)}`
     );
   }
-  if (path7.isAbsolute(resolved)) {
-    const normalized = resolved.toLowerCase();
-    const isProjectFile = normalized.includes(path7.sep + "src" + path7.sep) || normalized.includes(path7.sep + "lib" + path7.sep) || normalized.includes(path7.sep + "app" + path7.sep) || normalized.includes(path7.sep + "test" + path7.sep) || normalized.includes(path7.sep + "tests" + path7.sep) || normalized.includes(path7.sep + "public" + path7.sep) || normalized.includes(path7.sep + "assets" + path7.sep) || normalized.includes(path7.sep + "static" + path7.sep) || normalized.endsWith(".ts") || normalized.endsWith(".js") || normalized.endsWith(".tsx") || normalized.endsWith(".jsx") || normalized.endsWith(".py") || normalized.endsWith(".go") || normalized.endsWith(".rs") || normalized.endsWith(".java") || normalized.endsWith(".c") || normalized.endsWith(".cpp") || normalized.endsWith(".h") || normalized.endsWith(".hpp") || normalized.endsWith(".css") || normalized.endsWith(".html") || normalized.endsWith(".json") || normalized.endsWith(".yaml") || normalized.endsWith(".yml") || normalized.endsWith(".md") || normalized.endsWith(".txt") || normalized.endsWith(".toml") || normalized.endsWith(".ini") || normalized.endsWith(".cfg") || normalized.endsWith(".sh") || normalized.endsWith(".bat") || normalized.endsWith(".cmd") || normalized.endsWith(".ps1") || normalized.endsWith(".dockerfile") || normalized.endsWith(".makefile");
-    if (!isProjectFile) return null;
-  }
   const linkInfo = await lstat2(resolved).catch(() => null);
   if (linkInfo?.isSymbolicLink()) return null;
   const info = await stat5(resolved).catch((error) => {
@@ -2661,47 +2770,90 @@ function formatBytes(value) {
 
 // src/core/compact.ts
 var KEEP_USER_TURNS = 2;
-var MAX_SOURCE_CHARS = 5e5;
-var MAX_TOOL_RESULT_CHARS = 8e3;
-var MAX_TEXT_BLOCK_CHARS = 5e4;
+var SINGLE_REQUEST_MAX_CHARS = 8e4;
+var CHUNK_TARGET_CHARS = 35e3;
+var CHUNK_OVERLAP_MESSAGES = 2;
+var CHUNK_OVERLAP_MAX_CHARS = 4e3;
+var MERGE_TARGET_CHARS = 6e4;
+var MAX_USER_TEXT_CHARS = 12e3;
+var MAX_ASSISTANT_TEXT_CHARS = 6e3;
+var MAX_FILE_BLOCK_CHARS = 2e3;
+var MAX_TOOL_RESULT_CHARS = 1200;
+var MAX_TOOL_ERROR_CHARS = 2e3;
+var MAX_TOOL_INPUT_CHARS = 800;
+var SINGLE_MAX_TOKENS = 768;
+var CHUNK_MAX_TOKENS = 512;
+var MERGE_MAX_TOKENS = 1024;
+var CHUNK_CONCURRENCY = 3;
+var SYSTEM_SUMMARIZE = "You are summarizing a coding conversation so another agent can continue the work. Extract and preserve ONLY: concrete requirements, user preferences, files changed, commands run and their results, errors encountered, bugs found, architectural decisions, and unfinished work. Be terse and factual. Do NOT include greetings, acknowledgments, chain-of-thought, or step-by-step narration. Return only the summary.";
+var SYSTEM_MERGE = "Merge these partial summaries of a coding conversation into one coherent summary. Remove duplicates. Preserve: requirements, files changed, commands run, errors, decisions, and unfinished work. Be terse. Return only the merged summary.";
 async function compactHistory(options) {
   const cut = compactCutIndex(options.history);
   if (cut <= 0) {
     return { history: options.history, compacted: false, removedMessages: 0 };
   }
-  const source = renderHistory(options.history.slice(0, cut));
-  if (!source.trim()) {
+  const oldMessages = options.history.slice(0, cut);
+  const renderedMessages = renderMessages(oldMessages);
+  const rendered = renderedMessages.join("\n\n");
+  if (!rendered.trim()) {
     return { history: options.history, compacted: false, removedMessages: 0 };
   }
-  let summary = "";
-  let finalText2 = "";
+  let summary;
   let usage;
   let rateLimits;
-  const stream = options.provider.stream({
-    model: options.model,
-    system: "Summarize the earlier coding conversation for another agent. Preserve concrete requirements, user preferences, architectural decisions, commands and files changed, test results, bugs, errors, and unfinished work. Be concise but lossless. Do not include private chain-of-thought or invent details. Return only the durable summary.",
-    messages: [
-      {
-        role: "user",
-        content: [{ type: "text", text: `Earlier conversation to compact:
-
-${source}` }]
-      }
-    ],
-    tools: [],
-    maxTokens: Math.max(512, Math.min(4096, options.maxTokens)),
-    thinking: false,
-    signal: options.signal
-  });
-  for await (const event of stream) {
-    if (event.type === "text_delta") summary += event.text;
-    else if (event.type === "usage") usage = event.usage;
-    else if (event.type === "rate_limits") rateLimits = event.limits;
-    else if (event.type === "done") {
-      finalText2 = event.content.filter((block) => block.type === "text").map((block) => block.type === "text" ? block.text : "").join("");
+  if (rendered.length <= SINGLE_REQUEST_MAX_CHARS) {
+    const requestMax = singleOutputLimit(options.maxTokens, options.maxTotalOutputTokens);
+    const result = await summarizeText(
+      options.provider,
+      options.model,
+      options.maxTokens,
+      options.signal,
+      rendered,
+      SYSTEM_SUMMARIZE,
+      requestMax
+    );
+    summary = result.text;
+    usage = result.usage;
+    rateLimits = result.rateLimits;
+  } else {
+    const chunks = chunkRenderedMessages(
+      renderedMessages,
+      CHUNK_TARGET_CHARS,
+      CHUNK_OVERLAP_MESSAGES,
+      CHUNK_OVERLAP_MAX_CHARS
+    );
+    const limits = chunkOutputLimits(
+      chunks.length,
+      options.maxTokens,
+      options.maxTotalOutputTokens
+    );
+    const chunkResults = await summarizeSourcesParallel(
+      options.provider,
+      options.model,
+      options.maxTokens,
+      options.signal,
+      chunks,
+      SYSTEM_SUMMARIZE,
+      limits.chunk
+    );
+    const chunkUsages = chunkResults.map((result) => result.usage).filter(Boolean);
+    usage = chunkUsages.length > 0 ? mergeUsage(chunkUsages) : void 0;
+    rateLimits = [...chunkResults].reverse().find((r) => r.rateLimits)?.rateLimits;
+    const mergeResult = await mergePartialSummaries(
+      options.provider,
+      options.model,
+      options.maxTokens,
+      options.signal,
+      chunkResults.map((result) => result.text),
+      limits.merge
+    );
+    summary = mergeResult.text;
+    if (mergeResult.usage) {
+      usage = usage ? mergeUsage([usage, mergeResult.usage]) : mergeResult.usage;
     }
+    if (mergeResult.rateLimits) rateLimits = mergeResult.rateLimits;
   }
-  summary = (finalText2 || summary).trim();
+  summary = summary.trim();
   if (!summary) throw new Error("The provider returned an empty context summary.");
   const prefix = [
     {
@@ -2733,11 +2885,34 @@ function compactCutIndex(history) {
   if (userTurns.length <= KEEP_USER_TURNS) return 0;
   return userTurns[userTurns.length - KEEP_USER_TURNS] ?? 0;
 }
-function estimateCompactTokens(history) {
+function estimateCompactBudget(history, maxTokens = MERGE_MAX_TOKENS) {
   const cut = compactCutIndex(history);
-  if (cut <= 0) return 1;
-  const rendered = renderHistory(history.slice(0, cut));
-  return Math.max(1, Math.min(rendered.length, MAX_SOURCE_CHARS) + 1e3);
+  if (cut <= 0) return { inputTokens: 1, maxOutputTokens: 0 };
+  const renderedMessages = renderMessages(history.slice(0, cut));
+  const rendered = renderedMessages.join("\n\n");
+  if (rendered.length <= SINGLE_REQUEST_MAX_CHARS) {
+    return {
+      inputTokens: Math.max(1, rendered.length + 1e3),
+      maxOutputTokens: Math.max(1, Math.min(SINGLE_MAX_TOKENS, Math.floor(maxTokens)))
+    };
+  }
+  const chunks = chunkRenderedMessages(
+    renderedMessages,
+    CHUNK_TARGET_CHARS,
+    CHUNK_OVERLAP_MESSAGES,
+    CHUNK_OVERLAP_MAX_CHARS
+  );
+  const chunkInput = chunks.reduce((total, chunk) => total + chunk.length, 0);
+  const chunkOutput = Math.max(1, Math.min(CHUNK_MAX_TOKENS, Math.floor(maxTokens)));
+  const mergeOutput = Math.max(1, Math.min(MERGE_MAX_TOKENS, Math.floor(maxTokens)));
+  const mergeRequests = Math.max(0, chunks.length - 1);
+  const totalOutput = chunks.length * chunkOutput + mergeRequests * mergeOutput;
+  const intermediateOutput = chunks.length * chunkOutput + Math.max(0, mergeRequests - 1) * mergeOutput;
+  const requestCount = chunks.length + mergeRequests;
+  return {
+    inputTokens: Math.max(1, chunkInput + intermediateOutput * 8 + requestCount * 1e3),
+    maxOutputTokens: totalOutput
+  };
 }
 function isConversationUser(message) {
   if (message.role !== "user") return false;
@@ -2745,50 +2920,249 @@ function isConversationUser(message) {
     (block) => block.type === "image" || block.type === "file" || block.type === "text" && !block.text.startsWith("[Earlier conversation summary]")
   );
 }
-function renderHistory(history) {
-  let result = "";
-  for (const message of history) {
-    const blocks = message.content.map(renderBlock).filter(Boolean);
-    if (blocks.length === 0) continue;
-    const part = `${message.role.toUpperCase()}:
-${blocks.join("\n\n")}`;
-    if (result.length + part.length > MAX_SOURCE_CHARS) {
-      result += "\n\n[...older context truncated for compaction...]";
-      break;
+function chunkRenderedMessages(messages, targetChars, overlapMessages, overlapMaxChars) {
+  const units = messages.flatMap((message) => splitLongMessage(message, targetChars));
+  const chunks = [];
+  let current = [];
+  const sizeOf = (parts) => parts.reduce((total, part) => total + part.length, 0) + Math.max(0, parts.length - 1) * 2;
+  for (const unit of units) {
+    if (current.length > 0 && sizeOf([...current, unit]) > targetChars) {
+      chunks.push(current.join("\n\n"));
+      const overlap = [];
+      let overlapChars = 0;
+      for (let index = current.length - 1; index >= 0 && overlap.length < overlapMessages; index -= 1) {
+        const candidate = current[index];
+        if (overlapChars + candidate.length > overlapMaxChars) break;
+        overlap.unshift(candidate);
+        overlapChars += candidate.length;
+      }
+      current = overlap;
+      while (current.length > 0 && sizeOf([...current, unit]) > targetChars) current.shift();
     }
-    result += (result ? "\n\n" : "") + part;
+    current.push(unit);
+  }
+  if (current.length > 0) chunks.push(current.join("\n\n"));
+  return chunks;
+}
+function splitLongMessage(message, targetChars) {
+  if (message.length <= targetChars) return [message];
+  const parts = [];
+  let remaining = message;
+  const payloadLimit = Math.max(1, targetChars - 32);
+  while (remaining.length > payloadLimit) {
+    let cut = remaining.lastIndexOf("\n", payloadLimit);
+    if (cut < payloadLimit * 0.6) cut = payloadLimit;
+    parts.push(`${remaining.slice(0, cut)}
+[message continues]`);
+    remaining = `[continued message]
+${remaining.slice(cut).replace(/^\n/, "")}`;
+  }
+  if (remaining) parts.push(remaining);
+  return parts;
+}
+async function summarizeSourcesParallel(provider, model, maxTokens, signal, sources, systemPrompt, maxOutputTokens) {
+  const results = new Array(sources.length);
+  const controller = new AbortController();
+  const abort = () => controller.abort(signal.reason);
+  if (signal.aborted) abort();
+  else signal.addEventListener("abort", abort, { once: true });
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const index = next++;
+      if (index >= sources.length) return;
+      try {
+        results[index] = await summarizeText(
+          provider,
+          model,
+          maxTokens,
+          controller.signal,
+          sources[index],
+          systemPrompt,
+          maxOutputTokens
+        );
+      } catch (error) {
+        controller.abort(error);
+        throw error;
+      }
+    }
+  };
+  try {
+    await Promise.all(
+      Array.from({ length: Math.min(CHUNK_CONCURRENCY, sources.length) }, () => worker())
+    );
+    return results;
+  } finally {
+    signal.removeEventListener("abort", abort);
   }
-  return result;
 }
-function renderBlock(block) {
+async function mergePartialSummaries(provider, model, maxTokens, signal, summaries, mergeMaxTokens) {
+  let current = summaries;
+  const usages = [];
+  let rateLimits;
+  while (current.length > 1) {
+    const groups = groupSummaries(current, MERGE_TARGET_CHARS);
+    const sources = groups.map(
+      (group) => group.map((summary, index) => `## Part ${index + 1}
+${summary}`).join("\n\n")
+    );
+    const merged = await summarizeSourcesParallel(
+      provider,
+      model,
+      maxTokens,
+      signal,
+      sources,
+      SYSTEM_MERGE,
+      mergeMaxTokens
+    );
+    for (const result of merged) {
+      if (!result.text) throw new Error("The provider returned an empty partial context summary.");
+      if (result.usage) usages.push(result.usage);
+      if (result.rateLimits) rateLimits = result.rateLimits;
+    }
+    current = merged.map((result) => result.text);
+  }
+  return {
+    text: current[0] ?? "",
+    usage: usages.length > 0 ? mergeUsage(usages) : void 0,
+    rateLimits
+  };
+}
+function singleOutputLimit(maxTokens, totalBudget) {
+  const requested = Math.max(1, Math.min(SINGLE_MAX_TOKENS, Math.floor(maxTokens)));
+  if (totalBudget === void 0) return requested;
+  const allowed = Math.floor(totalBudget);
+  if (allowed < 1) throw new Error("The remaining turn budget is too small to compact context.");
+  return Math.min(requested, allowed);
+}
+function chunkOutputLimits(chunkCount, maxTokens, totalBudget) {
+  let chunk = Math.max(1, Math.min(CHUNK_MAX_TOKENS, Math.floor(maxTokens)));
+  let merge = Math.max(1, Math.min(MERGE_MAX_TOKENS, Math.floor(maxTokens)));
+  if (totalBudget === void 0) return { chunk, merge };
+  const mergeRequests = Math.max(0, chunkCount - 1);
+  const requestCount = chunkCount + mergeRequests;
+  const allowed = Math.floor(totalBudget);
+  if (allowed < requestCount) {
+    throw new Error("The remaining turn budget is too small for all context-compaction requests.");
+  }
+  const requested = chunkCount * chunk + mergeRequests * merge;
+  if (allowed >= requested) return { chunk, merge };
+  const scale = allowed / requested;
+  chunk = Math.max(1, Math.floor(chunk * scale));
+  merge = Math.max(1, Math.floor(merge * scale));
+  const total = () => chunkCount * chunk + mergeRequests * merge;
+  while (total() > allowed) {
+    if (mergeRequests > 0 && merge > 1 && merge >= chunk) merge -= 1;
+    else if (chunk > 1) chunk -= 1;
+    else if (merge > 1) merge -= 1;
+    else throw new Error("Could not fit context compaction into the remaining turn budget.");
+  }
+  return { chunk, merge };
+}
+function groupSummaries(summaries, targetChars) {
+  const groups = [];
+  let current = [];
+  let size = 0;
+  for (const summary of summaries) {
+    if (current.length >= 2 && size + 12 + summary.length > targetChars) {
+      groups.push(current);
+      current = [];
+      size = 0;
+    }
+    const separator = current.length > 0 ? 12 : 0;
+    current.push(summary);
+    size += separator + summary.length;
+  }
+  if (current.length > 0) groups.push(current);
+  return groups;
+}
+async function summarizeText(provider, model, maxTokens, signal, source, systemPrompt, maxOutputTokens) {
+  if (signal.aborted) throw signal.reason ?? new Error("Context compaction was cancelled.");
+  let summary = "";
+  let finalText2 = "";
+  let usage;
+  let rateLimits;
+  const stream = provider.stream({
+    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
+  });
+  for await (const event of stream) {
+    if (event.type === "text_delta") summary += event.text;
+    else if (event.type === "usage") usage = event.usage;
+    else if (event.type === "rate_limits") rateLimits = event.limits;
+    else if (event.type === "done") {
+      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.");
+  return { text: (finalText2 || summary).trim(), usage, rateLimits };
+}
+function mergeUsage(usages) {
+  return usages.reduce(
+    (acc, u) => ({
+      input: acc.input + u.input,
+      output: acc.output + u.output,
+      cacheWrite: acc.cacheWrite + u.cacheWrite,
+      cacheRead: acc.cacheRead + u.cacheRead
+    }),
+    { input: 0, output: 0, cacheWrite: 0, cacheRead: 0 }
+  );
+}
+function renderMessages(history) {
+  return history.flatMap((message) => {
+    const blocks = message.content.map((block) => renderBlock(block, message.role)).filter(Boolean);
+    return blocks.length > 0 ? [`${message.role.toUpperCase()}:
+${blocks.join("\n")}`] : [];
+  });
+}
+function renderBlock(block, role) {
   switch (block.type) {
     case "text":
-      return truncate(block.text, MAX_TEXT_BLOCK_CHARS);
+      return truncate(
+        block.text,
+        role === "user" ? MAX_USER_TEXT_CHARS : MAX_ASSISTANT_TEXT_CHARS
+      );
     case "thinking":
       return "";
     case "image":
-      return `[Image attached: ${block.name}]`;
+      return `[image: ${block.name}]`;
     case "file":
-      return `[File attached: ${block.name}]
-${truncate(block.text, MAX_TOOL_RESULT_CHARS)}`;
+      return `[file: ${block.name}]
+${truncate(block.text, MAX_FILE_BLOCK_CHARS)}`;
     case "tool_use":
-      return `[Tool call: ${block.name}]
-${safeJson(block.input)}`;
+      return `[tool: ${block.name}(${truncate(safeJson(block.input), MAX_TOOL_INPUT_CHARS)})]`;
     case "tool_result":
-      return `[Tool result${block.isError ? " (error)" : ""}]
-${truncate(block.content, MAX_TOOL_RESULT_CHARS)}`;
+      if (block.isError) {
+        return `[tool result error: ${truncate(block.content, MAX_TOOL_ERROR_CHARS)}]`;
+      }
+      if (isTrivialSuccess(block.content)) return "";
+      return truncate(block.content, MAX_TOOL_RESULT_CHARS);
   }
 }
+function isTrivialSuccess(content) {
+  const t = content.trim().toLowerCase();
+  if (!t || t === "ok" || t === "done" || t === "success") return true;
+  if (/^no matches found/.test(t)) return true;
+  if (t === "(no output)") return true;
+  return false;
+}
 function safeJson(value) {
   try {
-    return truncate(JSON.stringify(value, null, 2), MAX_TOOL_RESULT_CHARS);
+    return JSON.stringify(value);
   } catch {
-    return "[unserializable input]";
+    return "[unserializable]";
   }
 }
 function truncate(value, max) {
-  return value.length <= max ? value : `${value.slice(0, max)}
-[...truncated...]`;
+  if (value.length <= max) return value;
+  const keep = Math.floor(max * 0.4);
+  return `${value.slice(0, max - keep)}
+...${value.slice(-keep)}`;
 }
 
 // src/core/prompt.ts
@@ -3050,7 +3424,7 @@ function clip(value) {
 // package.json
 var package_default = {
   name: "@kernelonpanic/kitcode",
-  version: "1.1.1",
+  version: "1.2.0",
   description: "Terminal coding agent with a config you never have to write by hand",
   type: "module",
   license: "MIT",
@@ -3118,7 +3492,7 @@ var package_default = {
 // src/version.ts
 var KITCODE_VERSION = package_default.version;
 var KITCODE_REPOSITORY = "KernelEditor/KitCode";
-var KITCODE_COMMIT = true ? "a57e54102a5e1ca1e60cec4ee9c629c890d27057" : "development";
+var KITCODE_COMMIT = true ? "c93b03ff85112af7b4c28f543aff6b9377f84ad6" : "development";
 
 // src/mcp/client.ts
 var clientInfo = { name: "kitcode", version: KITCODE_VERSION };
@@ -3140,7 +3514,11 @@ var inheritedEnvKeys = /* @__PURE__ */ new Set([
   "COMSPEC",
   "PATHEXT",
   "APPDATA",
-  "LOCALAPPDATA"
+  "LOCALAPPDATA",
+  "USERPROFILE",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "USERNAME"
 ]);
 var blockedEnvKeys = /* @__PURE__ */ new Set([
   "ANTHROPIC_API_KEY",
@@ -3317,8 +3695,11 @@ function configuredSecrets(config) {
 }
 function inheritedEnv(source = process.env) {
   const env = {};
+  const allowed = new Set([...inheritedEnvKeys].map((key) => key.toUpperCase()));
+  const blocked = new Set([...blockedEnvKeys].map((key) => key.toUpperCase()));
   for (const [key, value] of Object.entries(source)) {
-    if (value !== void 0 && inheritedEnvKeys.has(key) && !blockedEnvKeys.has(key)) {
+    const normalized = key.toUpperCase();
+    if (value !== void 0 && allowed.has(normalized) && !blocked.has(normalized)) {
       env[key] = value;
     }
   }
@@ -3352,7 +3733,10 @@ async function fetchProviderBalance(config, apiKey2, options = {}) {
           },
           signal: controller.signal
         });
-        if (!response.ok) continue;
+        if (!response.ok) {
+          await response.body?.cancel().catch(() => void 0);
+          continue;
+        }
         const text = await limitedResponseText(response, MAX_RESPONSE_BYTES);
         if (text === null) continue;
         const balance = endpoint2.parse(JSON.parse(text));
@@ -3467,7 +3851,10 @@ function finiteNumber(value) {
 }
 async function limitedResponseText(response, limit) {
   const declared = Number(response.headers.get("content-length"));
-  if (Number.isFinite(declared) && declared > limit) return null;
+  if (Number.isFinite(declared) && declared > limit) {
+    await response.body?.cancel().catch(() => void 0);
+    return null;
+  }
   if (!response.body) return "";
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
@@ -3517,11 +3904,34 @@ function cacheFile(providerId) {
 }
 async function readCache(file) {
   try {
-    return JSON.parse(await readFile7(file, "utf8"));
+    const parsed = JSON.parse(await readFile7(file, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return void 0;
+    const candidate = parsed;
+    if (typeof candidate.fetchedAt !== "number" || !Number.isFinite(candidate.fetchedAt) || !Array.isArray(candidate.models) || candidate.models.length > 1e4 || !candidate.models.every(validModel)) {
+      return void 0;
+    }
+    return candidate;
   } catch {
     return void 0;
   }
 }
+function validModel(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const model = value;
+  if (typeof model.id !== "string" || model.id === "") return false;
+  if (model.name !== void 0 && typeof model.name !== "string") return false;
+  if (model.contextWindow !== void 0 && (!Number.isInteger(model.contextWindow) || model.contextWindow < 1)) {
+    return false;
+  }
+  if (model.pricing === void 0) return true;
+  const prices = [
+    model.pricing.input,
+    model.pricing.output,
+    model.pricing.cacheWrite,
+    model.pricing.cacheRead
+  ].filter((price2) => price2 !== void 0);
+  return prices.length >= 2 && prices.every((price2) => Number.isFinite(price2) && price2 >= 0);
+}
 async function writeCache(file, models) {
   const payload = { version: CACHE_VERSION, fetchedAt: Date.now(), models };
   try {
@@ -4629,7 +5039,7 @@ function toToolSchema(tool) {
 }
 
 // src/tools/write.ts
-import { lstat as lstat4, mkdir as mkdir3, readFile as readFile11, stat as stat9, writeFile as writeFile7 } from "fs/promises";
+import { lstat as lstat4, mkdir as mkdir4, readFile as readFile11, stat as stat9, writeFile as writeFile7 } from "fs/promises";
 import { dirname as dirname2 } from "path";
 var MAX_FILE_BYTES5 = 5e6;
 var writeTool = {
@@ -4698,7 +5108,7 @@ var writeTool = {
     let before = "";
     if (beforeBuffer) before = beforeBuffer.toString("utf8");
     try {
-      await mkdir3(dirname2(safe.path), { recursive: true });
+      await mkdir4(dirname2(safe.path), { recursive: true });
       await ctx.checkpoint?.capture(safe.path);
       await writeFile7(safe.path, content, "utf8");
       ctx.checkpoint?.markChanged(safe.path);
@@ -4915,11 +5325,22 @@ function parseFrontmatter(text) {
 }
 
 // src/skills/install.ts
+import { randomUUID as randomUUID3 } from "crypto";
 import { execFileSync } from "child_process";
-import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { chmod as chmod6, mkdir as mkdir4 } from "fs/promises";
+import {
+  existsSync as existsSync2,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  realpathSync as realpathSync2,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { chmod as chmod6, mkdir as mkdir5 } from "fs/promises";
 import path12 from "path";
 var TMP_DIR = path12.join(skillsDir, ".tmp");
+var MAX_SKILL_BYTES2 = 5e6;
 async function installSkill(source) {
   await ensureDir(skillsDir);
   if (isGitHubUrl(source)) {
@@ -4931,30 +5352,31 @@ async function installSkill(source) {
   return installFromLocal(source);
 }
 function isGitHubUrl(input) {
-  return /^https?:\/\/(www\.)?github\.com\/[\w.-]+\/[\w.-]+/.test(input);
+  try {
+    const url = new URL(input);
+    return url.protocol === "https:" && (url.hostname === "github.com" || url.hostname === "www.github.com");
+  } catch {
+    return false;
+  }
 }
 function isNpmPackage(input) {
-  if (input.includes("/") || input.includes("\\") || input.startsWith(".")) return false;
-  return /^(@[\w.-]+\/)?[\w.-]+(@[\w.*+-]+)?$/.test(input);
+  return npmSkillName(input) !== null;
 }
 async function installFromGitHub(url) {
   const { owner, repo, subdir, branch } = parseGitHubUrl(url);
-  const name = subdir || repo;
-  const skillDir = path12.join(skillsDir, name);
-  const tmpDir = path12.join(TMP_DIR, `${name}-${Date.now()}`);
+  const name = safeSkillName(subdir ? path12.posix.basename(subdir) : repo);
+  const skillDir = safeChildPath(skillsDir, name);
+  const tmpDir = safeChildPath(TMP_DIR, `${name}-${randomUUID3()}`);
   try {
-    rmSync(skillDir, { recursive: true, force: true });
     mkdirSync(tmpDir, { recursive: true });
     const cloneUrl = `https://github.com/${owner}/${repo}.git`;
     const gitArgs = ["clone", "--depth", "1"];
     if (branch) gitArgs.push("--branch", branch);
     gitArgs.push(cloneUrl, tmpDir);
     execFileSync("git", gitArgs, { stdio: "ignore" });
-    const skillFile = subdir ? path12.join(tmpDir, subdir, "SKILL.md") : path12.join(tmpDir, "SKILL.md");
-    if (!existsSync2(skillFile)) {
-      throw new Error(`No SKILL.md found in "${subdir || repo}"`);
-    }
-    const body = readFileSync(skillFile, "utf8");
+    const skillFile = subdir ? safeChildPath(tmpDir, ...subdir.split("/"), "SKILL.md") : safeChildPath(tmpDir, "SKILL.md");
+    const body = readSkillFile(skillFile, tmpDir, subdir || repo);
+    removeExistingSkillDir(skillDir);
     await writeSkillFile(skillDir, body);
     return { name, dir: skillDir, source: url };
   } finally {
@@ -4962,9 +5384,11 @@ async function installFromGitHub(url) {
   }
 }
 async function installFromNpm(packageName) {
-  const name = packageName.replace(/^@/, "").replace(/\/[^/]*$/, "").replace(/@[^@]*$/, "");
-  const skillDir = path12.join(skillsDir, name);
-  const tmpDir = path12.join(TMP_DIR, `${name}-${Date.now()}`);
+  const parsedName = npmSkillName(packageName);
+  if (!parsedName) throw new Error(`Invalid npm package name: ${packageName}`);
+  const name = safeSkillName(parsedName);
+  const skillDir = safeChildPath(skillsDir, name);
+  const tmpDir = safeChildPath(TMP_DIR, `${name}-${randomUUID3()}`);
   try {
     mkdirSync(tmpDir, { recursive: true });
     execFileSync("npm", ["pack", packageName, "--prefix", tmpDir], {
@@ -4976,6 +5400,7 @@ async function installFromNpm(packageName) {
       throw new Error(`Could not download npm package "${packageName}"`);
     }
     const tarballPath = path12.join(tmpDir, tarball);
+    validateTarball(tarballPath);
     const extractDir = path12.join(tmpDir, "extracted");
     mkdirSync(extractDir, { recursive: true });
     try {
@@ -4985,7 +5410,7 @@ async function installFromNpm(packageName) {
       if (existsSync2(packageDir)) {
         const skillFile2 = path12.join(packageDir, "SKILL.md");
         if (existsSync2(skillFile2)) {
-          const body2 = readFileSync(skillFile2, "utf8");
+          const body2 = readSkillFile(skillFile2, packageDir, packageName);
           await writeSkillFile(skillDir, body2);
           return { name, dir: skillDir, source: packageName };
         }
@@ -4999,13 +5424,41 @@ async function installFromNpm(packageName) {
     if (!existsSync2(skillFile)) {
       throw new Error(`No SKILL.md found in npm package "${packageName}"`);
     }
-    const body = readFileSync(skillFile, "utf8");
+    const body = readSkillFile(skillFile, extractDir, packageName);
     await writeSkillFile(skillDir, body);
     return { name, dir: skillDir, source: packageName };
   } finally {
     rmSync(tmpDir, { recursive: true, force: true });
   }
 }
+function npmSkillName(input) {
+  if (input.includes("\\") || input.startsWith(".")) return null;
+  const scoped = input.match(/^@[\w.-]+\/([\w.-]+)(?:@[\w.*+-]+)?$/);
+  if (scoped) return scoped[1] ?? null;
+  const unscoped = input.match(/^([\w.-]+)(?:@[\w.*+-]+)?$/);
+  return unscoped?.[1] ?? null;
+}
+function validateTarball(file) {
+  const info = lstatSync(file, { throwIfNoEntry: false });
+  if (!info?.isFile() || info.size > 2e7) {
+    throw new Error("The npm skill archive is missing or exceeds the 20 MB safety limit.");
+  }
+  const listing = execFileSync("tar", ["-tzf", file], {
+    encoding: "utf8",
+    maxBuffer: 2e6,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const entries = listing.split(/\r?\n/).filter(Boolean);
+  if (entries.length === 0 || entries.length > 1e4) {
+    throw new Error("The npm skill archive has an invalid number of entries.");
+  }
+  for (const entry of entries) {
+    const normalized = entry.replace(/^\.\//, "");
+    if (normalized.includes("\\") || path12.posix.isAbsolute(normalized) || normalized.split("/").some((segment) => segment === "..")) {
+      throw new Error(`Unsafe path in npm skill archive: ${entry}`);
+    }
+  }
+}
 async function installFromLocal(srcPath) {
   const resolved = path12.resolve(srcPath);
   let skillDir;
@@ -5021,29 +5474,102 @@ async function installFromLocal(srcPath) {
     throw new Error(`No SKILL.md found at "${srcPath}"`);
   }
   const name = path12.basename(skillDir);
-  const destDir = path12.join(skillsDir, name);
-  const body = readFileSync(skillFile, "utf8");
+  const destDir = safeChildPath(skillsDir, safeSkillName(name));
+  const body = readSkillFile(skillFile, skillDir, srcPath);
   await writeSkillFile(destDir, body);
   return { name, dir: destDir, source: resolved };
 }
 async function writeSkillFile(dir, body) {
-  await mkdir4(dir, { recursive: true, mode: 448 });
+  assertInside(skillsDir, dir);
+  const existingDir = lstatSync(dir, { throwIfNoEntry: false });
+  if (existingDir?.isSymbolicLink()) {
+    throw new Error(`Refusing to replace symlinked skill directory: ${dir}`);
+  }
+  await mkdir5(dir, { recursive: true, mode: 448 });
   const file = path12.join(dir, "SKILL.md");
-  writeFileSync(file, body);
+  const existingFile = lstatSync(file, { throwIfNoEntry: false });
+  if (existingFile?.isSymbolicLink()) {
+    throw new Error(`Refusing to replace symlinked skill file: ${file}`);
+  }
+  writeFileSync(file, body, { encoding: "utf8", mode: 384 });
   await chmod6(file, 384);
 }
 function parseGitHubUrl(url) {
-  const match = url.match(
-    /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+)(?:\/tree\/([^/]+)(?:\/(.+)))?/
-  );
-  if (!match) {
-    const simple = url.match(/^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+)/);
-    if (simple) {
-      return { owner: simple[1], repo: simple[2] };
-    }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
     throw new Error(`Cannot parse GitHub URL: ${url}`);
   }
-  return { owner: match[1], repo: match[2], branch: match[3], subdir: match[4] };
+  if (parsed.protocol !== "https:" || parsed.hostname !== "github.com" && parsed.hostname !== "www.github.com" || parsed.username || parsed.password) {
+    throw new Error("GitHub skills must use an https://github.com URL without credentials.");
+  }
+  let segments;
+  try {
+    segments = parsed.pathname.split("/").filter(Boolean).map((segment) => decodeURIComponent(segment));
+  } catch {
+    throw new Error(`Cannot parse GitHub URL: ${url}`);
+  }
+  if (segments.length < 2) throw new Error(`Cannot parse GitHub URL: ${url}`);
+  const owner = safeGitHubSegment(segments[0], "owner");
+  const repo = safeSkillName(segments[1].replace(/\.git$/i, ""));
+  if (segments.length === 2) return { owner, repo };
+  if (segments[2] !== "tree" || segments.length < 4) {
+    throw new Error(`Unsupported GitHub skill URL: ${url}`);
+  }
+  const branch = safeGitHubSegment(segments[3], "branch");
+  const subdirSegments = segments.slice(4).map((segment) => safeGitHubSegment(segment, "path"));
+  return {
+    owner,
+    repo,
+    branch,
+    subdir: subdirSegments.length > 0 ? subdirSegments.join("/") : void 0
+  };
+}
+function safeGitHubSegment(value, kind) {
+  if (value === "" || value === "." || value === ".." || value.length > 255 || /[\0-\x1f\x7f/\\:*?"<>|#%]/.test(value)) {
+    throw new Error(`Unsafe GitHub ${kind}: ${value || "(empty)"}`);
+  }
+  return value;
+}
+function safeSkillName(value) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value) || value === "." || value === "..") {
+    throw new Error(`Unsafe skill name: ${value || "(empty)"}`);
+  }
+  return value;
+}
+function safeChildPath(root, ...segments) {
+  const target = path12.resolve(root, ...segments);
+  assertInside(root, target);
+  return target;
+}
+function assertInside(root, target) {
+  const relative2 = path12.relative(path12.resolve(root), path12.resolve(target));
+  if (relative2 === "" || !path12.isAbsolute(relative2) && relative2 !== ".." && !relative2.startsWith(`..${path12.sep}`)) {
+    return;
+  }
+  throw new Error(`Path escapes the skills directory: ${target}`);
+}
+function readSkillFile(file, allowedRoot, source) {
+  const info = lstatSync(file, { throwIfNoEntry: false });
+  if (!info?.isFile() || info.isSymbolicLink()) {
+    throw new Error(`No regular SKILL.md found in "${source}"`);
+  }
+  if (info.size > MAX_SKILL_BYTES2) {
+    throw new Error(`SKILL.md in "${source}" exceeds the ${MAX_SKILL_BYTES2 / 1e6} MB limit`);
+  }
+  const root = realpathSync2(allowedRoot);
+  const resolved = realpathSync2(file);
+  assertInside(root, resolved);
+  return readFileSync(resolved, "utf8");
+}
+function removeExistingSkillDir(dir) {
+  const info = lstatSync(dir, { throwIfNoEntry: false });
+  if (!info) return;
+  if (info.isSymbolicLink()) {
+    throw new Error(`Refusing to remove symlinked skill directory: ${dir}`);
+  }
+  rmSync(dir, { recursive: true, force: true });
 }
 
 // src/tools/skill.ts
@@ -5185,6 +5711,7 @@ async function checkForUpdates(fetcher = fetch, currentCommit = KITCODE_COMMIT)
       signal: controller.signal
     });
     if (!response.ok) {
+      await response.body?.cancel().catch(() => void 0);
       return { status: "unknown", reason: `GitHub returned ${response.status}` };
     }
     const payload = await readJsonBounded(response);
@@ -5210,7 +5737,10 @@ async function checkForUpdates(fetcher = fetch, currentCommit = KITCODE_COMMIT)
 }
 async function readJsonBounded(response) {
   const declared = Number(response.headers.get("content-length"));
-  if (Number.isFinite(declared) && declared > MAX_RESPONSE_BYTES2) return null;
+  if (Number.isFinite(declared) && declared > MAX_RESPONSE_BYTES2) {
+    await response.body?.cancel().catch(() => void 0);
+    return null;
+  }
   if (!response.body) return null;
   const reader = response.body.getReader();
   const chunks = [];
@@ -5295,7 +5825,7 @@ async function boot(options) {
     session = (options.continueSession ? await latestSessionFor(options.cwd) : null) ?? createSession(options.cwd, config.model ?? "");
   }
   const usage = createUsageTracker(session.usage, resolvePricing);
-  const skillCatalogue = formatSkillCatalogue(skills);
+  let skillCatalogue = formatSkillCatalogue(skills);
   const mainSystemPrompt = () => buildSystemPrompt({
     cwd: options.cwd,
     toolNames: tools.list().map((tool) => tool.name),
@@ -5402,26 +5932,39 @@ async function boot(options) {
     createTaskTool(wrappedRunner, config.budget.maxSubagentsPerTurn)
   ]);
   let persistQueue = Promise.resolve();
-  const persistConfig = async (mutate) => {
-    mutate(config);
-    await saveConfig(config);
+  let configQueue = Promise.resolve();
+  const persistConfig = (mutate) => {
+    const save = configQueue.catch(() => void 0).then(async () => {
+      const before = structuredClone(config);
+      mutate(config);
+      try {
+        await saveConfig(config);
+      } catch (error) {
+        Object.assign(config, before);
+        throw error;
+      }
+    });
+    configQueue = save;
+    return save;
   };
   const compactWithBudget = async (history, signal, budget) => {
     if (compactCutIndex(history) <= 0) {
       return { history, compacted: false, removedMessages: 0 };
     }
     const resolved = registry.resolve(modelRef);
+    const estimate = estimateCompactBudget(history, config.maxTokens);
     const budgetDecision = budget.beforeRequest({
       modelRef,
-      maxOutputTokens: Math.min(4096, config.maxTokens),
-      estimatedInputTokens: estimateCompactTokens(history)
+      maxOutputTokens: estimate.maxOutputTokens,
+      estimatedInputTokens: estimate.inputTokens
     });
     if (!budgetDecision.allowed) throw new Error(budgetDecision.reason);
     const result = await compactHistory({
       provider: resolved.provider,
       model: resolved.modelId,
       history,
-      maxTokens: budgetDecision.maxOutputTokens,
+      maxTokens: config.maxTokens,
+      maxTotalOutputTokens: budgetDecision.maxOutputTokens,
       signal
     });
     if (result.usage) {
@@ -5442,12 +5985,22 @@ async function boot(options) {
     async addProvider(url, key) {
       const detected = await detectProvider(url, key);
       rememberModels(detected.id, detected.models);
+      const configBefore = structuredClone(config);
+      const authBefore = { ...auth };
       config.providers[detected.id] = detected.config;
       auth[detected.id] = key;
       const chosen = preferredModel(detected.models);
       if (chosen) config.model = formatModelRef(detected.id, chosen);
-      await saveConfig(config);
-      await saveAuth(auth);
+      try {
+        await saveConfig(config);
+        await saveAuth(auth);
+      } catch (error) {
+        Object.assign(config, configBefore);
+        for (const id of Object.keys(auth)) delete auth[id];
+        Object.assign(auth, authBefore);
+        await Promise.allSettled([saveConfig(config), saveAuth(auth)]);
+        throw error;
+      }
       registry = createRegistry(config, auth);
       const nextRef = config.model ?? "";
       const discovered = detected.models.find((model) => model.id === chosen)?.contextWindow;
@@ -5537,17 +6090,26 @@ async function boot(options) {
       const provider = config.providers[providerId];
       if (!provider) throw new Error(`Provider "${providerId}" is not configured.`);
       const previousKey = auth[providerId];
+      const restoreKey = () => {
+        if (previousKey === void 0) delete auth[providerId];
+        else auth[providerId] = previousKey;
+      };
       auth[providerId] = newKey;
       try {
         const testRegistry = createRegistry(config, auth);
-        await loadModels(testRegistry.get(providerId));
+        await testRegistry.get(providerId).listModels();
       } catch (error) {
-        auth[providerId] = previousKey;
+        restoreKey();
         throw new Error(
           `Key verification failed for "${providerId}": ${error instanceof Error ? error.message : String(error)}`
         );
       }
-      await saveAuth(auth);
+      try {
+        await saveAuth(auth);
+      } catch (error) {
+        restoreKey();
+        throw error;
+      }
       registry = createRegistry(config, auth);
       if (parseModelRef(modelRef)?.provider === providerId) {
         const models = await loadModels(registry.get(providerId));
@@ -5614,7 +6176,7 @@ async function boot(options) {
     async exportSession(id, destination) {
       await persistQueue.catch(() => void 0);
       const target = destination ? path13.resolve(options.cwd, destination) : path13.join(options.cwd, ".kitcode-exports");
-      if (!destination) await mkdir5(target, { recursive: true, mode: 448 });
+      if (!destination) await mkdir6(target, { recursive: true, mode: 448 });
       return (await exportSession(id, target)).path;
     },
     configPath: () => location.path,
@@ -5810,6 +6372,9 @@ ${lines.join("\n")}` : null;
     async installSkill(source) {
       const result = await installSkill(source);
       skills = await discoverSkills(skillRoots);
+      skillCatalogue = formatSkillCatalogue(skills);
+      tools.unregister(["skill"]);
+      if (skills.length > 0) tools.register([createSkillTool(skills)]);
       return result;
     },
     async loadAttachment(requestedPath) {
@@ -5972,7 +6537,7 @@ ${lines.join("\n")}` : null;
     warnings,
     async shutdown() {
       try {
-        await persistQueue;
+        await Promise.all([persistQueue, configQueue]);
       } finally {
         await mcp.close();
       }
@@ -6165,8 +6730,7 @@ function validateKey(value) {
 import { render } from "ink";
 
 // src/ui/App.tsx
-import { Box as Box12, Text as Text12, useApp, useInput as useInput2 } from "ink";
-import { execFile as execFile2, execFileSync as execFileSync2 } from "child_process";
+import { Box as Box13, Text as Text12, useApp, useInput as useInput2, useWindowSize as useWindowSize2 } from "ink";
 import { useCallback, useEffect as useEffect2, useMemo as useMemo4, useRef as useRef4, useState as useState5 } from "react";
 
 // src/mcp/add.ts
@@ -6834,7 +7398,13 @@ function Logo({ subtitle, workspace }) {
   return /* @__PURE__ */ jsxs2(Box2, { width: "100%", marginBottom: 1, children: [
     /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", flexShrink: 0, children: CAT.map((line) => /* @__PURE__ */ jsx2(Text2, { color: theme.accent, children: line }, line)) }),
     /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginLeft: 2, flexGrow: 1, flexShrink: 1, minWidth: 0, children: [
-      /* @__PURE__ */ jsx2(Text2, { color: theme.accent, bold: true, children: "kitcode" }),
+      /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { color: theme.accent, bold: true, children: "kitcode" }),
+        /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          " v",
+          KITCODE_VERSION
+        ] })
+      ] }),
       /* @__PURE__ */ jsx2(Text2, { dimColor: true, wrap: "truncate-end", children: subtitle ?? strings.hint }),
       location && /* @__PURE__ */ jsxs2(Box2, { width: "100%", children: [
         /* @__PURE__ */ jsx2(Text2, { color: theme.accent, children: "\u2302 " }),
@@ -7608,69 +8178,88 @@ function ContextMeter({
   ] });
 }
 
+// src/ui/components/TerminalViewport.tsx
+import { Box as Box10 } from "ink";
+import { jsx as jsx10 } from "react/jsx-runtime";
+function interactiveViewportRows(rows) {
+  if (!Number.isFinite(rows)) return 23;
+  return Math.max(1, Math.floor(rows) - 1);
+}
+function TerminalViewport({ children, rows }) {
+  return /* @__PURE__ */ jsx10(
+    Box10,
+    {
+      flexDirection: "column",
+      maxHeight: interactiveViewportRows(rows),
+      overflowY: "hidden",
+      children
+    }
+  );
+}
+
 // src/ui/components/Transcript.tsx
-import { Box as Box11, Static, Text as Text11 } from "ink";
+import { Box as Box12, Static, Text as Text11 } from "ink";
 import { memo as memo2, useMemo as useMemo3, useRef as useRef3 } from "react";
 import Spinner2 from "ink-spinner";
 
 // src/ui/markdown.tsx
-import { Box as Box10, Text as Text10 } from "ink";
+import { Box as Box11, Text as Text10 } from "ink";
 import { useMemo as useMemo2 } from "react";
-import { Fragment as Fragment4, jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+import { Fragment as Fragment4, jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
 function Markdown({ children }) {
   const blocks = useMemo2(() => extractBlocks(children), [children]);
-  return /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: blocks.map((block, i) => /* @__PURE__ */ jsx10(BlockView, { block }, i)) });
+  return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: blocks.map((block, i) => /* @__PURE__ */ jsx11(BlockView, { block }, i)) });
 }
 function BlockView({ block }) {
   switch (block.type) {
     case "heading": {
       const sizes = [22, 20, 18, 16, 14, 13];
       const size = sizes[(block.level ?? 1) - 1] ?? 14;
-      return /* @__PURE__ */ jsx10(Box10, { marginTop: block.level === 1 ? 1 : 0, children: /* @__PURE__ */ jsx10(Text10, { bold: true, children: truncateBySize(block.text ?? "", size) }) });
+      return /* @__PURE__ */ jsx11(Box11, { marginTop: block.level === 1 ? 1 : 0, children: /* @__PURE__ */ jsx11(Text10, { bold: true, children: truncateBySize(block.text ?? "", size) }) });
     }
     case "blockquote":
-      return /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", marginLeft: 2, children: (block.text ?? "").split("\n").map((line, i) => /* @__PURE__ */ jsxs10(Box10, { children: [
-        /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "\u2502 " }),
-        /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: line })
+      return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", marginLeft: 2, children: (block.text ?? "").split("\n").map((line, i) => /* @__PURE__ */ jsxs10(Box11, { children: [
+        /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "\u2502 " }),
+        /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: line })
       ] }, i)) });
     case "ul":
-      return /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: (block.items ?? []).map((item, i) => /* @__PURE__ */ jsxs10(Box10, { children: [
-        /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "\u2022 " }),
-        /* @__PURE__ */ jsx10(Box10, { marginLeft: 2, children: /* @__PURE__ */ jsx10(BlockView, { block: item }) })
+      return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: (block.items ?? []).map((item, i) => /* @__PURE__ */ jsxs10(Box11, { children: [
+        /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "\u2022 " }),
+        /* @__PURE__ */ jsx11(Box11, { marginLeft: 2, children: /* @__PURE__ */ jsx11(BlockView, { block: item }) })
       ] }, i)) });
     case "ol":
-      return /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: (block.items ?? []).map((item, i) => /* @__PURE__ */ jsxs10(Box10, { children: [
-        /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: `${i + 1}. ` }),
-        /* @__PURE__ */ jsx10(Box10, { marginLeft: 2, children: /* @__PURE__ */ jsx10(BlockView, { block: item }) })
+      return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: (block.items ?? []).map((item, i) => /* @__PURE__ */ jsxs10(Box11, { children: [
+        /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: `${i + 1}. ` }),
+        /* @__PURE__ */ jsx11(Box11, { marginLeft: 2, children: /* @__PURE__ */ jsx11(BlockView, { block: item }) })
       ] }, i)) });
     case "paragraph":
     default:
-      return /* @__PURE__ */ jsx10(Text10, { children: inline(block.text ?? "") });
+      return /* @__PURE__ */ jsx11(Text10, { children: inline(block.text ?? "") });
     case "table":
-      return /* @__PURE__ */ jsx10(TableView, { block });
+      return /* @__PURE__ */ jsx11(TableView, { block });
     case "code":
-      return /* @__PURE__ */ jsx10(CodeBlock, { lang: block.lang, code: block.text ?? "" });
+      return /* @__PURE__ */ jsx11(CodeBlock, { lang: block.lang, code: block.text ?? "" });
     case "hr":
-      return /* @__PURE__ */ jsx10(Box10, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "\u2500".repeat(60) }) });
+      return /* @__PURE__ */ jsx11(Box11, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "\u2500".repeat(60) }) });
   }
 }
 function CodeBlock({ lang, code }) {
   const theme = useTheme();
   const lines = code.split("\n");
-  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", marginTop: 1, children: [
-    lang && /* @__PURE__ */ jsx10(Text10, { dimColor: true, color: theme.accent, children: lang }),
-    /* @__PURE__ */ jsx10(Box10, { borderColor: "gray", borderStyle: "round", paddingX: 1, children: /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: lines.map((line, i) => /* @__PURE__ */ jsx10(Text10, { color: "cyan", children: line }, i)) }) })
+  return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", marginTop: 1, children: [
+    lang && /* @__PURE__ */ jsx11(Text10, { dimColor: true, color: theme.accent, children: lang }),
+    /* @__PURE__ */ jsx11(Box11, { borderColor: "gray", borderStyle: "round", paddingX: 1, children: /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: lines.map((line, i) => /* @__PURE__ */ jsx11(Text10, { color: "cyan", children: line }, i)) }) })
   ] });
 }
 function TableView({ block }) {
   const headers = block.headers ?? [];
   const rows = block.rows ?? [];
   if (headers.length === 0 && rows.length === 0) {
-    return /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "(empty table)" });
+    return /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "(empty table)" });
   }
   const colCount = Math.max(headers.length, ...rows.map((r) => r?.length ?? 0));
   if (colCount === 0) {
-    return /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "(empty table)" });
+    return /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "(empty table)" });
   }
   const colWidths = new Array(colCount).fill(0);
   const allRows = [headers, ...rows];
@@ -7702,13 +8291,13 @@ function TableView({ block }) {
       cells.push(padded);
     }
     lines.push(
-      /* @__PURE__ */ jsx10(Text10, { bold: rowIdx === 0, children: cells.join(" \u2502 ") }, `row-${rowIdx}`)
+      /* @__PURE__ */ jsx11(Text10, { bold: rowIdx === 0, children: cells.join(" \u2502 ") }, `row-${rowIdx}`)
     );
     if (rowIdx === 0) {
-      lines.push(/* @__PURE__ */ jsx10(Text10, { dimColor: true, children: separator }, `sep-${rowIdx}`));
+      lines.push(/* @__PURE__ */ jsx11(Text10, { dimColor: true, children: separator }, `sep-${rowIdx}`));
     }
   });
-  return /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: lines });
+  return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: lines });
 }
 var CHARS_PER_FONT_LEVEL = 3;
 function truncateBySize(text, size) {
@@ -7963,7 +8552,7 @@ function inline(text, depth = 0) {
     {
       re: /(\[)([^\]]*)\]\(([^)]+)\)/,
       handler: (m) => /* @__PURE__ */ jsxs10(Fragment4, { children: [
-        /* @__PURE__ */ jsx10(Text10, { color: "cyan", underline: true, children: inline(m[2], depth + 1) }, key++),
+        /* @__PURE__ */ jsx11(Text10, { color: "cyan", underline: true, children: inline(m[2], depth + 1) }, key++),
         /* @__PURE__ */ jsxs10(Text10, { dimColor: true, color: "gray", children: [
           "(",
           m[3],
@@ -7973,23 +8562,23 @@ function inline(text, depth = 0) {
     },
     {
       re: /(`+)([^`]+?)\1/,
-      handler: (m) => /* @__PURE__ */ jsx10(Text10, { bold: true, color: "cyan", children: m[2] }, key++)
+      handler: (m) => /* @__PURE__ */ jsx11(Text10, { bold: true, color: "cyan", children: m[2] }, key++)
     },
     {
       re: /(\*\*)(.+?)\1/,
-      handler: (m) => /* @__PURE__ */ jsx10(Text10, { bold: true, children: inline(m[2], depth + 1) }, key++)
+      handler: (m) => /* @__PURE__ */ jsx11(Text10, { bold: true, children: inline(m[2], depth + 1) }, key++)
     },
     {
       re: /(__)(.+?)\1/,
-      handler: (m) => /* @__PURE__ */ jsx10(Text10, { bold: true, children: inline(m[2], depth + 1) }, key++)
+      handler: (m) => /* @__PURE__ */ jsx11(Text10, { bold: true, children: inline(m[2], depth + 1) }, key++)
     },
     {
       re: /(~~)(.+?)\1/,
-      handler: (m) => /* @__PURE__ */ jsx10(Text10, { strikethrough: true, children: m[2] }, key++)
+      handler: (m) => /* @__PURE__ */ jsx11(Text10, { strikethrough: true, children: m[2] }, key++)
     },
     {
       re: /(\*)(.+?)\1/,
-      handler: (m) => /* @__PURE__ */ jsx10(Text10, { italic: true, children: inline(m[2], depth + 1) }, key++)
+      handler: (m) => /* @__PURE__ */ jsx11(Text10, { italic: true, children: inline(m[2], depth + 1) }, key++)
     }
   ];
   while (rest.length > 0) {
@@ -8013,12 +8602,15 @@ function inline(text, depth = 0) {
 }
 
 // src/ui/components/Transcript.tsx
-import { Fragment as Fragment5, jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+import { Fragment as Fragment5, jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
 var HEADER = { kind: "header" };
-var Transcript = memo2(function Transcript2({ bubbles, workspace }) {
-  const liveAt = bubbles.findLastIndex(
-    (bubble) => bubble.kind === "assistant" && bubble.streaming || bubble.kind === "tool" && bubble.state === "running"
+function firstMutableBubbleIndex(bubbles) {
+  return bubbles.findIndex(
+    (bubble) => bubble.kind === "assistant" && bubble.streaming || bubble.kind === "tool" && bubble.state === "running" || bubble.kind === "subagent" && bubble.state === "running"
   );
+}
+var Transcript = memo2(function Transcript2({ bubbles, workspace }) {
+  const liveAt = firstMutableBubbleIndex(bubbles);
   const stableCount = liveAt === -1 ? bubbles.length : liveAt;
   const stableRef = useRef3([]);
   if (stableRef.current.length < stableCount) {
@@ -8029,40 +8621,48 @@ var Transcript = memo2(function Transcript2({ bubbles, workspace }) {
   } else if (stableRef.current.length > stableCount) {
     stableRef.current = bubbles.slice(0, stableCount);
   }
-  const stable = stableRef.current;
   const live = liveAt === -1 ? [] : bubbles.slice(liveAt);
-  const staticItems = [HEADER, ...stable];
-  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsx11(Static, { items: staticItems, children: (item) => item.kind === "header" ? /* @__PURE__ */ jsx11(Logo, { workspace }, "kitcode-header") : /* @__PURE__ */ jsx11(BubbleView, { bubble: item }, item.id) }),
-    live.map((bubble) => /* @__PURE__ */ jsx11(BubbleView, { bubble }, bubble.id))
+  const staticItems = [HEADER, ...stableRef.current];
+  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", marginBottom: 1, flexShrink: 1, overflowY: "hidden", children: [
+    /* @__PURE__ */ jsx12(Static, { items: staticItems, children: (item) => item.kind === "header" ? /* @__PURE__ */ jsx12(Logo, { workspace }, "kitcode-header") : /* @__PURE__ */ jsx12(BubbleView, { bubble: item }, item.id) }),
+    /* @__PURE__ */ jsx12(
+      Box12,
+      {
+        flexDirection: "column",
+        flexShrink: 1,
+        overflowY: "hidden",
+        justifyContent: "flex-end",
+        children: live.map((bubble) => /* @__PURE__ */ jsx12(BubbleView, { bubble }, bubble.id))
+      }
+    )
   ] });
 });
 var BubbleView = memo2(function BubbleView2({ bubble }) {
   const theme = useTheme();
   if (bubble.kind === "user") {
-    return /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsxs11(Text11, { color: theme.accent, bold: true, children: [
+    return /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsxs11(Text11, { color: theme.accent, bold: true, children: [
       "\u203A ",
       bubble.text
     ] }) });
   }
   if (bubble.kind === "notice") {
     const color = bubble.level === "error" ? theme.error : bubble.level === "warn" ? theme.warn : theme.accent;
-    return /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { color, children: bubble.text }) });
+    return /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text11, { color, children: bubble.text }) });
   }
   if (bubble.kind === "assistant") {
-    return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginTop: 1, children: [
-      bubble.thinking.trim() !== "" && /* @__PURE__ */ jsx11(Text11, { dimColor: true, italic: true, children: bubble.thinking.trim() }),
-      bubble.streaming ? /* @__PURE__ */ jsx11(Text11, { children: bubble.text }) : /* @__PURE__ */ jsx11(Markdown, { children: bubble.text }),
+    return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", marginTop: 1, children: [
+      bubble.thinking.trim() !== "" && /* @__PURE__ */ jsx12(Text11, { dimColor: true, italic: true, children: bubble.thinking.trim() }),
+      bubble.streaming ? /* @__PURE__ */ jsx12(Text11, { children: bubble.text }) : /* @__PURE__ */ jsx12(Markdown, { children: bubble.text }),
       bubble.streaming && bubble.text === "" && /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
-        /* @__PURE__ */ jsx11(Spinner2, { type: "dots" }),
+        /* @__PURE__ */ jsx12(Spinner2, { type: "dots" }),
         " thinking"
       ] })
     ] });
   }
   if (bubble.kind === "subagent") {
-    return /* @__PURE__ */ jsx11(SubagentView, { bubble });
+    return /* @__PURE__ */ jsx12(SubagentView, { bubble });
   }
-  return /* @__PURE__ */ jsx11(ToolView, { bubble });
+  return /* @__PURE__ */ jsx12(ToolView, { bubble });
 });
 function ToolView({ bubble }) {
   const theme = useTheme();
@@ -8073,19 +8673,19 @@ function ToolView({ bubble }) {
     () => display?.kind === "diff" ? diffLines(display.before, display.after) : null,
     [display]
   );
-  if (!diff) return /* @__PURE__ */ jsx11(NonDiffToolView, { bubble, mark, color });
+  if (!diff) return /* @__PURE__ */ jsx12(NonDiffToolView, { bubble, mark, color });
   const hasChanges = diff.added > 0 || diff.removed > 0;
-  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginTop: 1, children: [
+  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", marginTop: 1, children: [
     /* @__PURE__ */ jsxs11(Text11, { color, children: [
       mark,
       " ",
       bubble.summary,
       hasChanges && /* @__PURE__ */ jsxs11(Fragment5, { children: [
-        diff.added > 0 && /* @__PURE__ */ jsx11(Text11, { color: theme.ok, bold: true, children: ` +${diff.added}` }),
-        diff.removed > 0 && /* @__PURE__ */ jsx11(Text11, { color: theme.error, bold: true, children: ` -${diff.removed}` })
+        diff.added > 0 && /* @__PURE__ */ jsx12(Text11, { color: theme.ok, bold: true, children: ` +${diff.added}` }),
+        diff.removed > 0 && /* @__PURE__ */ jsx12(Text11, { color: theme.error, bold: true, children: ` -${diff.removed}` })
       ] })
     ] }),
-    /* @__PURE__ */ jsx11(Box11, { marginLeft: 2, children: /* @__PURE__ */ jsx11(DiffHunk, { lines: diff.hunk, hidden: diff.hidden }) })
+    /* @__PURE__ */ jsx12(Box12, { marginLeft: 2, children: /* @__PURE__ */ jsx12(DiffHunk, { lines: diff.hunk, hidden: diff.hidden }) })
   ] });
 }
 function NonDiffToolView({
@@ -8093,13 +8693,13 @@ function NonDiffToolView({
   mark,
   color
 }) {
-  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginTop: 1, children: [
+  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", marginTop: 1, children: [
     /* @__PURE__ */ jsxs11(Text11, { color, children: [
       mark,
       " ",
       bubble.summary
     ] }),
-    bubble.state !== "running" && bubble.content.trim() !== "" && /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", marginLeft: 2, children: previewLines(bubble.content).map((line, index) => /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: truncate2(line, 110) }, index)) })
+    bubble.state !== "running" && bubble.content.trim() !== "" && /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", marginLeft: 2, children: previewLines(bubble.content).map((line, index) => /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: truncate2(line, 110) }, index)) })
   ] });
 }
 function previewLines(content) {
@@ -8111,15 +8711,15 @@ function SubagentView({ bubble }) {
   const theme = useTheme();
   const mark = bubble.state === "running" ? "\u25CC" : "\u25CF";
   const color = bubble.state === "running" ? theme.warn : theme.ok;
-  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginTop: 1, children: [
+  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", marginTop: 1, children: [
     /* @__PURE__ */ jsxs11(Text11, { color, bold: true, children: [
       mark,
       " subagent: ",
       bubble.description
     ] }),
-    /* @__PURE__ */ jsxs11(Box11, { marginLeft: 2, flexDirection: "column", children: [
-      bubble.bubbles.map((inner, index) => /* @__PURE__ */ jsx11(BubbleView, { bubble: inner }, index)),
-      bubble.state === "done" && bubble.result && /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "\u2500\u2500 result \u2500\u2500" }) })
+    /* @__PURE__ */ jsxs11(Box12, { marginLeft: 2, flexDirection: "column", children: [
+      bubble.bubbles.map((inner, index) => /* @__PURE__ */ jsx12(BubbleView, { bubble: inner }, index)),
+      bubble.state === "done" && bubble.result && /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: "\u2500\u2500 result \u2500\u2500" }) })
     ] })
   ] });
 }
@@ -8361,26 +8961,17 @@ function sanitizeDisplay(display) {
 }
 
 // src/ui/App.tsx
-import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
 var EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 var STREAM_FRAME_MS = 50;
 var MAX_ATTACHMENTS = 8;
-var NEEDS_IDLE = /* @__PURE__ */ new Set([
-  "clear",
-  "resume",
-  "sessions",
-  "logout",
-  "bypass",
-  "undo",
-  "compact",
-  "checker"
-]);
 function App({
   runtime,
   initialHistory,
   warnings = []
 }) {
   const { exit } = useApp();
+  const { rows } = useWindowSize2();
   const [transcript, setTranscript] = useState5(
     () => warnings.reduce((state, text) => pushNotice(state, "warn", text), fromHistory(initialHistory))
   );
@@ -8390,8 +8981,12 @@ function App({
     () => inputHistoryFromMessages(initialHistory)
   );
   const [busy, setBusy] = useState5(false);
+  const busyRef = useRef4(false);
   const [pendingCount, setPendingCount] = useState5(0);
   const queueRef = useRef4([]);
+  const slashQueueRef = useRef4(Promise.resolve());
+  const slashPendingRef = useRef4(0);
+  const drainQueueRef = useRef4(() => void 0);
   const [attachments, setAttachments] = useState5([]);
   const attachmentsRef = useRef4([]);
   const automaticAttachmentTask = useRef4(null);
@@ -8458,43 +9053,6 @@ function App({
     const timer = setInterval(() => tick((n) => n + 1), 1e3);
     return () => clearInterval(timer);
   }, [turnStart]);
-  useEffect2(() => {
-    if (process.platform === "darwin" || process.platform === "win32") return;
-    let last = "";
-    let cancelling = false;
-    let giveUp = false;
-    let polling = false;
-    let interval = null;
-    const poll = () => {
-      if (cancelling || giveUp || polling) return;
-      polling = true;
-      execFile2(
-        "xclip",
-        ["-o", "-selection", "primary"],
-        { encoding: "utf8" },
-        (error, stdout) => {
-          polling = false;
-          if (cancelling) return;
-          if (error) {
-            giveUp = true;
-            if (interval) clearInterval(interval);
-            return;
-          }
-          const sel = stdout.trim();
-          if (sel && sel !== last) {
-            last = sel;
-            copyToClipboard(sel);
-          }
-        }
-      );
-    };
-    poll();
-    interval = setInterval(poll, 750);
-    return () => {
-      cancelling = true;
-      if (interval) clearInterval(interval);
-    };
-  }, []);
   const theme = useMemo4(() => makeTheme(accent), [accent]);
   const strings = useMemo4(() => stringsFor(lang), [lang]);
   const notice = useCallback(
@@ -8540,8 +9098,10 @@ function App({
     []
   );
   const runAgent = useCallback(async () => {
+    if (busyRef.current) return;
     const controller = new AbortController();
     abort.current = controller;
+    busyRef.current = true;
     setBusy(true);
     setTurnStart(Date.now());
     turns.current += 1;
@@ -8577,17 +9137,10 @@ function App({
     } finally {
       flushTranscriptEvents();
       abort.current = null;
+      busyRef.current = false;
       setBusy(false);
       setTurnStart(null);
-      const queue = queueRef.current;
-      if (queue.length > 0) {
-        const [next, ...rest] = queue;
-        queueRef.current = rest;
-        setPendingCount(rest.length);
-        queueMicrotask(() => enqueueNext(next));
-      } else {
-        setPendingCount(0);
-      }
+      drainQueueRef.current();
     }
   }, [flushTranscriptEvents, notice, queueTranscriptEvent, runtime]);
   const applyAccent = useCallback(
@@ -9161,6 +9714,7 @@ ${strings.mcpAddUsage}`
         case "compact": {
           const controller = new AbortController();
           abort.current = controller;
+          busyRef.current = true;
           setBusy(true);
           setTurnStart(Date.now());
           notice("info", strings.compactStarting);
@@ -9183,17 +9737,9 @@ ${strings.mcpAddUsage}`
             }
           } finally {
             abort.current = null;
+            busyRef.current = false;
             setBusy(false);
             setTurnStart(null);
-            const queue = queueRef.current;
-            if (queue.length > 0) {
-              const [next, ...remaining] = queue;
-              queueRef.current = remaining;
-              setPendingCount(remaining.length);
-              if (next) queueMicrotask(() => enqueueNext(next));
-            } else {
-              setPendingCount(0);
-            }
           }
           forceRender((n) => n + 1);
           return;
@@ -9396,18 +9942,46 @@ Rename the file if you want a different name.`);
     },
     [applyAccent, appendAttachment, ask2, exit, notice, pick, replaceAttachments, runtime, strings]
   );
+  const runSlash = useCallback(
+    (line) => {
+      slashPendingRef.current += 1;
+      const task = slashQueueRef.current.catch(() => void 0).then(() => handleSlash(line));
+      slashQueueRef.current = task;
+      void task.catch(
+        (error) => notice("error", error instanceof Error ? error.message : String(error))
+      );
+      const finished = () => {
+        slashPendingRef.current = Math.max(0, slashPendingRef.current - 1);
+        drainQueueRef.current();
+      };
+      void task.then(finished, finished);
+    },
+    [handleSlash, notice]
+  );
   const enqueueNext = useCallback(
     (item) => {
       if (item.kind === "command") {
-        void handleSlash(item.line);
+        runSlash(item.line);
         return;
       }
       setTranscript((state) => pushUser(state, userDisplay(item.text, item.content)));
       history.current = [...history.current, { role: "user", content: item.content }];
       void runAgent();
     },
-    [handleSlash, runAgent]
+    [runAgent, runSlash]
   );
+  const drainQueue = useCallback(() => {
+    if (busyRef.current || slashPendingRef.current > 0) return;
+    const [next, ...remaining] = queueRef.current;
+    if (!next) {
+      setPendingCount(0);
+      return;
+    }
+    queueRef.current = remaining;
+    setPendingCount(remaining.length);
+    queueMicrotask(() => enqueueNext(next));
+  }, [enqueueNext]);
+  drainQueueRef.current = drainQueue;
   const tryQueueAutomaticAttachment = useCallback(
     (requestedPath) => {
       if (!looksLikeAttachmentPath(requestedPath)) return Promise.resolve(false);
@@ -9469,12 +10043,12 @@ Rename the file if you want a different name.`);
       const text = raw.trim();
       const submitSlash = () => {
         if (!detachedInput) setInput("");
-        if (busy && slashNeedsIdle(text)) {
+        if (busyRef.current || slashPendingRef.current > 0) {
           queueRef.current = [...queueRef.current, { kind: "command", line: text }];
           setPendingCount(queueRef.current.length);
           return;
         }
-        void handleSlash(text);
+        runSlash(text);
       };
       if (isKnownSlashCommand(text)) {
         submitSlash();
@@ -9498,7 +10072,7 @@ Rename the file if you want a different name.`);
       ];
       replaceAttachments([]);
       const item = { kind: "message", text, content };
-      if (busy) {
+      if (busyRef.current || slashPendingRef.current > 0) {
         queueRef.current = [...queueRef.current, item];
         setPendingCount(queueRef.current.length);
         return;
@@ -9507,7 +10081,7 @@ Rename the file if you want a different name.`);
       history.current = [...history.current, { role: "user", content }];
       void runAgent();
     },
-    [busy, handleSlash, replaceAttachments, runAgent, tryQueueAutomaticAttachment]
+    [replaceAttachments, runAgent, runSlash, tryQueueAutomaticAttachment]
   );
   useTerminalInput((_char, key) => {
     if (key.tab && key.shift) {
@@ -9541,10 +10115,10 @@ Rename the file if you want a different name.`);
     }
     setInput("");
   });
-  const shell = (children) => /* @__PURE__ */ jsx12(ThemeContext.Provider, { value: theme, children: /* @__PURE__ */ jsx12(StringsContext.Provider, { value: strings, children }) });
+  const shell = (children) => /* @__PURE__ */ jsx13(ThemeContext.Provider, { value: theme, children: /* @__PURE__ */ jsx13(StringsContext.Provider, { value: strings, children }) });
   if (lang === void 0) {
     return shell(
-      /* @__PURE__ */ jsx12(
+      /* @__PURE__ */ jsx13(
         LanguagePicker,
         {
           onPick: (chosen) => {
@@ -9557,7 +10131,7 @@ Rename the file if you want a different name.`);
   }
   if (setup) {
     return shell(
-      /* @__PURE__ */ jsx12(
+      /* @__PURE__ */ jsx13(
         Onboarding,
         {
           onSubmit: async (url, key) => {
@@ -9572,8 +10146,8 @@ ${strings.configAt(runtime.configPath())}`);
     );
   }
   return shell(
-    /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx12(
+    /* @__PURE__ */ jsxs12(TerminalViewport, { rows, children: [
+      /* @__PURE__ */ jsx13(
         Transcript,
         {
           bubbles: transcript.bubbles,
@@ -9581,7 +10155,7 @@ ${strings.configAt(runtime.configPath())}`);
         },
         transcriptRevision
       ),
-      overlay.kind === "permission" && /* @__PURE__ */ jsx12(
+      overlay.kind === "permission" && /* @__PURE__ */ jsx13(
         PermissionPrompt,
         {
           request: overlay.request,
@@ -9591,7 +10165,7 @@ ${strings.configAt(runtime.configPath())}`);
           }
         }
       ),
-      overlay.kind === "picker" && /* @__PURE__ */ jsx12(
+      overlay.kind === "picker" && /* @__PURE__ */ jsx13(
         Picker,
         {
           title: overlay.title,
@@ -9606,7 +10180,7 @@ ${strings.configAt(runtime.configPath())}`);
           }
         }
       ),
-      overlay.kind === "confirm" && /* @__PURE__ */ jsx12(
+      overlay.kind === "confirm" && /* @__PURE__ */ jsx13(
         Confirm,
         {
           title: overlay.title,
@@ -9618,7 +10192,7 @@ ${strings.configAt(runtime.configPath())}`);
           }
         }
       ),
-      overlay.kind === "textinput" && /* @__PURE__ */ jsx12(
+      overlay.kind === "textinput" && /* @__PURE__ */ jsx13(
         TextInputOverlay,
         {
           title: overlay.title,
@@ -9633,7 +10207,7 @@ ${strings.configAt(runtime.configPath())}`);
           }
         }
       ),
-      overlay.kind === "none" && /* @__PURE__ */ jsx12(
+      overlay.kind === "none" && /* @__PURE__ */ jsx13(
         PromptInput,
         {
           value: input,
@@ -9651,7 +10225,7 @@ ${strings.configAt(runtime.configPath())}`);
           })
         }
       ),
-      /* @__PURE__ */ jsx12(
+      /* @__PURE__ */ jsx13(
         StatusBar,
         {
           status: {
@@ -9687,9 +10261,9 @@ function TextInputOverlay({
   useInput2((_input, key) => {
     if (key.escape) onCancel();
   });
-  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: title }),
-    /* @__PURE__ */ jsx12(
+  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx13(Text12, { dimColor: true, children: title }),
+    /* @__PURE__ */ jsx13(
       TextInput2,
       {
         value,
@@ -9698,13 +10272,9 @@ function TextInputOverlay({
         mask: mask ? "\u2022" : void 0
       }
     ),
-    /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, color: theme.accent, children: "enter submit \xB7 esc cancel" }) })
+    /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx13(Text12, { dimColor: true, color: theme.accent, children: "enter submit \xB7 esc cancel" }) })
   ] });
 }
-function slashNeedsIdle(line) {
-  const [command = "", subcommand = ""] = line.slice(1).trim().toLowerCase().split(/\s+/);
-  return NEEDS_IDLE.has(command) || command === "mcp" && (subcommand === "add" || subcommand === "delete" || subcommand === "enable" || subcommand === "disable");
-}
 function isKnownSlashCommand(line) {
   if (!line.startsWith("/")) return false;
   const [name = ""] = line.slice(1).trim().toLowerCase().split(/\s+/);
@@ -9773,38 +10343,9 @@ function unquoteArg(value) {
   const last = value.at(-1);
   return first2 === '"' && last === '"' || first2 === "'" && last === "'" ? value.slice(1, -1) : value;
 }
-function copyToClipboard(text) {
-  const run = (cmd, args) => execFileSync2(cmd, args, { input: text, stdio: ["pipe", "ignore", "ignore"] });
-  if (process.platform === "darwin") {
-    try {
-      run("pbcopy", []);
-    } catch {
-    }
-    return;
-  }
-  if (process.platform === "win32") {
-    try {
-      run("clip", []);
-    } catch {
-    }
-    return;
-  }
-  const candidates = [
-    ["wl-copy", []],
-    ["xclip", ["-selection", "clipboard"]],
-    ["xsel", ["--clipboard", "--input"]]
-  ];
-  for (const [cmd, args] of candidates) {
-    try {
-      run(cmd, args);
-      return;
-    } catch {
-    }
-  }
-}
 
 // src/app/tui.tsx
-import { jsx as jsx13 } from "react/jsx-runtime";
+import { jsx as jsx14 } from "react/jsx-runtime";
 function clearTerminal() {
   if (process.stdout.isTTY) process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
 }
@@ -9817,7 +10358,7 @@ async function startTui(options) {
     mode: options.mode
   });
   clearTerminal();
-  const instance = render(/* @__PURE__ */ jsx13(App, { runtime, initialHistory: history, warnings }), {
+  const instance = render(/* @__PURE__ */ jsx14(App, { runtime, initialHistory: history, warnings }), {
     incrementalRendering: true,
     maxFps: 30
   });