@tractorscorch/clank 1.3.1 → 1.4.1

package/dist/index.js

@@ -297,6 +297,67 @@ ${summary.trim()}`,
   }
 });
 
+// src/memory/auto-persist.ts
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+function shouldPersist(userMessage) {
+  return PERSIST_TRIGGERS.some((pattern) => pattern.test(userMessage));
+}
+function extractMemory(userMessage) {
+  const rememberMatch = userMessage.match(/remember\s+(?:that\s+)?(.+)/i);
+  if (rememberMatch) return rememberMatch[1].trim();
+  for (const pattern of PERSIST_TRIGGERS) {
+    if (pattern.test(userMessage)) {
+      const firstSentence = userMessage.split(/[.!?\n]/)[0]?.trim();
+      return firstSentence && firstSentence.length < 200 ? firstSentence : userMessage.slice(0, 200);
+    }
+  }
+  return null;
+}
+async function appendToMemory(workspaceDir, entry) {
+  const memoryPath = join(workspaceDir, "MEMORY.md");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const newEntry = `
+- [${timestamp}] ${entry}`;
+  if (existsSync(memoryPath)) {
+    const existing = await readFile(memoryPath, "utf-8");
+    if (existing.includes(entry)) return;
+    const lines = existing.split("\n");
+    if (lines.length > 200) return;
+    await writeFile(memoryPath, existing.trimEnd() + newEntry + "\n", "utf-8");
+  } else {
+    await writeFile(
+      memoryPath,
+      `# MEMORY.md \u2014 Persistent Memory
+
+Things learned across sessions:
+${newEntry}
+`,
+      "utf-8"
+    );
+  }
+}
+var PERSIST_TRIGGERS;
+var init_auto_persist = __esm({
+  "src/memory/auto-persist.ts"() {
+    "use strict";
+    init_esm_shims();
+    PERSIST_TRIGGERS = [
+      /remember\s+(that|this|:)/i,
+      /don'?t\s+forget/i,
+      /always\s+(use|do|make|keep)/i,
+      /never\s+(use|do|make)/i,
+      /my\s+(name|email|timezone|preference)/i,
+      /i\s+(prefer|like|want|need|use)\s/i,
+      /from now on/i,
+      /going forward/i,
+      /important:\s/i,
+      /note:\s/i
+    ];
+  }
+});
+
 // src/providers/types.ts
 var BaseProvider;
 var init_types = __esm({
@@ -685,6 +746,7 @@ var init_agent = __esm({
     "use strict";
     init_esm_shims();
     init_context_engine();
+    init_auto_persist();
     init_ollama();
     init_prompt_fallback();
     MAX_ITERATIONS = 50;
@@ -731,6 +793,9 @@ var init_agent = __esm({
           const ctxSize = await this.resolvedProvider.provider.detectContextWindow();
           this.contextEngine.setContextWindow(ctxSize);
         }
+        if (this.contextEngine.needsCompaction()) {
+          await this.contextEngine.compactSmart();
+        }
       }
       /** Cancel the current request */
       cancel() {
@@ -748,6 +813,13 @@ var init_agent = __esm({
         this.abortController = new AbortController();
         const signal = this.abortController.signal;
         this.contextEngine.ingest({ role: "user", content: text });
+        if (shouldPersist(text)) {
+          const memory = extractMemory(text);
+          if (memory) {
+            appendToMemory(this.identity.workspace, memory).catch(() => {
+            });
+          }
+        }
         if (this.currentSession && !this.currentSession.label) {
           const label = text.length > 60 ? text.slice(0, 57) + "..." : text;
           await this.sessionStore.setLabel(this.currentSession.normalizedKey, label);
@@ -788,36 +860,58 @@ var init_agent = __esm({
             const toolCalls = [];
             let promptTokens = 0;
             let outputTokens = 0;
+            let streamSuccess = false;
             this.emit("response-start");
-            for await (const event of activeProvider.stream(
-              this.contextEngine.getMessages(),
-              this.systemPrompt,
-              toolDefs,
-              signal
-            )) {
-              switch (event.type) {
-                case "text":
-                  iterationText += event.content;
-                  this.emit("token", { content: event.content });
-                  break;
-                case "thinking":
-                  this.emit("thinking-start");
-                  break;
-                case "tool_call":
-                  toolCalls.push({
-                    id: event.id,
-                    name: event.name,
-                    arguments: event.arguments
+            for (let attempt = 0; attempt < 2; attempt++) {
+              try {
+                const streamIterator = activeProvider.stream(
+                  this.contextEngine.getMessages(),
+                  this.systemPrompt,
+                  toolDefs,
+                  signal
+                );
+                for await (const event of streamIterator) {
+                  switch (event.type) {
+                    case "text":
+                      iterationText += event.content;
+                      this.emit("token", { content: event.content });
+                      break;
+                    case "thinking":
+                      this.emit("thinking-start");
+                      break;
+                    case "tool_call":
+                      toolCalls.push({
+                        id: event.id,
+                        name: event.name,
+                        arguments: event.arguments
+                      });
+                      break;
+                    case "usage":
+                      promptTokens = event.promptTokens;
+                      outputTokens = event.outputTokens;
+                      break;
+                    case "done":
+                      break;
+                  }
+                }
+                streamSuccess = true;
+                break;
+              } catch (streamErr) {
+                if (attempt === 0 && !signal.aborted) {
+                  this.emit("error", {
+                    message: `Model connection failed, retrying... (${streamErr instanceof Error ? streamErr.message : "unknown"})`,
+                    recoverable: true
                   });
-                  break;
-                case "usage":
-                  promptTokens = event.promptTokens;
-                  outputTokens = event.outputTokens;
-                  break;
-                case "done":
-                  break;
+                  await new Promise((r) => setTimeout(r, 2e3));
+                  continue;
+                }
+                throw streamErr;
               }
             }
+            if (!streamSuccess) {
+              this.emit("error", { message: "Model failed to respond after retry", recoverable: false });
+              break;
+            }
             this.emit("usage", {
               promptTokens,
               outputTokens,
@@ -956,30 +1050,47 @@ __export(system_prompt_exports, {
   buildSystemPrompt: () => buildSystemPrompt,
   ensureWorkspaceFiles: () => ensureWorkspaceFiles
 });
-import { readFile } from "fs/promises";
-import { existsSync } from "fs";
-import { join } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 import { platform, hostname } from "os";
 async function buildSystemPrompt(opts) {
   const parts = [];
-  const workspaceContent = await loadWorkspaceFiles(opts.workspaceDir);
-  if (workspaceContent) {
-    parts.push(workspaceContent);
-    parts.push("---");
-  }
-  parts.push("## Runtime");
-  parts.push(`Agent: ${opts.identity.name} (${opts.identity.id})`);
-  parts.push(`Model: ${opts.identity.model.primary}`);
-  parts.push(`Workspace: ${opts.identity.workspace}`);
-  parts.push(`Platform: ${platform()} (${hostname()})`);
-  parts.push(`Channel: ${opts.channel || "cli"}`);
-  parts.push(`Tool tier: ${opts.identity.toolTier}`);
+  const compact = opts.compact ?? false;
+  if (!compact) {
+    const workspaceContent = await loadWorkspaceFiles(opts.workspaceDir);
+    if (workspaceContent) {
+      parts.push(workspaceContent);
+      parts.push("---");
+    }
+  }
+  if (compact) {
+    parts.push(`Agent: ${opts.identity.name} | Model: ${opts.identity.model.primary} | Dir: ${opts.identity.workspace}`);
+  } else {
+    parts.push("## Runtime");
+    parts.push(`Agent: ${opts.identity.name} (${opts.identity.id})`);
+    parts.push(`Model: ${opts.identity.model.primary}`);
+    parts.push(`Workspace: ${opts.identity.workspace}`);
+    parts.push(`Platform: ${platform()} (${hostname()})`);
+    parts.push(`Channel: ${opts.channel || "cli"}`);
+    parts.push(`Tool tier: ${opts.identity.toolTier}`);
+  }
   parts.push("");
-  parts.push("## Instructions");
-  parts.push("You are a helpful AI assistant with access to tools for reading/writing files, running commands, and more.");
-  parts.push("Be concise and direct. Use tools proactively to accomplish tasks.");
-  parts.push("When you need to make changes, read the relevant files first to understand the context.");
-  parts.push("You can configure yourself \u2014 use the config, channel, agent, and model management tools to modify your own setup.");
+  if (compact) {
+    parts.push("You are a helpful AI assistant with tools. Be concise. Use tools proactively. Read files before editing.");
+  } else {
+    parts.push("## Instructions");
+    parts.push("You are a helpful AI assistant with access to tools for reading/writing files, running commands, and more.");
+    parts.push("Be concise and direct. Use tools proactively to accomplish tasks.");
+    parts.push("When you need to make changes, read the relevant files first to understand the context.");
+    parts.push("You can configure yourself \u2014 use the config, channel, agent, and model management tools to modify your own setup.");
+  }
+  if (opts.thinking === "off") {
+    parts.push("");
+    parts.push("Do NOT use extended thinking or reasoning blocks. Respond directly and concisely.");
+  }
+  parts.push("");
+  parts.push("When you learn something important about the user or project, save it using the config or memory tools so you remember it next time.");
   parts.push("");
   const projectMemory = await loadProjectMemory(opts.identity.workspace);
   if (projectMemory) {
@@ -992,10 +1103,10 @@ async function buildSystemPrompt(opts) {
 async function loadWorkspaceFiles(workspaceDir) {
   const sections = [];
   for (const filename of WORKSPACE_FILES) {
-    const filePath = join(workspaceDir, filename);
-    if (existsSync(filePath)) {
+    const filePath = join2(workspaceDir, filename);
+    if (existsSync2(filePath)) {
       try {
-        const content = await readFile(filePath, "utf-8");
+        const content = await readFile2(filePath, "utf-8");
         if (content.trim()) {
           sections.push(content.trim());
         }
@@ -1008,10 +1119,10 @@ async function loadWorkspaceFiles(workspaceDir) {
 async function loadProjectMemory(projectRoot) {
   const candidates = [".clank.md", ".clankbuild.md", ".llamabuild.md"];
   for (const filename of candidates) {
-    const filePath = join(projectRoot, filename);
-    if (existsSync(filePath)) {
+    const filePath = join2(projectRoot, filename);
+    if (existsSync2(filePath)) {
       try {
-        const content = await readFile(filePath, "utf-8");
+        const content = await readFile2(filePath, "utf-8");
         return content.trim() || null;
       } catch {
         continue;
@@ -1024,9 +1135,9 @@ async function ensureWorkspaceFiles(workspaceDir, templateDir) {
   const { mkdir: mkdir7, copyFile } = await import("fs/promises");
   await mkdir7(workspaceDir, { recursive: true });
   for (const filename of [...WORKSPACE_FILES, "BOOTSTRAP.md", "HEARTBEAT.md"]) {
-    const target = join(workspaceDir, filename);
-    const source = join(templateDir, filename);
-    if (!existsSync(target) && existsSync(source)) {
+    const target = join2(workspaceDir, filename);
+    const source = join2(templateDir, filename);
+    if (!existsSync2(target) && existsSync2(source)) {
       await copyFile(source, target);
     }
   }
@@ -1165,6 +1276,10 @@ var init_registry = __esm({
 });
 
 // src/tools/path-guard.ts
+var path_guard_exports = {};
+__export(path_guard_exports, {
+  guardPath: () => guardPath
+});
 import { resolve, isAbsolute, normalize, relative } from "path";
 function guardPath(inputPath, projectRoot, opts) {
   const resolved = isAbsolute(inputPath) ? normalize(inputPath) : normalize(resolve(projectRoot, inputPath));
@@ -1186,7 +1301,7 @@ var init_path_guard = __esm({
 });
 
 // src/tools/read-file.ts
-import { readFile as readFile2, stat } from "fs/promises";
+import { readFile as readFile3, stat } from "fs/promises";
 var readFileTool;
 var init_read_file = __esm({
   "src/tools/read-file.ts"() {
@@ -1235,7 +1350,7 @@ var init_read_file = __esm({
           if (probe.subarray(0, probeLen).includes(0)) {
             return `Binary file detected: ${filePath} (${fileStats.size} bytes)`;
           }
-          const content = await readFile2(filePath, "utf-8");
+          const content = await readFile3(filePath, "utf-8");
           const lines = content.split("\n");
           const offset = Math.max(1, Number(args.offset) || 1);
           const limit = Number(args.limit) || lines.length;
@@ -1252,7 +1367,7 @@ var init_read_file = __esm({
 });
 
 // src/tools/write-file.ts
-import { writeFile, mkdir } from "fs/promises";
+import { writeFile as writeFile2, mkdir } from "fs/promises";
 import { dirname, isAbsolute as isAbsolute2 } from "path";
 var writeFileTool;
 var init_write_file = __esm({
@@ -1294,7 +1409,7 @@ var init_write_file = __esm({
         const filePath = guard.path;
         try {
           await mkdir(dirname(filePath), { recursive: true });
-          await writeFile(filePath, args.content, "utf-8");
+          await writeFile2(filePath, args.content, "utf-8");
           const lines = args.content.split("\n").length;
           return `Wrote ${lines} lines to ${filePath}`;
         } catch (err) {
@@ -1310,7 +1425,7 @@ var init_write_file = __esm({
 });
 
 // src/tools/edit-file.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import { isAbsolute as isAbsolute3 } from "path";
 var editFileTool;
 var init_edit_file = __esm({
@@ -1351,7 +1466,7 @@ var init_edit_file = __esm({
         if (!guard.ok) return guard.error;
         const filePath = guard.path;
         try {
-          const content = await readFile3(filePath, "utf-8");
+          const content = await readFile4(filePath, "utf-8");
           const oldStr = args.old_string;
           const newStr = args.new_string;
           const replaceAll = Boolean(args.replace_all);
@@ -1365,7 +1480,7 @@ var init_edit_file = __esm({
             }
           }
           const updated = replaceAll ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
-          await writeFile2(filePath, updated, "utf-8");
+          await writeFile3(filePath, updated, "utf-8");
           const replacements = replaceAll ? content.split(oldStr).length - 1 : 1;
           return `Edited ${filePath} (${replacements} replacement${replacements > 1 ? "s" : ""})`;
         } catch (err) {
@@ -1382,7 +1497,7 @@ var init_edit_file = __esm({
 
 // src/tools/list-directory.ts
 import { readdir, stat as stat2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes}B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
@@ -1423,7 +1538,7 @@ var init_list_directory = __esm({
           const lines = [];
           for (const entry of entries.slice(0, 100)) {
             try {
-              const full = join2(dirPath, entry);
+              const full = join3(dirPath, entry);
               const s = await stat2(full);
               const type = s.isDirectory() ? "dir" : "file";
               const size = s.isDirectory() ? "" : ` (${formatSize(s.size)})`;
@@ -1446,8 +1561,8 @@ var init_list_directory = __esm({
 });
 
 // src/tools/search-files.ts
-import { readdir as readdir2, readFile as readFile4, stat as stat3 } from "fs/promises";
-import { join as join3, relative as relative2 } from "path";
+import { readdir as readdir2, readFile as readFile5, stat as stat3 } from "fs/promises";
+import { join as join4, relative as relative2 } from "path";
 var IGNORE_DIRS, searchFilesTool;
 var init_search_files = __esm({
   "src/tools/search-files.ts"() {
@@ -1522,7 +1637,7 @@ var init_search_files = __esm({
           for (const entry of entries) {
             if (results.length >= maxResults) return;
             if (IGNORE_DIRS.has(entry)) continue;
-            const full = join3(dir, entry);
+            const full = join4(dir, entry);
             let s;
             try {
               s = await stat3(full);
@@ -1537,7 +1652,7 @@ var init_search_files = __esm({
                 if (!entry.endsWith(ext)) continue;
               }
               try {
-                const content = await readFile4(full, "utf-8");
+                const content = await readFile5(full, "utf-8");
                 const lines = content.split("\n");
                 for (let i = 0; i < lines.length; i++) {
                   regex.lastIndex = 0;
@@ -1562,7 +1677,7 @@ var init_search_files = __esm({
 
 // src/tools/glob-files.ts
 import { readdir as readdir3, stat as stat4 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function globToRegex(pattern) {
   let regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
   return new RegExp(`^${regex}$`, "i");
@@ -1628,7 +1743,7 @@ var init_glob_files = __esm({
           for (const entry of entries) {
             if (matches.length >= 200) return;
             if (IGNORE_DIRS2.has(entry)) continue;
-            const full = join4(dir, entry);
+            const full = join5(dir, entry);
             const rel = relDir ? `${relDir}/${entry}` : entry;
             let s;
             try {
@@ -1854,19 +1969,19 @@ var init_git = __esm({
 });
 
 // src/config/config.ts
-import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join5 } from "path";
+import { readFile as readFile6, writeFile as writeFile4, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join6 } from "path";
 import { homedir, platform as platform3 } from "os";
 import JSON5 from "json5";
 function getConfigDir() {
   if (platform3() === "win32") {
-    return join5(process.env.APPDATA || join5(homedir(), "AppData", "Roaming"), "Clank");
+    return join6(process.env.APPDATA || join6(homedir(), "AppData", "Roaming"), "Clank");
   }
-  return join5(homedir(), ".clank");
+  return join6(homedir(), ".clank");
 }
 function getConfigPath() {
-  return join5(getConfigDir(), "config.json5");
+  return join6(getConfigDir(), "config.json5");
 }
 function defaultConfig() {
   return {
@@ -1878,7 +1993,7 @@ function defaultConfig() {
     agents: {
       defaults: {
         model: { primary: "ollama/qwen3.5" },
-        workspace: join5(getConfigDir(), "workspace"),
+        workspace: join6(getConfigDir(), "workspace"),
         toolTier: "auto",
         temperature: 0.7
       },
@@ -1937,11 +2052,11 @@ function deepMerge(target, source) {
 async function loadConfig() {
   const configPath = getConfigPath();
   const defaults = defaultConfig();
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     return defaults;
   }
   try {
-    const raw = await readFile5(configPath, "utf-8");
+    const raw = await readFile6(configPath, "utf-8");
     const parsed = JSON5.parse(raw);
     const substituted = substituteEnvVars(parsed);
     return deepMerge(defaults, substituted);
@@ -1954,15 +2069,15 @@ async function saveConfig(config) {
   const configPath = getConfigPath();
   await mkdir2(getConfigDir(), { recursive: true });
   const content = JSON5.stringify(config, null, 2);
-  await writeFile3(configPath, content, "utf-8");
+  await writeFile4(configPath, content, "utf-8");
 }
 async function ensureConfigDir() {
   const configDir = getConfigDir();
   await mkdir2(configDir, { recursive: true });
-  await mkdir2(join5(configDir, "workspace"), { recursive: true });
-  await mkdir2(join5(configDir, "conversations"), { recursive: true });
-  await mkdir2(join5(configDir, "memory"), { recursive: true });
-  await mkdir2(join5(configDir, "logs"), { recursive: true });
+  await mkdir2(join6(configDir, "workspace"), { recursive: true });
+  await mkdir2(join6(configDir, "conversations"), { recursive: true });
+  await mkdir2(join6(configDir, "memory"), { recursive: true });
+  await mkdir2(join6(configDir, "logs"), { recursive: true });
 }
 var init_config = __esm({
   "src/config/config.ts"() {
@@ -2144,6 +2259,12 @@ var init_web_fetch = __esm({
           if (host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "0.0.0.0") {
             return { ok: false, error: "localhost URLs are blocked (SSRF protection)" };
           }
+          if (/^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host)) {
+            return { ok: false, error: "Private network IPs are blocked (SSRF protection)" };
+          }
+          if (host.startsWith("[::ffff:")) {
+            return { ok: false, error: "IPv4-mapped IPv6 addresses are blocked" };
+          }
           if (host === "169.254.169.254" || host === "metadata.google.internal") {
             return { ok: false, error: "Cloud metadata endpoints are blocked" };
           }
@@ -2280,9 +2401,21 @@ var init_config_tool = __esm({
               return `Key not found: ${key}`;
             }
           }
-          return typeof current === "object" ? JSON.stringify(current, null, 2) : String(current);
+          if (typeof current === "object") {
+            return JSON.stringify(redactConfig(current), null, 2);
+          }
+          const SENSITIVE = /* @__PURE__ */ new Set(["apikey", "api_key", "apiKey", "token", "bottoken", "botToken", "secret", "password", "pin"]);
+          const lastKey = keys[keys.length - 1];
+          if (SENSITIVE.has(lastKey) && typeof current === "string") {
+            return "[REDACTED]";
+          }
+          return String(current);
         }
         if (action === "set") {
+          const BLOCKED_KEYS = ["__proto__", "constructor", "prototype"];
+          if (keys.some((k) => BLOCKED_KEYS.includes(k))) {
+            return "Error: blocked \u2014 unsafe key";
+          }
           let parsed = args.value;
           try {
             parsed = JSON.parse(args.value);
@@ -3358,9 +3491,9 @@ var init_model_tool = __esm({
 });
 
 // src/sessions/store.ts
-import { readFile as readFile6, writeFile as writeFile4, unlink, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { join as join6 } from "path";
+import { readFile as readFile7, writeFile as writeFile5, unlink, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join7 } from "path";
 import { randomUUID } from "crypto";
 var SessionStore;
 var init_store = __esm({
@@ -3373,14 +3506,14 @@ var init_store = __esm({
       index = /* @__PURE__ */ new Map();
       constructor(storeDir) {
         this.storeDir = storeDir;
-        this.indexPath = join6(storeDir, "sessions.json");
+        this.indexPath = join7(storeDir, "sessions.json");
       }
       /** Initialize the store — load index from disk */
       async init() {
         await mkdir3(this.storeDir, { recursive: true });
-        if (existsSync3(this.indexPath)) {
+        if (existsSync4(this.indexPath)) {
           try {
-            const raw = await readFile6(this.indexPath, "utf-8");
+            const raw = await readFile7(this.indexPath, "utf-8");
             const entries = JSON.parse(raw);
             for (const entry of entries) {
               this.index.set(entry.normalizedKey, entry);
@@ -3393,7 +3526,7 @@ var init_store = __esm({
       /** Save the index to disk */
       async saveIndex() {
         const entries = Array.from(this.index.values());
-        await writeFile4(this.indexPath, JSON.stringify(entries, null, 2), "utf-8");
+        await writeFile5(this.indexPath, JSON.stringify(entries, null, 2), "utf-8");
       }
       /** Get or create a session for a normalized key */
       async resolve(normalizedKey, opts) {
@@ -3419,10 +3552,10 @@ var init_store = __esm({
       }
       /** Load conversation messages for a session */
       async loadMessages(sessionId) {
-        const path2 = join6(this.storeDir, `${sessionId}.json`);
-        if (!existsSync3(path2)) return [];
+        const path2 = join7(this.storeDir, `${sessionId}.json`);
+        if (!existsSync4(path2)) return [];
         try {
-          const raw = await readFile6(path2, "utf-8");
+          const raw = await readFile7(path2, "utf-8");
           return JSON.parse(raw);
         } catch {
           return [];
@@ -3430,8 +3563,8 @@ var init_store = __esm({
       }
       /** Save conversation messages for a session */
       async saveMessages(sessionId, messages) {
-        const path2 = join6(this.storeDir, `${sessionId}.json`);
-        await writeFile4(path2, JSON.stringify(messages, null, 2), "utf-8");
+        const path2 = join7(this.storeDir, `${sessionId}.json`);
+        await writeFile5(path2, JSON.stringify(messages, null, 2), "utf-8");
       }
       /** List all sessions, sorted by last used */
       list() {
@@ -3443,7 +3576,7 @@ var init_store = __esm({
         if (!entry) return false;
         this.index.delete(normalizedKey);
         await this.saveIndex();
-        const path2 = join6(this.storeDir, `${entry.id}.json`);
+        const path2 = join7(this.storeDir, `${entry.id}.json`);
         try {
           await unlink(path2);
         } catch {
@@ -3454,7 +3587,7 @@ var init_store = __esm({
       async reset(normalizedKey) {
         const entry = this.index.get(normalizedKey);
         if (!entry) return null;
-        const path2 = join6(this.storeDir, `${entry.id}.json`);
+        const path2 = join7(this.storeDir, `${entry.id}.json`);
         try {
           await unlink(path2);
         } catch {
@@ -3500,7 +3633,7 @@ var init_sessions = __esm({
 });
 
 // src/tools/self-config/session-tool.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var sessionTool;
 var init_session_tool = __esm({
   "src/tools/self-config/session-tool.ts"() {
@@ -3534,7 +3667,7 @@ var init_session_tool = __esm({
         return { ok: true };
       },
       async execute(args) {
-        const store = new SessionStore(join7(getConfigDir(), "conversations"));
+        const store = new SessionStore(join8(getConfigDir(), "conversations"));
         await store.init();
         const action = args.action;
         if (action === "list") {
@@ -3563,9 +3696,9 @@ var init_session_tool = __esm({
 });
 
 // src/cron/scheduler.ts
-import { readFile as readFile7, appendFile, mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join8 } from "path";
+import { readFile as readFile8, appendFile, mkdir as mkdir4, writeFile as writeFile6 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join9 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var CronScheduler;
 var init_scheduler = __esm({
@@ -3580,8 +3713,8 @@ var init_scheduler = __esm({
       running = false;
       onJobDue;
       constructor(storeDir) {
-        this.jobsPath = join8(storeDir, "jobs.jsonl");
-        this.runsDir = join8(storeDir, "runs");
+        this.jobsPath = join9(storeDir, "jobs.jsonl");
+        this.runsDir = join9(storeDir, "runs");
       }
       /** Initialize — load jobs from disk */
       async init() {
@@ -3703,9 +3836,9 @@ var init_scheduler = __esm({
       }
       /** Load jobs from JSONL file */
       async loadJobs() {
-        if (!existsSync4(this.jobsPath)) return;
+        if (!existsSync5(this.jobsPath)) return;
         try {
-          const raw = await readFile7(this.jobsPath, "utf-8");
+          const raw = await readFile8(this.jobsPath, "utf-8");
           this.jobs = raw.split("\n").filter(Boolean).map((line) => JSON.parse(line));
         } catch {
           this.jobs = [];
@@ -3714,11 +3847,11 @@ var init_scheduler = __esm({
       /** Save jobs to JSONL file */
       async saveJobs() {
         const content = this.jobs.map((j) => JSON.stringify(j)).join("\n") + "\n";
-        await writeFile5(this.jobsPath, content, "utf-8");
+        await writeFile6(this.jobsPath, content, "utf-8");
       }
       /** Log a run result */
       async logRun(log) {
-        const logPath = join8(this.runsDir, `${log.jobId}.jsonl`);
+        const logPath = join9(this.runsDir, `${log.jobId}.jsonl`);
         await appendFile(logPath, JSON.stringify(log) + "\n", "utf-8");
       }
     };
@@ -3739,7 +3872,7 @@ var init_cron = __esm({
 });
 
 // src/tools/self-config/cron-tool.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var cronTool;
 var init_cron_tool = __esm({
   "src/tools/self-config/cron-tool.ts"() {
@@ -3777,7 +3910,7 @@ var init_cron_tool = __esm({
         return { ok: true };
       },
       async execute(args, ctx) {
-        const scheduler = new CronScheduler(join9(getConfigDir(), "cron"));
+        const scheduler = new CronScheduler(join10(getConfigDir(), "cron"));
         await scheduler.init();
         const action = args.action;
         if (action === "list") {
@@ -4041,12 +4174,12 @@ var init_tts = __esm({
       /** Transcribe via local whisper.cpp */
       async transcribeLocal(audioBuffer, format) {
         try {
-          const { writeFile: writeFile9, unlink: unlink5 } = await import("fs/promises");
+          const { writeFile: writeFile10, unlink: unlink5 } = await import("fs/promises");
           const { execSync: execSync3 } = await import("child_process");
-          const { join: join19 } = await import("path");
+          const { join: join20 } = await import("path");
           const { tmpdir } = await import("os");
-          const tmpFile = join19(tmpdir(), `clank-stt-${Date.now()}.${format}`);
-          await writeFile9(tmpFile, audioBuffer);
+          const tmpFile = join20(tmpdir(), `clank-stt-${Date.now()}.${format}`);
+          await writeFile10(tmpFile, audioBuffer);
           const output = execSync3(`whisper "${tmpFile}" --model base.en --output-txt`, {
             encoding: "utf-8",
             timeout: 6e4
@@ -4114,11 +4247,11 @@ var init_voice_tool = __esm({
           voiceId: args.voice_id
         });
         if (!result) return "Error: TTS synthesis failed";
-        const { writeFile: writeFile9 } = await import("fs/promises");
-        const { join: join19 } = await import("path");
+        const { writeFile: writeFile10 } = await import("fs/promises");
+        const { join: join20 } = await import("path");
         const { tmpdir } = await import("os");
-        const outPath = join19(tmpdir(), `clank-tts-${Date.now()}.${result.format}`);
-        await writeFile9(outPath, result.audioBuffer);
+        const outPath = join20(tmpdir(), `clank-tts-${Date.now()}.${result.format}`);
+        await writeFile10(outPath, result.audioBuffer);
         return `Audio generated: ${outPath} (${result.format}, ${Math.round(result.audioBuffer.length / 1024)}KB)`;
       }
     };
@@ -4136,21 +4269,24 @@ var init_voice_tool = __esm({
       },
       safetyLevel: "low",
       readOnly: true,
-      validate(args) {
+      validate(args, ctx) {
         if (!args.file_path || typeof args.file_path !== "string") return { ok: false, error: "file_path is required" };
         return { ok: true };
       },
-      async execute(args) {
-        const { readFile: readFile12 } = await import("fs/promises");
-        const { existsSync: existsSync10 } = await import("fs");
-        const filePath = args.file_path;
-        if (!existsSync10(filePath)) return `Error: File not found: ${filePath}`;
+      async execute(args, ctx) {
+        const { readFile: readFile13 } = await import("fs/promises");
+        const { existsSync: existsSync12 } = await import("fs");
+        const { guardPath: guardPath2 } = await Promise.resolve().then(() => (init_path_guard(), path_guard_exports));
+        const guard = guardPath2(args.file_path, ctx.projectRoot, { allowExternal: ctx.allowExternal });
+        if (!guard.ok) return guard.error;
+        const filePath = guard.path;
+        if (!existsSync12(filePath)) return `Error: File not found: ${filePath}`;
         const config = await loadConfig();
         const engine = new STTEngine(config);
         if (!engine.isAvailable()) {
           return "Error: Speech-to-text not configured. Need OpenAI API key or local whisper.cpp installed.";
         }
-        const audioBuffer = await readFile12(filePath);
+        const audioBuffer = await readFile13(filePath);
         const ext = filePath.split(".").pop() || "wav";
         const result = await engine.transcribe(audioBuffer, ext);
         if (!result) return "Error: Transcription failed";
@@ -4182,6 +4318,53 @@ var init_voice_tool = __esm({
   }
 });
 
+// src/tools/self-config/file-share-tool.ts
+import { existsSync as existsSync6 } from "fs";
+import { stat as stat5 } from "fs/promises";
+var MAX_FILE_SIZE, fileShareTool;
+var init_file_share_tool = __esm({
+  "src/tools/self-config/file-share-tool.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_path_guard();
+    MAX_FILE_SIZE = 10 * 1024 * 1024;
+    fileShareTool = {
+      definition: {
+        name: "share_file",
+        description: "Share a file from the workspace with the user via the current channel (Telegram, Discord, etc.). The file must be within the workspace. Max 10MB.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "Path to the file to share" },
+            caption: { type: "string", description: "Optional message to send with the file" }
+          },
+          required: ["path"]
+        }
+      },
+      safetyLevel: "medium",
+      readOnly: true,
+      validate(args, ctx) {
+        if (!args.path || typeof args.path !== "string") return { ok: false, error: "path is required" };
+        const guard = guardPath(args.path, ctx.projectRoot);
+        if (!guard.ok) return { ok: false, error: guard.error };
+        return { ok: true };
+      },
+      async execute(args, ctx) {
+        const guard = guardPath(args.path, ctx.projectRoot, { allowExternal: ctx.allowExternal });
+        if (!guard.ok) return guard.error;
+        if (!existsSync6(guard.path)) return `Error: File not found: ${guard.path}`;
+        const fileStats = await stat5(guard.path);
+        if (fileStats.size > MAX_FILE_SIZE) return `Error: File too large (${Math.round(fileStats.size / 1024 / 1024)}MB, max 10MB)`;
+        const caption = args.caption ? ` with caption: "${args.caption}"` : "";
+        return `File ready to share: ${guard.path} (${Math.round(fileStats.size / 1024)}KB)${caption}. The file will be sent through the current channel.`;
+      },
+      formatConfirmation(args) {
+        return `Share file: ${args.path}`;
+      }
+    };
+  }
+});
+
 // src/tools/self-config/index.ts
 function registerSelfConfigTools(registry) {
   registry.register(configTool);
@@ -4195,6 +4378,7 @@ function registerSelfConfigTools(registry) {
   registry.register(ttsTool);
   registry.register(sttTool);
   registry.register(voiceListTool);
+  registry.register(fileShareTool);
 }
 var init_self_config = __esm({
   "src/tools/self-config/index.ts"() {
@@ -4209,6 +4393,7 @@ var init_self_config = __esm({
     init_gateway_tool();
     init_message_tool();
     init_voice_tool();
+    init_file_share_tool();
     init_config_tool();
     init_channel_tool();
     init_agent_tool();
@@ -4218,6 +4403,7 @@ var init_self_config = __esm({
     init_gateway_tool();
     init_message_tool();
     init_voice_tool();
+    init_file_share_tool();
   }
 });
 
@@ -4279,7 +4465,7 @@ __export(chat_exports, {
   runChat: () => runChat
 });
 import { createInterface } from "readline";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 async function runChat(opts) {
   await ensureConfigDir();
   const config = await loadConfig();
@@ -4296,9 +4482,9 @@ async function runChat(opts) {
       console.log(dim("Starting gateway..."));
       const { fork: fork2 } = await import("child_process");
       const { fileURLToPath: fileURLToPath6 } = await import("url");
-      const { dirname: dirname6, join: join19 } = await import("path");
+      const { dirname: dirname6, join: join20 } = await import("path");
       const __filename4 = fileURLToPath6(import.meta.url);
-      const entryPoint = join19(dirname6(__filename4), "index.js");
+      const entryPoint = join20(dirname6(__filename4), "index.js");
       const child = fork2(entryPoint, ["gateway", "start", "--foreground"], {
         detached: true,
         stdio: "ignore"
@@ -4346,7 +4532,7 @@ async function runChat(opts) {
     console.error(dim("Make sure Ollama is running or configure a cloud provider in ~/.clank/config.json5"));
     process.exit(1);
   }
-  const sessionStore = new SessionStore(join10(getConfigDir(), "conversations"));
+  const sessionStore = new SessionStore(join11(getConfigDir(), "conversations"));
   await sessionStore.init();
   const toolRegistry = createFullRegistry();
   const identity = {
@@ -4504,9 +4690,9 @@ var init_chat = __esm({
 });
 
 // src/memory/memory.ts
-import { readFile as readFile8, writeFile as writeFile6, readdir as readdir5, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { join as join11 } from "path";
+import { readFile as readFile9, writeFile as writeFile7, readdir as readdir5, mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import { join as join12 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function tokenize(text) {
   return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 3 && !STOPWORDS.has(t));
@@ -4654,12 +4840,12 @@ var init_memory = __esm({
       meta = /* @__PURE__ */ new Map();
       constructor(memoryDir) {
         this.memoryDir = memoryDir;
-        this.metaPath = join11(memoryDir, "_meta.json");
+        this.metaPath = join12(memoryDir, "_meta.json");
       }
       /** Initialize — create dirs and load metadata */
       async init() {
         for (const cat of ["identity", "knowledge", "lessons", "context"]) {
-          await mkdir5(join11(this.memoryDir, cat), { recursive: true });
+          await mkdir5(join12(this.memoryDir, cat), { recursive: true });
         }
         await this.loadMeta();
       }
@@ -4704,10 +4890,10 @@ var init_memory = __esm({
         let used = 0;
         if (projectRoot) {
           for (const name of [".clank.md", ".clankbuild.md", ".llamabuild.md"]) {
-            const path2 = join11(projectRoot, name);
-            if (existsSync5(path2)) {
+            const path2 = join12(projectRoot, name);
+            if (existsSync7(path2)) {
               try {
-                const content = await readFile8(path2, "utf-8");
+                const content = await readFile9(path2, "utf-8");
                 if (content.trim() && used + content.length < budgetChars) {
                   parts.push("## Project Memory\n" + content.trim());
                   used += content.length;
@@ -4718,10 +4904,10 @@ var init_memory = __esm({
             }
           }
         }
-        const globalPath = join11(this.memoryDir, "..", "workspace", "MEMORY.md");
-        if (existsSync5(globalPath)) {
+        const globalPath = join12(this.memoryDir, "..", "workspace", "MEMORY.md");
+        if (existsSync7(globalPath)) {
           try {
-            const content = await readFile8(globalPath, "utf-8");
+            const content = await readFile9(globalPath, "utf-8");
             if (content.trim() && used + content.length < budgetChars) {
               parts.push("## Global Memory\n" + content.trim());
               used += content.length;
@@ -4742,8 +4928,8 @@ ${entry.content}`);
       async add(category, title, content) {
         const id = randomUUID3();
         const filename = `${title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50)}.md`;
-        const filePath = join11(this.memoryDir, category, filename);
-        await writeFile6(filePath, `# ${title}
+        const filePath = join12(this.memoryDir, category, filename);
+        await writeFile7(filePath, `# ${title}
 
 ${content}`, "utf-8");
         this.meta.set(id, {
@@ -4788,15 +4974,15 @@ ${content}`, "utf-8");
       async loadAll() {
         const entries = [];
         for (const category of ["identity", "knowledge", "lessons", "context"]) {
-          const dir = join11(this.memoryDir, category);
-          if (!existsSync5(dir)) continue;
+          const dir = join12(this.memoryDir, category);
+          if (!existsSync7(dir)) continue;
           try {
             const files = await readdir5(dir);
             for (const file of files) {
               if (!file.endsWith(".md")) continue;
-              const filePath = join11(dir, file);
+              const filePath = join12(dir, file);
               try {
-                const content = await readFile8(filePath, "utf-8");
+                const content = await readFile9(filePath, "utf-8");
                 const title = content.split("\n")[0]?.replace(/^#\s*/, "") || file;
                 entries.push({
                   id: file,
@@ -4821,9 +5007,9 @@ ${content}`, "utf-8");
         return recency * frequencyBoost;
       }
       async loadMeta() {
-        if (!existsSync5(this.metaPath)) return;
+        if (!existsSync7(this.metaPath)) return;
         try {
-          const raw = await readFile8(this.metaPath, "utf-8");
+          const raw = await readFile9(this.metaPath, "utf-8");
           const entries = JSON.parse(raw);
           for (const e of entries) this.meta.set(e.id, e);
         } catch {
@@ -4831,7 +5017,7 @@ ${content}`, "utf-8");
       }
       async saveMeta() {
         const entries = Array.from(this.meta.values());
-        await writeFile6(this.metaPath, JSON.stringify(entries, null, 2), "utf-8");
+        await writeFile7(this.metaPath, JSON.stringify(entries, null, 2), "utf-8");
       }
     };
   }
@@ -4843,6 +5029,7 @@ var init_memory2 = __esm({
     "use strict";
     init_esm_shims();
     init_memory();
+    init_auto_persist();
   }
 });
 
@@ -5038,15 +5225,53 @@ var init_telegram = __esm({
               if (!this.gateway) return;
               try {
                 await ctx.api.sendChatAction(chatId, "typing");
-                const response = await this.gateway.handleInboundMessage(
+                let streamMsgId = null;
+                let accumulated = "";
+                let lastEditTime = 0;
+                const EDIT_INTERVAL = 800;
+                const response = await this.gateway.handleInboundMessageStreaming(
                   {
                     channel: "telegram",
                     peerId: chatId,
                     peerKind: isGroup ? "group" : "dm"
                   },
-                  msg.text
+                  msg.text,
+                  {
+                    onToken: (content) => {
+                      accumulated += content;
+                      const now = Date.now();
+                      if (!streamMsgId && accumulated.length > 20) {
+                        bot.api.sendMessage(chatId, accumulated + " \u258D").then((sent) => {
+                          streamMsgId = sent.message_id;
+                          lastEditTime = now;
+                        }).catch(() => {
+                        });
+                        return;
+                      }
+                      if (streamMsgId && now - lastEditTime > EDIT_INTERVAL) {
+                        lastEditTime = now;
+                        const display = accumulated.length > 4e3 ? accumulated.slice(-3900) + " \u258D" : accumulated + " \u258D";
+                        bot.api.editMessageText(chatId, streamMsgId, display).catch(() => {
+                        });
+                      }
+                    },
+                    onToolStart: (name) => {
+                      if (!streamMsgId) {
+                        bot.api.sendChatAction(chatId, "typing").catch(() => {
+                        });
+                      }
+                    },
+                    onError: (message) => {
+                      bot.api.sendMessage(chatId, `Error: ${message.slice(0, 200)}`).catch(() => {
+                      });
+                    }
+                  }
                 );
-                if (response) {
+                if (streamMsgId && response) {
+                  const finalText = response.length > 4e3 ? response.slice(0, 3950) + "\n... (truncated)" : response;
+                  await bot.api.editMessageText(chatId, streamMsgId, finalText).catch(() => {
+                  });
+                } else if (response && !streamMsgId) {
                   const chunks = splitMessage(response, 4e3);
                   for (const chunk of chunks) {
                     await ctx.api.sendMessage(chatId, chunk);
@@ -5110,7 +5335,8 @@ var init_telegram = __esm({
                   const { TTSEngine: TTSEngine2 } = await Promise.resolve().then(() => (init_voice(), voice_exports));
                   const tts = new TTSEngine2(config);
                   if (tts.isAvailable() && response.length < 2e3) {
-                    const audio = await tts.synthesize(response);
+                    const agentVoice = config.agents.list.find((a) => a.voiceId)?.voiceId;
+                    const audio = await tts.synthesize(response, { voiceId: agentVoice });
                     if (audio) {
                       const { InputFile } = await import("grammy");
                       await ctx.api.sendVoice(chatId, new InputFile(audio.audioBuffer, "reply.mp3"));
@@ -5132,6 +5358,94 @@ var init_telegram = __esm({
             });
             chatLocks.set(chatId, next);
           });
+          bot.on("message:photo", async (ctx) => {
+            const msg = ctx.message;
+            const chatId = msg.chat.id;
+            if (msg.date < startupTime - 30) return;
+            if (telegramConfig.allowFrom && telegramConfig.allowFrom.length > 0) {
+              const username = msg.from?.username ? `@${msg.from.username}` : "";
+              const userIdStr = String(msg.from?.id || "");
+              const allowed = telegramConfig.allowFrom.map(String);
+              if (!allowed.some((a) => a === userIdStr || a.toLowerCase() === username.toLowerCase() || a.toLowerCase() === (msg.from?.username || "").toLowerCase())) return;
+            }
+            const processPhoto = async () => {
+              if (!this.gateway) return;
+              try {
+                const photo = msg.photo[msg.photo.length - 1];
+                const file = await bot.api.getFile(photo.file_id);
+                const fileUrl = `https://api.telegram.org/file/bot${telegramConfig.botToken}/${file.file_path}`;
+                const caption = msg.caption || "";
+                const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
+                const response = await this.gateway.handleInboundMessage(
+                  { channel: "telegram", peerId: chatId, peerKind: isGroup ? "group" : "dm" },
+                  `[Image received: ${fileUrl}]${caption ? ` Caption: ${caption}` : ""}
+
+Describe or analyze the image if you can, or acknowledge it.`
+                );
+                if (response) {
+                  const chunks = splitMessage(response, 4e3);
+                  for (const chunk of chunks) await ctx.api.sendMessage(chatId, chunk);
+                }
+              } catch (err) {
+                await ctx.api.sendMessage(chatId, `Error: ${(err instanceof Error ? err.message : String(err)).slice(0, 200)}`);
+              }
+            };
+            const prev = chatLocks.get(chatId) || Promise.resolve();
+            chatLocks.set(chatId, prev.then(processPhoto).catch(() => {
+            }));
+          });
+          bot.on("message:document", async (ctx) => {
+            const msg = ctx.message;
+            const chatId = msg.chat.id;
+            if (msg.date < startupTime - 30) return;
+            if (telegramConfig.allowFrom && telegramConfig.allowFrom.length > 0) {
+              const username = msg.from?.username ? `@${msg.from.username}` : "";
+              const userIdStr = String(msg.from?.id || "");
+              const allowed = telegramConfig.allowFrom.map(String);
+              if (!allowed.some((a) => a === userIdStr || a.toLowerCase() === username.toLowerCase() || a.toLowerCase() === (msg.from?.username || "").toLowerCase())) return;
+            }
+            const processDoc = async () => {
+              if (!this.gateway) return;
+              try {
+                const doc = msg.document;
+                if (!doc) return;
+                if (doc.file_size && doc.file_size > 10 * 1024 * 1024) {
+                  await ctx.api.sendMessage(chatId, "File too large (max 10MB).");
+                  return;
+                }
+                const file = await bot.api.getFile(doc.file_id);
+                const fileUrl = `https://api.telegram.org/file/bot${telegramConfig.botToken}/${file.file_path}`;
+                const res = await fetch(fileUrl);
+                if (!res.ok) {
+                  await ctx.api.sendMessage(chatId, "Could not download file.");
+                  return;
+                }
+                const { writeFile: wf } = await import("fs/promises");
+                const { join: join20 } = await import("path");
+                const { tmpdir } = await import("os");
+                const safeName = (doc.file_name || "file").replace(/[^a-zA-Z0-9._-]/g, "_");
+                const savePath = join20(tmpdir(), `clank-upload-${Date.now()}-${safeName}`);
+                await wf(savePath, Buffer.from(await res.arrayBuffer()));
+                const caption = msg.caption || "";
+                const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
+                const response = await this.gateway.handleInboundMessage(
+                  { channel: "telegram", peerId: chatId, peerKind: isGroup ? "group" : "dm" },
+                  `[File received: "${doc.file_name}" saved to ${savePath}]${caption ? ` Note: ${caption}` : ""}
+
+You can read this file with the read_file tool.`
+                );
+                if (response) {
+                  const chunks = splitMessage(response, 4e3);
+                  for (const chunk of chunks) await ctx.api.sendMessage(chatId, chunk);
+                }
+              } catch (err) {
+                await ctx.api.sendMessage(chatId, `Error: ${(err instanceof Error ? err.message : String(err)).slice(0, 200)}`);
+              }
+            };
+            const prev = chatLocks.get(chatId) || Promise.resolve();
+            chatLocks.set(chatId, prev.then(processDoc).catch(() => {
+            }));
+          });
           bot.start({
             onStart: () => {
               this.running = true;
@@ -5374,9 +5688,9 @@ var init_web = __esm({
 });
 
 // src/plugins/loader.ts
-import { readdir as readdir6, readFile as readFile9 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join12 } from "path";
+import { readdir as readdir6, readFile as readFile10 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { join as join13 } from "path";
 import { homedir as homedir2 } from "os";
 var PluginLoader;
 var init_loader = __esm({
@@ -5409,25 +5723,25 @@ var init_loader = __esm({
       /** Discover plugin directories */
       async discoverPlugins() {
         const dirs = [];
-        const userPluginDir = join12(homedir2(), ".clank", "plugins");
-        if (existsSync6(userPluginDir)) {
+        const userPluginDir = join13(homedir2(), ".clank", "plugins");
+        if (existsSync8(userPluginDir)) {
           try {
             const entries = await readdir6(userPluginDir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.isDirectory()) {
-                dirs.push(join12(userPluginDir, entry.name));
+                dirs.push(join13(userPluginDir, entry.name));
               }
             }
           } catch {
           }
         }
-        const nodeModulesDir = join12(process.cwd(), "node_modules");
-        if (existsSync6(nodeModulesDir)) {
+        const nodeModulesDir = join13(process.cwd(), "node_modules");
+        if (existsSync8(nodeModulesDir)) {
           try {
             const entries = await readdir6(nodeModulesDir);
             for (const entry of entries) {
               if (entry.startsWith("clank-plugin-")) {
-                dirs.push(join12(nodeModulesDir, entry));
+                dirs.push(join13(nodeModulesDir, entry));
               }
             }
           } catch {
@@ -5437,9 +5751,9 @@ var init_loader = __esm({
       }
       /** Load a single plugin from a directory */
       async loadPlugin(dir) {
-        const manifestPath = join12(dir, "clank-plugin.json");
-        if (!existsSync6(manifestPath)) return null;
-        const raw = await readFile9(manifestPath, "utf-8");
+        const manifestPath = join13(dir, "clank-plugin.json");
+        if (!existsSync8(manifestPath)) return null;
+        const raw = await readFile10(manifestPath, "utf-8");
         const manifest = JSON.parse(raw);
         if (!manifest.name) return null;
         const plugin = {
@@ -5451,7 +5765,7 @@ var init_loader = __esm({
         if (manifest.tools) {
           for (const toolEntry of manifest.tools) {
             try {
-              const entrypoint = join12(dir, toolEntry.entrypoint);
+              const entrypoint = join13(dir, toolEntry.entrypoint);
               const mod = await import(entrypoint);
               const tool = mod.default || mod.tool;
               if (tool) {
@@ -5465,7 +5779,7 @@ var init_loader = __esm({
         if (manifest.hooks) {
           for (const hookEntry of manifest.hooks) {
             try {
-              const handlerPath = join12(dir, hookEntry.handler);
+              const handlerPath = join13(dir, hookEntry.handler);
               const mod = await import(handlerPath);
               const handler = mod.default || mod.handler;
               if (handler) {
@@ -5523,8 +5837,8 @@ var init_plugins = __esm({
 // src/gateway/server.ts
 import { createServer } from "http";
 import { WebSocketServer, WebSocket } from "ws";
-import { readFile as readFile10 } from "fs/promises";
-import { join as join13, dirname as dirname2 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join14, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var GatewayServer;
 var init_server = __esm({
@@ -5558,12 +5872,18 @@ var init_server = __esm({
       pluginLoader;
       adapters = [];
       running = false;
+      /** Rate limiting: track message timestamps per session */
+      rateLimiter = /* @__PURE__ */ new Map();
+      RATE_LIMIT_WINDOW = 6e4;
+      // 1 minute
+      RATE_LIMIT_MAX = 20;
+      // max 20 messages per minute per session
       constructor(config) {
         this.config = config;
-        this.sessionStore = new SessionStore(join13(getConfigDir(), "conversations"));
+        this.sessionStore = new SessionStore(join14(getConfigDir(), "conversations"));
         this.toolRegistry = createFullRegistry();
-        this.memoryManager = new MemoryManager(join13(getConfigDir(), "memory"));
-        this.cronScheduler = new CronScheduler(join13(getConfigDir(), "cron"));
+        this.memoryManager = new MemoryManager(join14(getConfigDir(), "memory"));
+        this.cronScheduler = new CronScheduler(join14(getConfigDir(), "cron"));
         this.configWatcher = new ConfigWatcher();
         this.pluginLoader = new PluginLoader();
       }
@@ -5633,6 +5953,10 @@ var init_server = __esm({
        * This is the main entry point for all non-WebSocket messages.
        */
       async handleInboundMessage(context, text) {
+        const rlKey = deriveSessionKey(context);
+        if (this.isRateLimited(rlKey)) {
+          throw new Error("Rate limited \u2014 too many messages. Wait a moment.");
+        }
         const agentId = resolveRoute(
           context,
           [],
@@ -5644,6 +5968,58 @@ var init_server = __esm({
         const engine = await this.getOrCreateEngine(sessionKey, agentId, context.channel);
         return engine.sendMessage(text);
       }
+      /**
+       * Handle an inbound message with streaming callbacks.
+       * Used by channel adapters for real-time streaming (e.g., Telegram message editing).
+       */
+      async handleInboundMessageStreaming(context, text, callbacks) {
+        const rlKey = deriveSessionKey(context);
+        if (this.isRateLimited(rlKey)) {
+          throw new Error("Rate limited \u2014 too many messages. Wait a moment.");
+        }
+        return this._handleInboundMessageStreamingInner(context, text, callbacks);
+      }
+      async _handleInboundMessageStreamingInner(context, text, callbacks) {
+        const agentId = resolveRoute(
+          context,
+          [],
+          this.config.agents.list.map((a) => ({ id: a.id, name: a.name })),
+          this.config.agents.list[0]?.id || "default"
+        );
+        const sessionKey = deriveSessionKey(context);
+        const engine = await this.getOrCreateEngine(sessionKey, agentId, context.channel);
+        const listeners = [];
+        if (callbacks.onToken) {
+          const fn = (data) => callbacks.onToken(data.content);
+          engine.on("token", fn);
+          listeners.push(["token", fn]);
+        }
+        if (callbacks.onToolStart) {
+          const fn = (data) => callbacks.onToolStart(data.name);
+          engine.on("tool-start", fn);
+          listeners.push(["tool-start", fn]);
+        }
+        if (callbacks.onToolResult) {
+          const fn = (data) => {
+            const d = data;
+            callbacks.onToolResult(d.name, d.success);
+          };
+          engine.on("tool-result", fn);
+          listeners.push(["tool-result", fn]);
+        }
+        if (callbacks.onError) {
+          const fn = (data) => callbacks.onError(data.message);
+          engine.on("error", fn);
+          listeners.push(["error", fn]);
+        }
+        try {
+          return await engine.sendMessage(text);
+        } finally {
+          for (const [event, fn] of listeners) {
+            engine.removeListener(event, fn);
+          }
+        }
+      }
       /** Stop the gateway server */
       async stop() {
         this.running = false;
@@ -5677,7 +6053,7 @@ var init_server = __esm({
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify({
             status: "ok",
-            version: "1.3.1",
+            version: "1.4.1",
             uptime: process.uptime(),
             clients: this.clients.size,
             agents: this.engines.size
@@ -5707,14 +6083,14 @@ var init_server = __esm({
         if (url === "/chat" || url === "/") {
           try {
             const __dirname4 = dirname2(fileURLToPath2(import.meta.url));
-            const htmlPath = join13(__dirname4, "..", "web", "index.html");
-            const html = await readFile10(htmlPath, "utf-8");
+            const htmlPath = join14(__dirname4, "..", "web", "index.html");
+            const html = await readFile11(htmlPath, "utf-8");
             res.writeHead(200, { "Content-Type": "text/html" });
             res.end(html);
             return;
           } catch {
             try {
-              const html = await readFile10(join13(process.cwd(), "src", "web", "index.html"), "utf-8");
+              const html = await readFile11(join14(process.cwd(), "src", "web", "index.html"), "utf-8");
               res.writeHead(200, { "Content-Type": "text/html" });
               res.end(html);
               return;
@@ -5785,7 +6161,7 @@ var init_server = __esm({
         const hello = {
           type: "hello",
           protocol: PROTOCOL_VERSION,
-          version: "1.3.1",
+          version: "1.4.1",
           agents: this.config.agents.list.map((a) => ({
             id: a.id,
             name: a.name || a.id,
@@ -5959,6 +6335,10 @@ var init_server = __esm({
           this.sendResponse(client, frame.id, false, void 0, "message is required");
           return;
         }
+        if (this.isRateLimited(client.sessionKey)) {
+          this.sendResponse(client, frame.id, false, void 0, "Rate limited \u2014 too many messages. Wait a moment.");
+          return;
+        }
         try {
           const engine = await this.getOrCreateEngine(client.sessionKey, client.agentId, client.clientName);
           const cleanup = this.wireEngineEvents(engine, client);
@@ -5973,6 +6353,15 @@ var init_server = __esm({
           this.sendResponse(client, frame.id, false, void 0, msg);
         }
       }
+      /** Check if a session is rate limited */
+      isRateLimited(sessionKey) {
+        const now = Date.now();
+        const timestamps = this.rateLimiter.get(sessionKey) || [];
+        const recent = timestamps.filter((t) => now - t < this.RATE_LIMIT_WINDOW);
+        recent.push(now);
+        this.rateLimiter.set(sessionKey, recent);
+        return recent.length > this.RATE_LIMIT_MAX;
+      }
       /** Cancel current request for a client */
       handleCancel(client) {
         const engine = this.engines.get(client.sessionKey);
@@ -5998,10 +6387,14 @@ var init_server = __esm({
           toolTier: agentConfig?.toolTier || this.config.agents.defaults.toolTier || "auto",
           tools: agentConfig?.tools
         };
+        const compact = agentConfig?.compactPrompt ?? this.config.agents.defaults.compactPrompt ?? false;
+        const thinking = agentConfig?.thinking ?? this.config.agents.defaults.thinking ?? "auto";
         const systemPrompt = await buildSystemPrompt({
           identity,
           workspaceDir: identity.workspace,
-          channel
+          channel,
+          compact,
+          thinking
         });
         const memoryBlock = await this.memoryManager.buildMemoryBlock("", identity.workspace);
         const fullPrompt = memoryBlock ? systemPrompt + "\n\n---\n\n" + memoryBlock : systemPrompt;
@@ -6116,9 +6509,9 @@ __export(gateway_cmd_exports, {
   isGatewayRunning: () => isGatewayRunning
 });
 import { fork } from "child_process";
-import { writeFile as writeFile7, readFile as readFile11, unlink as unlink3 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import { join as join14, dirname as dirname3 } from "path";
+import { writeFile as writeFile8, readFile as readFile12, unlink as unlink3 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import { join as join15, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function isGatewayRunning(port) {
   const config = await loadConfig();
@@ -6131,7 +6524,7 @@ async function isGatewayRunning(port) {
   }
 }
 function pidFilePath() {
-  return join14(getConfigDir(), "gateway.pid");
+  return join15(getConfigDir(), "gateway.pid");
 }
 async function gatewayStartForeground(opts) {
   await ensureConfigDir();
@@ -6143,7 +6536,7 @@ async function gatewayStartForeground(opts) {
     console.log(green2(`  Gateway already running on port ${config.gateway.port}`));
     return;
   }
-  await writeFile7(pidFilePath(), String(process.pid), "utf-8");
+  await writeFile8(pidFilePath(), String(process.pid), "utf-8");
   const server = new GatewayServer(config);
   const shutdown = async () => {
     console.log(dim2("\nShutting down..."));
@@ -6176,10 +6569,10 @@ async function gatewayStartBackground() {
     return true;
   }
   console.log(dim2("  Starting gateway in background..."));
-  const entryPoint = join14(dirname3(__filename2), "index.js");
-  const logFile = join14(getConfigDir(), "logs", "gateway.log");
+  const entryPoint = join15(dirname3(__filename2), "index.js");
+  const logFile = join15(getConfigDir(), "logs", "gateway.log");
   const { mkdir: mkdir7 } = await import("fs/promises");
-  await mkdir7(join14(getConfigDir(), "logs"), { recursive: true });
+  await mkdir7(join15(getConfigDir(), "logs"), { recursive: true });
   const child = fork(entryPoint, ["gateway", "start", "--foreground"], {
     detached: true,
     stdio: ["ignore", "ignore", "ignore", "ipc"]
@@ -6208,9 +6601,9 @@ async function gatewayStart(opts) {
 }
 async function gatewayStop() {
   const pidPath = pidFilePath();
-  if (existsSync7(pidPath)) {
+  if (existsSync9(pidPath)) {
     try {
-      const pid = parseInt(await readFile11(pidPath, "utf-8"), 10);
+      const pid = parseInt(await readFile12(pidPath, "utf-8"), 10);
       process.kill(pid, "SIGTERM");
       await unlink3(pidPath);
       console.log(green2("Gateway stopped"));
@@ -6241,8 +6634,8 @@ async function gatewayStatus() {
       console.log(dim2(`  Clients: ${data.clients?.length || 0}`));
       console.log(dim2(`  Sessions: ${data.sessions?.length || 0}`));
       const pidPath = pidFilePath();
-      if (existsSync7(pidPath)) {
-        const pid = await readFile11(pidPath, "utf-8");
+      if (existsSync9(pidPath)) {
+        const pid = await readFile12(pidPath, "utf-8");
         console.log(dim2(`  PID: ${pid.trim()}`));
       }
     } else {
@@ -6270,8 +6663,8 @@ var init_gateway_cmd = __esm({
 });
 
 // src/daemon/install.ts
-import { writeFile as writeFile8, mkdir as mkdir6, unlink as unlink4 } from "fs/promises";
-import { join as join15 } from "path";
+import { writeFile as writeFile9, mkdir as mkdir6, unlink as unlink4 } from "fs/promises";
+import { join as join16 } from "path";
 import { homedir as homedir3, platform as platform4 } from "os";
 import { execSync } from "child_process";
 async function installDaemon() {
@@ -6339,8 +6732,8 @@ async function daemonStatus() {
   }
 }
 async function installLaunchd() {
-  const plistDir = join15(homedir3(), "Library", "LaunchAgents");
-  const plistPath = join15(plistDir, "com.clank.gateway.plist");
+  const plistDir = join16(homedir3(), "Library", "LaunchAgents");
+  const plistPath = join16(plistDir, "com.clank.gateway.plist");
   const clankPath = execSync("which clank || echo clank", { encoding: "utf-8" }).trim();
   await mkdir6(plistDir, { recursive: true });
   const plist = `<?xml version="1.0" encoding="UTF-8"?>
@@ -6361,18 +6754,18 @@ async function installLaunchd() {
   <key>KeepAlive</key>
   <true/>
   <key>StandardOutPath</key>
-  <string>${join15(homedir3(), ".clank", "logs", "gateway.log")}</string>
+  <string>${join16(homedir3(), ".clank", "logs", "gateway.log")}</string>
   <key>StandardErrorPath</key>
-  <string>${join15(homedir3(), ".clank", "logs", "gateway-error.log")}</string>
+  <string>${join16(homedir3(), ".clank", "logs", "gateway-error.log")}</string>
 </dict>
 </plist>`;
-  await writeFile8(plistPath, plist, "utf-8");
+  await writeFile9(plistPath, plist, "utf-8");
   execSync(`launchctl load "${plistPath}"`);
   console.log(green3("Daemon installed (launchd)"));
   console.log(dim3(`  Plist: ${plistPath}`));
 }
 async function uninstallLaunchd() {
-  const plistPath = join15(homedir3(), "Library", "LaunchAgents", "com.clank.gateway.plist");
+  const plistPath = join16(homedir3(), "Library", "LaunchAgents", "com.clank.gateway.plist");
   try {
     execSync(`launchctl unload "${plistPath}"`);
     await unlink4(plistPath);
@@ -6410,8 +6803,8 @@ async function uninstallTaskScheduler() {
   }
 }
 async function installSystemd() {
-  const unitDir = join15(homedir3(), ".config", "systemd", "user");
-  const unitPath = join15(unitDir, "clank-gateway.service");
+  const unitDir = join16(homedir3(), ".config", "systemd", "user");
+  const unitPath = join16(unitDir, "clank-gateway.service");
   const clankPath = execSync("which clank || echo clank", { encoding: "utf-8" }).trim();
   await mkdir6(unitDir, { recursive: true });
   const unit = `[Unit]
@@ -6426,7 +6819,7 @@ RestartSec=5
 [Install]
 WantedBy=default.target
 `;
-  await writeFile8(unitPath, unit, "utf-8");
+  await writeFile9(unitPath, unit, "utf-8");
   execSync("systemctl --user daemon-reload");
   execSync("systemctl --user enable clank-gateway");
   execSync("systemctl --user start clank-gateway");
@@ -6437,7 +6830,7 @@ async function uninstallSystemd() {
   try {
     execSync("systemctl --user stop clank-gateway");
     execSync("systemctl --user disable clank-gateway");
-    const unitPath = join15(homedir3(), ".config", "systemd", "user", "clank-gateway.service");
+    const unitPath = join16(homedir3(), ".config", "systemd", "user", "clank-gateway.service");
     await unlink4(unitPath);
     execSync("systemctl --user daemon-reload");
     console.log(green3("Daemon uninstalled"));
@@ -6478,7 +6871,7 @@ __export(setup_exports, {
 });
 import { createInterface as createInterface2 } from "readline";
 import { randomBytes } from "crypto";
-import { dirname as dirname4, join as join16 } from "path";
+import { dirname as dirname4, join as join17 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function ask(rl, question) {
   return new Promise((resolve4) => rl.question(question, resolve4));
@@ -6581,8 +6974,8 @@ async function runSetup(opts) {
     console.log("");
     console.log(dim4("  Creating workspace..."));
     const { ensureWorkspaceFiles: ensureWorkspaceFiles2 } = await Promise.resolve().then(() => (init_system_prompt(), system_prompt_exports));
-    const templateDir = join16(__dirname2, "..", "workspace", "templates");
-    const wsDir = join16(getConfigDir(), "workspace");
+    const templateDir = join17(__dirname2, "..", "workspace", "templates");
+    const wsDir = join17(getConfigDir(), "workspace");
     try {
       await ensureWorkspaceFiles2(wsDir, templateDir);
     } catch {
@@ -6743,9 +7136,9 @@ var fix_exports = {};
 __export(fix_exports, {
   runFix: () => runFix
 });
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { readdir as readdir7 } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 async function runFix(opts) {
   console.log("");
   console.log("  Clank Diagnostics");
@@ -6775,7 +7168,7 @@ async function runFix(opts) {
 }
 async function checkConfig() {
   const configPath = getConfigPath();
-  if (!existsSync8(configPath)) {
+  if (!existsSync10(configPath)) {
     return {
       name: "Config",
       status: "warn",
@@ -6843,8 +7236,8 @@ async function checkModels() {
   return { name: "Model (primary)", status: "ok", message: modelId };
 }
 async function checkSessions() {
-  const sessDir = join17(getConfigDir(), "conversations");
-  if (!existsSync8(sessDir)) {
+  const sessDir = join18(getConfigDir(), "conversations");
+  if (!existsSync10(sessDir)) {
     return { name: "Sessions", status: "ok", message: "no sessions yet" };
   }
   try {
@@ -6856,8 +7249,8 @@ async function checkSessions() {
   }
 }
 async function checkWorkspace() {
-  const wsDir = join17(getConfigDir(), "workspace");
-  if (!existsSync8(wsDir)) {
+  const wsDir = join18(getConfigDir(), "workspace");
+  if (!existsSync10(wsDir)) {
     return {
       name: "Workspace",
       status: "warn",
@@ -7150,7 +7543,7 @@ async function runTui(opts) {
   ws.on("open", () => {
     ws.send(JSON.stringify({
       type: "connect",
-      params: { auth: { token }, mode: "tui", version: "1.3.1" }
+      params: { auth: { token }, mode: "tui", version: "1.4.1" }
     }));
   });
   ws.on("message", (data) => {
@@ -7499,7 +7892,7 @@ __export(uninstall_exports, {
 });
 import { createInterface as createInterface4 } from "readline";
 import { rm } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 async function runUninstall(opts) {
   const configDir = getConfigDir();
   console.log("");
@@ -7538,7 +7931,7 @@ async function runUninstall(opts) {
   } catch {
   }
   console.log(dim10("  Deleting data..."));
-  if (existsSync9(configDir)) {
+  if (existsSync11(configDir)) {
     await rm(configDir, { recursive: true, force: true });
     console.log(green10(`  Removed ${configDir}`));
   } else {
@@ -7576,12 +7969,12 @@ init_esm_shims();
 import { Command } from "commander";
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname5, join as join18 } from "path";
+import { dirname as dirname5, join as join19 } from "path";
 var __filename3 = fileURLToPath5(import.meta.url);
 var __dirname3 = dirname5(__filename3);
-var version = "1.3.1";
+var version = "1.4.1";
 try {
-  const pkg = JSON.parse(readFileSync(join18(__dirname3, "..", "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync(join19(__dirname3, "..", "package.json"), "utf-8"));
   version = pkg.version;
 } catch {
 }
@@ -7690,10 +8083,10 @@ pipeline.command("status <id>").description("Check pipeline execution status").a
 });
 var cron = program.command("cron").description("Manage scheduled jobs");
 cron.command("list").description("List cron jobs").action(async () => {
-  const { join: join19 } = await import("path");
+  const { join: join20 } = await import("path");
   const { getConfigDir: getConfigDir3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
   const { CronScheduler: CronScheduler2 } = await Promise.resolve().then(() => (init_cron(), cron_exports));
-  const scheduler = new CronScheduler2(join19(getConfigDir3(), "cron"));
+  const scheduler = new CronScheduler2(join20(getConfigDir3(), "cron"));
   await scheduler.init();
   const jobs = scheduler.listJobs();
   if (jobs.length === 0) {
@@ -7705,10 +8098,10 @@ cron.command("list").description("List cron jobs").action(async () => {
   }
 });
 cron.command("add").description("Add a cron job").requiredOption("--schedule <expr>", "Schedule (e.g., '1h', '30m', 'daily')").requiredOption("--prompt <text>", "What the agent should do").option("--name <name>", "Job name").option("--agent <id>", "Agent ID", "default").action(async (opts) => {
-  const { join: join19 } = await import("path");
+  const { join: join20 } = await import("path");
   const { getConfigDir: getConfigDir3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
   const { CronScheduler: CronScheduler2 } = await Promise.resolve().then(() => (init_cron(), cron_exports));
-  const scheduler = new CronScheduler2(join19(getConfigDir3(), "cron"));
+  const scheduler = new CronScheduler2(join20(getConfigDir3(), "cron"));
   await scheduler.init();
   const job = await scheduler.addJob({
     name: opts.name || "CLI Job",
@@ -7719,10 +8112,10 @@ cron.command("add").description("Add a cron job").requiredOption("--schedule <ex
   console.log(`  Job created: ${job.id.slice(0, 8)} \u2014 "${job.name}" every ${job.schedule}`);
 });
 cron.command("remove <id>").description("Remove a cron job").action(async (id) => {
-  const { join: join19 } = await import("path");
+  const { join: join20 } = await import("path");
   const { getConfigDir: getConfigDir3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
   const { CronScheduler: CronScheduler2 } = await Promise.resolve().then(() => (init_cron(), cron_exports));
-  const scheduler = new CronScheduler2(join19(getConfigDir3(), "cron"));
+  const scheduler = new CronScheduler2(join20(getConfigDir3(), "cron"));
   await scheduler.init();
   const removed = await scheduler.removeJob(id);
   console.log(removed ? `  Job ${id.slice(0, 8)} removed` : `  Job not found`);