@kernelonpanic/kitcode 1.2.9 → 1.3.0

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"),
@@ -1024,14 +1024,120 @@ 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/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 +1156,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 +1183,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 +1206,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 +1232,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 +1257,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 +1278,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 +1292,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 +1322,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 +1402,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) {
@@ -1867,20 +1973,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";
+import path6 from "path";
 
 // src/tools/safepath.ts
 import { realpathSync } from "fs";
@@ -1975,7 +2081,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 +2112,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 +2126,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 +2182,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 +2199,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 +2211,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 +2220,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 +2250,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 +2263,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 +2279,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 +2311,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,19 +2331,11 @@ function assertSessionId2(id) {
 }
 
 // src/core/diagnostics.ts
-import { readFile as readFile5, stat as stat4 } from "fs/promises";
-import path6 from "path";
+import { readFile as readFile6, stat as stat4 } from "fs/promises";
+import path7 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;
-}
-
-// src/tools/bash.ts
 var DEFAULT_TIMEOUT = 12e4;
 var MAX_TIMEOUT = 6e5;
 var MAX_OUTPUT = 1e5;
@@ -2377,7 +2475,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,11 +2484,11 @@ 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);
@@ -2480,7 +2578,7 @@ 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 +2592,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 +2612,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 +2645,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 +2654,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 +2664,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 +2684,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 +2723,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 +2757,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 +2770,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 +2925,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 +2978,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) {
@@ -3283,6 +3381,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 +3637,7 @@ function clip(value) {
 // package.json
 var package_default = {
   name: "@kernelonpanic/kitcode",
-  version: "1.2.9",
+  version: "1.3.0",
   description: "Terminal coding agent with a config you never have to write by hand",
   type: "module",
   license: "MIT",
@@ -3601,7 +3705,7 @@ var package_default = {
 
 // src/version.ts
 var KITCODE_VERSION = package_default.version;
-var KITCODE_COMMIT = true ? "cc499fc443e73408f49b928f204b77c48e9d2d05" : "development";
+var KITCODE_COMMIT = true ? "7cd983ca3dc89406326e5e513870686036c3ab9c" : "development";
 
 // src/mcp/client.ts
 var clientInfo = { name: "kitcode", version: KITCODE_VERSION };
@@ -3892,8 +3996,8 @@ 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"];
@@ -3986,8 +4090,8 @@ 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) {
@@ -4009,11 +4113,11 @@ async function loadModels(provider, refresh = false) {
   return models;
 }
 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 +4148,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 +4298,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 +4487,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,
@@ -4683,11 +4790,11 @@ function isFileEdit(tool) {
 }
 
 // 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 { chmod as chmod5, lstat as lstat3, open, rename as rename5, rm as rm4 } from "fs/promises";
 import { basename as basename2, dirname as dirname2, join } from "path";
 var UnsafeFileChangeError = class extends Error {
   constructor(message) {
@@ -4750,7 +4857,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 +4952,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 +5014,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 }
     };
   }
 };
@@ -4946,11 +5053,11 @@ var globTool = {
     return `glob(${brief(input.pattern)})`;
   },
   async execute(input, ctx) {
-    const { pattern, path: path14 = "." } = input;
+    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, path14);
+    const safe = resolveInside(ctx.cwd, path15);
     if (!safe.ok) return { content: safe.reason, isError: true };
     const entries = await fg(pattern, {
       cwd: safe.path,
@@ -4972,12 +5079,12 @@ var globTool = {
 };
 
 // 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";
 
 // src/tools/sensitive.ts
-import path9 from "path";
+import path10 from "path";
 var sensitiveNames = /* @__PURE__ */ new Set([
   ".npmrc",
   ".pypirc",
@@ -5004,9 +5111,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 +5231,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,10 +5255,10 @@ 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 };
+    if (!target) return { content: `Path not found: ${path15}`, isError: true };
     const discovered = target.isDirectory() ? (await fg2(glob, {
       cwd: safe.path,
       dot: false,
@@ -5182,7 +5289,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 +5319,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 +5348,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 +5398,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,64 +5418,64 @@ 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 }
     };
   }
 };
@@ -5397,8 +5504,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 +5517,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 +5528,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 +5544,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 +5552,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 +5610,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 +5623,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 +5663,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 +5763,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 +5789,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 +5824,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 +5845,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 +5879,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 +5911,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 +5964,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}`);
@@ -6189,10 +6296,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;
@@ -6538,7 +6652,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 +6667,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) => {
@@ -7195,6 +7324,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" },
@@ -7388,7 +7518,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 +7564,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",
@@ -7504,6 +7634,7 @@ ${url}`,
     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",
@@ -7576,7 +7707,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 +7753,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",
@@ -7692,6 +7823,7 @@ ${url}`,
     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",
@@ -8545,6 +8677,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" },
@@ -9624,7 +9757,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({
@@ -10476,14 +10609,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;
         }