npm - @tractorscorch/clank - Versions diffs - 1.3.0 → 1.4.0 - Mend

@tractorscorch/clank 1.3.0 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.js CHANGED Viewed

@@ -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);
     }
   }
@@ -1186,7 +1297,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 +1346,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 +1363,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 +1405,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 +1421,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 +1462,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 +1476,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 +1493,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 +1534,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 +1557,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 +1633,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 +1648,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 +1673,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 +1739,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 +1965,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 +1989,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 +2048,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 +2065,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"() {
@@ -3358,9 +3469,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 +3484,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 +3504,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 +3530,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 +3541,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 +3554,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 +3565,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 +3611,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 +3645,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 +3674,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 +3691,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 +3814,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 +3825,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 +3850,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 +3888,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") {
@@ -3931,11 +4042,9 @@ var init_tts = __esm({
       constructor(config) {
         this.config = config;
       }
-      /** Check if TTS is available */
       isAvailable() {
         return !!(this.config.integrations.elevenlabs?.enabled && this.config.integrations.elevenlabs?.apiKey);
       }
-      /** Convert text to speech */
       async synthesize(text, opts) {
         const elevenlabs = this.config.integrations.elevenlabs;
         if (!elevenlabs?.enabled || !elevenlabs.apiKey) return null;
@@ -3953,29 +4062,21 @@ var init_tts = __esm({
               body: JSON.stringify({
                 text,
                 model_id: model,
-                voice_settings: {
-                  stability: 0.5,
-                  similarity_boost: 0.75
-                }
+                voice_settings: { stability: 0.5, similarity_boost: 0.75 }
               })
             }
           );
           if (!res.ok) {
-            const err = await res.text().catch(() => "");
-            console.error(`ElevenLabs TTS error ${res.status}: ${err}`);
+            console.error(`ElevenLabs TTS error ${res.status}`);
             return null;
           }
           const arrayBuffer = await res.arrayBuffer();
-          return {
-            audioBuffer: Buffer.from(arrayBuffer),
-            format: "mp3"
-          };
+          return { audioBuffer: Buffer.from(arrayBuffer), format: "mp3" };
         } catch (err) {
           console.error(`TTS error: ${err instanceof Error ? err.message : err}`);
           return null;
         }
       }
-      /** List available voices from ElevenLabs */
       async listVoices() {
         const elevenlabs = this.config.integrations.elevenlabs;
         if (!elevenlabs?.enabled || !elevenlabs.apiKey) return [];
@@ -3996,53 +4097,67 @@ var init_tts = __esm({
       constructor(config) {
         this.config = config;
       }
-      /** Check if STT is available */
       isAvailable() {
         const whisper = this.config.integrations.whisper;
         if (whisper?.enabled) {
+          if (whisper.provider === "groq" && whisper.apiKey) return true;
           if (whisper.provider === "openai" && whisper.apiKey) return true;
           if (whisper.provider === "local") return true;
         }
         if (this.config.models.providers.openai?.apiKey) return true;
+        if (this.config.integrations.groq?.apiKey) return true;
         return false;
       }
-      /** Transcribe audio to text */
       async transcribe(audioBuffer, format = "ogg") {
         const whisper = this.config.integrations.whisper;
-        const apiKey = whisper?.apiKey || this.config.models.providers.openai?.apiKey;
-        if (apiKey && whisper?.provider !== "local") {
-          return this.transcribeOpenAI(audioBuffer, format, apiKey);
+        const groqKey = whisper?.provider === "groq" && whisper?.apiKey ? whisper.apiKey : this.config.integrations.groq?.apiKey;
+        if (groqKey) {
+          const result = await this.transcribeAPI(audioBuffer, format, groqKey, "https://api.groq.com/openai/v1/audio/transcriptions", "whisper-large-v3-turbo");
+          if (result) return result;
+        }
+        const openaiKey = whisper?.provider === "openai" && whisper?.apiKey ? whisper.apiKey : this.config.models.providers.openai?.apiKey;
+        if (openaiKey) {
+          const result = await this.transcribeAPI(audioBuffer, format, openaiKey, "https://api.openai.com/v1/audio/transcriptions", "whisper-1");
+          if (result) return result;
         }
-        return this.transcribeLocal(audioBuffer, format);
+        if (whisper?.provider === "local") {
+          return this.transcribeLocal(audioBuffer, format);
+        }
+        return null;
       }
-      /** Transcribe via OpenAI Whisper API */
-      async transcribeOpenAI(audioBuffer, format, apiKey) {
+      /** Transcribe via OpenAI-compatible API (works for both OpenAI and Groq) */
+      async transcribeAPI(audioBuffer, format, apiKey, endpoint, model) {
         try {
           const blob = new Blob([new Uint8Array(audioBuffer)], { type: `audio/${format}` });
           const formData = new FormData();
           formData.append("file", blob, `audio.${format}`);
-          formData.append("model", "whisper-1");
-          const res = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+          formData.append("model", model);
+          const res = await fetch(endpoint, {
             method: "POST",
             headers: { "Authorization": `Bearer ${apiKey}` },
             body: formData
           });
-          if (!res.ok) return null;
+          if (!res.ok) {
+            const errText = await res.text().catch(() => "");
+            console.error(`STT API error ${res.status}: ${errText.slice(0, 200)}`);
+            return null;
+          }
           const data = await res.json();
           return data.text ? { text: data.text, language: data.language } : null;
-        } catch {
+        } catch (err) {
+          console.error(`STT error: ${err instanceof Error ? err.message : err}`);
           return null;
         }
       }
       /** 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
@@ -4110,11 +4225,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)`;
       }
     };
@@ -4137,16 +4252,16 @@ var init_voice_tool = __esm({
         return { ok: true };
       },
       async execute(args) {
-        const { readFile: readFile12 } = await import("fs/promises");
-        const { existsSync: existsSync10 } = await import("fs");
+        const { readFile: readFile13 } = await import("fs/promises");
+        const { existsSync: existsSync12 } = await import("fs");
         const filePath = args.file_path;
-        if (!existsSync10(filePath)) return `Error: File not found: ${filePath}`;
+        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";
@@ -4178,6 +4293,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);
@@ -4191,6 +4353,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"() {
@@ -4205,6 +4368,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();
@@ -4214,6 +4378,7 @@ var init_self_config = __esm({
     init_gateway_tool();
     init_message_tool();
     init_voice_tool();
+    init_file_share_tool();
   }
 });
@@ -4275,7 +4440,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();
@@ -4292,9 +4457,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"
@@ -4342,7 +4507,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 = {
@@ -4500,9 +4665,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));
@@ -4650,12 +4815,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();
       }
@@ -4700,10 +4865,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;
@@ -4714,10 +4879,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;
@@ -4738,8 +4903,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, {
@@ -4784,15 +4949,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,
@@ -4817,9 +4982,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 {
@@ -4827,7 +4992,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");
       }
     };
   }
@@ -4839,6 +5004,7 @@ var init_memory2 = __esm({
     "use strict";
     init_esm_shims();
     init_memory();
+    init_auto_persist();
   }
 });
@@ -5034,15 +5200,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);
@@ -5106,7 +5310,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"));
@@ -5128,6 +5333,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;
@@ -5370,9 +5663,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({
@@ -5405,25 +5698,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 {
@@ -5433,9 +5726,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 = {
@@ -5447,7 +5740,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) {
@@ -5461,7 +5754,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) {
@@ -5519,8 +5812,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({
@@ -5554,12 +5847,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();
       }
@@ -5629,6 +5928,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,
           [],
@@ -5640,6 +5943,51 @@ 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 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;
@@ -5673,7 +6021,7 @@ var init_server = __esm({
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify({
             status: "ok",
-            version: "1.3.0",
+            version: "1.4.0",
             uptime: process.uptime(),
             clients: this.clients.size,
             agents: this.engines.size
@@ -5703,14 +6051,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;
@@ -5781,7 +6129,7 @@ var init_server = __esm({
         const hello = {
           type: "hello",
           protocol: PROTOCOL_VERSION,
-          version: "1.3.0",
+          version: "1.4.0",
           agents: this.config.agents.list.map((a) => ({
             id: a.id,
             name: a.name || a.id,
@@ -5955,6 +6303,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);
@@ -5969,6 +6321,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);
@@ -5994,10 +6355,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;
@@ -6112,9 +6477,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();
@@ -6127,7 +6492,7 @@ async function isGatewayRunning(port) {
   }
 }
 function pidFilePath() {
-  return join14(getConfigDir(), "gateway.pid");
+  return join15(getConfigDir(), "gateway.pid");
 }
 async function gatewayStartForeground(opts) {
   await ensureConfigDir();
@@ -6139,7 +6504,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..."));
@@ -6172,10 +6537,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"]
@@ -6204,9 +6569,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"));
@@ -6237,8 +6602,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 {
@@ -6266,8 +6631,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() {
@@ -6335,8 +6700,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"?>
@@ -6357,18 +6722,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);
@@ -6406,8 +6771,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]
@@ -6422,7 +6787,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");
@@ -6433,7 +6798,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"));
@@ -6474,7 +6839,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));
@@ -6577,8 +6942,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 {
@@ -6642,27 +7007,35 @@ async function runSetup(opts) {
         console.log(green4("    ElevenLabs configured (TTS available)"));
       }
     }
-    const addWhisper = await ask(rl, cyan2("  Set up speech-to-text (Whisper)? [y/N] "));
+    const addWhisper = await ask(rl, cyan2("  Set up speech-to-text (voice messages)? [y/N] "));
     if (addWhisper.toLowerCase() === "y") {
-      console.log(dim4("    1. OpenAI Whisper API (cloud, uses OpenAI key)"));
-      console.log(dim4("    2. Local whisper.cpp (requires whisper installed)"));
+      console.log(dim4("    1. Groq (recommended \u2014 free, fast)"));
+      console.log(dim4("    2. OpenAI Whisper API (paid, uses OpenAI key)"));
+      console.log(dim4("    3. Local whisper.cpp (requires manual install)"));
       const whisperChoice = await ask(rl, cyan2("    Choice [1]: "));
-      if (whisperChoice === "2") {
+      if (whisperChoice === "3") {
         config.integrations.whisper = { enabled: true, provider: "local" };
         console.log(green4("    Local whisper.cpp configured"));
         console.log(dim4("    Make sure whisper is installed and in PATH"));
-      } else {
+      } else if (whisperChoice === "2") {
         const existingKey = config.models.providers.openai?.apiKey;
         if (existingKey) {
           config.integrations.whisper = { enabled: true, provider: "openai", apiKey: existingKey };
           console.log(green4("    Whisper configured (using existing OpenAI key)"));
         } else {
-          const key = await ask(rl, cyan2("    OpenAI API key for Whisper: "));
+          const key = await ask(rl, cyan2("    OpenAI API key: "));
           if (key.trim()) {
             config.integrations.whisper = { enabled: true, provider: "openai", apiKey: key.trim() };
             console.log(green4("    Whisper configured"));
           }
         }
+      } else {
+        console.log(dim4("    Get a free API key at: https://console.groq.com/keys"));
+        const key = await ask(rl, cyan2("    Groq API key: "));
+        if (key.trim()) {
+          config.integrations.whisper = { enabled: true, provider: "groq", apiKey: key.trim() };
+          console.log(green4("    Groq Whisper configured (free, fast)"));
+        }
       }
     }
     if (isAdvanced) {
@@ -6731,9 +7104,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");
@@ -6763,7 +7136,7 @@ async function runFix(opts) {
 }
 async function checkConfig() {
   const configPath = getConfigPath();
-  if (!existsSync8(configPath)) {
+  if (!existsSync10(configPath)) {
     return {
       name: "Config",
       status: "warn",
@@ -6831,8 +7204,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 {
@@ -6844,8 +7217,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",
@@ -7138,7 +7511,7 @@ async function runTui(opts) {
   ws.on("open", () => {
     ws.send(JSON.stringify({
       type: "connect",
-      params: { auth: { token }, mode: "tui", version: "1.3.0" }
+      params: { auth: { token }, mode: "tui", version: "1.4.0" }
     }));
   });
   ws.on("message", (data) => {
@@ -7487,7 +7860,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("");
@@ -7526,7 +7899,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 {
@@ -7564,12 +7937,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.0";
+var version = "1.4.0";
 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 {
 }
@@ -7678,10 +8051,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) {
@@ -7693,10 +8066,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",
@@ -7707,10 +8080,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`);