@kernelonpanic/kitcode 1.2.9 → 1.3.1

package/dist/index.js

@@ -40,7 +40,7 @@ var providerConfigSchema = z.object({
   keyEnv: z.string().optional(),
   headers: z.record(z.string(), z.string()).optional()
 });
-var effortSchema = z.enum(["low", "medium", "high", "xhigh", "max"]);
+var effortSchema = z.enum(["auto", "low", "medium", "high", "xhigh", "max"]);
 var permissionModeSchema = z.enum(["allow", "ask", "deny"]);
 var mcpStdioSchema = z.object({
   type: z.literal("stdio"),
@@ -210,8 +210,8 @@ async function readHead(stream) {
   let text = "";
   try {
     while (text.length < CAPTURE_CHARS) {
-      const { done, value } = await reader.read();
-      if (done) break;
+      const { done: done2, value } = await reader.read();
+      if (done2) break;
       text += decoder.decode(value, { stream: true });
     }
   } catch {
@@ -420,39 +420,52 @@ async function detectProvider(rawUrl, apiKey2, opts = {}) {
       `${anthropicBaseUrl}/v1/models?limit=1000`,
       anthropicHeaders(apiKey2)
     );
-    return {
-      id,
-      config: { type: "anthropic", baseUrl: anthropicBaseUrl },
-      models: probed.ok ? parseModelList(probed.body) : []
-    };
+    return [
+      {
+        id,
+        config: { type: "anthropic", baseUrl: anthropicBaseUrl },
+        models: probed.ok ? parseModelList(probed.body) : []
+      }
+    ];
   }
+  const found = [];
   let last;
   for (const candidate of candidateBaseUrls(baseUrl)) {
+    if (found.length === schemes.length) break;
     const url = `${candidate}/models`;
-    let attempt = await probe(fetchImpl, url, { Authorization: `Bearer ${apiKey2}` });
-    last = attempt;
-    if (attempt.ok && isModelListBody(attempt.body)) {
-      const anthropic = advertisesAnthropicProtocol(attempt.body);
-      return {
-        id,
-        config: anthropic ? { type: "anthropic", baseUrl: anthropicRoot(candidate) } : { type: "openai", baseUrl: candidate },
-        models: parseModelList(attempt.body)
-      };
-    }
-    if (attempt.status === 401 || attempt.status === 403) {
-      attempt = await probe(fetchImpl, url, anthropicHeaders(apiKey2));
+    for (const scheme of schemes) {
+      const attempt = await probe(fetchImpl, url, schemeHeaders(scheme, apiKey2));
       last = attempt;
-      if (attempt.ok) {
-        return {
-          id,
-          config: { type: "anthropic", baseUrl: anthropicRoot(candidate) },
-          models: parseModelList(attempt.body)
-        };
-      }
+      if (attempt.status === 404 || attempt.status === 0) break;
+      if (attempt.ok && isModelListBody(attempt.body)) record(found, candidate, scheme, attempt.body);
+      if (found.length === schemes.length) break;
     }
-    if (!attempt.ok && attempt.status !== 404 && attempt.status !== 0) break;
+    if (found.length === 0 && !last.ok && last.status !== 404 && last.status !== 0) break;
   }
-  throw new Error(describeFailure(last, apiKey2));
+  if (found.length === 0) throw new Error(describeFailure(last, apiKey2));
+  return found.map((entry, index) => ({
+    id: index === 0 ? id : `${id.slice(0, MAX_ID_STEM)}-${entry.type}`,
+    config: { type: entry.type, baseUrl: entry.baseUrl },
+    models: entry.models
+  }));
+}
+var schemes = ["bearer", "anthropic"];
+var MAX_ID_STEM = 120;
+function schemeHeaders(scheme, apiKey2) {
+  return scheme === "bearer" ? { Authorization: `Bearer ${apiKey2}` } : anthropicHeaders(apiKey2);
+}
+function record(found, candidate, scheme, body) {
+  const type = scheme === "anthropic" || advertisesAnthropicProtocol(body) ? "anthropic" : "openai";
+  if (found.some((entry) => entry.type === type)) return;
+  const models = parseModelList(body);
+  const fingerprint2 = models.map((model) => model.id).sort().join("\n");
+  if (found.some((entry) => entry.fingerprint === fingerprint2)) return;
+  found.push({
+    type,
+    baseUrl: type === "anthropic" ? anthropicRoot(candidate) : candidate,
+    models,
+    fingerprint: fingerprint2
+  });
 }
 function normaliseBaseUrl(rawUrl) {
   return rawUrl.trim().replace(/\/+$/, "");
@@ -519,8 +532,8 @@ async function boundedResponseText(response) {
   let text = "";
   try {
     for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
+      const { done: done2, value } = await reader.read();
+      if (done2) break;
       bytes += value.byteLength;
       if (bytes > MAX_DETECT_BODY_BYTES) {
         throw new Error(`response exceeded ${MAX_DETECT_BODY_BYTES / 1e6} MB`);
@@ -566,11 +579,9 @@ function anthropicRoot(baseUrl) {
 function advertisesAnthropicProtocol(body) {
   const entries = modelEntries(body);
   if (entries.length === 0) return false;
-  const endpointTypes = new Set(
-    entries.flatMap((entry) => stringList(entry["supported_endpoint_types"]))
-  );
-  if (endpointTypes.size > 0) {
-    return endpointTypes.has("anthropic") && !endpointTypes.has("openai");
+  const advertised = entries.map((entry) => stringList(entry["supported_endpoint_types"]));
+  if (advertised.some((types) => types.length > 0)) {
+    return advertised.every((types) => types.includes("anthropic"));
   }
   if (entries.some(isVendorNamespaced)) return false;
   return entries.every((entry) => entry["owned_by"] === "anthropic");
@@ -827,9 +838,9 @@ function conventionalKeyEnv(providerId) {
 function expandEnvRefs(value) {
   return value.replace(/\$\{env:([^}]+)\}/g, (_match, name) => process.env[name] ?? "");
 }
-function expandEnvRecord(record2) {
+function expandEnvRecord(record3) {
   return Object.fromEntries(
-    Object.entries(record2).map(([key, value]) => [key, expandEnvRefs(value)])
+    Object.entries(record3).map(([key, value]) => [key, expandEnvRefs(value)])
   );
 }
 async function readJson(file) {
@@ -895,12 +906,15 @@ async function addProvider(url, key, options = {}) {
   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;
+  for (const provider of detected) {
+    config.providers[provider.id] = provider.config;
+    auth[provider.id] = key;
+  }
+  const primary = detected[0];
+  const models = detected.flatMap((provider) => provider.models);
   if (!config.model) {
-    const chosen = pickDefault(models);
-    if (chosen) config.model = formatModelRef(detected.id, chosen);
+    const chosen = pickDefaultRef(detected);
+    if (chosen) config.model = chosen;
   }
   try {
     await saveConfig(config);
@@ -913,14 +927,15 @@ async function addProvider(url, key, options = {}) {
     throw error;
   }
   const location = await configLocation();
-  const protocol = detected.config.type === "anthropic" ? "Anthropic" : "OpenAI-compatible";
-  const rows = [
-    ["provider", `${detected.id} \u2014 this endpoint speaks the ${protocol} protocol`],
+  const rows = detected.map((provider) => [
+    "provider",
+    `${provider.id} \u2014 this endpoint speaks the ${protocolLabel(provider)} protocol`
+  ]);
+  rows.push(
     ["models", models.length === 0 ? "none listed by this endpoint" : `${models.length} available`],
-    ["default", describeDefault(config.model, detected.id, models)]
-  ];
-  alternatives(models, config.model, detected.id).forEach((model, index) => {
-    const ref = formatModelRef(detected.id, model.id);
+    ["default", describeDefault(config.model, detected)]
+  );
+  alternatives(detected, config.model).forEach(([ref, model], index) => {
     rows.push([index === 0 ? "also try" : "", `${ref}  ${price(model)}`]);
   });
   rows.push(["config", `${location.path} (${location.scope})`]);
@@ -928,11 +943,15 @@ async function addProvider(url, key, options = {}) {
   rows.push(["next", "run kitcode to start a session; /model switches models"]);
   for (const [label, value] of rows) console.log(label.padEnd(LABEL_WIDTH) + value);
 }
-function describeDefault(ref, providerId, models) {
+function protocolLabel(provider) {
+  return provider.config.type === "anthropic" ? "Anthropic" : "OpenAI-compatible";
+}
+function describeDefault(ref, detected) {
   if (!ref) return "not set \u2014 start kitcode and pick one with /model";
   const parsed = parseModelRef(ref);
-  if (parsed?.provider !== providerId) return `${ref} \u2014 already in your config, left alone`;
-  return `${ref}  ${price(models.find((model) => model.id === parsed.model))}`;
+  const owner = detected.find((provider) => provider.id === parsed?.provider);
+  if (!owner) return `${ref} \u2014 already in your config, left alone`;
+  return `${ref}  ${price(owner.models.find((model) => model.id === parsed.model))}`;
 }
 function price(model) {
   const pricing = model?.pricing;
@@ -942,25 +961,35 @@ function price(model) {
 function money(value) {
   return `$${value >= 1 ? value.toFixed(2) : Number(value.toFixed(4))}`;
 }
-function pickDefault(models) {
+function pickDefaultRef(detected) {
+  const refs = modelRefs(detected);
   for (const preferred of PREFERRED) {
-    const match = models.find((model) => model.id.endsWith(preferred));
-    if (match) return match.id;
+    const match = refs.find(([, model]) => model.id.endsWith(preferred));
+    if (match) return match[0];
   }
-  return models[0]?.id;
+  return refs[0]?.[0];
 }
-function alternatives(models, defaultRef, providerId) {
+function alternatives(detected, defaultRef) {
+  const refs = modelRefs(detected);
   const ranked = [
-    ...PREFERRED.flatMap((preferred) => models.filter((model) => model.id.endsWith(preferred))),
-    ...models.filter((model) => model.pricing),
-    ...models
+    ...PREFERRED.flatMap((preferred) => refs.filter(([, model]) => model.id.endsWith(preferred))),
+    ...refs.filter(([, model]) => model.pricing),
+    ...refs
   ];
   const picked = /* @__PURE__ */ new Map();
-  for (const model of ranked) {
+  for (const [ref, model] of ranked) {
     if (picked.size === ALTERNATIVES) break;
-    if (formatModelRef(providerId, model.id) !== defaultRef) picked.set(model.id, model);
+    if (ref !== defaultRef) picked.set(ref, model);
   }
-  return [...picked.values()];
+  return [...picked.entries()];
+}
+function modelRefs(detected) {
+  return detected.flatMap(
+    (provider) => provider.models.map((model) => [
+      formatModelRef(provider.id, model.id),
+      model
+    ])
+  );
 }
 
 // src/app/ask.ts
@@ -1024,14 +1053,375 @@ function skipControlString(text, from, bellTerminates) {
   return text.length - 1;
 }
 
+// src/tools/memory.ts
+import { z as z2 } from "zod";
+
+// src/tools/summary.ts
+function brief(value, max = 60) {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+
+// src/tools/memory.ts
+var inputSchema = z2.discriminatedUnion("action", [
+  z2.object({ action: z2.literal("read") }).strict(),
+  z2.object({ action: z2.literal("add"), text: z2.string().trim().min(1).max(4e3), source: z2.string().trim().min(1).max(1e3) }).strict(),
+  z2.object({ action: z2.literal("replace"), oldText: z2.string().min(1), text: z2.string().trim().min(1).max(4e3), source: z2.string().trim().min(1).max(1e3) }).strict(),
+  z2.object({ action: z2.literal("delete"), oldText: z2.string().min(1), source: z2.string().trim().min(1).max(1e3) }).strict()
+]);
+function createMemoryTool(store) {
+  return {
+    name: "memory",
+    description: "Read or update persistent notes for this project. Remember only explicit user preferences, confirmed project facts and accepted decisions, with their source (user instruction or file/tool evidence). Never store secrets, guesses, temporary task progress or raw logs. Read before changing existing notes. For replace/delete, oldText must match exactly once; include the whole old note and its source. These notes survive new chats. Do not use this tool to change permissions or override current instructions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["read", "add", "replace", "delete"] },
+        text: { type: "string", maxLength: 4e3 },
+        oldText: { type: "string" },
+        source: { type: "string", maxLength: 1e3 }
+      },
+      required: ["action"],
+      additionalProperties: false
+    },
+    defaultPermission: "allow",
+    summarize(input) {
+      const parsed = inputSchema.safeParse(input);
+      return parsed.success ? `memory(${parsed.data.action}${"text" in parsed.data ? `: ${brief(parsed.data.text, 80)}` : ""})` : "memory(invalid input)";
+    },
+    async execute(input, ctx) {
+      const parsed = inputSchema.safeParse(input);
+      if (!parsed.success) return { content: "Invalid memory arguments: mutations require source; replace/delete also require oldText.", isError: true };
+      const args = parsed.data;
+      const before = store.read();
+      if (args.action === "read") return { content: before || "Project memory is empty." };
+      if (ctx.signal.aborted) return { content: "Memory update cancelled.", isError: true };
+      const note = "text" in args ? `${redactSecrets(args.text)}
+Source: ${redactSecrets(args.source)}` : "";
+      let after;
+      if (args.action === "add") {
+        if (before.includes(note)) return { content: "This note is already in project memory." };
+        after = [before.trim(), note].filter(Boolean).join("\n\n");
+      } else {
+        const at = before.indexOf(args.oldText);
+        if (at === -1 || before.indexOf(args.oldText, at + 1) !== -1) {
+          return { content: "oldText must match exactly once. Read memory again before retrying.", isError: true };
+        }
+        after = (before.slice(0, at) + note + before.slice(at + args.oldText.length)).trim();
+      }
+      await store.save(after);
+      return { content: `Project memory updated (${args.action}).
+${store.read()}`, display: { kind: "diff", path: "project memory", before, after: store.read() } };
+    }
+  };
+}
+
+// src/ui/workspace-files.ts
+import fg2 from "fast-glob";
+
+// src/tools/glob.ts
+import { join } from "path";
+import fg from "fast-glob";
+
+// src/tools/safepath.ts
+import { realpathSync } from "fs";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "path";
+function canonicalize(target) {
+  try {
+    return realpathSync(target);
+  } catch {
+    let current = target;
+    const trailing = [];
+    for (let i = 0; i < 64; i++) {
+      try {
+        return resolve(realpathSync(current), ...trailing);
+      } catch {
+        const parent = dirname(current);
+        if (parent === current) break;
+        trailing.unshift(basename(current));
+        current = parent;
+      }
+    }
+    return resolve(current, ...trailing);
+  }
+}
+function resolveInside(cwd, userPath) {
+  const root = canonicalize(resolve(cwd));
+  const target = canonicalize(resolve(root, userPath));
+  const rel = relative(root, target);
+  if (rel !== "" && (isAbsolute(rel) || rel.split(sep)[0] === "..")) {
+    return { ok: false, reason: `Path ${userPath} resolves outside the workspace root ${root}` };
+  }
+  return { ok: true, path: target, relative: rel };
+}
+function patternEscapes(pattern) {
+  return isAbsolute(pattern) || pattern.split("/").includes("..") || pattern.split("\\").includes("..");
+}
+
+// src/tools/glob.ts
+var MAX_RESULTS = 500;
+var IGNORED_DIRECTORIES = ["**/node_modules/**", "**/.git/**", "**/dist/**"];
+var globTool = {
+  name: "glob",
+  description: 'Find files by glob pattern, most recently modified first. Supports patterns like "src/**/*.ts". Hidden files, node_modules, .git and dist are skipped.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Glob pattern, e.g. **/*.test.ts" },
+      path: { type: "string", description: "Directory to search in, relative to the workspace root" }
+    },
+    required: ["pattern"],
+    additionalProperties: false
+  },
+  defaultPermission: "allow",
+  readOnly: true,
+  summarize(input) {
+    return `glob(${brief(input.pattern)})`;
+  },
+  async execute(input, ctx) {
+    const { pattern, path: path15 = "." } = input;
+    if (patternEscapes(pattern)) {
+      return { content: `Pattern ${pattern} must be relative to the workspace root.`, isError: true };
+    }
+    const safe = resolveInside(ctx.cwd, path15);
+    if (!safe.ok) return { content: safe.reason, isError: true };
+    const entries = await fg(pattern, {
+      cwd: safe.path,
+      dot: false,
+      onlyFiles: true,
+      followSymbolicLinks: false,
+      suppressErrors: true,
+      ignore: IGNORED_DIRECTORIES,
+      stats: true
+    });
+    if (entries.length === 0) return { content: `No files matched ${pattern}` };
+    entries.sort((a, b) => (b.stats?.mtimeMs ?? 0) - (a.stats?.mtimeMs ?? 0));
+    const paths = entries.slice(0, MAX_RESULTS).map((entry) => join(safe.relative, entry.path));
+    if (entries.length > MAX_RESULTS) {
+      paths.push(`... truncated: ${entries.length - MAX_RESULTS} more files matched.`);
+    }
+    return { content: paths.join("\n") };
+  }
+};
+
+// src/ui/workspace-files.ts
+var MAX_SCANNED = 2e4;
+var MAX_RESULTS2 = 12;
+var CACHE_TTL_MS = 1e4;
+var cached;
+var inFlight;
+async function searchWorkspaceFiles(cwd, query) {
+  const files = await workspaceFiles(cwd);
+  const needle = query.trim().toLowerCase();
+  if (needle === "") return files.slice(0, MAX_RESULTS2);
+  const exact = [];
+  const loose = [];
+  for (const file of files) {
+    const haystack = file.toLowerCase();
+    if (haystack.includes(needle)) exact.push(file);
+    else if (isSubsequence(needle, haystack)) loose.push(file);
+    if (exact.length >= MAX_RESULTS2) break;
+  }
+  exact.sort((a, b) => score(a, needle) - score(b, needle));
+  return [...exact, ...loose].slice(0, MAX_RESULTS2);
+}
+function workspaceFiles(cwd) {
+  const fresh = cached && cached.cwd === cwd && Date.now() - cached.at < CACHE_TTL_MS;
+  if (fresh) return Promise.resolve(cached.files);
+  if (inFlight) return inFlight;
+  inFlight = fg2("**/*", {
+    cwd,
+    dot: false,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    suppressErrors: true,
+    ignore: IGNORED_DIRECTORIES
+  }).then((entries) => {
+    const files = entries.slice(0, MAX_SCANNED).sort((a, b) => a.length - b.length);
+    cached = { cwd, files, at: Date.now() };
+    return files;
+  }).catch(() => []).finally(() => {
+    inFlight = void 0;
+  });
+  return inFlight;
+}
+function score(file, needle) {
+  const basename3 = file.slice(file.lastIndexOf("/") + 1).toLowerCase();
+  if (basename3.startsWith(needle)) return 0;
+  if (basename3.includes(needle)) return 1;
+  return 2;
+}
+function isSubsequence(needle, haystack) {
+  let index = 0;
+  for (const character of haystack) {
+    if (character === needle[index]) index += 1;
+    if (index === needle.length) return true;
+  }
+  return needle.length === 0;
+}
+
+// src/tools/jobs.ts
+import { spawn } from "child_process";
+var MAX_JOBS = 8;
+var MAX_JOB_OUTPUT = 1e5;
+var jobs = /* @__PURE__ */ new Map();
+var counter = 0;
+function startJob(command, cwd) {
+  const live = [...jobs.values()].filter((job2) => job2.state === "running");
+  if (live.length >= MAX_JOBS) {
+    return { error: `At most ${MAX_JOBS} background commands can run at once.` };
+  }
+  counter += 1;
+  const id = `bg-${counter}`;
+  const child = spawn(command, {
+    shell: true,
+    cwd,
+    detached: process.platform !== "win32",
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  const job = {
+    id,
+    command,
+    state: "running",
+    exitCode: null,
+    signal: null,
+    child,
+    buffer: "",
+    reported: 0,
+    truncated: false
+  };
+  jobs.set(id, job);
+  const collect = (chunk) => {
+    const text = chunk.toString("utf8");
+    const room = MAX_JOB_OUTPUT - job.buffer.length;
+    if (text.length <= room) {
+      job.buffer += text;
+      return;
+    }
+    job.truncated = true;
+    job.buffer = (job.buffer + text).slice(-MAX_JOB_OUTPUT);
+    job.reported = Math.min(job.reported, job.buffer.length);
+  };
+  child.stdout?.on("data", collect);
+  child.stderr?.on("data", collect);
+  child.on("error", (error) => {
+    job.buffer += `
+Command failed to start: ${error.message}`;
+    job.state = "exited";
+    job.exitCode = job.exitCode ?? 1;
+  });
+  child.on("close", (code, signal) => {
+    if (job.state !== "killed") job.state = "exited";
+    job.exitCode = code;
+    job.signal = signal;
+  });
+  return { id };
+}
+function readJob(id) {
+  const job = jobs.get(id);
+  if (!job) return void 0;
+  const output = job.buffer.slice(job.reported);
+  job.reported = job.buffer.length;
+  return { ...summary(job), output, truncated: job.truncated };
+}
+function killJob(id) {
+  const job = jobs.get(id);
+  if (!job) return false;
+  if (job.state === "running") {
+    job.state = "killed";
+    killTree(job.child);
+  }
+  return true;
+}
+function listJobs() {
+  return [...jobs.values()].map(summary);
+}
+function killAllJobs() {
+  for (const job of jobs.values()) {
+    if (job.state === "running") {
+      job.state = "killed";
+      killTree(job.child);
+    }
+  }
+}
+function summary(job) {
+  return {
+    id: job.id,
+    command: job.command,
+    state: job.state,
+    exitCode: job.exitCode,
+    signal: job.signal
+  };
+}
+function killTree(child) {
+  if (child.pid == null) return;
+  if (process.platform === "win32") {
+    try {
+      spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
+    } catch {
+      child.kill("SIGKILL");
+    }
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGKILL");
+  } catch {
+    child.kill("SIGKILL");
+  }
+}
+
+// src/core/memory.ts
+import { createHash } from "crypto";
+import { readFile as readFile3, writeFile as writeFile3, rm as rm3 } from "fs/promises";
+import path4 from "path";
+function projectMemoryPath(workspace) {
+  const key = process.platform === "win32" ? workspace.toLowerCase() : workspace;
+  return path4.join(homeDir, "memory", createHash("sha256").update(key).digest("hex") + ".txt");
+}
+async function readProjectMemory(workspace) {
+  try {
+    return await readFile3(projectMemoryPath(workspace), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+}
+async function saveProjectMemory(workspace, text) {
+  if (text.length > 16e3) throw new Error("Project memory is limited to 16,000 characters.");
+  const file = projectMemoryPath(workspace);
+  await ensureDir(path4.dirname(file));
+  await writeFile3(file, redactSecrets(text), { mode: 384 });
+}
+async function clearProjectMemory(workspace) {
+  await rm3(projectMemoryPath(workspace), { force: true });
+}
+
+// src/providers/effort.ts
+function resolveEffort(effort, messages) {
+  if (effort !== "auto") return effort;
+  const latest = messages.findLast((message) => message.role === "user" && message.content.some((block) => block.type === "text"));
+  const text = latest?.content.filter((block) => block.type === "text").map((block) => block.text).join("\n") ?? "";
+  return text.length > 500 || /bug|fix|debug|test|refactor|implement|баг|фикс|исправ|тест|рефактор|реализ/i.test(text) ? "high" : "medium";
+}
+function openAiEffort(model, effort) {
+  const id = model.split("/").at(-1) ?? model;
+  if (!/^(?:o[134](?:-|$)|gpt-5(?:[.-]|$))/.test(id)) return void 0;
+  if (/^(?:o[134](?:-|$)|gpt-5(?:-(?:mini|nano|\d{4})|$)|gpt-5\.1(?:-|$))/.test(id)) {
+    return effort === "max" || effort === "xhigh" ? "high" : effort;
+  }
+  if (/^gpt-5\.[234](?:-|$)/.test(id)) return effort === "max" ? "xhigh" : effort;
+  return effort === "max" || effort === "xhigh" ? "high" : effort;
+}
+
 // src/app/runtime.ts
-import path13 from "path";
+import path14 from "path";
 import { mkdir as mkdir6 } from "fs/promises";
 
 // src/core/session.ts
 import { randomBytes } from "crypto";
-import { readFile as readFile3, readdir, rename as rename3, stat as stat2, unlink, writeFile as writeFile3 } from "fs/promises";
-import path4 from "path";
+import { readFile as readFile4, readdir, rename as rename3, stat as stat2, unlink, writeFile as writeFile4 } from "fs/promises";
+import path5 from "path";
 var MAX_SESSION_BYTES = 5e7;
 function createSession(cwd, model) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1050,10 +1440,10 @@ async function saveSession(state) {
   assertSessionId(state.id);
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await ensureDir(sessionsDir);
-  const file = path4.join(sessionsDir, `${state.id}.json`);
+  const file = path5.join(sessionsDir, `${state.id}.json`);
   const temp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
   try {
-    await writeFile3(temp, JSON.stringify(state), { encoding: "utf8", mode: 384 });
+    await writeFile4(temp, JSON.stringify(state), { encoding: "utf8", mode: 384 });
     await atomicRename(temp, file);
   } catch (error) {
     await unlink(temp).catch(() => void 0);
@@ -1077,14 +1467,14 @@ async function atomicRename(from, to, retries = 5) {
 }
 async function loadSession(id) {
   assertSessionId(id);
-  const file = path4.join(sessionsDir, `${id}.json`);
+  const file = path5.join(sessionsDir, `${id}.json`);
   let raw;
   try {
     const info = await stat2(file);
     if (info.size > MAX_SESSION_BYTES) {
       throw new Error(`Session exceeds the ${MAX_SESSION_BYTES / 1e6} MB load limit: ${file}`);
     }
-    raw = await readFile3(file, "utf8");
+    raw = await readFile4(file, "utf8");
   } catch (error) {
     if (error instanceof Error && error.message.startsWith("Session exceeds")) throw error;
     if (error.code === "ENOENT") {
@@ -1100,7 +1490,7 @@ async function listSessions(limit = 20) {
   const files = await filesByRecency();
   const summaries = [];
   for (const file of files.slice(0, limit)) {
-    const state = readState(await readFile3(file, "utf8").catch(() => ""));
+    const state = readState(await readFile4(file, "utf8").catch(() => ""));
     if (state) {
       summaries.push({
         id: state.id,
@@ -1126,7 +1516,7 @@ async function renameSession(query, title) {
 async function deleteSession(query) {
   const id = await resolveSessionId(query);
   assertSessionId(id);
-  await unlink(path4.join(sessionsDir, `${id}.json`)).catch((error) => {
+  await unlink(path5.join(sessionsDir, `${id}.json`)).catch((error) => {
     if (error.code === "ENOENT") throw new Error(`Session no longer exists: ${id}`);
     throw error;
   });
@@ -1151,7 +1541,7 @@ async function deleteAllSessions() {
     }
   });
   const results = await Promise.allSettled(
-    ids.map((id) => unlink(path4.join(sessionsDir, `${id}.json`)))
+    ids.map((id) => unlink(path5.join(sessionsDir, `${id}.json`)))
   );
   const deleted = [];
   const failed = [];
@@ -1172,7 +1562,7 @@ async function exportSession(query, destination) {
   const id = await resolveSessionId(query);
   const state = await loadSession(id);
   const target = await resolveExportTarget(destination, state);
-  await writeFile3(target, renderSessionMarkdown(state), {
+  await writeFile4(target, renderSessionMarkdown(state), {
     encoding: "utf8",
     mode: 384,
     flag: "wx"
@@ -1186,7 +1576,7 @@ async function exportSession(query, destination) {
 }
 async function latestSessionFor(cwd) {
   for (const file of await filesByRecency()) {
-    const state = readState(await readFile3(file, "utf8").catch(() => ""));
+    const state = readState(await readFile4(file, "utf8").catch(() => ""));
     if (state?.cwd === cwd) return state;
   }
   return null;
@@ -1216,7 +1606,7 @@ async function filesByRecency() {
   }
   const dated = await Promise.all(
     names.filter((name) => name.endsWith(".json")).map(async (name) => {
-      const file = path4.join(sessionsDir, name);
+      const file = path5.join(sessionsDir, name);
       const info = await stat2(file).catch(() => null);
       return { file, at: info?.mtimeMs ?? 0, size: info?.size ?? 0 };
     })
@@ -1296,14 +1686,14 @@ function readUsageEntries(value) {
   });
 }
 async function resolveExportTarget(destination, state) {
-  const resolved = path4.resolve(destination);
+  const resolved = path5.resolve(destination);
   const info = await stat2(resolved).catch(() => null);
   if (info?.isDirectory()) {
-    return path4.join(resolved, exportFileName(state));
+    return path5.join(resolved, exportFileName(state));
   }
   if (info) throw new Error(`Export destination is not a directory: ${resolved}`);
-  const parent = await stat2(path4.dirname(resolved)).catch(() => null);
-  if (!parent?.isDirectory()) throw new Error(`Export directory does not exist: ${path4.dirname(resolved)}`);
+  const parent = await stat2(path5.dirname(resolved)).catch(() => null);
+  if (!parent?.isDirectory()) throw new Error(`Export directory does not exist: ${path5.dirname(resolved)}`);
   return resolved;
 }
 function exportFileName(state) {
@@ -1672,7 +2062,7 @@ async function runOneCall(cfg, call, hooks, signal) {
   if (!tool) {
     return toolError(call.id, `Unknown tool "${call.name}". Use only the tools provided.`);
   }
-  const summary = describeCall(tool, call.input);
+  const summary2 = describeCall(tool, call.input);
   const ctx = {
     cwd: cfg.cwd,
     signal,
@@ -1696,7 +2086,7 @@ async function runOneCall(cfg, call, hooks, signal) {
   if (gate === "ask") {
     const decision = await hooks.requestPermission({
       toolName: tool.name,
-      summary,
+      summary: summary2,
       input: call.input,
       display: await previewCall(tool, call.input, ctx),
       allowAlways: canAlwaysApprove(tool)
@@ -1709,7 +2099,7 @@ async function runOneCall(cfg, call, hooks, signal) {
   if (signal.aborted) {
     return toolError(call.id, "Interrupted by the user before this tool ran.");
   }
-  hooks.onEvent({ type: "tool_start", id: call.id, name: tool.name, summary });
+  hooks.onEvent({ type: "tool_start", id: call.id, name: tool.name, summary: summary2 });
   try {
     const result = await tool.execute(call.input, ctx);
     hooks.onEvent({
@@ -1867,57 +2257,20 @@ function finitePositive(value) {
 }
 
 // src/core/checkpoint.ts
-import { createHash, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
 import { createReadStream } from "fs";
 import {
   chmod as chmod3,
   lstat,
   mkdir as mkdir3,
-  readFile as readFile4,
+  readFile as readFile5,
   readdir as readdir2,
   rename as rename4,
   stat as stat3,
   unlink as unlink2,
-  writeFile as writeFile4
+  writeFile as writeFile5
 } from "fs/promises";
-import path5 from "path";
-
-// src/tools/safepath.ts
-import { realpathSync } from "fs";
-import { basename, dirname, isAbsolute, relative, resolve, sep } from "path";
-function canonicalize(target) {
-  try {
-    return realpathSync(target);
-  } catch {
-    let current = target;
-    const trailing = [];
-    for (let i = 0; i < 64; i++) {
-      try {
-        return resolve(realpathSync(current), ...trailing);
-      } catch {
-        const parent = dirname(current);
-        if (parent === current) break;
-        trailing.unshift(basename(current));
-        current = parent;
-      }
-    }
-    return resolve(current, ...trailing);
-  }
-}
-function resolveInside(cwd, userPath) {
-  const root = canonicalize(resolve(cwd));
-  const target = canonicalize(resolve(root, userPath));
-  const rel = relative(root, target);
-  if (rel !== "" && (isAbsolute(rel) || rel.split(sep)[0] === "..")) {
-    return { ok: false, reason: `Path ${userPath} resolves outside the workspace root ${root}` };
-  }
-  return { ok: true, path: target, relative: rel };
-}
-function patternEscapes(pattern) {
-  return isAbsolute(pattern) || pattern.split("/").includes("..") || pattern.split("\\").includes("..");
-}
-
-// src/core/checkpoint.ts
+import path6 from "path";
 var VERSION = 1;
 var MAX_FILE_BYTES = 5e6;
 var MAX_CHECKPOINT_BYTES = 2e7;
@@ -1975,7 +2328,7 @@ function beginCheckpoint(options) {
     },
     markChanged(absolutePath) {
       if (finished) return;
-      const resolved = path5.resolve(absolutePath);
+      const resolved = path6.resolve(absolutePath);
       let capturedEntry = [...captured.values()].find((entry) => entry.absolutePath === resolved);
       if (!capturedEntry) {
         const safe = resolveInside(root, absolutePath);
@@ -2006,12 +2359,12 @@ function beginCheckpoint(options) {
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         entries
       };
-      const sessionDir = path5.join(storageDir, options.sessionId);
+      const sessionDir = path6.join(storageDir, options.sessionId);
       await ensureDir(storageDir);
       await ensureDir(sessionDir);
       lastCheckpointTimestamp = Math.max(Date.now(), lastCheckpointTimestamp + 1);
       const id = `${String(lastCheckpointTimestamp).padStart(13, "0")}-${randomBytes2(4).toString("hex")}`;
-      await writeCheckpoint(path5.join(sessionDir, `${id}.json`), stored);
+      await writeCheckpoint(path6.join(sessionDir, `${id}.json`), stored);
       pruneCheckpoints(sessionDir).catch(() => void 0);
       return { id, paths: entries.map((entry) => entry.path) };
     }
@@ -2020,7 +2373,7 @@ function beginCheckpoint(options) {
 async function undoLatestCheckpoint(options) {
   assertSessionId2(options.sessionId);
   const root = workspaceRoot(options.cwd);
-  const sessionDir = path5.join(options.storageDir ?? checkpointsDir, options.sessionId);
+  const sessionDir = path6.join(options.storageDir ?? checkpointsDir, options.sessionId);
   const file = await newestCheckpoint(sessionDir);
   const empty = { found: false, restored: [], removed: [], conflicts: [], failed: [] };
   if (!file) return empty;
@@ -2076,7 +2429,7 @@ async function snapshotFile(file) {
   if (info.size > MAX_FILE_BYTES) {
     throw new Error(`Cannot checkpoint ${file}: it exceeds the ${MAX_FILE_BYTES / 1e6} MB limit.`);
   }
-  const data = await readFile4(file);
+  const data = await readFile5(file);
   if (data.length > MAX_FILE_BYTES) {
     throw new Error(`Cannot checkpoint ${file}: it changed beyond the file-size limit while reading.`);
   }
@@ -2093,7 +2446,7 @@ async function fingerprint(file) {
     if (error.code === "ENOENT") return { existed: false };
     throw error;
   }
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   if (!info.isFile()) {
     hash.update(`kitcode:${info.isDirectory() ? "directory" : "non-file"}`);
     return { existed: true, sha256: hash.digest("hex") };
@@ -2105,7 +2458,7 @@ function matchesSnapshot(before, after) {
   if (before.existed !== after.existed) return false;
   if (!before.existed) return true;
   const data = Buffer.from(before.data ?? "", "base64");
-  return after.sha256 === createHash("sha256").update(data).digest("hex");
+  return after.sha256 === createHash2("sha256").update(data).digest("hex");
 }
 function sameFingerprint(a, b) {
   return a.existed === b.existed && (!a.existed || a.sha256 === b.sha256);
@@ -2114,14 +2467,14 @@ 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 mkdir3(path5.dirname(safe.path), { recursive: true });
+  await mkdir3(path6.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.");
   }
   const temp = `${rechecked.path}.${process.pid}.${randomBytes2(4).toString("hex")}.undo`;
   try {
-    await writeFile4(temp, data, { mode: snapshot.mode ?? 384 });
+    await writeFile5(temp, data, { mode: snapshot.mode ?? 384 });
     await chmod3(temp, snapshot.mode ?? 384);
     const finalPath = resolveInside(root, relativePath);
     if (!finalPath.ok || finalPath.path !== rechecked.path || finalPath.relative !== relativePath) {
@@ -2144,7 +2497,7 @@ async function writeCheckpoint(file, checkpoint) {
   }
   const temp = `${file}.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`;
   try {
-    await writeFile4(temp, body, { encoding: "utf8", mode: 384 });
+    await writeFile5(temp, body, { encoding: "utf8", mode: 384 });
     await chmod3(temp, 384);
     await rename4(temp, file);
   } catch (error) {
@@ -2157,7 +2510,7 @@ async function readCheckpoint(file) {
   if (info.size > MAX_CHECKPOINT_JSON_BYTES) throw new Error("Undo checkpoint is too large to read.");
   let parsed;
   try {
-    parsed = JSON.parse(await readFile4(file, "utf8"));
+    parsed = JSON.parse(await readFile5(file, "utf8"));
   } catch (error) {
     throw new Error(`Undo checkpoint is not valid JSON: ${error.message}`);
   }
@@ -2173,7 +2526,7 @@ function isCheckpoint(value) {
   return item.entries.every((entry) => {
     if (typeof entry !== "object" || entry === null) return false;
     const candidate = entry;
-    if (typeof candidate.path !== "string" || candidate.path === "" || path5.isAbsolute(candidate.path) || typeof candidate.before !== "object" || candidate.before === null || typeof candidate.after !== "object" || candidate.after === null || typeof candidate.before.existed !== "boolean" || typeof candidate.after.existed !== "boolean") {
+    if (typeof candidate.path !== "string" || candidate.path === "" || path6.isAbsolute(candidate.path) || typeof candidate.before !== "object" || candidate.before === null || typeof candidate.after !== "object" || candidate.after === null || typeof candidate.before.existed !== "boolean" || typeof candidate.after.existed !== "boolean") {
       return false;
     }
     if (candidate.before.existed) {
@@ -2205,12 +2558,12 @@ async function newestCheckpoint(sessionDir) {
     throw error;
   }
   const name = names.filter((candidate) => CHECKPOINT_NAME.test(candidate)).sort().at(-1);
-  return name ? path5.join(sessionDir, name) : null;
+  return name ? path6.join(sessionDir, name) : null;
 }
 async function pruneCheckpoints(sessionDir) {
   const names = (await readdir2(sessionDir)).filter((candidate) => CHECKPOINT_NAME.test(candidate)).sort().reverse();
   await Promise.all(
-    names.slice(MAX_CHECKPOINTS_PER_SESSION).map((name) => unlink2(path5.join(sessionDir, name)))
+    names.slice(MAX_CHECKPOINTS_PER_SESSION).map((name) => unlink2(path6.join(sessionDir, name)))
   );
 }
 function workspaceRoot(cwd) {
@@ -2225,26 +2578,18 @@ function assertSessionId2(id) {
 }
 
 // src/core/diagnostics.ts
-import { readFile as readFile5, stat as stat4 } from "fs/promises";
-import path6 from "path";
-
-// src/tools/bash.ts
-import { spawn } from "child_process";
-
-// src/tools/summary.ts
-function brief(value, max = 60) {
-  const text = String(value ?? "").replace(/\s+/g, " ").trim();
-  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
-}
+import { readFile as readFile6, stat as stat4 } from "fs/promises";
+import path7 from "path";
 
 // src/tools/bash.ts
+import { spawn as spawn2 } from "child_process";
 var DEFAULT_TIMEOUT = 12e4;
 var MAX_TIMEOUT = 6e5;
 var MAX_OUTPUT = 1e5;
 var MAX_COMMAND_CHARS = 2e4;
 var bashTool = {
   name: "bash",
-  description: "Run a shell command in the workspace root. stdout and stderr are merged. Avoid commands that wait for interactive input.",
+  description: "Run a shell command in the workspace root. stdout and stderr are merged. Avoid commands that wait for interactive input. Set background: true to keep a long command (dev server, test watcher, build) running while you carry on with other work, then collect its output with bash_output.",
   inputSchema: {
     type: "object",
     properties: {
@@ -2255,8 +2600,12 @@ var bashTool = {
       },
       timeoutMs: {
         type: "integer",
-        description: `Timeout in milliseconds (default ${DEFAULT_TIMEOUT}, maximum ${MAX_TIMEOUT})`,
+        description: `Timeout in milliseconds (default ${DEFAULT_TIMEOUT}, maximum ${MAX_TIMEOUT}); ignored for background commands`,
         minimum: 1
+      },
+      background: {
+        type: "boolean",
+        description: "Start the command and return at once instead of waiting for it. Read its output later with bash_output. Background commands have no timeout and are killed when the session ends."
       }
     },
     required: ["command"],
@@ -2264,13 +2613,14 @@ var bashTool = {
   },
   defaultPermission: "ask",
   summarize(input) {
-    return `bash(${brief(input.command)})`;
+    const { command, background } = input;
+    return background ? `bash(${brief(command)}, background)` : `bash(${brief(command)})`;
   },
   async preview(input) {
     return { kind: "text", text: input.command };
   },
   execute(input, ctx) {
-    const { command, timeoutMs } = input;
+    const { command, timeoutMs, background } = input;
     if (command.length > MAX_COMMAND_CHARS) {
       return Promise.resolve({
         content: `Command exceeds the ${MAX_COMMAND_CHARS} character limit.`,
@@ -2282,8 +2632,17 @@ var bashTool = {
     if (ctx.signal.aborted) {
       return Promise.resolve({ content: "[cancelled before the command started]", isError: true });
     }
+    if (background) {
+      const started = startJob(command, ctx.cwd);
+      if ("error" in started) {
+        return Promise.resolve({ content: started.error, isError: true });
+      }
+      return Promise.resolve({
+        content: `[started in the background as ${started.id}] Read its output with bash_output({ id: "${started.id}" }).`
+      });
+    }
     return new Promise((settle) => {
-      const child = spawn(command, {
+      const child = spawn2(command, {
         shell: true,
         cwd: ctx.cwd,
         detached: process.platform !== "win32",
@@ -2311,11 +2670,11 @@ var bashTool = {
       };
       child.stdout.on("data", collect);
       child.stderr.on("data", collect);
-      const killTree = () => {
+      const killTree2 = () => {
         if (child.pid == null) return;
         if (process.platform === "win32") {
           try {
-            spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
+            spawn2("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
           } catch {
             child.kill("SIGKILL");
           }
@@ -2331,11 +2690,11 @@ var bashTool = {
       let aborted = false;
       const timer = setTimeout(() => {
         timedOut = true;
-        killTree();
+        killTree2();
       }, timeout);
       const onAbort = () => {
         aborted = true;
-        killTree();
+        killTree2();
       };
       ctx.signal.addEventListener("abort", onAbort, { once: true });
       const finish = (result) => {
@@ -2377,7 +2736,7 @@ async function detectDiagnosticCommands(cwd, configured = []) {
   const custom = configured.map((command) => command.trim()).filter(Boolean);
   if (custom.length > 0) return custom.slice(0, 8);
   const commands = [];
-  const packageJson = await readPackageJson(path6.join(cwd, "package.json"));
+  const packageJson = await readPackageJson(path7.join(cwd, "package.json"));
   if (packageJson) {
     const manager = await packageManager(cwd, packageJson.packageManager);
     for (const name of ["lint", "typecheck", "check", "test"]) {
@@ -2386,31 +2745,31 @@ async function detectDiagnosticCommands(cwd, configured = []) {
       }
     }
   }
-  if (await isFile2(path6.join(cwd, "Cargo.toml"))) {
+  if (await isFile2(path7.join(cwd, "Cargo.toml"))) {
     commands.push("cargo check", "cargo test");
   }
-  if (await isFile2(path6.join(cwd, "go.mod"))) commands.push("go test ./...");
-  if (await isFile2(path6.join(cwd, "pyproject.toml")) || await isFile2(path6.join(cwd, "pytest.ini")) || await isFile2(path6.join(cwd, "tox.ini"))) {
+  if (await isFile2(path7.join(cwd, "go.mod"))) commands.push("go test ./...");
+  if (await isFile2(path7.join(cwd, "pyproject.toml")) || await isFile2(path7.join(cwd, "pytest.ini")) || await isFile2(path7.join(cwd, "tox.ini"))) {
     commands.push("python -m pytest");
   }
   return [...new Set(commands)].slice(0, 8);
 }
 async function runAutomaticDiagnostics(options) {
   const commands = await detectDiagnosticCommands(options.cwd, options.configuredCommands);
-  const summary = { commands, failed: [], skipped: false };
+  const summary2 = { commands, failed: [], skipped: false };
   if (options.changedFiles.length === 0 || commands.length === 0 || options.signal.aborted) {
-    summary.skipped = true;
-    return summary;
+    summary2.skipped = true;
+    return summary2;
   }
   const gate = options.permissions.decide(diagnosticsTool);
   if (gate === "deny") {
-    summary.skipped = true;
+    summary2.skipped = true;
     options.hooks.onEvent({
       type: "notice",
       level: "warn",
       text: "Automatic project checks were skipped by the current permission settings."
     });
-    return summary;
+    return summary2;
   }
   if (gate === "ask") {
     const decision = await options.hooks.requestPermission({
@@ -2425,17 +2784,17 @@ async function runAutomaticDiagnostics(options) {
       allowAlways: true
     });
     if (options.signal.aborted) {
-      summary.skipped = true;
-      return summary;
+      summary2.skipped = true;
+      return summary2;
     }
     if (decision === "deny") {
-      summary.skipped = true;
+      summary2.skipped = true;
       options.hooks.onEvent({
         type: "notice",
         level: "warn",
         text: "Automatic project checks were skipped."
       });
-      return summary;
+      return summary2;
     }
     if (decision === "always") options.permissions.grantForSession(diagnosticsTool.name);
   }
@@ -2448,7 +2807,7 @@ async function runAutomaticDiagnostics(options) {
   const execute = options.execute ?? ((command, context) => bashTool.execute({ command, timeoutMs: DIAGNOSTIC_TIMEOUT_MS }, context));
   for (const [index, command] of commands.entries()) {
     if (options.signal.aborted) {
-      summary.skipped = true;
+      summary2.skipped = true;
       break;
     }
     const id = `diagnostics-${Date.now()}-${index}`;
@@ -2456,7 +2815,7 @@ async function runAutomaticDiagnostics(options) {
     options.hooks.onEvent({ type: "tool_start", id, name: diagnosticsTool.name, summary: callSummary });
     try {
       const result = await execute(command, ctx);
-      if (result.isError) summary.failed.push(command);
+      if (result.isError) summary2.failed.push(command);
       options.hooks.onEvent({
         type: "tool_end",
         id,
@@ -2465,7 +2824,7 @@ async function runAutomaticDiagnostics(options) {
         display: result.display
       });
     } catch (error) {
-      summary.failed.push(command);
+      summary2.failed.push(command);
       options.hooks.onEvent({
         type: "tool_end",
         id,
@@ -2474,13 +2833,13 @@ async function runAutomaticDiagnostics(options) {
       });
     }
   }
-  return summary;
+  return summary2;
 }
 async function readPackageJson(file) {
   try {
     const info = await stat4(file);
     if (!info.isFile() || info.size > MAX_PACKAGE_BYTES) return null;
-    const value = JSON.parse(await readFile5(file, "utf8"));
+    const value = JSON.parse(await readFile6(file, "utf8"));
     if (typeof value !== "object" || value === null) return null;
     const candidate = value;
     return {
@@ -2494,9 +2853,9 @@ async function readPackageJson(file) {
 async function packageManager(cwd, declared) {
   const name = declared?.split("@")[0];
   if (name === "pnpm" || name === "yarn" || name === "bun" || name === "npm") return name;
-  if (await isFile2(path6.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (await isFile2(path6.join(cwd, "yarn.lock"))) return "yarn";
-  if (await isFile2(path6.join(cwd, "bun.lock")) || await isFile2(path6.join(cwd, "bun.lockb"))) {
+  if (await isFile2(path7.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (await isFile2(path7.join(cwd, "yarn.lock"))) return "yarn";
+  if (await isFile2(path7.join(cwd, "bun.lock")) || await isFile2(path7.join(cwd, "bun.lockb"))) {
     return "bun";
   }
   return "npm";
@@ -2514,9 +2873,9 @@ async function isFile2(file) {
 
 // src/core/attachments.ts
 import { execFile } from "child_process";
-import { lstat as lstat2, readdir as readdir3, readFile as readFile6, stat as stat5 } from "fs/promises";
+import { lstat as lstat2, readdir as readdir3, readFile as readFile7, stat as stat5 } from "fs/promises";
 import os2 from "os";
-import path7 from "path";
+import path8 from "path";
 import { fileURLToPath } from "url";
 var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
 var MAX_TEXT_BYTES = 256 * 1024;
@@ -2547,7 +2906,7 @@ async function loadAttachment(cwd, requestedPath) {
   const resolved = resolveAttachmentPath(cwd, requestedPath);
   const linkInfo = await lstat2(resolved).catch(() => null);
   if (linkInfo?.isSymbolicLink()) {
-    throw new Error(`Cannot attach symbolic links: ${path7.basename(resolved)}`);
+    throw new Error(`Cannot attach symbolic links: ${path8.basename(resolved)}`);
   }
   const info = await stat5(resolved).catch((error) => {
     if (error.code === "ENOENT") throw new Error(`Attachment not found: ${resolved}`);
@@ -2556,7 +2915,7 @@ async function loadAttachment(cwd, requestedPath) {
   if (info.isDirectory()) {
     const attachment = await loadFirstImageFromDirectory(resolved);
     if (attachment) return attachment;
-    throw new Error(`No supported images found in directory: ${path7.basename(resolved)}`);
+    throw new Error(`No supported images found in directory: ${path8.basename(resolved)}`);
   }
   if (!info.isFile()) throw new Error(`Attachment is not a regular file: ${resolved}`);
   return loadResolvedAttachment(resolved, info.size);
@@ -2566,7 +2925,7 @@ async function loadAutomaticAttachment(cwd, requestedPath) {
   const resolved = resolveAttachmentPath(cwd, requestedPath);
   if (isSensitiveAutomaticPath(resolved)) {
     throw new Error(
-      `For safety, sensitive-looking files must be attached explicitly with /attach: ${path7.basename(resolved)}`
+      `For safety, sensitive-looking files must be attached explicitly with /attach: ${path8.basename(resolved)}`
     );
   }
   const linkInfo = await lstat2(resolved).catch(() => null);
@@ -2586,14 +2945,14 @@ function looksLikeAttachmentPath(value) {
   if (trimmed.length > MAX_PATH_CHARS) return false;
   const candidate = normalizeInputPath(trimmed);
   if (/^file:\/\//i.test(candidate)) return true;
-  if (path7.isAbsolute(candidate)) return true;
+  if (path8.isAbsolute(candidate)) return true;
   if (/^(?:~|\.{1,2})[\\/]/.test(candidate)) return true;
   if (candidate.includes("/") || candidate.includes("\\")) {
     if (trimmed.length > 200) return false;
     return true;
   }
-  const basename3 = path7.basename(candidate).toLowerCase();
-  return path7.extname(basename3) !== "" || AUTO_PATH_NAMES.has(basename3);
+  const basename3 = path8.basename(candidate).toLowerCase();
+  return path8.extname(basename3) !== "" || AUTO_PATH_NAMES.has(basename3);
 }
 async function loadClipboardImage(platform = process.platform, runner = runClipboardCommand) {
   const commands = clipboardCommands(platform);
@@ -2625,12 +2984,12 @@ async function loadClipboardImage(platform = process.platform, runner = runClipb
   throw new Error(`No supported image found in the clipboard. ${hint}`);
 }
 async function loadResolvedAttachment(resolved, size) {
-  const name = safeName(path7.basename(resolved));
+  const name = safeName(path8.basename(resolved));
   const imageLimitCandidate = size <= MAX_IMAGE_BYTES;
   if (!imageLimitCandidate) {
     throw new Error(`Attachment is larger than ${formatBytes(MAX_IMAGE_BYTES)}: ${name}`);
   }
-  const data = await readFile6(resolved);
+  const data = await readFile7(resolved);
   const mediaType = detectImage(data);
   if (mediaType) {
     return {
@@ -2659,10 +3018,10 @@ async function loadFirstImageFromDirectory(dirPath) {
   const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"]);
   const entries = await readdir3(dirPath, { withFileTypes: true }).catch(() => null);
   if (!entries) return null;
-  const sorted = entries.filter((entry) => entry.isFile() && IMAGE_EXTENSIONS.has(path7.extname(entry.name).toLowerCase())).sort((a, b) => a.name.localeCompare(b.name));
+  const sorted = entries.filter((entry) => entry.isFile() && IMAGE_EXTENSIONS.has(path8.extname(entry.name).toLowerCase())).sort((a, b) => a.name.localeCompare(b.name));
   if (sorted.length === 0) return null;
   const first2 = sorted[0];
-  const filePath = path7.join(dirPath, first2.name);
+  const filePath = path8.join(dirPath, first2.name);
   const info = await stat5(filePath).catch(() => null);
   if (!info?.isFile()) return null;
   return loadResolvedAttachment(filePath, info.size);
@@ -2672,17 +3031,17 @@ function resolveAttachmentPath(cwd, requestedPath) {
   if (!cleaned) throw new Error("Give a file path: /attach <path>");
   if (/^file:\/\//i.test(cleaned)) {
     try {
-      return path7.normalize(fileURLToPath(cleaned));
+      return path8.normalize(fileURLToPath(cleaned));
     } catch {
       throw new Error(`Invalid local file URL: ${cleaned}`);
     }
   }
-  const expanded = cleaned === "~" ? os2.homedir() : cleaned.startsWith("~/") ? path7.join(os2.homedir(), cleaned.slice(2)) : cleaned;
-  return path7.isAbsolute(expanded) ? path7.normalize(expanded) : path7.resolve(cwd, expanded);
+  const expanded = cleaned === "~" ? os2.homedir() : cleaned.startsWith("~/") ? path8.join(os2.homedir(), cleaned.slice(2)) : cleaned;
+  return path8.isAbsolute(expanded) ? path8.normalize(expanded) : path8.resolve(cwd, expanded);
 }
 function isSensitiveAutomaticPath(file) {
-  const basename3 = path7.basename(file).toLowerCase();
-  return basename3.startsWith(".env.") || SENSITIVE_AUTO_NAMES.has(basename3) || SENSITIVE_AUTO_EXTENSIONS.has(path7.extname(basename3));
+  const basename3 = path8.basename(file).toLowerCase();
+  return basename3.startsWith(".env.") || SENSITIVE_AUTO_NAMES.has(basename3) || SENSITIVE_AUTO_EXTENSIONS.has(path8.extname(basename3));
 }
 function attachmentLabel(block) {
   if (block.type === "image") return `image: ${block.name}`;
@@ -2827,7 +3186,7 @@ try {
 }
 `;
 function textMime(file) {
-  const extension = path7.extname(file).toLowerCase();
+  const extension = path8.extname(file).toLowerCase();
   const known = {
     ".json": "application/json",
     ".md": "text/markdown",
@@ -2880,8 +3239,8 @@ 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.";
+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. Use these sections: Requirements; Verified facts (with file paths or tool evidence); Changes made; Verification (exact commands, pass/fail/not run, and unresolved error excerpts); Decisions and assumptions; Remaining work. Keep plans and assumptions separate from verified facts. Never turn an intended command into a completed check. When checks conflict, retain the latest result and mark earlier results as superseded. Preserve explicit user corrections and project constraints. Do not retain credentials or secret values. 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. Keep the structured sections and evidence from the source summaries. Separate verified facts, assumptions, and planned work; keep exact verification commands and their latest outcomes. Do not resolve conflicting evidence by guessing. Do not retain credentials or secret values. Be terse. Return only the merged summary.";
 async function compactHistory(options) {
   const cut = compactCutIndex(options.history);
   if (cut <= 0) {
@@ -2893,7 +3252,7 @@ async function compactHistory(options) {
   if (!rendered.trim()) {
     return { history: options.history, compacted: false, removedMessages: 0 };
   }
-  let summary;
+  let summary2;
   let usage;
   let rateLimits;
   if (rendered.length <= SINGLE_REQUEST_MAX_CHARS) {
@@ -2907,7 +3266,7 @@ async function compactHistory(options) {
       SYSTEM_SUMMARIZE,
       requestMax
     );
-    summary = result.text;
+    summary2 = result.text;
     usage = result.usage;
     rateLimits = result.rateLimits;
   } else {
@@ -2942,19 +3301,19 @@ async function compactHistory(options) {
       chunkResults.map((result) => result.text),
       limits.merge
     );
-    summary = mergeResult.text;
+    summary2 = mergeResult.text;
     if (mergeResult.usage) {
       usage = usage ? mergeUsage([usage, mergeResult.usage]) : mergeResult.usage;
     }
     if (mergeResult.rateLimits) rateLimits = mergeResult.rateLimits;
   }
-  summary = summary.trim();
-  if (!summary) throw new Error("The provider returned an empty context summary.");
+  summary2 = summary2.trim();
+  if (!summary2) throw new Error("The provider returned an empty context summary.");
   const prefix = [
     {
       role: "user",
       content: [{ type: "text", text: `[Earlier conversation summary]
-${summary}` }]
+${summary2}` }]
     },
     {
       role: "assistant",
@@ -3098,8 +3457,8 @@ async function mergePartialSummaries(provider, model, maxTokens, signal, summari
   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")
+      (group) => group.map((summary2, index) => `## Part ${index + 1}
+${summary2}`).join("\n\n")
     );
     const merged = await summarizeSourcesParallel(
       provider,
@@ -3158,22 +3517,22 @@ 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) {
+  for (const summary2 of summaries) {
+    if (current.length >= 2 && size + 12 + summary2.length > targetChars) {
       groups.push(current);
       current = [];
       size = 0;
     }
     const separator = current.length > 0 ? 12 : 0;
-    current.push(summary);
-    size += separator + summary.length;
+    current.push(summary2);
+    size += separator + summary2.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 summary2 = "";
   let finalText2 = "";
   let usage;
   let rateLimits;
@@ -3187,7 +3546,7 @@ async function summarizeText(provider, model, maxTokens, signal, source, systemP
     signal
   });
   for await (const event of stream) {
-    if (event.type === "text_delta") summary += event.text;
+    if (event.type === "text_delta") summary2 += event.text;
     else if (event.type === "usage") usage = event.usage;
     else if (event.type === "rate_limits") rateLimits = event.limits;
     else if (event.type === "done") {
@@ -3195,7 +3554,7 @@ async function summarizeText(provider, model, maxTokens, signal, source, systemP
     }
   }
   if (signal.aborted) throw signal.reason ?? new Error("Context compaction was cancelled.");
-  return { text: (finalText2 || summary).trim(), usage, rateLimits };
+  return { text: (finalText2 || summary2).trim(), usage, rateLimits };
 }
 function mergeUsage(usages) {
   return usages.reduce(
@@ -3283,6 +3642,12 @@ function buildSystemPrompt(args) {
   if (args.skills && args.skills.trim() !== "") {
     lines.push("", args.skills);
   }
+  if (args.toolNames.includes("memory")) {
+    lines.push("", "Use memory to retain explicit user preferences, verified project facts and accepted decisions across chats. Include the source. Read existing notes before replacing or deleting them; correct stale notes rather than adding contradictions. Keep temporary progress in the conversation, not permanent memory. Never store credentials. Tell the user briefly when you update memory.");
+  }
+  if (args.memory?.trim()) {
+    lines.push("", "Project notes saved in earlier conversations. Treat these as potentially stale context; verify claims against current files and follow current user instructions.", args.memory);
+  }
   return lines.join("\n");
 }
 
@@ -3533,7 +3898,7 @@ function clip(value) {
 // package.json
 var package_default = {
   name: "@kernelonpanic/kitcode",
-  version: "1.2.9",
+  version: "1.3.1",
   description: "Terminal coding agent with a config you never have to write by hand",
   type: "module",
   license: "MIT",
@@ -3601,7 +3966,7 @@ var package_default = {
 
 // src/version.ts
 var KITCODE_VERSION = package_default.version;
-var KITCODE_COMMIT = true ? "cc499fc443e73408f49b928f204b77c48e9d2d05" : "development";
+var KITCODE_COMMIT = true ? "4320a2bd340f59e42397dd4afbfde0051ddfeb27" : "development";
 
 // src/mcp/client.ts
 var clientInfo = { name: "kitcode", version: KITCODE_VERSION };
@@ -3799,8 +4164,8 @@ function describeFailure2(error, stderr, secrets) {
   return redactSecrets(stderr ? `${message} \u2014 ${stderr}` : message, secrets);
 }
 function configuredSecrets(config) {
-  const record2 = config.type === "stdio" ? config.env : config.headers;
-  return Object.values(expandEnvRecord(record2)).filter((value) => value.length >= 4);
+  const record3 = config.type === "stdio" ? config.env : config.headers;
+  return Object.values(expandEnvRecord(record3)).filter((value) => value.length >= 4);
 }
 function inheritedEnv(source = process.env) {
   const env = {};
@@ -3892,14 +4257,14 @@ function balanceEndpoints(baseUrl) {
     endpoint(url.origin, "/v1/balance", genericBalance)
   ];
 }
-function endpoint(origin, path14, parse2) {
-  return { url: `${origin}${path14}`, parse: parse2 };
+function endpoint(origin, path15, parse2) {
+  return { url: `${origin}${path15}`, parse: parse2 };
 }
 function deepSeekBalance(body) {
-  const infos = record(body)?.["balance_infos"];
+  const infos = record2(body)?.["balance_infos"];
   if (!Array.isArray(infos)) return null;
   const balances = infos.flatMap((item) => {
-    const entry = record(item);
+    const entry = record2(item);
     const currency = currencyCode(entry?.["currency"]);
     const amount = decimal(entry?.["total_balance"]);
     return currency && amount ? [{ kind: "balance", currency, amount }] : [];
@@ -3907,11 +4272,11 @@ function deepSeekBalance(body) {
   return balances.length > 0 ? balances : null;
 }
 function openRouterKeyBalance(body) {
-  const remaining = finiteNumber(record(record(body)?.["data"])?.["limit_remaining"]);
+  const remaining = finiteNumber(record2(record2(body)?.["data"])?.["limit_remaining"]);
   return remaining === null ? null : [{ kind: "key-limit", currency: "USD", amount: String(remaining) }];
 }
 function openRouterCreditsBalance(body) {
-  const data = record(record(body)?.["data"]);
+  const data = record2(record2(body)?.["data"]);
   const credits = finiteNumber(data?.["total_credits"]);
   const usage = finiteNumber(data?.["total_usage"]);
   if (credits === null || usage === null) return null;
@@ -3924,26 +4289,26 @@ function openRouterCreditsBalance(body) {
   ];
 }
 function siliconFlowBalance(body) {
-  const root = record(body);
+  const root = record2(body);
   if (root?.["status"] !== true) return null;
-  const amount = decimal(record(root["data"])?.["balance"]);
+  const amount = decimal(record2(root["data"])?.["balance"]);
   return amount ? [{ kind: "balance", currency: "credits", amount }] : null;
 }
 function apiMartBalance(body) {
-  const root = record(body);
+  const root = record2(body);
   if (root?.["success"] !== true) return null;
   const amount = decimal(root["remain_balance"]);
   return amount ? [{ kind: "balance", currency: "credits", amount }] : null;
 }
 function genericBalance(body) {
-  const root = record(body);
-  const data = record(root?.["data"]);
+  const root = record2(body);
+  const data = record2(root?.["data"]);
   const amount = decimal(root?.["balance"] ?? data?.["balance"]);
   if (!amount) return null;
   const currency = currencyCode(root?.["currency"] ?? data?.["currency"]) ?? "credits";
   return [{ kind: "balance", currency, amount }];
 }
-function record(value) {
+function record2(value) {
   return typeof value === "object" && value !== null ? value : null;
 }
 function currencyCode(value) {
@@ -3971,8 +4336,8 @@ async function limitedResponseText(response, limit) {
   let text = "";
   try {
     while (true) {
-      const { done, value } = await reader.read();
-      if (done) return text + decoder.decode();
+      const { done: done2, value } = await reader.read();
+      if (done2) return text + decoder.decode();
       size += value.byteLength;
       if (size > limit) {
         await reader.cancel();
@@ -3986,21 +4351,21 @@ async function limitedResponseText(response, limit) {
 }
 
 // src/providers/catalog.ts
-import { chmod as chmod4, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
-import path8 from "path";
+import { chmod as chmod4, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import path9 from "path";
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var CACHE_VERSION = 3;
 async function loadModels(provider, refresh = false) {
   const file = cacheFile(provider.id);
-  const cached = await readCache(file);
-  if (!refresh && cached?.version === CACHE_VERSION && Date.now() - cached.fetchedAt < MAX_AGE_MS) {
-    return cached.models;
+  const cached2 = await readCache(file);
+  if (!refresh && cached2?.version === CACHE_VERSION && Date.now() - cached2.fetchedAt < MAX_AGE_MS) {
+    return cached2.models;
   }
   let models;
   try {
     models = await provider.listModels();
   } catch (error) {
-    if (cached) return cached.models;
+    if (cached2) return cached2.models;
     const known = provider.knownModels();
     if (known.length > 0) return known;
     throw error;
@@ -4008,12 +4373,15 @@ async function loadModels(provider, refresh = false) {
   await writeCache(file, models);
   return models;
 }
+function refreshModels(provider) {
+  return loadModels(provider, true);
+}
 function cacheFile(providerId) {
-  return path8.join(cacheDir, "models", `${providerId.replace(/[^\w.-]/g, "_")}.json`);
+  return path9.join(cacheDir, "models", `${providerId.replace(/[^\w.-]/g, "_")}.json`);
 }
 async function readCache(file) {
   try {
-    const parsed = JSON.parse(await readFile7(file, "utf8"));
+    const parsed = JSON.parse(await readFile8(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)) {
@@ -4044,8 +4412,8 @@ function validModel(value) {
 async function writeCache(file, models) {
   const payload = { version: CACHE_VERSION, fetchedAt: Date.now(), models };
   try {
-    await ensureDir(path8.dirname(file));
-    await writeFile5(file, JSON.stringify(payload), { encoding: "utf8", mode: 384 });
+    await ensureDir(path9.dirname(file));
+    await writeFile6(file, JSON.stringify(payload), { encoding: "utf8", mode: 384 });
     await chmod4(file, 384);
   } catch {
     return;
@@ -4194,7 +4562,8 @@ async function* streamTurn(client, providerId, apiKey2, req) {
     tools: toToolParams(req.tools)
   };
   if (req.thinking) params.thinking = { type: "adaptive", display: "summarized" };
-  if (req.effort) params.output_config = { effort: req.effort };
+  const effort = resolveEffort(req.effort, req.messages);
+  if (effort) params.output_config = { effort };
   let thinking = "";
   let text = "";
   let events = 0;
@@ -4382,11 +4751,13 @@ async function* streamTurn2(client, providerId, apiKey2, req) {
   let recognised = 0;
   const calls = /* @__PURE__ */ new Map();
   const capture = captureResponseHead();
+  const effort = openAiEffort(req.model, resolveEffort(req.effort, req.messages));
   try {
     const stream = await client.withOptions({ fetch: capture.fetch }).chat.completions.create(
       {
         model: req.model,
         max_tokens: req.maxTokens,
+        ...effort ? { reasoning_effort: effort } : {},
         messages: toChatMessages(req.system, req.messages),
         ...req.tools.length > 0 ? { tools: toChatTools(req.tools) } : {},
         stream: true,
@@ -4589,8 +4960,8 @@ function normalizeOpenAiUsage(usage) {
 function createRegistry(config, auth) {
   const built = /* @__PURE__ */ new Map();
   function get(id) {
-    const cached = built.get(id);
-    if (cached) return cached;
+    const cached2 = built.get(id);
+    if (cached2) return cached2;
     const entry = config.providers[id];
     if (!entry) throw new Error(unknownProviderMessage(id, Object.keys(config.providers)));
     const provider = build(id, entry, apiKey(id, entry, auth));
@@ -4682,13 +5053,66 @@ function isFileEdit(tool) {
   return tool.name === "write" || tool.name === "edit";
 }
 
+// src/tools/bash-output.ts
+var bashOutputTool = {
+  name: "bash_output",
+  description: "Collect output from commands started with bash({ background: true }). Returns only the output that arrived since the last read. Omit id to list every background command. Set kill to stop one.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      id: { type: "string", description: 'Background command id, e.g. "bg-1"' },
+      kill: { type: "boolean", description: "Stop the command instead of reading it" }
+    },
+    additionalProperties: false
+  },
+  defaultPermission: "allow",
+  readOnly: true,
+  summarize(input) {
+    const { id, kill } = input;
+    if (!id) return "bash_output(list)";
+    return kill ? `bash_output(${id}, kill)` : `bash_output(${id})`;
+  },
+  execute(input) {
+    const { id, kill } = input;
+    if (!id) {
+      const jobs2 = listJobs();
+      if (jobs2.length === 0) return done({ content: "No background commands have been started." });
+      const lines = jobs2.map((job2) => `${job2.id}  ${describeState(job2.state, job2.exitCode, job2.signal)}  ${job2.command}`);
+      return done({ content: lines.join("\n") });
+    }
+    if (kill) {
+      const stopped = killJob(id);
+      return done(
+        stopped ? { content: `[${id} stopped]` } : { content: `No background command with id "${id}".`, isError: true }
+      );
+    }
+    const job = readJob(id);
+    if (!job) return done({ content: `No background command with id "${id}".`, isError: true });
+    const notes = [`[${id} ${describeState(job.state, job.exitCode, job.signal)}]`];
+    if (job.truncated) notes.push("[output buffer full; earlier output was dropped]");
+    const body = job.output.trim() === "" ? "(no new output)" : job.output.replace(/\n+$/, "");
+    return done({
+      content: [body, ...notes].join("\n"),
+      isError: job.state === "exited" && job.exitCode !== null && job.exitCode !== 0
+    });
+  }
+};
+function describeState(state, exitCode, signal) {
+  if (state === "running") return "still running";
+  if (state === "killed") return `stopped${signal ? ` by ${signal}` : ""}`;
+  return exitCode === 0 ? "finished" : `exit code ${exitCode}`;
+}
+function done(result) {
+  return Promise.resolve(result);
+}
+
 // src/tools/edit.ts
-import { readFile as readFile8, stat as stat6 } from "fs/promises";
+import { readFile as readFile9, stat as stat6 } from "fs/promises";
 
 // src/tools/safe-write.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { chmod as chmod5, lstat as lstat3, open, rename as rename5, rm as rm3 } from "fs/promises";
-import { basename as basename2, dirname as dirname2, join } from "path";
+import { chmod as chmod5, lstat as lstat3, open, rename as rename5, rm as rm4 } from "fs/promises";
+import { basename as basename2, dirname as dirname2, join as join2 } from "path";
 var UnsafeFileChangeError = class extends Error {
   constructor(message) {
     super(message);
@@ -4733,7 +5157,7 @@ async function readSafeFileSnapshot(file, maxBytes) {
 async function atomicWriteSafeFile(file, data, snapshot) {
   const parent = dirname2(file);
   await assertSameParent(parent, snapshot.parent);
-  const temp = join(parent, `.${basename2(file)}.${process.pid}.${randomUUID3()}.tmp`);
+  const temp = join2(parent, `.${basename2(file)}.${process.pid}.${randomUUID3()}.tmp`);
   let handle;
   try {
     handle = await open(temp, "wx", snapshot.mode);
@@ -4750,7 +5174,7 @@ async function atomicWriteSafeFile(file, data, snapshot) {
     await rename5(temp, file);
   } catch (error) {
     await handle?.close().catch(() => void 0);
-    await rm3(temp, { force: true }).catch(() => void 0);
+    await rm4(temp, { force: true }).catch(() => void 0);
     throw error;
   }
 }
@@ -4845,56 +5269,56 @@ var editTool = {
     return `edit(${brief(input.path)})`;
   },
   async preview(input, ctx) {
-    const { path: path14, oldString, newString, replaceAll = false } = input;
-    const safe = resolveInside(ctx.cwd, path14);
+    const { path: path15, oldString, newString, replaceAll = false } = input;
+    const safe = resolveInside(ctx.cwd, path15);
     if (!safe.ok) return { kind: "text", text: safe.reason };
     const info = await stat6(safe.path).catch(() => null);
     if (info && info.size > MAX_FILE_BYTES2) {
-      return { kind: "text", text: `Cannot preview ${path14}: the file is too large.` };
+      return { kind: "text", text: `Cannot preview ${path15}: the file is too large.` };
     }
-    const beforeBuffer = await readFile8(safe.path).catch(() => null);
-    if (!beforeBuffer) return { kind: "text", text: `Cannot read ${path14}.` };
+    const beforeBuffer = await readFile9(safe.path).catch(() => null);
+    if (!beforeBuffer) return { kind: "text", text: `Cannot read ${path15}.` };
     if (beforeBuffer.subarray(0, 8192).includes(0)) {
-      return { kind: "text", text: `Cannot preview binary file ${path14}` };
+      return { kind: "text", text: `Cannot preview binary file ${path15}` };
     }
     const before = beforeBuffer.toString("utf8");
     const after = replacement(before, oldString, newString, replaceAll);
-    return after === null ? { kind: "text", text: `Cannot preview edit: oldString is not a valid match in ${path14}.` } : { kind: "diff", path: path14, before, after };
+    return after === null ? { kind: "text", text: `Cannot preview edit: oldString is not a valid match in ${path15}.` } : { kind: "diff", path: path15, before, after };
   },
   async execute(input, ctx) {
-    const { path: path14, oldString, newString, replaceAll = false } = input;
-    const safe = resolveInside(ctx.cwd, path14);
+    const { path: path15, oldString, newString, replaceAll = false } = input;
+    const safe = resolveInside(ctx.cwd, path15);
     if (!safe.ok) return { content: safe.reason, isError: true };
     let snapshot;
     try {
       snapshot = await readSafeFileSnapshot(safe.path, MAX_FILE_BYTES2);
     } catch (error) {
-      return { content: `Cannot edit ${path14}: ${error.message}.`, isError: true };
+      return { content: `Cannot edit ${path15}: ${error.message}.`, isError: true };
     }
-    if (!snapshot.exists) return { content: `Cannot read ${path14}.`, isError: true };
+    if (!snapshot.exists) return { content: `Cannot read ${path15}.`, isError: true };
     const beforeBuffer = snapshot.data;
     if (beforeBuffer.subarray(0, 8192).includes(0)) {
-      return { content: `Cannot edit ${path14}: it is a binary file, not text.`, isError: true };
+      return { content: `Cannot edit ${path15}: it is a binary file, not text.`, isError: true };
     }
     const before = beforeBuffer.toString("utf8");
     const count = countOccurrences(before, oldString);
     if (count === 0) {
       return {
-        content: `oldString was not found in ${path14}. Read the file again and match the text exactly, including whitespace.`,
+        content: `oldString was not found in ${path15}. Read the file again and match the text exactly, including whitespace.`,
         isError: true
       };
     }
     if (count > 1 && !replaceAll) {
       return {
-        content: `oldString matches ${count} places in ${path14}. Add more surrounding context to identify a single one, or set replaceAll to true.`,
+        content: `oldString matches ${count} places in ${path15}. Add more surrounding context to identify a single one, or set replaceAll to true.`,
         isError: true
       };
     }
     const after = replacement(before, oldString, newString, replaceAll);
-    if (after === null) return { content: `Could not prepare edit for ${path14}.`, isError: true };
+    if (after === null) return { content: `Could not prepare edit for ${path15}.`, isError: true };
     if (Buffer.byteLength(after, "utf8") > MAX_FILE_BYTES2) {
       return {
-        content: `Cannot edit ${path14}: the result exceeds the ${MAX_FILE_BYTES2 / 1e6} MB limit.`,
+        content: `Cannot edit ${path15}: the result exceeds the ${MAX_FILE_BYTES2 / 1e6} MB limit.`,
         isError: true
       };
     }
@@ -4907,11 +5331,11 @@ var editTool = {
       await atomicWriteSafeFile(safe.path, after, snapshot);
       ctx.checkpoint?.markChanged(safe.path);
     } catch (error) {
-      return { content: `Failed to write ${path14}: ${error.message}`, isError: true };
+      return { content: `Failed to write ${path15}: ${error.message}`, isError: true };
     }
     return {
-      content: `Edited ${path14} (${count} ${count === 1 ? "replacement" : "replacements"})`,
-      display: { kind: "diff", path: path14, before, after }
+      content: `Edited ${path15} (${count} ${count === 1 ? "replacement" : "replacements"})`,
+      display: { kind: "diff", path: path15, before, after }
     };
   }
 };
@@ -4923,61 +5347,13 @@ function replacement(before, oldString, newString, replaceAll) {
   return before.slice(0, at) + newString + before.slice(at + oldString.length);
 }
 
-// src/tools/glob.ts
-import { join as join2 } from "path";
-import fg from "fast-glob";
-var MAX_RESULTS = 500;
-var IGNORED_DIRECTORIES = ["**/node_modules/**", "**/.git/**", "**/dist/**"];
-var globTool = {
-  name: "glob",
-  description: 'Find files by glob pattern, most recently modified first. Supports patterns like "src/**/*.ts". Hidden files, node_modules, .git and dist are skipped.',
-  inputSchema: {
-    type: "object",
-    properties: {
-      pattern: { type: "string", description: "Glob pattern, e.g. **/*.test.ts" },
-      path: { type: "string", description: "Directory to search in, relative to the workspace root" }
-    },
-    required: ["pattern"],
-    additionalProperties: false
-  },
-  defaultPermission: "allow",
-  readOnly: true,
-  summarize(input) {
-    return `glob(${brief(input.pattern)})`;
-  },
-  async execute(input, ctx) {
-    const { pattern, path: path14 = "." } = input;
-    if (patternEscapes(pattern)) {
-      return { content: `Pattern ${pattern} must be relative to the workspace root.`, isError: true };
-    }
-    const safe = resolveInside(ctx.cwd, path14);
-    if (!safe.ok) return { content: safe.reason, isError: true };
-    const entries = await fg(pattern, {
-      cwd: safe.path,
-      dot: false,
-      onlyFiles: true,
-      followSymbolicLinks: false,
-      suppressErrors: true,
-      ignore: IGNORED_DIRECTORIES,
-      stats: true
-    });
-    if (entries.length === 0) return { content: `No files matched ${pattern}` };
-    entries.sort((a, b) => (b.stats?.mtimeMs ?? 0) - (a.stats?.mtimeMs ?? 0));
-    const paths = entries.slice(0, MAX_RESULTS).map((entry) => join2(safe.relative, entry.path));
-    if (entries.length > MAX_RESULTS) {
-      paths.push(`... truncated: ${entries.length - MAX_RESULTS} more files matched.`);
-    }
-    return { content: paths.join("\n") };
-  }
-};
-
 // src/tools/grep.ts
-import { readFile as readFile9, stat as stat7 } from "fs/promises";
+import { readFile as readFile10, stat as stat7 } from "fs/promises";
 import { join as join3 } from "path";
-import fg2 from "fast-glob";
+import fg3 from "fast-glob";
 
 // src/tools/sensitive.ts
-import path9 from "path";
+import path10 from "path";
 var sensitiveNames = /* @__PURE__ */ new Set([
   ".npmrc",
   ".pypirc",
@@ -5004,9 +5380,9 @@ var sensitiveExtensions = /* @__PURE__ */ new Set([".pem", ".key", ".p12", ".pfx
 function isSensitivePath(value) {
   if (typeof value !== "string") return false;
   const normalized = value.replaceAll("\\", "/").toLowerCase();
-  const name = path9.posix.basename(normalized);
+  const name = path10.posix.basename(normalized);
   if (name === ".env" || name.startsWith(".env.")) return true;
-  if (sensitiveNames.has(name) || sensitiveExtensions.has(path9.posix.extname(name))) return true;
+  if (sensitiveNames.has(name) || sensitiveExtensions.has(path10.posix.extname(name))) return true;
   return normalized.split("/").some((part) => part === ".ssh" || part === ".aws");
 }
 function mentionsSensitivePattern(value) {
@@ -5124,16 +5500,16 @@ var grepTool = {
   defaultPermission: "allow",
   readOnly: true,
   permission(input, ctx) {
-    const { path: path14, glob } = input ?? {};
-    if (isSensitivePath(path14) || mentionsSensitivePattern(glob)) return "ask";
-    const safe = ctx && path14 ? resolveInside(ctx.cwd, path14) : void 0;
+    const { path: path15, glob } = input ?? {};
+    if (isSensitivePath(path15) || mentionsSensitivePattern(glob)) return "ask";
+    const safe = ctx && path15 ? resolveInside(ctx.cwd, path15) : void 0;
     return safe?.ok && isSensitivePath(safe.relative) ? "ask" : void 0;
   },
   summarize(input) {
     return `grep(${brief(input.pattern)})`;
   },
   async execute(input, ctx) {
-    const { pattern, path: path14 = ".", glob = "**/*", maxMatches } = input;
+    const { pattern, path: path15 = ".", glob = "**/*", maxMatches } = input;
     if (pattern.length > MAX_PATTERN_CHARS) {
       return {
         content: `Regular expression is limited to ${MAX_PATTERN_CHARS} characters.`,
@@ -5148,11 +5524,11 @@ var grepTool = {
     if (patternEscapes(glob)) {
       return { content: `Glob ${glob} must be relative to the workspace root.`, isError: true };
     }
-    const safe = resolveInside(ctx.cwd, path14);
+    const safe = resolveInside(ctx.cwd, path15);
     if (!safe.ok) return { content: safe.reason, isError: true };
     const target = await stat7(safe.path).catch(() => null);
-    if (!target) return { content: `Path not found: ${path14}`, isError: true };
-    const discovered = target.isDirectory() ? (await fg2(glob, {
+    if (!target) return { content: `Path not found: ${path15}`, isError: true };
+    const discovered = target.isDirectory() ? (await fg3(glob, {
       cwd: safe.path,
       dot: false,
       onlyFiles: true,
@@ -5182,7 +5558,7 @@ var grepTool = {
           break;
         }
         scannedBytes += file.size;
-        const buffer = await readFile9(file.absolute).catch(() => null);
+        const buffer = await readFile10(file.absolute).catch(() => null);
         if (!buffer || buffer.subarray(0, 4096).includes(0)) continue;
         const lines = buffer.toString("utf8").split("\n");
         const remaining = limit - hits.length;
@@ -5212,7 +5588,7 @@ var grepTool = {
 };
 
 // src/tools/read.ts
-import { readFile as readFile10, stat as stat8 } from "fs/promises";
+import { readFile as readFile11, stat as stat8 } from "fs/promises";
 var MAX_LINES = 2e3;
 var MAX_CHARS = 2e5;
 var MAX_FILE_BYTES4 = 5e6;
@@ -5241,30 +5617,30 @@ var readTool = {
     return `read(${brief(input.path)})`;
   },
   async execute(input, ctx) {
-    const { path: path14, offset = 1, limit } = input;
-    const safe = resolveInside(ctx.cwd, path14);
+    const { path: path15, offset = 1, limit } = input;
+    const safe = resolveInside(ctx.cwd, path15);
     if (!safe.ok) return { content: safe.reason, isError: true };
     const info = await stat8(safe.path).catch(() => null);
-    if (!info) return { content: `File not found: ${path14}`, isError: true };
+    if (!info) return { content: `File not found: ${path15}`, isError: true };
     if (info.isDirectory()) {
-      return { content: `${path14} is a directory, not a file. Use glob to list its contents.`, isError: true };
+      return { content: `${path15} is a directory, not a file. Use glob to list its contents.`, isError: true };
     }
     if (info.size > MAX_FILE_BYTES4) {
       return {
-        content: `${path14} is ${(info.size / 1e6).toFixed(1)} MB; read is limited to ${MAX_FILE_BYTES4 / 1e6} MB per file. Use grep or another targeted tool instead.`,
+        content: `${path15} is ${(info.size / 1e6).toFixed(1)} MB; read is limited to ${MAX_FILE_BYTES4 / 1e6} MB per file. Use grep or another targeted tool instead.`,
         isError: true
       };
     }
-    const buffer = await readFile10(safe.path);
+    const buffer = await readFile11(safe.path);
     if (buffer.subarray(0, 4096).includes(0)) {
-      return { content: `${path14} looks like a binary file and cannot be read as text.`, isError: true };
+      return { content: `${path15} looks like a binary file and cannot be read as text.`, isError: true };
     }
     const lines = buffer.toString("utf8").split("\n");
     if (lines.at(-1) === "") lines.pop();
-    if (lines.length === 0) return { content: `${path14} is empty.` };
+    if (lines.length === 0) return { content: `${path15} is empty.` };
     const start = Math.max(1, offset) - 1;
     if (start >= lines.length) {
-      return { content: `${path14} has ${lines.length} lines, so offset ${offset} is past the end.`, isError: true };
+      return { content: `${path15} has ${lines.length} lines, so offset ${offset} is past the end.`, isError: true };
     }
     const window = lines.slice(start, start + Math.min(limit ?? MAX_LINES, MAX_LINES));
     const rendered = [];
@@ -5291,7 +5667,7 @@ function toToolSchema(tool) {
 }
 
 // src/tools/write.ts
-import { mkdir as mkdir4, readFile as readFile11, stat as stat9 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile12, stat as stat9 } from "fs/promises";
 import { dirname as dirname3 } from "path";
 var MAX_FILE_BYTES5 = 5e6;
 var writeTool = {
@@ -5311,71 +5687,71 @@ var writeTool = {
     return `write(${brief(input.path)})`;
   },
   async preview(input, ctx) {
-    const { path: path14, content } = input;
+    const { path: path15, content } = input;
     if (Buffer.byteLength(content, "utf8") > MAX_FILE_BYTES5) {
       return { kind: "text", text: `Write is limited to ${MAX_FILE_BYTES5 / 1e6} MB.` };
     }
-    const safe = resolveInside(ctx.cwd, path14);
+    const safe = resolveInside(ctx.cwd, path15);
     if (!safe.ok) return { kind: "text", text: safe.reason };
     const beforeInfo = await stat9(safe.path).catch(() => null);
     if (beforeInfo && beforeInfo.size > MAX_FILE_BYTES5) {
-      return { kind: "text", text: `Cannot preview ${path14}: the existing file is too large.` };
+      return { kind: "text", text: `Cannot preview ${path15}: the existing file is too large.` };
     }
-    const beforeBuffer = await readFile11(safe.path).catch(() => null);
+    const beforeBuffer = await readFile12(safe.path).catch(() => null);
     if (beforeBuffer?.subarray(0, 8192).includes(0)) {
-      return { kind: "text", text: `Cannot preview binary file ${path14}` };
+      return { kind: "text", text: `Cannot preview binary file ${path15}` };
     }
     return {
       kind: "diff",
-      path: path14,
+      path: path15,
       before: beforeBuffer?.toString("utf8") ?? "",
       after: content
     };
   },
   async execute(input, ctx) {
-    const { path: path14, content } = input;
+    const { path: path15, content } = input;
     if (Buffer.byteLength(content, "utf8") > MAX_FILE_BYTES5) {
       return {
-        content: `Cannot write ${path14}: content exceeds the ${MAX_FILE_BYTES5 / 1e6} MB limit.`,
+        content: `Cannot write ${path15}: content exceeds the ${MAX_FILE_BYTES5 / 1e6} MB limit.`,
         isError: true
       };
     }
-    const safe = resolveInside(ctx.cwd, path14);
+    const safe = resolveInside(ctx.cwd, path15);
     if (!safe.ok) return { content: safe.reason, isError: true };
     let target = safe.path;
     let snapshot;
     try {
       await mkdir4(dirname3(target), { recursive: true });
-      const rechecked = resolveInside(ctx.cwd, path14);
+      const rechecked = resolveInside(ctx.cwd, path15);
       if (!rechecked.ok || rechecked.path !== target) {
         return {
-          content: `Cannot write ${path14}: the path changed while its parent was created.`,
+          content: `Cannot write ${path15}: the path changed while its parent was created.`,
           isError: true
         };
       }
       target = rechecked.path;
       snapshot = await readSafeFileSnapshot(target, MAX_FILE_BYTES5);
       if (snapshot.exists && snapshot.data.subarray(0, 8192).includes(0)) {
-        return { content: `Cannot write ${path14}: the existing file is binary, not text.`, isError: true };
+        return { content: `Cannot write ${path15}: the existing file is binary, not text.`, isError: true };
       }
       await ctx.checkpoint?.capture(target);
       await atomicWriteSafeFile(target, content, snapshot);
       ctx.checkpoint?.markChanged(target);
     } catch (error) {
-      return { content: `Failed to write ${path14}: ${error.message}`, isError: true };
+      return { content: `Failed to write ${path15}: ${error.message}`, isError: true };
     }
     const before = snapshot.exists ? snapshot.data.toString("utf8") : "";
     const lines = content === "" ? 0 : content.replace(/\n$/, "").split("\n").length;
     return {
-      content: `${before === "" ? "Created" : "Updated"} ${path14} (${lines} ${lines === 1 ? "line" : "lines"})`,
-      display: { kind: "diff", path: path14, before, after: content }
+      content: `${before === "" ? "Created" : "Updated"} ${path15} (${lines} ${lines === 1 ? "line" : "lines"})`,
+      display: { kind: "diff", path: path15, before, after: content }
     };
   }
 };
 
 // src/tools/registry.ts
 function builtinTools() {
-  return [readTool, writeTool, editTool, bashTool, globTool, grepTool];
+  return [readTool, writeTool, editTool, bashTool, bashOutputTool, globTool, grepTool];
 }
 function createToolRegistry(tools) {
   const byName = /* @__PURE__ */ new Map();
@@ -5397,8 +5773,8 @@ function createToolRegistry(tools) {
 }
 
 // src/prompts/library.ts
-import { chmod as chmod6, readFile as readFile12, readdir as readdir4, unlink as unlink3, writeFile as writeFile6 } from "fs/promises";
-import path10 from "path";
+import { chmod as chmod6, readFile as readFile13, readdir as readdir4, unlink as unlink3, writeFile as writeFile7 } from "fs/promises";
+import path11 from "path";
 async function savePrompt(input) {
   const slug = slugify(input.name);
   if (!slug) throw new Error(`Prompt name has no letters or digits to name a file after: ${input.name}`);
@@ -5410,8 +5786,8 @@ async function savePrompt(input) {
     body: input.body.trim()
   };
   await ensureDir(promptsDir);
-  const file = path10.join(promptsDir, `${slug}.md`);
-  await writeFile6(file, serialize(prompt), {
+  const file = path11.join(promptsDir, `${slug}.md`);
+  await writeFile7(file, serialize(prompt), {
     encoding: "utf8",
     mode: 384
   });
@@ -5421,7 +5797,7 @@ async function savePrompt(input) {
 async function getPrompt(slug) {
   assertSlug(slug);
   try {
-    return parse(slug, await readFile12(path10.join(promptsDir, `${slug}.md`), "utf8"));
+    return parse(slug, await readFile13(path11.join(promptsDir, `${slug}.md`), "utf8"));
   } catch (error) {
     if (isMissing(error)) return null;
     throw error;
@@ -5437,7 +5813,7 @@ async function listPrompts() {
   }
   const prompts2 = await Promise.all(
     names.filter((name) => name.endsWith(".md")).map(
-      async (name) => parse(name.slice(0, -3), await readFile12(path10.join(promptsDir, name), "utf8"))
+      async (name) => parse(name.slice(0, -3), await readFile13(path11.join(promptsDir, name), "utf8"))
     )
   );
   return prompts2.sort((a, b) => a.name.localeCompare(b.name));
@@ -5445,7 +5821,7 @@ async function listPrompts() {
 async function deletePrompt(slug) {
   assertSlug(slug);
   try {
-    await unlink3(path10.join(promptsDir, `${slug}.md`));
+    await unlink3(path11.join(promptsDir, `${slug}.md`));
     return true;
   } catch (error) {
     if (isMissing(error)) return false;
@@ -5503,7 +5879,7 @@ function parse(slug, text) {
 
 // src/skills/library.ts
 import { lstat as lstat4, open as open2, readdir as readdir5 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 var SKILL_FILE = "SKILL.md";
 var FRONTMATTER_BYTES = 8192;
 var MAX_SKILL_BYTES = 5e6;
@@ -5516,7 +5892,7 @@ async function discoverSkills(dirs) {
     if (!rootInfo?.isDirectory() || rootInfo.isSymbolicLink()) continue;
     const entries = await readdir5(root, { withFileTypes: true }).catch(() => []);
     const found = await Promise.all(
-      entries.filter((entry) => entry.isDirectory() && !entry.isSymbolicLink()).slice(0, MAX_SKILLS_PER_ROOT).map((entry) => readMeta(root, rootInfo, path11.join(root, entry.name)))
+      entries.filter((entry) => entry.isDirectory() && !entry.isSymbolicLink()).slice(0, MAX_SKILLS_PER_ROOT).map((entry) => readMeta(root, rootInfo, path12.join(root, entry.name)))
     );
     for (const meta of found) {
       if (meta && !byName.has(meta.name)) byName.set(meta.name, meta);
@@ -5556,11 +5932,11 @@ function formatSkillCatalogue(skills) {
 async function readMeta(root, rootInfo, dir) {
   const dirInfo = await lstat4(dir).catch(() => null);
   if (!dirInfo?.isDirectory() || dirInfo.isSymbolicLink()) return null;
-  const file = path11.join(dir, SKILL_FILE);
+  const file = path12.join(dir, SKILL_FILE);
   const head = await readFrontmatterBytes(file);
   if (!head) return null;
   const { fields } = parseFrontmatter(head.text);
-  const meta = { name: fields.name || path11.basename(dir), description: fields.description ?? "", dir, file };
+  const meta = { name: fields.name || path12.basename(dir), description: fields.description ?? "", dir, file };
   guards.set(meta, {
     root,
     rootIdentity: identity(rootInfo),
@@ -5656,8 +6032,8 @@ import {
   writeFileSync
 } from "fs";
 import { chmod as chmod7, mkdir as mkdir5 } from "fs/promises";
-import path12 from "path";
-var TMP_DIR = path12.join(skillsDir, ".tmp");
+import path13 from "path";
+var TMP_DIR = path13.join(skillsDir, ".tmp");
 var MAX_SKILL_BYTES2 = 5e6;
 async function installSkill(source) {
   await ensureDir(skillsDir);
@@ -5682,7 +6058,7 @@ function isNpmPackage(input) {
 }
 async function installFromGitHub(url) {
   const { owner, repo, subdir, branch } = parseGitHubUrl(url);
-  const name = safeSkillName(subdir ? path12.posix.basename(subdir) : repo);
+  const name = safeSkillName(subdir ? path13.posix.basename(subdir) : repo);
   const skillDir = safeChildPath(skillsDir, name);
   const tmpDir = safeChildPath(TMP_DIR, `${name}-${randomUUID4()}`);
   try {
@@ -5717,16 +6093,16 @@ async function installFromNpm(packageName) {
     if (!tarball) {
       throw new Error(`Could not download npm package "${packageName}"`);
     }
-    const tarballPath = path12.join(tmpDir, tarball);
+    const tarballPath = path13.join(tmpDir, tarball);
     validateTarball(tarballPath);
-    const extractDir = path12.join(tmpDir, "extracted");
+    const extractDir = path13.join(tmpDir, "extracted");
     mkdirSync(extractDir, { recursive: true });
     try {
       execFileSync("tar", ["-xzf", tarballPath, "-C", extractDir], { stdio: "ignore" });
     } catch {
-      const packageDir = path12.join(tmpDir, "node_modules", packageName);
+      const packageDir = path13.join(tmpDir, "node_modules", packageName);
       if (existsSync2(packageDir)) {
-        const skillFile2 = path12.join(packageDir, "SKILL.md");
+        const skillFile2 = path13.join(packageDir, "SKILL.md");
         if (existsSync2(skillFile2)) {
           const body2 = readSkillFile(skillFile2, packageDir, packageName);
           await writeSkillFile(skillDir, body2);
@@ -5738,7 +6114,7 @@ async function installFromNpm(packageName) {
     const extractedFiles = readdirSync(extractDir);
     const packageRoot = extractedFiles.find((f) => f === "package");
     if (!packageRoot) throw new Error("Could not find package root in extracted files");
-    const skillFile = path12.join(extractDir, "package", "SKILL.md");
+    const skillFile = path13.join(extractDir, "package", "SKILL.md");
     if (!existsSync2(skillFile)) {
       throw new Error(`No SKILL.md found in npm package "${packageName}"`);
     }
@@ -5772,26 +6148,26 @@ function validateTarball(file) {
   }
   for (const entry of entries) {
     const normalized = entry.replace(/^\.\//, "");
-    if (normalized.includes("\\") || path12.posix.isAbsolute(normalized) || normalized.split("/").some((segment) => segment === "..")) {
+    if (normalized.includes("\\") || path13.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);
+  const resolved = path13.resolve(srcPath);
   let skillDir;
   let skillFile;
-  const directSkill = path12.join(resolved, "SKILL.md");
+  const directSkill = path13.join(resolved, "SKILL.md");
   if (existsSync2(directSkill)) {
     skillDir = resolved;
     skillFile = directSkill;
   } else if (resolved.endsWith("SKILL.md") && existsSync2(resolved)) {
-    skillDir = path12.dirname(resolved);
+    skillDir = path13.dirname(resolved);
     skillFile = resolved;
   } else {
     throw new Error(`No SKILL.md found at "${srcPath}"`);
   }
-  const name = path12.basename(skillDir);
+  const name = path13.basename(skillDir);
   const destDir = safeChildPath(skillsDir, safeSkillName(name));
   const body = readSkillFile(skillFile, skillDir, srcPath);
   await writeSkillFile(destDir, body);
@@ -5804,7 +6180,7 @@ async function writeSkillFile(dir, body) {
     throw new Error(`Refusing to replace symlinked skill directory: ${dir}`);
   }
   await mkdir5(dir, { recursive: true, mode: 448 });
-  const file = path12.join(dir, "SKILL.md");
+  const file = path13.join(dir, "SKILL.md");
   const existingFile = lstatSync(file, { throwIfNoEntry: false });
   if (existingFile?.isSymbolicLink()) {
     throw new Error(`Refusing to replace symlinked skill file: ${file}`);
@@ -5857,13 +6233,13 @@ function safeSkillName(value) {
   return value;
 }
 function safeChildPath(root, ...segments) {
-  const target = path12.resolve(root, ...segments);
+  const target = path13.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}`)) {
+  const relative2 = path13.relative(path13.resolve(root), path13.resolve(target));
+  if (relative2 === "" || !path13.isAbsolute(relative2) && relative2 !== ".." && !relative2.startsWith(`..${path13.sep}`)) {
     return;
   }
   throw new Error(`Path escapes the skills directory: ${target}`);
@@ -6110,8 +6486,8 @@ async function readJsonBounded(response) {
   let bytes = 0;
   try {
     while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
+      const { done: done2, value } = await reader.read();
+      if (done2) break;
       bytes += value.byteLength;
       if (bytes > MAX_RESPONSE_BYTES2) {
         await reader.cancel();
@@ -6189,10 +6565,17 @@ async function boot(options) {
   }
   const usage = createUsageTracker(session.usage, resolvePricing);
   let skillCatalogue = formatSkillCatalogue(skills);
+  let projectMemory = await readProjectMemory(workspaceRoot2);
+  const saveMemory = async (text) => {
+    await saveProjectMemory(workspaceRoot2, text);
+    projectMemory = await readProjectMemory(workspaceRoot2);
+  };
+  tools.register([createMemoryTool({ read: () => projectMemory, save: saveMemory })]);
   const mainSystemPrompt = () => buildSystemPrompt({
     cwd: options.cwd,
     toolNames: tools.list().map((tool) => tool.name),
-    skills: skillCatalogue
+    skills: skillCatalogue,
+    memory: projectMemory
   });
   let modelRef = session.model || config.model || "";
   if (options.modelRef) modelRef = options.modelRef;
@@ -6277,9 +6660,9 @@ async function boot(options) {
       activeAgents.push(entry);
       const trackedRequest = {
         ...request,
-        onProgress: (summary) => {
-          entry.progress.push(summary);
-          request.onProgress(summary);
+        onProgress: (summary2) => {
+          entry.progress.push(summary2);
+          request.onProgress(summary2);
         }
       };
       try {
@@ -6347,13 +6730,15 @@ async function boot(options) {
     needsSetup: () => Object.keys(config.providers).length === 0,
     async addProvider(url, key) {
       const detected = await detectProvider(url, key);
-      rememberModels(detected.id, detected.models);
+      for (const provider of detected) rememberModels(provider.id, provider.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);
+      for (const provider of detected) {
+        config.providers[provider.id] = provider.config;
+        auth[provider.id] = key;
+      }
+      const chosen = preferredDetectedModel(detected);
+      if (chosen) config.model = formatModelRef(chosen.providerId, chosen.model.id);
       try {
         await saveConfig(config);
         await saveAuth(auth);
@@ -6366,11 +6751,12 @@ async function boot(options) {
       }
       registry = createRegistry(config, auth);
       const nextRef = config.model ?? "";
-      const discovered = detected.models.find((model) => model.id === chosen)?.contextWindow;
-      activateModel(nextRef, void 0, discovered);
+      activateModel(nextRef, void 0, chosen?.model.contextWindow);
       void refreshModelContextWindow();
-      const kind = detected.config.type === "anthropic" ? "Anthropic" : "OpenAI-compatible";
-      return `${detected.id} \xB7 ${kind} \xB7 ${detected.models.length} models`;
+      return detected.map((provider) => {
+        const kind = provider.config.type === "anthropic" ? "Anthropic" : "OpenAI-compatible";
+        return `${provider.id} \xB7 ${kind} \xB7 ${provider.models.length} models`;
+      }).join("\n");
     },
     currentProviderId: () => parseModelRef(modelRef)?.provider,
     listProviderItems: () => Object.entries(config.providers).map(([id, entry]) => ({
@@ -6538,7 +6924,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");
+      const target = destination ? path14.resolve(options.cwd, destination) : path14.join(options.cwd, ".kitcode-exports");
       if (!destination) await mkdir6(target, { recursive: true, mode: 448 });
       return (await exportSession(id, target)).path;
     },
@@ -6553,6 +6939,21 @@ async function boot(options) {
       });
       void refreshModelContextWindow();
     },
+    readMemory: () => projectMemory,
+    async saveMemory(text) {
+      await saveMemory(text);
+    },
+    async clearMemory() {
+      await clearProjectMemory(workspaceRoot2);
+      projectMemory = "";
+    },
+    effortDescription(history) {
+      if (!modelRef) return "unavailable";
+      const { provider, modelId } = registry.resolve(modelRef);
+      const requested = resolveEffort(config.effort, history);
+      const effective = provider.kind === "openai" ? openAiEffort(modelId, requested) : requested;
+      return effective ? `${config.effort} \u2192 ${effective} (API request)` : `${config.effort} \u2192 not sent: unknown model support`;
+    },
     getEffort: () => config.effort,
     async setEffort(effort) {
       await persistConfig((draft) => {
@@ -6709,6 +7110,15 @@ ${lines.join("\n")}` : null;
       }
       return items;
     },
+    async refreshProviderModels(providerId) {
+      const models = await refreshModels(registry.get(providerId));
+      rememberModels(providerId, models);
+      if (parseModelRef(modelRef)?.provider === providerId) void refreshModelContextWindow();
+      return models.length;
+    },
+    async listWorkspaceFiles(query) {
+      return searchWorkspaceFiles(options.cwd, query);
+    },
     async listPromptItems() {
       const prompts2 = await listPrompts();
       return prompts2.map((prompt) => ({
@@ -6904,6 +7314,7 @@ ${lines.join("\n")}` : null;
       try {
         await Promise.all([persistQueue, configQueue]);
       } finally {
+        killAllJobs();
         await mcp.close();
       }
     }
@@ -6916,6 +7327,16 @@ function preferredModel(models) {
   }
   return models[0]?.id;
 }
+function preferredDetectedModel(detected) {
+  const candidates = detected.flatMap(
+    (provider) => provider.models.map((model) => ({ providerId: provider.id, model }))
+  );
+  for (const preferred of PREFERRED2) {
+    const match = candidates.find((candidate) => candidate.model.id.endsWith(preferred));
+    if (match) return match;
+  }
+  return candidates[0];
+}
 
 // src/app/ask.ts
 var RU_YES = /* @__PURE__ */ new Set(["y", "\u043D"]);
@@ -7184,6 +7605,7 @@ var COMMANDS = [
   { name: "provider" },
   { name: "logout", args: "[provider]" },
   { name: "key", args: "[provider]" },
+  { name: "refresh", args: "[provider]" },
   { name: "effort" },
   { name: "thinking" },
   { name: "budget", args: "[tokens]" },
@@ -7195,6 +7617,7 @@ var COMMANDS = [
   { name: "usage" },
   { name: "mcp", args: "[add|list|delete|enable|disable]" },
   { name: "attach", args: "<path|clipboard|clear>" },
+  { name: "memory", args: "[show|set <text>|clear]" },
   { name: "compact" },
   { name: "update" },
   { name: "checker" },
@@ -7232,22 +7655,22 @@ function matchCommands(line) {
   if (starts.length > 0) return starts;
   const contains = COMMANDS.filter((command) => command.name.includes(needle));
   if (contains.length > 0) return contains;
-  return COMMANDS.filter((command) => isSubsequence(needle, command.name));
+  return COMMANDS.filter((command) => isSubsequence2(needle, command.name));
 }
 function closestCommand(name) {
   const needle = name.toLowerCase();
   let best;
   let bestScore = Number.POSITIVE_INFINITY;
   for (const command of COMMANDS) {
-    const score = editDistance(needle, command.name);
-    if (score < bestScore) {
-      bestScore = score;
+    const score2 = editDistance(needle, command.name);
+    if (score2 < bestScore) {
+      bestScore = score2;
       best = command;
     }
   }
   return bestScore <= Math.max(2, Math.floor(needle.length / 2)) ? best : void 0;
 }
-function isSubsequence(needle, haystack) {
+function isSubsequence2(needle, haystack) {
   let index = 0;
   for (const character of haystack) {
     if (character === needle[index]) index += 1;
@@ -7272,6 +7695,43 @@ function editDistance(a, b) {
   return previous[b.length] ?? 0;
 }
 
+// src/ui/mentions.ts
+var MENTION_PATTERN = /(?:^|\s)@([^\s@]+)/g;
+var TRAILING_PUNCTUATION = /[,;:!?]+$/;
+function mentionSpan(value, cursor) {
+  const at = clamp(cursor, 0, value.length);
+  const before = value.slice(0, at);
+  const start = before.lastIndexOf("@");
+  if (start === -1) return null;
+  const preceding = start === 0 ? "" : value[start - 1] ?? "";
+  if (preceding !== "" && !/\s/.test(preceding)) return null;
+  const query = before.slice(start + 1);
+  if (/[\s@]/.test(query)) return null;
+  let end = at;
+  while (end < value.length && !/[\s@]/.test(value[end] ?? "")) end += 1;
+  return { start, end, query };
+}
+function completeMention(value, span, path15) {
+  const rest = value.slice(span.end);
+  const spaced = rest.startsWith(" ");
+  const inserted = `@${path15}${spaced ? "" : " "}`;
+  return {
+    value: value.slice(0, span.start) + inserted + rest,
+    cursor: span.start + inserted.length + (spaced ? 1 : 0)
+  };
+}
+function extractMentions(text) {
+  const found = [];
+  for (const match of text.matchAll(MENTION_PATTERN)) {
+    const path15 = (match[1] ?? "").replace(TRAILING_PUNCTUATION, "");
+    if (path15 !== "" && !found.includes(path15)) found.push(path15);
+  }
+  return found;
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+
 // src/ui/App.tsx
 import TextInput2 from "ink-text-input";
 
@@ -7373,6 +7833,7 @@ var en = {
   titleProvider: "Provider",
   titleLogout: "Sign out of a provider",
   titleKeyChange: "Change API key for a provider",
+  titleModelRefresh: "Reload models for a provider",
   titleSessions: "Resume a session",
   titleSessionAction: "Session action",
   resumed: (id, count) => `Resumed ${id} \u2014 ${count} messages restored`,
@@ -7388,7 +7849,7 @@ var en = {
   escHelp: "esc \u2014 cancel the running turn",
   cancelled: "Cancelled.",
   queued: (count) => `queued: ${count}`,
-  configAt: (path14) => `config: ${path14}`,
+  configAt: (path15) => `config: ${path15}`,
   skillsEmpty: "No skills installed. Drop a folder with a SKILL.md into ~/.kitcode/skills or ./.kitcode/skills",
   skillsInstallUsage: "Usage: /skills install <github-url|npm-package|local-path>",
   skillsInstalling: (source) => `Installing skill from "${source}"\u2026`,
@@ -7434,7 +7895,7 @@ var en = {
   sessionDeleteAllFinalBody: "This cannot be undone. Press y only if you want to erase the complete session history.",
   sessionsDeletedAll: (count) => `All saved chats deleted \xB7 ${count} sessions removed.`,
   sessionsDeleteAllFailed: (deleted, failed) => `Session cleanup was incomplete \xB7 ${deleted} removed, ${failed} failed.`,
-  sessionExported: (path14) => `Session exported to ${path14}`,
+  sessionExported: (path15) => `Session exported to ${path15}`,
   sessionActionResume: "resume",
   sessionActionRename: "rename",
   sessionActionDelete: "delete",
@@ -7452,6 +7913,7 @@ ${url}`,
   budgetUnlimited: "Token budget: unlimited (0). Set /budget <tokens> to restore a limit.",
   budgetInvalid: "Invalid budget: must be between 1,000 and 10,000,000",
   modelSet: (value) => `Model: ${value}`,
+  modelsRefreshed: (provider, count) => `${provider}: ${count} models reloaded from the endpoint.`,
   noModels: "No models available. Use /login to add a provider.",
   bypassOff: "Approval prompts are back on.",
   bypassAsk1: "Disable approval prompts for this session?",
@@ -7499,11 +7961,13 @@ ${url}`,
     provider: "switch between configured providers",
     logout: "choose a provider to sign out from",
     key: "change API key for a provider",
+    refresh: "reload the model list for a provider",
     effort: "set reasoning depth",
     thinking: "toggle reasoning",
     budget: "set token budget per turn",
     theme: "change the accent colour",
     lang: "change the interface language",
+    memory: "view, replace or clear project memory",
     prompt: "insert or save a prompt",
     "prompt save": "save the current or recent text as a prompt",
     "prompt delete": "delete a saved prompt",
@@ -7561,6 +8025,7 @@ var ru = {
   titleProvider: "\u041F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440",
   titleLogout: "\u0412\u044B\u0431\u0440\u0430\u0442\u044C API \u0434\u043B\u044F \u0432\u044B\u0445\u043E\u0434\u0430",
   titleKeyChange: "\u0421\u043C\u0435\u043D\u0438\u0442\u044C \u043A\u043B\u044E\u0447 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440\u0430",
+  titleModelRefresh: "\u041E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u043C\u043E\u0434\u0435\u043B\u0438 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440\u0430",
   titleSessions: "\u0412\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u044C \u0441\u0435\u0441\u0441\u0438\u044E",
   titleSessionAction: "\u0414\u0435\u0439\u0441\u0442\u0432\u0438\u0435 \u0441 \u0441\u0435\u0441\u0441\u0438\u0435\u0439",
   resumed: (id, count) => `\u0421\u0435\u0441\u0441\u0438\u044F ${id} \u0432\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0430 \u2014 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0439: ${count}`,
@@ -7576,7 +8041,7 @@ var ru = {
   escHelp: "esc \u2014 \u043E\u0442\u043C\u0435\u043D\u0438\u0442\u044C \u0442\u0435\u043A\u0443\u0449\u0438\u0439 \u0445\u043E\u0434",
   cancelled: "\u041E\u0442\u043C\u0435\u043D\u0435\u043D\u043E.",
   queued: (count) => `\u0432 \u043E\u0447\u0435\u0440\u0435\u0434\u0438: ${count}`,
-  configAt: (path14) => `\u043A\u043E\u043D\u0444\u0438\u0433: ${path14}`,
+  configAt: (path15) => `\u043A\u043E\u043D\u0444\u0438\u0433: ${path15}`,
   skillsEmpty: "\u0421\u043A\u0438\u043B\u043B\u043E\u0432 \u043D\u0435\u0442. \u041F\u043E\u043B\u043E\u0436\u0438 \u043F\u0430\u043F\u043A\u0443 \u0441 \u0444\u0430\u0439\u043B\u043E\u043C SKILL.md \u0432 ~/.kitcode/skills \u0438\u043B\u0438 ./.kitcode/skills",
   skillsInstallUsage: "\u0418\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435: /skills install <github-url|npm-\u043F\u0430\u043A\u0435\u0442|\u043B\u043E\u043A\u0430\u043B\u044C\u043D\u044B\u0439-\u043F\u0443\u0442\u044C>",
   skillsInstalling: (source) => `\u0423\u0441\u0442\u0430\u043D\u0430\u0432\u043B\u0438\u0432\u0430\u044E \u0441\u043A\u0438\u043B\u043B \u0438\u0437 "${source}"\u2026`,
@@ -7622,7 +8087,7 @@ var ru = {
   sessionDeleteAllFinalBody: "\u042D\u0442\u043E \u043D\u0435\u043B\u044C\u0437\u044F \u043E\u0442\u043C\u0435\u043D\u0438\u0442\u044C. \u041D\u0430\u0436\u0438\u043C\u0430\u0439 y \u0442\u043E\u043B\u044C\u043A\u043E \u0435\u0441\u043B\u0438 \u0445\u043E\u0447\u0435\u0448\u044C \u0441\u0442\u0435\u0440\u0435\u0442\u044C \u0432\u0441\u044E \u0438\u0441\u0442\u043E\u0440\u0438\u044E \u0441\u0435\u0441\u0441\u0438\u0439.",
   sessionsDeletedAll: (count) => `\u0412\u0441\u0435 \u0441\u043E\u0445\u0440\u0430\u043D\u0451\u043D\u043D\u044B\u0435 \u0447\u0430\u0442\u044B \u0443\u0434\u0430\u043B\u0435\u043D\u044B \xB7 \u0441\u0435\u0441\u0441\u0438\u0439: ${count}.`,
   sessionsDeleteAllFailed: (deleted, failed) => `\u0423\u0434\u0430\u043B\u0435\u043D\u0438\u0435 \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u043E \u043D\u0435 \u043F\u043E\u043B\u043D\u043E\u0441\u0442\u044C\u044E \xB7 \u0443\u0434\u0430\u043B\u0435\u043D\u043E: ${deleted}, \u043E\u0448\u0438\u0431\u043E\u043A: ${failed}.`,
-  sessionExported: (path14) => `\u0421\u0435\u0441\u0441\u0438\u044F \u044D\u043A\u0441\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u0430: ${path14}`,
+  sessionExported: (path15) => `\u0421\u0435\u0441\u0441\u0438\u044F \u044D\u043A\u0441\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u0430: ${path15}`,
   sessionActionResume: "\u043E\u0442\u043A\u0440\u044B\u0442\u044C",
   sessionActionRename: "\u043F\u0435\u0440\u0435\u0438\u043C\u0435\u043D\u043E\u0432\u0430\u0442\u044C",
   sessionActionDelete: "\u0443\u0434\u0430\u043B\u0438\u0442\u044C",
@@ -7640,6 +8105,7 @@ ${url}`,
   budgetUnlimited: "\u041B\u0438\u043C\u0438\u0442 \u0442\u043E\u043A\u0435\u043D\u043E\u0432: \u0431\u0435\u0437\u043B\u0438\u043C\u0438\u0442\u043D\u044B\u0439 (0). \u0412\u0432\u0435\u0434\u0438 /budget <\u0447\u0438\u0441\u043B\u043E> \u0447\u0442\u043E\u0431\u044B \u0432\u0435\u0440\u043D\u0443\u0442\u044C \u043B\u0438\u043C\u0438\u0442.",
   budgetInvalid: "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u043B\u0438\u043C\u0438\u0442: \u043E\u0442 1 000 \u0434\u043E 10 000 000",
   modelSet: (value) => `\u041C\u043E\u0434\u0435\u043B\u044C: ${value}`,
+  modelsRefreshed: (provider, count) => `${provider}: \u0441 \u044D\u043D\u0434\u043F\u043E\u0438\u043D\u0442\u0430 \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E \u043C\u043E\u0434\u0435\u043B\u0435\u0439 \u2014 ${count}.`,
   noModels: "\u041C\u043E\u0434\u0435\u043B\u0435\u0439 \u043D\u0435\u0442. \u0414\u043E\u0431\u0430\u0432\u044C \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440\u0430 \u0447\u0435\u0440\u0435\u0437 /login.",
   bypassOff: "\u041F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u044F \u0441\u043D\u043E\u0432\u0430 \u0432\u043A\u043B\u044E\u0447\u0435\u043D\u044B.",
   bypassAsk1: "\u041E\u0442\u043A\u043B\u044E\u0447\u0438\u0442\u044C \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u044F \u043D\u0430 \u044D\u0442\u0443 \u0441\u0435\u0441\u0441\u0438\u044E?",
@@ -7687,11 +8153,13 @@ ${url}`,
     provider: "\u043F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0438\u0442\u044C\u0441\u044F \u043C\u0435\u0436\u0434\u0443 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440\u0430\u043C\u0438",
     logout: "\u0432\u044B\u0431\u0440\u0430\u0442\u044C \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440\u0430 \u0438 \u0443\u0434\u0430\u043B\u0438\u0442\u044C \u0435\u0433\u043E \u043A\u043B\u044E\u0447",
     key: "\u0441\u043C\u0435\u043D\u0438\u0442\u044C \u043A\u043B\u044E\u0447 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440\u0430",
+    refresh: "\u043E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u0441\u043F\u0438\u0441\u043E\u043A \u043C\u043E\u0434\u0435\u043B\u0435\u0439 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440\u0430",
     effort: "\u0433\u043B\u0443\u0431\u0438\u043D\u0430 \u0440\u0430\u0437\u043C\u044B\u0448\u043B\u0435\u043D\u0438\u0439",
     thinking: "\u0432\u043A\u043B\u044E\u0447\u0438\u0442\u044C/\u0432\u044B\u043A\u043B\u044E\u0447\u0438\u0442\u044C \u0440\u0430\u0437\u043C\u044B\u0448\u043B\u0435\u043D\u0438\u044F",
     budget: "\u043B\u0438\u043C\u0438\u0442 \u0442\u043E\u043A\u0435\u043D\u043E\u0432 \u0437\u0430 \u0445\u043E\u0434 (0 = \u0431\u0435\u0437\u043B\u0438\u043C\u0438\u0442)",
     theme: "\u0441\u043C\u0435\u043D\u0438\u0442\u044C \u0446\u0432\u0435\u0442 \u0430\u043A\u0446\u0435\u043D\u0442\u0430",
     lang: "\u0441\u043C\u0435\u043D\u0438\u0442\u044C \u044F\u0437\u044B\u043A \u0438\u043D\u0442\u0435\u0440\u0444\u0435\u0439\u0441\u0430",
+    memory: "\u043F\u043E\u043A\u0430\u0437\u0430\u0442\u044C, \u0437\u0430\u043C\u0435\u043D\u0438\u0442\u044C \u0438\u043B\u0438 \u043E\u0447\u0438\u0441\u0442\u0438\u0442\u044C \u043F\u0430\u043C\u044F\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442\u0430",
     prompt: "\u0432\u0441\u0442\u0430\u0432\u0438\u0442\u044C \u0438\u043B\u0438 \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u043F\u0440\u043E\u043C\u0442",
     skills: "\u0441\u043F\u0438\u0441\u043E\u043A \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u043D\u044B\u0445 \u0441\u043A\u0438\u043B\u043B\u043E\u0432",
     "prompt delete": "\u0443\u0434\u0430\u043B\u0438\u0442\u044C \u0441\u043E\u0445\u0440\u0430\u043D\u0451\u043D\u043D\u044B\u0439 \u043F\u0440\u043E\u043C\u0442",
@@ -8174,7 +8642,8 @@ var PromptInput = memo(function PromptInput2({
   pending,
   hint,
   history,
-  attachments = []
+  attachments = [],
+  onListFiles
 }) {
   const theme = useTheme();
   const { columns } = useTerminalSize();
@@ -8189,9 +8658,28 @@ var PromptInput = memo(function PromptInput2({
   const cursorRef = useRef2(inputCursor);
   valueRef.current = safeValue;
   cursorRef.current = inputCursor;
-  const suggestions = matchCommands(safeValue);
-  const open3 = suggestions.length > 0;
-  const active2 = Math.min(selectionCursor, Math.max(0, suggestions.length - 1));
+  const commandSuggestions = matchCommands(safeValue);
+  const mention = onListFiles ? mentionSpan(safeValue, inputCursor) : null;
+  const [files, setFiles] = useState4([]);
+  const mentionQuery = mention?.query ?? null;
+  useEffect(() => {
+    if (mentionQuery === null || !onListFiles) {
+      setFiles([]);
+      return;
+    }
+    let live = true;
+    void onListFiles(mentionQuery).then((found) => {
+      if (live) setFiles(found);
+    });
+    return () => {
+      live = false;
+    };
+  }, [mentionQuery, onListFiles]);
+  const showFiles = mention !== null && files.length > 0;
+  const suggestions = showFiles ? [] : commandSuggestions;
+  const open3 = suggestions.length > 0 || showFiles;
+  const optionCount = showFiles ? files.length : suggestions.length;
+  const active2 = Math.min(selectionCursor, Math.max(0, optionCount - 1));
   useEffect(() => {
     setSelectionCursor(0);
   }, [safeValue]);
@@ -8199,14 +8687,14 @@ var PromptInput = memo(function PromptInput2({
     const length = characters2(safeValue).length;
     if (pendingValue.current === safeValue) {
       pendingValue.current = null;
-      setInputCursor((cursor) => clamp(cursor, 0, length));
+      setInputCursor((cursor) => clamp2(cursor, 0, length));
       return;
     }
     setInputCursor(length);
   }, [safeValue]);
   const change = (next, cursor = characters2(next).length) => {
     next = sanitizeTerminalText(next);
-    const nextCursor2 = clamp(cursor, 0, characters2(next).length);
+    const nextCursor2 = clamp2(cursor, 0, characters2(next).length);
     pendingValue.current = next;
     valueRef.current = next;
     cursorRef.current = nextCursor2;
@@ -8224,7 +8712,7 @@ var PromptInput = memo(function PromptInput2({
     const inserted = characters2(sanitizeTerminalText(pasted));
     if (inserted.length === 0) return;
     const valueCharacters = characters2(valueRef.current);
-    const cursor = clamp(cursorRef.current, 0, valueCharacters.length);
+    const cursor = clamp2(cursorRef.current, 0, valueCharacters.length);
     valueCharacters.splice(cursor, 0, ...inserted);
     change(valueCharacters.join(""), cursor + inserted.length);
   };
@@ -8248,7 +8736,15 @@ var PromptInput = memo(function PromptInput2({
       return;
     }
     if (open3 && key.downArrow) {
-      setSelectionCursor(Math.min(suggestions.length - 1, active2 + 1));
+      setSelectionCursor(Math.min(optionCount - 1, active2 + 1));
+      return;
+    }
+    if (showFiles && (key.tab || key.return) && !key.shift) {
+      const chosen = files[active2];
+      if (chosen && mention) {
+        const completed = completeMention(safeValue, mention, chosen);
+        change(completed.value, completed.cursor);
+      }
       return;
     }
     if (open3 && key.tab && !key.shift) {
@@ -8286,7 +8782,7 @@ var PromptInput = memo(function PromptInput2({
       return;
     }
     const valueCharacters = characters2(safeValue);
-    const cursor = clamp(inputCursor, 0, valueCharacters.length);
+    const cursor = clamp2(inputCursor, 0, valueCharacters.length);
     if (key.leftArrow || key.rightArrow || key.home || key.end) {
       setInputCursor(nextCursor(cursor, valueCharacters.length, key));
       return;
@@ -8313,6 +8809,7 @@ var PromptInput = memo(function PromptInput2({
   });
   const start = Math.max(0, Math.min(active2 - WINDOW2 + 2, suggestions.length - WINDOW2));
   const visible = suggestions.slice(start, start + WINDOW2);
+  const fileStart = Math.max(0, Math.min(active2 - WINDOW2 + 2, files.length - WINDOW2));
   return /* @__PURE__ */ jsxs8(Box8, { width: columns, maxWidth: "100%", flexDirection: "column", marginTop: 1, flexShrink: 0, children: [
     /* @__PURE__ */ jsxs8(
       Box8,
@@ -8341,6 +8838,18 @@ var PromptInput = memo(function PromptInput2({
       "  ",
       sanitizeTerminalText(hint)
     ] }),
+    showFiles && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginLeft: 2, children: [
+      files.slice(fileStart, fileStart + WINDOW2).map((file, index) => {
+        const selected = fileStart + index === active2;
+        return /* @__PURE__ */ jsxs8(Text8, { color: selected ? theme.accent : void 0, dimColor: !selected, children: [
+          selected ? "\u276F " : "  ",
+          "@",
+          sanitizeTerminalText(file)
+        ] }, file);
+      }),
+      files.length > WINDOW2 && /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: strings.more(files.length - WINDOW2) }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: strings.suggestHelp })
+    ] }),
     open3 && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginLeft: 2, children: [
       visible.map((command, index) => {
         const selected = start + index === active2;
@@ -8366,7 +8875,7 @@ function EditableText({
   placeholder
 }) {
   const valueCharacters = characters2(value);
-  const at = clamp(cursor, 0, valueCharacters.length);
+  const at = clamp2(cursor, 0, valueCharacters.length);
   if (valueCharacters.length === 0) {
     const placeholderCharacters = characters2(sanitizeTerminalText(placeholder));
     return /* @__PURE__ */ jsxs8(Text8, { children: [
@@ -8390,7 +8899,7 @@ function nextCursor(cursor, length, key) {
 function characters2(value) {
   return [...value];
 }
-function clamp(value, min, max) {
+function clamp2(value, min, max) {
   return Math.max(min, Math.min(value, max));
 }
 
@@ -8545,6 +9054,7 @@ function ModelBadge({ ref: modelRef }) {
   return /* @__PURE__ */ jsx9(Box9, { borderColor: theme.accent, borderStyle: "round", paddingX: 1, children: /* @__PURE__ */ jsx9(Text9, { color: theme.accent, bold: true, children: name }) });
 }
 var EFFORT_STYLES = {
+  auto: { label: "auto", color: "cyan" },
   max: { label: "max", color: "red", bold: true },
   xhigh: { label: "xhigh", color: "yellow", bold: true },
   high: { label: "high", color: "cyan" },
@@ -8638,13 +9148,18 @@ import Spinner2 from "ink-spinner";
 import stringWidth2 from "string-width";
 
 // src/ui/markdown.tsx
-import { Box as Box11, Text as Text10 } from "ink";
-import { Fragment as Fragment4, useMemo as useMemo3 } from "react";
+import { Box as Box11, Text as InkText } from "ink";
+import { createContext as createContext3, Fragment as Fragment4, useContext as useContext3, useMemo as useMemo3 } from "react";
 import stringWidth from "string-width";
 import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
-function Markdown({ children }) {
+var DimContext = createContext3(false);
+function Text10({ dimColor, ...props }) {
+  const dim = useContext3(DimContext);
+  return /* @__PURE__ */ jsx11(InkText, { ...props, dimColor: dimColor ?? dim });
+}
+function Markdown({ children, dim = false }) {
   const blocks = useMemo3(() => extractBlocks(children), [children]);
-  return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: blocks.map((block, i) => /* @__PURE__ */ jsx11(BlockView, { block }, i)) });
+  return /* @__PURE__ */ jsx11(DimContext.Provider, { value: dim, children: /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: blocks.map((block, i) => /* @__PURE__ */ jsx11(BlockView, { block }, i)) }) });
 }
 function BlockView({ block }) {
   switch (block.type) {
@@ -9292,7 +9807,7 @@ function AssistantView({ bubble: source, maxRows }) {
   const usedThinkingRows = frameThinking === "" ? 0 : frameThinking.split("\n").length;
   const frameText = liveBudget === void 0 ? bubble.text : clipTextToRows(bubble.text, Math.max(1, liveBudget - usedThinkingRows), columns);
   return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", marginTop: 1, children: [
-    frameThinking !== "" && /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", maxHeight: thinkingBudget, overflowY: "hidden", children: /* @__PURE__ */ jsx12(Markdown, { children: frameThinking }) }),
+    frameThinking !== "" && /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", maxHeight: thinkingBudget, overflowY: "hidden", children: /* @__PURE__ */ jsx12(Markdown, { dim: true, children: frameThinking }) }),
     bubble.streaming ? /* @__PURE__ */ jsx12(Text11, { children: frameText }) : /* @__PURE__ */ jsx12(Markdown, { children: bubble.text }),
     bubble.streaming && bubble.text === "" && /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
       /* @__PURE__ */ jsx12(Spinner2, { type: "dots" }),
@@ -9624,7 +10139,7 @@ function sanitizeDisplay(display) {
 
 // src/ui/App.tsx
 import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
-var EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+var EFFORTS = ["auto", "low", "medium", "high", "xhigh", "max"];
 var STREAM_FRAME_MS = 50;
 var MAX_ATTACHMENTS = 8;
 function App({
@@ -9796,6 +10311,11 @@ function App({
       })
     };
     try {
+      try {
+        await runtime.persist(history.current);
+      } catch (error) {
+        notice("error", error instanceof Error ? error.message : String(error));
+      }
       history.current = await runtime.run(history.current, hooks, controller.signal);
       void runtime.persist(history.current).catch((error) => notice("error", error instanceof Error ? error.message : String(error)));
     } catch (error) {
@@ -10123,6 +10643,29 @@ ${strings.modelSet(result.nextModel)}` : ""}`;
           }
           return;
         }
+        case "refresh": {
+          const providers = runtime.listProviderItems();
+          if (providers.length === 0) {
+            notice("warn", strings.logoutNothing);
+            return;
+          }
+          let providerId = rest[0];
+          if (!providerId) {
+            providerId = providers.length === 1 ? providers[0]?.key : await pick(strings.titleModelRefresh, providers) ?? void 0;
+          }
+          if (!providerId) return;
+          if (!providers.some((provider) => provider.key === providerId)) {
+            notice("warn", `Provider "${providerId}" is not configured.`);
+            return;
+          }
+          try {
+            const count = await runtime.refreshProviderModels(providerId);
+            notice("info", strings.modelsRefreshed(providerId, count));
+          } catch (error) {
+            notice("error", error instanceof Error ? error.message : String(error));
+          }
+          return;
+        }
         case "lang": {
           const choice = await pick(
             strings.titleLang,
@@ -10476,14 +11019,27 @@ ${strings.mcpAddUsage}`
           forceRender((n) => n + 1);
           return;
         }
+        case "memory": {
+          if (rawRest === "clear") {
+            if (await ask2(lang === "ru" ? "\u041E\u0447\u0438\u0441\u0442\u0438\u0442\u044C \u043F\u0430\u043C\u044F\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442\u0430?" : "Clear project memory?")) await runtime.clearMemory();
+          } else if (rawRest.startsWith("set ")) {
+            await runtime.saveMemory(rawRest.slice(4).trim());
+          } else if (rawRest !== "" && rawRest !== "show") {
+            notice("warn", "/memory show | /memory set <text> | /memory clear");
+            return;
+          }
+          notice("info", runtime.readMemory() || (lang === "ru" ? "\u041F\u0430\u043C\u044F\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u043F\u0443\u0441\u0442\u0430." : "Project memory is empty."));
+          return;
+        }
         case "effort": {
-          const choice = await pick(
+          notice("info", runtime.effortDescription(history.current));
+          const choice = EFFORTS.includes(rawRest) ? rawRest : await pick(
             strings.titleEffort,
             EFFORTS.map((effort) => ({ key: effort, label: effort }))
           );
           if (!choice) return;
           await runtime.setEffort(choice);
-          notice("info", strings.effortSet(choice));
+          notice("info", `${strings.effortSet(choice)} \xB7 ${runtime.effortDescription(history.current)}`);
           forceRender((n) => n + 1);
           return;
         }
@@ -10704,6 +11260,10 @@ Rename the file if you want a different name.`);
     },
     [appendAttachment, notice, runtime, strings]
   );
+  const listWorkspaceFiles = useCallback(
+    (query) => runtime.listWorkspaceFiles(query).catch(() => []),
+    [runtime]
+  );
   const pasteClipboardImage = useCallback(() => {
     if (clipboardPasteTask.current) return;
     if (attachmentsRef.current.length >= MAX_ATTACHMENTS) {
@@ -10767,11 +11327,21 @@ Rename the file if you want a different name.`);
       }
       const queuedAttachments = attachmentsRef.current;
       if (!text && queuedAttachments.length === 0) return;
+      const mentioned = [];
+      for (const path15 of extractMentions(text)) {
+        if (queuedAttachments.length + mentioned.length >= MAX_ATTACHMENTS) break;
+        try {
+          mentioned.push(await runtime.loadAttachment(path15));
+        } catch {
+        }
+      }
+      if (generation !== attachmentGeneration.current) return;
       if (text) setPromptHistory((state) => appendInputHistory(state, text));
       if (!detachedInput) setInput("");
       const content = [
         ...text ? [{ type: "text", text }] : [],
-        ...queuedAttachments
+        ...queuedAttachments,
+        ...mentioned
       ];
       replaceAttachments([]);
       const item = { kind: "message", text, content };
@@ -10846,11 +11416,11 @@ Rename the file if you want a different name.`);
         Onboarding,
         {
           onSubmit: async (url, key) => {
-            const summary = await runtime.addProvider(url, key);
+            const summary2 = await runtime.addProvider(url, key);
             setSetup(false);
-            notice("info", `${summary}
+            notice("info", `${summary2}
 ${strings.configAt(runtime.configPath())}`);
-            return summary;
+            return summary2;
           }
         }
       )
@@ -10927,6 +11497,7 @@ ${strings.configAt(runtime.configPath())}`);
           onSubmit: submit,
           onPastePath: tryQueueAutomaticAttachment,
           onPasteImage: pasteClipboardImage,
+          onListFiles: listWorkspaceFiles,
           disabled: busy,
           pending: pendingCount,
           hint: busy ? strings.escCancel : void 0,