0agent 1.0.43 → 1.0.45

package/bin/chat.js

@@ -7,7 +7,7 @@
  * /model to switch. /key to add provider keys. Never forgets previous keys.
  */
 
-import { createInterface, emitKeypressEvents, moveCursor, clearLine } from 'node:readline';
+import { createInterface, emitKeypressEvents } from 'node:readline';
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
@@ -31,6 +31,7 @@ const SLASH_COMMANDS = [
   { cmd: '/security-audit',desc: 'Security audit — find vulnerabilities'           },
   { cmd: '/design-review', desc: 'Design review — architecture and patterns'       },
   // Built-ins
+  { cmd: '/telegram',      desc: 'Connect Telegram bot — forward messages to 0agent'},
   { cmd: '/model',         desc: 'Show or switch the LLM model'                   },
   { cmd: '/key',           desc: 'Update a stored API key'                         },
   { cmd: '/status',        desc: 'Daemon health, graph stats, active sessions'     },
@@ -754,6 +755,33 @@ async function handleCommand(input) {
       break;
     }
 
+    // /telegram — configure Telegram bot token
+    case '/telegram': {
+      if (!cfg) { console.log(fmt(C.red, '  No config found. Run: 0agent init')); break; }
+      const existingToken = cfg?.telegram?.token;
+      if (existingToken) {
+        console.log(`\n  Telegram bot: ${fmt(C.green, '✓ configured')}`);
+        console.log(`  Token: ${existingToken.slice(0, 10)}••••`);
+        console.log(`  ${fmt(C.dim, 'To update: /telegram <new-token>\n')}`);
+      }
+      const token = parts[1];
+      if (!token) {
+        if (!existingToken) {
+          console.log('\n  Connect your Telegram bot to 0agent:\n');
+          console.log(`  1. Create a bot: ${fmt(C.cyan, 'https://t.me/BotFather')} → /newbot`);
+          console.log(`  2. Copy the token and run: ${fmt(C.cyan, '/telegram <token>')}`);
+          console.log(`  3. Restart daemon: ${fmt(C.dim, '0agent stop && 0agent start')}\n`);
+        }
+        break;
+      }
+      if (!cfg.telegram) cfg.telegram = {};
+      cfg.telegram.token = token;
+      saveConfig(cfg);
+      console.log(`  ${fmt(C.green, '✓')} Telegram token saved`);
+      console.log(`  ${fmt(C.dim, 'Restart daemon for changes to take effect: 0agent stop && 0agent start\n')}`);
+      break;
+    }
+
     case '/skills': {
       try {
         const skills = await fetch(`${BASE_URL}/api/skills`).then(r => r.json());
@@ -808,61 +836,114 @@ async function handleCommand(input) {
   }
 }
 
-// ─── Live slash-command menu ──────────────────────────────────────────────────
-// Drawn below the prompt as the user types. Uses moveCursor to avoid cursor
-// save/restore conflicts with readline.
-let _menuLines = 0; // how many lines the current menu occupies below the cursor
+// ─── Command palette ──────────────────────────────────────────────────────────
+// Fully takes over stdin when open. No cursor tricks — pauses readline,
+// reads raw bytes directly, draws with \x1b[NA\x1b[0J (up + clear-to-end).
+// Returns the selected command string, or null if cancelled.
 
-function _drawMenu(filter) {
-  if (pendingResolve) { _clearMenu(); return; } // don't show while session running
+let _paletteOpen = false;
 
-  const items = filter === null ? [] :
-    SLASH_COMMANDS.filter(c =>
-      !filter || c.cmd.slice(1).toLowerCase().startsWith(filter.toLowerCase())
-    ).slice(0, 10);
+async function openPalette(initialFilter = '') {
+  if (_paletteOpen || pendingResolve) return null;
+  _paletteOpen = true;
 
-  // If nothing changed (same count), skip redraw to avoid flicker
-  if (items.length === 0) { _clearMenu(); return; }
+  // Pause readline so it stops consuming stdin events
+  rl.pause();
+  // Resume the raw stream so our data handler receives bytes
+  process.stdin.resume();
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
-  const needed = items.length + 1; // +1 for blank line
+  let filter  = initialFilter.toLowerCase();
+  let idx     = 0;
+  let drawn   = 0; // number of lines we've printed so far
 
-  // Move down past existing menu lines (or 0), then clear downward
-  const existingLines = _menuLines;
-  if (existingLines > 0) {
-    moveCursor(process.stdout, 0, existingLines);
-    for (let i = 0; i < existingLines; i++) {
-      clearLine(process.stdout, 0);
-      if (i < existingLines - 1) moveCursor(process.stdout, 0, -1);
-    }
-    moveCursor(process.stdout, 0, -(existingLines - 1));
-  }
+  const getItems = () => SLASH_COMMANDS.filter(c =>
+    !filter || c.cmd.slice(1).startsWith(filter)
+  );
 
-  // Print blank separator + menu items, tracking column 0
-  process.stdout.write('\n');
-  for (const m of items) {
-    process.stdout.write(
-      `  ${fmt(C.cyan, m.cmd.padEnd(20))} ${fmt(C.dim, m.desc)}\x1b[K\n`
-    );
-  }
+  const paint = () => {
+    // Erase previous draw: move up `drawn` lines, clear everything below
+    if (drawn > 0) process.stdout.write(`\x1b[${drawn}A\x1b[0J`);
 
-  // Move back up to the prompt line and restore cursor after the typed text
-  moveCursor(process.stdout, 0, -(needed));
-  // Jump to end of current line (readline already put cursor there)
-  moveCursor(process.stdout, 999, 0);
+    const items  = getItems();
+    const show   = items.slice(0, 14);
+    if (idx >= items.length) idx = Math.max(0, items.length - 1);
 
-  _menuLines = needed;
-}
+    const lines = [];
 
-function _clearMenu() {
-  if (_menuLines === 0) return;
-  const n = _menuLines;
-  _menuLines = 0;
-  moveCursor(process.stdout, 0, n);
-  for (let i = 0; i < n; i++) {
-    clearLine(process.stdout, 0);
-    moveCursor(process.stdout, 0, -1);
-  }
-  moveCursor(process.stdout, 0, 1); // back to prompt line
+    // Top border
+    lines.push(`  \x1b[2m${'─'.repeat(58)}\x1b[0m`);
+
+    if (show.length === 0) {
+      lines.push(`  \x1b[2m  no commands match "/${filter}"\x1b[0m`);
+    } else {
+      for (let i = 0; i < show.length; i++) {
+        const m   = show[i];
+        const sel = i === idx;
+        if (sel) {
+          lines.push(
+            `  \x1b[36;1m›\x1b[0m \x1b[36;1m${m.cmd.padEnd(22)}\x1b[0m \x1b[0m${m.desc}\x1b[0m`
+          );
+        } else {
+          lines.push(
+            `    \x1b[36m${m.cmd.padEnd(22)}\x1b[0m \x1b[2m${m.desc}\x1b[0m`
+          );
+        }
+      }
+    }
+
+    if (items.length > 14) lines.push(`  \x1b[2m  …${items.length - 14} more\x1b[0m`);
+
+    // Bottom: search input line
+    lines.push(`  \x1b[2m${'─'.repeat(58)}\x1b[0m`);
+    lines.push(`  ${fmt(C.cyan, '/')}${filter}\x1b[K  \x1b[2m↑↓ navigate · Enter select · Esc cancel\x1b[0m`);
+
+    const out = lines.join('\n') + '\n';
+    process.stdout.write(out);
+    drawn = lines.length;
+  };
+
+  paint();
+
+  return new Promise((resolve) => {
+    const onData = (chunk) => {
+      const s = chunk.toString();
+
+      if (s === '\r' || s === '\n') {           // Enter — select
+        const sel = getItems()[idx]?.cmd ?? null;
+        finish(sel);
+      } else if (s === '\x1b' || s === '\x03') { // Esc / Ctrl-C — cancel
+        finish(null);
+      } else if (s === '\x1b[A') {              // Up arrow
+        idx = Math.max(0, idx - 1);
+        paint();
+      } else if (s === '\x1b[B') {              // Down arrow
+        idx = Math.min(getItems().length - 1, idx + 1);
+        paint();
+      } else if (s === '\x7f' || s === '\x08') { // Backspace
+        filter = filter.slice(0, -1);
+        idx = 0;
+        paint();
+      } else if (/^[a-z0-9\-_]$/i.test(s)) {   // Printable letter/digit/hyphen
+        filter += s.toLowerCase();
+        idx = 0;
+        paint();
+      }
+    };
+
+    const finish = (selected) => {
+      process.stdin.removeListener('data', onData);
+      // Erase the palette
+      if (drawn > 0) process.stdout.write(`\x1b[${drawn}A\x1b[0J`);
+      drawn = 0;
+      _paletteOpen = false;
+      // Hand control back to readline
+      rl.resume();
+      resolve(selected);
+    };
+
+    process.stdin.on('data', onData);
+  });
 }
 
 // ─── Main REPL ────────────────────────────────────────────────────────────────
@@ -874,50 +955,31 @@ const rl = createInterface({
   completer: (line, callback) => {
     if (!line.startsWith('/')) return callback(null, [[], line]);
 
-    const filter = line.slice(1).toLowerCase();
-    const matches = SLASH_COMMANDS.filter(c =>
-      !filter || c.cmd.slice(1).startsWith(filter)
-    );
-
-    if (matches.length === 0) return callback(null, [[], line]);
+    const filter  = line.slice(1).toLowerCase();
+    const matches = SLASH_COMMANDS.filter(c => !filter || c.cmd.slice(1).startsWith(filter));
 
-    // Single match — let readline silently auto-complete
-    if (matches.length === 1) {
-      _clearMenu();
-      return callback(null, [[matches[0].cmd + ' '], line]);
-    }
+    // Single exact match — let readline silently auto-complete
+    if (matches.length === 1) return callback(null, [[matches[0].cmd + ' '], line]);
 
-    // Multiple matches — print formatted menu, suppress readline's plain list
-    _clearMenu();
-    process.stdout.write('\n\n');
-    for (const m of matches.slice(0, 12)) {
-      process.stdout.write(`  ${fmt(C.cyan, m.cmd.padEnd(22))} ${fmt(C.dim, m.desc)}\n`);
-    }
-    if (matches.length > 12) {
-      process.stdout.write(`  ${fmt(C.dim, `…and ${matches.length - 12} more`)}\n`);
-    }
-    process.stdout.write('\n');
-    setImmediate(() => rl.prompt(true));
+    // Multiple (or bare /) — open interactive palette
+    // Schedule after this tick so readline finishes its Tab handling first
+    setImmediate(async () => {
+      // Clear the typed fragment from the prompt line before opening palette
+      process.stdout.write('\r\x1b[2K');
+      const selected = await openPalette(filter);
+      if (selected) {
+        await executeInput(selected);
+      } else {
+        rl.prompt();
+      }
+    });
     return callback(null, [[], line]);
   },
 });
 
-// Live menu on keypress — draws below the prompt as user types
+// Trigger palette when user types exactly '/' and presses Tab or Enter isn't needed —
+// the completer above handles Tab. For bare '/' + Enter, handled in rl.on('line') below.
 emitKeypressEvents(process.stdin, rl);
-process.stdin.on('keypress', (_char, key) => {
-  if (key?.name === 'return' || key?.name === 'enter') {
-    _clearMenu(); // clear before readline processes the line
-    return;
-  }
-  setImmediate(() => {
-    const line = rl.line ?? '';
-    if (line.startsWith('/') && !pendingResolve) {
-      _drawMenu(line.slice(1));
-    } else {
-      _clearMenu();
-    }
-  });
-});
 
 printHeader();
 printInsights();
@@ -1225,19 +1287,21 @@ async function drainQueue() {
 }
 
 rl.on('line', async (input) => {
-  _clearMenu(); // always clear menu when a line is submitted
   const line = input.trim();
   if (!line) { rl.prompt(); return; }
 
-  // Bare `/` → show full command palette
-  if (line === '/') {
-    console.log('');
-    for (const m of SLASH_COMMANDS) {
-      console.log(`  ${fmt(C.cyan, m.cmd.padEnd(22))} ${fmt(C.dim, m.desc)}`);
+  // Bare `/` or partial `/cmd` with no session running → open interactive palette
+  if (line.startsWith('/') && !pendingResolve) {
+    const filter = line === '/' ? '' : line.slice(1);
+    const exact  = SLASH_COMMANDS.find(c => c.cmd === line);
+    if (!exact) {
+      // Clear the echoed input line before opening palette
+      process.stdout.write('\x1b[1A\r\x1b[2K');
+      const selected = await openPalette(filter);
+      if (selected) await executeInput(selected);
+      else rl.prompt();
+      return;
     }
-    console.log('');
-    rl.prompt();
-    return;
   }
 
   // If a session is already running, queue the message.

package/dist/daemon.mjs

@@ -3027,13 +3027,19 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
           `- Be concise in your final response: state what was done and where to find it`,
           ...hasMemory ? [
             ``,
-            `Memory (IMPORTANT):`,
-            `- ALWAYS call memory_write after discovering important facts:`,
-            `  \xB7 Live URLs (ngrok, deployed apps, APIs): memory_write({label:"ngrok_url", content:"https://...", type:"url"})`,
+            `Memory (CRITICAL \u2014 write EVERYTHING you learn):`,
+            `- Call memory_write for ANY fact you discover \u2014 conversational OR from tools:`,
+            `  \xB7 User's name/identity: memory_write({label:"user_name", content:"Sahil", type:"identity"})`,
+            `  \xB7 Projects they mention: memory_write({label:"project_telegram_bot", content:"user has a Telegram bot", type:"project"})`,
+            `  \xB7 Tech stack / tools: memory_write({label:"tech_stack", content:"Node.js, Telegram", type:"tech"})`,
+            `  \xB7 Preferences and decisions they express`,
+            `  \xB7 Live URLs (ngrok, deployed apps): memory_write({label:"ngrok_url", content:"https://...", type:"url"})`,
             `  \xB7 Server ports: memory_write({label:"dev_server_port", content:"3000", type:"config"})`,
             `  \xB7 File paths of created projects: memory_write({label:"project_path", content:"/path/to/project", type:"path"})`,
-            `  \xB7 Task outcomes: memory_write({label:"last_task_result", content:"...", type:"outcome"})`,
-            `- Call memory_write immediately when you find the value, not just at the end`
+            `  \xB7 Task outcomes: memory_write({label:"last_outcome", content:"...", type:"outcome"})`,
+            `- Write to memory FIRST when the user tells you something about themselves or their work`,
+            `- If the user says "my name is X" \u2192 memory_write immediately, before anything else`,
+            `- If they say "we have a Y" or "our Y" \u2192 memory_write it as a project fact`
           ] : []
         ];
         if (isSelfMod && this.agentRoot) {
@@ -4516,6 +4522,7 @@ var SessionManager = class {
   weightUpdater;
   anthropicFetcher = new AnthropicSkillFetcher();
   agentRoot;
+  onMemoryWritten;
   constructor(deps = {}) {
     this.inferenceEngine = deps.inferenceEngine;
     this.eventBus = deps.eventBus;
@@ -4525,6 +4532,7 @@ var SessionManager = class {
     this.identity = deps.identity;
     this.projectContext = deps.projectContext;
     this.agentRoot = deps.agentRoot;
+    this.onMemoryWritten = deps.onMemoryWritten;
     if (deps.adapter) {
       this.conversationStore = new ConversationStore(deps.adapter);
       this.conversationStore.init();
@@ -4816,6 +4824,8 @@ Current task:`;
           this.addStep(sessionId, `Commands run: ${agentResult.commands_run.length}`);
         }
         this.addStep(sessionId, `Done (${agentResult.tokens_used} tokens, ${agentResult.iterations} LLM turns)`);
+        this._extractAndPersistFacts(enrichedReq.task, agentResult.output, activeLLM).catch(() => {
+        });
         this.completeSession(sessionId, {
           output: agentResult.output,
           files_written: agentResult.files_written,
@@ -4884,6 +4894,68 @@ Current task:`;
     }
     return this.llm;
   }
+  /**
+   * After every session, run a lightweight LLM pass to extract factual entities
+   * (name, projects, tech, preferences, URLs) and persist them to the graph.
+   * This catches everything the agent didn't explicitly memory_write during execution.
+   */
+  async _extractAndPersistFacts(task, output, llm) {
+    if (!this.graph || !llm.isConfigured) return;
+    const prompt = `Extract factual entities from this conversation that should be remembered long-term.
+Return ONLY a JSON array, no other text, max 12 items.
+
+Types: identity (name/role), project (apps/products), tech (stack/tools), preference, url, path, config, outcome
+
+Format: [{"label":"snake_case_key","content":"value to remember","type":"type"}]
+
+Examples:
+- User says "my name is Sahil" \u2192 {"label":"user_name","content":"Sahil","type":"identity"}
+- User says "we have a telegram bot" \u2192 {"label":"project_telegram_bot","content":"user has a Telegram bot project","type":"project"}
+- User says "I use React and Next.js" \u2192 {"label":"tech_stack","content":"React, Next.js","type":"tech"}
+
+Conversation:
+User: ${task.slice(0, 600)}
+Agent: ${output.slice(0, 400)}`;
+    try {
+      const resp = await llm.complete(
+        [{ role: "user", content: prompt }],
+        "You are a concise memory extraction system. Extract only factual, durable information. Skip generic statements."
+      );
+      const jsonMatch = resp.content.match(/\[[\s\S]*?\]/);
+      if (!jsonMatch) return;
+      const entities = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(entities) || entities.length === 0) return;
+      let wrote = 0;
+      for (const e of entities.slice(0, 12)) {
+        if (!e.label?.trim() || !e.content?.trim()) continue;
+        const nodeId = `memory:${e.label.toLowerCase().replace(/[^a-z0-9_]/g, "_")}`;
+        try {
+          const existing = this.graph.getNode(nodeId);
+          if (existing) {
+            this.graph.updateNode(nodeId, {
+              label: e.label,
+              metadata: { ...existing.metadata, content: e.content, type: e.type ?? "note", updated_at: (/* @__PURE__ */ new Date()).toISOString() }
+            });
+          } else {
+            this.graph.addNode(createNode({
+              id: nodeId,
+              graph_id: "root",
+              label: e.label,
+              type: "context" /* CONTEXT */,
+              metadata: { content: e.content, type: e.type ?? "note", saved_at: (/* @__PURE__ */ new Date()).toISOString() }
+            }));
+          }
+          wrote++;
+        } catch {
+        }
+      }
+      if (wrote > 0) {
+        console.log(`[0agent] Memory: extracted ${wrote} facts from session`);
+        this.onMemoryWritten?.();
+      }
+    } catch {
+    }
+  }
   /**
    * Convert a task result into a weight signal for the knowledge graph.
    *
@@ -6930,6 +7002,192 @@ var CodespaceManager = class {
 
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_RuntimeSelfHeal();
+
+// packages/daemon/src/TelegramBridge.ts
+var TelegramBridge = class {
+  constructor(config, sessions, eventBus) {
+    this.config = config;
+    this.sessions = sessions;
+    this.eventBus = eventBus;
+    this.token = config.token;
+    this.allowedUsers = new Set(config.allowed_users ?? []);
+  }
+  token;
+  allowedUsers;
+  offset = 0;
+  pollTimer = null;
+  running = false;
+  // session_id per chat for streaming
+  pendingSessions = /* @__PURE__ */ new Map();
+  start() {
+    if (this.running) return;
+    this.running = true;
+    console.log("[0agent] Telegram: bot polling started");
+    this._poll();
+    this.eventBus.onEvent((event) => {
+      const chatId = this._getChatIdForSession(String(event.session_id ?? ""));
+      if (!chatId) return;
+      if (event.type === "session.completed") {
+        const result = event.result;
+        const output = String(result?.output ?? "").trim();
+        if (output && output !== "(no output)") {
+          this._send(chatId, output).catch(() => {
+          });
+        }
+        this.pendingSessions.delete(chatId);
+      } else if (event.type === "session.failed") {
+        const err = String(event.error ?? "Task failed");
+        this._send(chatId, `\u26A0\uFE0F ${err}`).catch(() => {
+        });
+        this.pendingSessions.delete(chatId);
+      }
+    });
+  }
+  stop() {
+    this.running = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  _getChatIdForSession(sessionId) {
+    for (const [chatId, sid] of this.pendingSessions) {
+      if (sid === sessionId) return chatId;
+    }
+    return null;
+  }
+  async _poll() {
+    if (!this.running) return;
+    try {
+      const updates = await this._getUpdates();
+      for (const u of updates) {
+        await this._handleUpdate(u);
+      }
+    } catch {
+    }
+    if (this.running) {
+      this.pollTimer = setTimeout(() => this._poll(), 1e3);
+    }
+  }
+  async _getUpdates() {
+    const res = await fetch(
+      `https://api.telegram.org/bot${this.token}/getUpdates?offset=${this.offset}&timeout=10&limit=20`,
+      { signal: AbortSignal.timeout(15e3) }
+    );
+    if (!res.ok) return [];
+    const data = await res.json();
+    if (!data.ok || !data.result.length) return [];
+    this.offset = data.result[data.result.length - 1].update_id + 1;
+    return data.result;
+  }
+  async _handleUpdate(u) {
+    const msg = u.message;
+    if (!msg?.text || !msg.from) return;
+    const chatId = msg.chat.id;
+    const userId = msg.from.id;
+    const text = msg.text.trim();
+    const userName = msg.from.first_name ?? msg.from.username ?? "User";
+    if (this.allowedUsers.size > 0 && !this.allowedUsers.has(userId)) {
+      await this._send(chatId, "\u26D4 You are not authorised to use this agent.");
+      return;
+    }
+    if (text === "/start" || text === "/help") {
+      await this._send(
+        chatId,
+        `\u{1F44B} Hi ${userName}! I'm 0agent \u2014 your AI that runs on your machine.
+
+Send me any task and I'll get it done:
+\u2022 "make a website for my coffee shop"
+\u2022 "research my competitor's pricing"
+\u2022 "fix the bug in auth.ts"
+
+I remember everything across sessions.`
+      );
+      return;
+    }
+    if (text === "/status") {
+      try {
+        const r = await fetch("http://localhost:4200/api/health", { signal: AbortSignal.timeout(2e3) });
+        const h = await r.json();
+        await this._send(
+          chatId,
+          `\u2705 Daemon running
+Graph: ${h.graph_nodes} nodes \xB7 ${h.graph_edges} edges
+Sessions: ${h.active_sessions} active`
+        );
+      } catch {
+        await this._send(chatId, "\u26A0\uFE0F Daemon not reachable");
+      }
+      return;
+    }
+    await this._sendAction(chatId, "typing");
+    await this._send(chatId, `\u23F3 Working on it\u2026`);
+    try {
+      const res = await fetch("http://localhost:4200/api/sessions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          task: text,
+          context: { system_context: `User's name: ${userName}. Message from Telegram.` }
+        }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      const session = await res.json();
+      const sessionId = session.session_id ?? session.id;
+      if (sessionId) {
+        this.pendingSessions.set(chatId, sessionId);
+      } else {
+        await this._send(chatId, "\u26A0\uFE0F Could not start session");
+      }
+    } catch (e) {
+      await this._send(chatId, `\u26A0\uFE0F Error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  async _send(chatId, text) {
+    const chunks = this._splitMessage(text);
+    for (const chunk of chunks) {
+      await fetch(`https://api.telegram.org/bot${this.token}/sendMessage`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ chat_id: chatId, text: chunk, parse_mode: "Markdown" }),
+        signal: AbortSignal.timeout(1e4)
+      }).catch(() => {
+        return fetch(`https://api.telegram.org/bot${this.token}/sendMessage`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ chat_id: chatId, text: chunk }),
+          signal: AbortSignal.timeout(1e4)
+        }).catch(() => {
+        });
+      });
+    }
+  }
+  async _sendAction(chatId, action) {
+    await fetch(`https://api.telegram.org/bot${this.token}/sendChatAction`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, action }),
+      signal: AbortSignal.timeout(5e3)
+    }).catch(() => {
+    });
+  }
+  _splitMessage(text) {
+    if (text.length <= 4e3) return [text];
+    const chunks = [];
+    let i = 0;
+    while (i < text.length) {
+      chunks.push(text.slice(i, i + 4e3));
+      i += 4e3;
+    }
+    return chunks;
+  }
+  static isConfigured(config) {
+    const c = config;
+    return !!(c?.token && typeof c.token === "string" && c.token.length > 10);
+  }
+};
+
+// packages/daemon/src/ZeroAgentDaemon.ts
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { dirname as dirname6 } from "node:path";
 var ZeroAgentDaemon = class {
@@ -6949,6 +7207,7 @@ var ZeroAgentDaemon = class {
   codespaceManager = null;
   schedulerManager = null;
   runtimeHealer = null;
+  telegramBridge = null;
   startedAt = 0;
   pidFilePath;
   constructor() {
@@ -7042,8 +7301,12 @@ var ZeroAgentDaemon = class {
       identity: identity ?? void 0,
       projectContext: projectContext ?? void 0,
       adapter: this.adapter,
-      agentRoot
+      agentRoot,
       // agent source path — self-improvement tasks read the right files
+      // Mark GitHub memory dirty immediately when facts are extracted — pushes within 2min
+      onMemoryWritten: () => {
+        this.githubMemorySync?.markDirty();
+      }
     });
     const teamSync = identity && teams.length > 0 ? new TeamSync(teamManager, this.adapter, identity.entity_node_id) : null;
     if (this.githubMemorySync) {
@@ -7055,7 +7318,7 @@ var ZeroAgentDaemon = class {
             console.log(`[0agent] Memory auto-synced: ${result.nodes_synced} nodes`);
           }
         }
-      }, 30 * 60 * 1e3);
+      }, 2 * 60 * 1e3);
       if (typeof this.memorySyncTimer === "object") this.memorySyncTimer.unref?.();
     }
     let proactiveSurface = null;
@@ -7085,6 +7348,11 @@ var ZeroAgentDaemon = class {
     }
     this.schedulerManager = new SchedulerManager(this.adapter, this.sessionManager, this.eventBus);
     this.schedulerManager.start();
+    const tgCfg = this.config["telegram"];
+    if (TelegramBridge.isConfigured(tgCfg) && this.sessionManager && this.eventBus) {
+      this.telegramBridge = new TelegramBridge(tgCfg, this.sessionManager, this.eventBus);
+      this.telegramBridge.start();
+    }
     this.backgroundWorkers = new BackgroundWorkers({
       graph: this.graph,
       traceStore: this.traceStore,
@@ -7156,6 +7424,8 @@ var ZeroAgentDaemon = class {
       this.memorySyncTimer = null;
     }
     this.githubMemorySync = null;
+    this.telegramBridge?.stop();
+    this.telegramBridge = null;
     this.schedulerManager?.stop();
     this.schedulerManager = null;
     this.codespaceManager?.closeTunnel();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0agent",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",