@openacp/cli 2026.402.1 → 2026.402.3

package/dist/index.js

@@ -198,11 +198,11 @@ async function shutdownLogger() {
   logDir = void 0;
   initialized = false;
   if (transport) {
-    await new Promise((resolve5) => {
-      const timeout = setTimeout(resolve5, 3e3);
+    await new Promise((resolve6) => {
+      const timeout = setTimeout(resolve6, 3e3);
       transport.on("close", () => {
         clearTimeout(timeout);
-        resolve5();
+        resolve6();
       });
       transport.end();
     });
@@ -1263,7 +1263,7 @@ import https from "https";
 import os9 from "os";
 import { execSync } from "child_process";
 function downloadFile(url, dest) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const file = fs22.createWriteStream(dest);
     const cleanup = () => {
       try {
@@ -1275,7 +1275,7 @@ function downloadFile(url, dest) {
       if (response.statusCode === 301 || response.statusCode === 302) {
         file.close(() => {
           cleanup();
-          downloadFile(response.headers.location, dest).then(resolve5).catch(reject);
+          downloadFile(response.headers.location, dest).then(resolve6).catch(reject);
         });
         return;
       }
@@ -1287,7 +1287,7 @@ function downloadFile(url, dest) {
         return;
       }
       response.pipe(file);
-      file.on("finish", () => file.close(() => resolve5(dest)));
+      file.on("finish", () => file.close(() => resolve6(dest)));
       file.on("error", (err) => {
         file.close(() => {
           cleanup();
@@ -2306,6 +2306,160 @@ var init_static_server = __esm({
   }
 });
 
+// src/plugins/telegram/topics.ts
+var topics_exports = {};
+__export(topics_exports, {
+  buildDeepLink: () => buildDeepLink,
+  createSessionTopic: () => createSessionTopic,
+  deleteSessionTopic: () => deleteSessionTopic,
+  ensureTopics: () => ensureTopics,
+  renameSessionTopic: () => renameSessionTopic
+});
+async function ensureTopics(bot, chatId, config, saveConfig) {
+  let notificationTopicId = config.notificationTopicId;
+  let assistantTopicId = config.assistantTopicId;
+  if (notificationTopicId === null) {
+    const topic = await bot.api.createForumTopic(chatId, "\u{1F4CB} Notifications");
+    notificationTopicId = topic.message_thread_id;
+    await saveConfig({ notificationTopicId });
+  }
+  if (assistantTopicId === null) {
+    const topic = await bot.api.createForumTopic(chatId, "\u{1F916} Assistant");
+    assistantTopicId = topic.message_thread_id;
+    await saveConfig({ assistantTopicId });
+  }
+  return { notificationTopicId, assistantTopicId };
+}
+async function createSessionTopic(bot, chatId, name) {
+  const topic = await bot.api.createForumTopic(chatId, name);
+  return topic.message_thread_id;
+}
+async function renameSessionTopic(bot, chatId, threadId, name) {
+  try {
+    await bot.api.editForumTopic(chatId, threadId, { name });
+  } catch {
+  }
+}
+async function deleteSessionTopic(bot, chatId, threadId) {
+  await bot.api.deleteForumTopic(chatId, threadId);
+}
+function buildDeepLink(chatId, threadId, messageId) {
+  const cleanId = String(chatId).replace("-100", "");
+  if (messageId && messageId !== threadId) {
+    return `https://t.me/c/${cleanId}/${threadId}/${messageId}`;
+  }
+  return `https://t.me/c/${cleanId}/${threadId}`;
+}
+var init_topics = __esm({
+  "src/plugins/telegram/topics.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/version.ts
+var version_exports = {};
+__export(version_exports, {
+  checkAndPromptUpdate: () => checkAndPromptUpdate,
+  compareVersions: () => compareVersions,
+  getCurrentVersion: () => getCurrentVersion,
+  getLatestVersion: () => getLatestVersion,
+  runUpdate: () => runUpdate
+});
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname11, join as join20, resolve as resolve5 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync14 } from "fs";
+function findPackageJson() {
+  let dir = dirname11(fileURLToPath2(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    const candidate = join20(dir, "package.json");
+    if (existsSync18(candidate)) return candidate;
+    const parent = resolve5(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function getCurrentVersion() {
+  try {
+    const pkgPath = findPackageJson();
+    if (!pkgPath) return "0.0.0-dev";
+    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0-dev";
+  }
+}
+async function getLatestVersion() {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function compareVersions(current, latest) {
+  const a = current.split(".").map(Number);
+  const b = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return -1;
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return 1;
+  }
+  return 0;
+}
+async function runUpdate() {
+  const { spawn: spawn4 } = await import("child_process");
+  return new Promise((resolve6) => {
+    const child = spawn4("npm", ["install", "-g", `${NPM_PACKAGE}@latest`], {
+      stdio: "inherit",
+      shell: true
+    });
+    const onSignal = () => {
+      child.kill("SIGTERM");
+      resolve6(false);
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    child.on("close", (code) => {
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      resolve6(code === 0);
+    });
+  });
+}
+async function checkAndPromptUpdate() {
+  if (process.env.OPENACP_DEV_LOOP || process.env.OPENACP_SKIP_UPDATE_CHECK) return;
+  const current = getCurrentVersion();
+  if (current === "0.0.0-dev") return;
+  const latest = await getLatestVersion();
+  if (!latest || compareVersions(current, latest) >= 0) return;
+  console.log(`\x1B[33mUpdate available: v${current} \u2192 v${latest}\x1B[0m`);
+  const clack3 = await import("@clack/prompts");
+  const yes = await clack3.confirm({
+    message: "Update now before starting?"
+  });
+  if (clack3.isCancel(yes) || !yes) {
+    return;
+  }
+  const ok2 = await runUpdate();
+  if (ok2) {
+    console.log(`\x1B[32m\u2713 Updated to v${latest}. Please re-run your command.\x1B[0m`);
+    process.exit(0);
+  } else {
+    console.error("\x1B[31mUpdate failed. Continuing with current version.\x1B[0m");
+  }
+}
+var NPM_PACKAGE;
+var init_version = __esm({
+  "src/cli/version.ts"() {
+    "use strict";
+    NPM_PACKAGE = "@openacp/cli";
+  }
+});
+
 // src/cli/integrate.ts
 var integrate_exports = {};
 __export(integrate_exports, {
@@ -2314,8 +2468,8 @@ __export(integrate_exports, {
   listIntegrations: () => listIntegrations,
   uninstallIntegration: () => uninstallIntegration
 });
-import { existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync14, writeFileSync as writeFileSync12, unlinkSync as unlinkSync7, chmodSync, rmdirSync } from "fs";
-import { join as join20, dirname as dirname11 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync12, unlinkSync as unlinkSync7, chmodSync, rmdirSync } from "fs";
+import { join as join21, dirname as dirname12 } from "path";
 import { homedir as homedir10 } from "os";
 function expandPath(p) {
   return p.replace(/^~/, homedir10());
@@ -2437,8 +2591,8 @@ Examples:
 function mergeSettingsJson(settingsPath, hookEvent, hookScriptPath) {
   const fullPath = expandPath(settingsPath);
   let settings = {};
-  if (existsSync18(fullPath)) {
-    const raw = readFileSync14(fullPath, "utf-8");
+  if (existsSync19(fullPath)) {
+    const raw = readFileSync15(fullPath, "utf-8");
     writeFileSync12(`${fullPath}.bak`, raw);
     settings = JSON.parse(raw);
   }
@@ -2454,14 +2608,14 @@ function mergeSettingsJson(settingsPath, hookEvent, hookScriptPath) {
       hooks: [{ type: "command", command: hookScriptPath }]
     });
   }
-  mkdirSync12(dirname11(fullPath), { recursive: true });
+  mkdirSync12(dirname12(fullPath), { recursive: true });
   writeFileSync12(fullPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function mergeHooksJson(settingsPath, hookEvent, hookScriptPath) {
   const fullPath = expandPath(settingsPath);
   let config = { version: 1 };
-  if (existsSync18(fullPath)) {
-    const raw = readFileSync14(fullPath, "utf-8");
+  if (existsSync19(fullPath)) {
+    const raw = readFileSync15(fullPath, "utf-8");
     writeFileSync12(`${fullPath}.bak`, raw);
     config = JSON.parse(raw);
   }
@@ -2473,13 +2627,13 @@ function mergeHooksJson(settingsPath, hookEvent, hookScriptPath) {
   if (!alreadyInstalled) {
     eventHooks.push({ command: hookScriptPath });
   }
-  mkdirSync12(dirname11(fullPath), { recursive: true });
+  mkdirSync12(dirname12(fullPath), { recursive: true });
   writeFileSync12(fullPath, JSON.stringify(config, null, 2) + "\n");
 }
 function removeFromSettingsJson(settingsPath, hookEvent) {
   const fullPath = expandPath(settingsPath);
-  if (!existsSync18(fullPath)) return;
-  const raw = readFileSync14(fullPath, "utf-8");
+  if (!existsSync19(fullPath)) return;
+  const raw = readFileSync15(fullPath, "utf-8");
   const settings = JSON.parse(raw);
   const hooks = settings.hooks;
   if (!hooks?.[hookEvent]) return;
@@ -2493,8 +2647,8 @@ function removeFromSettingsJson(settingsPath, hookEvent) {
 }
 function removeFromHooksJson(settingsPath, hookEvent) {
   const fullPath = expandPath(settingsPath);
-  if (!existsSync18(fullPath)) return;
-  const raw = readFileSync14(fullPath, "utf-8");
+  if (!existsSync19(fullPath)) return;
+  const raw = readFileSync15(fullPath, "utf-8");
   const config = JSON.parse(raw);
   const hooks = config.hooks;
   if (!hooks?.[hookEvent]) return;
@@ -2517,30 +2671,30 @@ async function installIntegration(agentKey, spec) {
     }
     const hooksDir = expandPath(spec.hooksDirPath);
     mkdirSync12(hooksDir, { recursive: true });
-    const injectPath = join20(hooksDir, "openacp-inject-session.sh");
+    const injectPath = join21(hooksDir, "openacp-inject-session.sh");
     writeFileSync12(injectPath, generateInjectScript(agentKey, spec));
     chmodSync(injectPath, 493);
     logs.push(`Created ${injectPath}`);
-    const handoffPath = join20(hooksDir, "openacp-handoff.sh");
+    const handoffPath = join21(hooksDir, "openacp-handoff.sh");
     writeFileSync12(handoffPath, generateHandoffScript(agentKey));
     chmodSync(handoffPath, 493);
     logs.push(`Created ${handoffPath}`);
     if (spec.commandsPath && spec.handoffCommandName) {
       if (spec.commandFormat === "skill") {
-        const skillDir = expandPath(join20(spec.commandsPath, spec.handoffCommandName));
+        const skillDir = expandPath(join21(spec.commandsPath, spec.handoffCommandName));
         mkdirSync12(skillDir, { recursive: true });
-        const skillPath = join20(skillDir, "SKILL.md");
+        const skillPath = join21(skillDir, "SKILL.md");
         writeFileSync12(skillPath, generateHandoffCommand(agentKey, spec));
         logs.push(`Created ${skillPath}`);
       } else {
         const cmdsDir = expandPath(spec.commandsPath);
         mkdirSync12(cmdsDir, { recursive: true });
-        const cmdPath = join20(cmdsDir, `${spec.handoffCommandName}.md`);
+        const cmdPath = join21(cmdsDir, `${spec.handoffCommandName}.md`);
         writeFileSync12(cmdPath, generateHandoffCommand(agentKey, spec));
         logs.push(`Created ${cmdPath}`);
       }
     }
-    const injectFullPath = join20(hooksDir, "openacp-inject-session.sh");
+    const injectFullPath = join21(hooksDir, "openacp-inject-session.sh");
     if (spec.settingsFormat === "hooks_json") {
       mergeHooksJson(spec.settingsPath, spec.hookEvent, injectFullPath);
     } else {
@@ -2558,17 +2712,17 @@ async function uninstallIntegration(agentKey, spec) {
   try {
     const hooksDir = expandPath(spec.hooksDirPath);
     for (const filename of ["openacp-inject-session.sh", "openacp-handoff.sh"]) {
-      const filePath = join20(hooksDir, filename);
-      if (existsSync18(filePath)) {
+      const filePath = join21(hooksDir, filename);
+      if (existsSync19(filePath)) {
         unlinkSync7(filePath);
         logs.push(`Removed ${filePath}`);
       }
     }
     if (spec.commandsPath && spec.handoffCommandName) {
       if (spec.commandFormat === "skill") {
-        const skillDir = expandPath(join20(spec.commandsPath, spec.handoffCommandName));
-        const skillPath = join20(skillDir, "SKILL.md");
-        if (existsSync18(skillPath)) {
+        const skillDir = expandPath(join21(spec.commandsPath, spec.handoffCommandName));
+        const skillPath = join21(skillDir, "SKILL.md");
+        if (existsSync19(skillPath)) {
           unlinkSync7(skillPath);
           try {
             rmdirSync(skillDir);
@@ -2577,8 +2731,8 @@ async function uninstallIntegration(agentKey, spec) {
           logs.push(`Removed ${skillPath}`);
         }
       } else {
-        const cmdPath = expandPath(join20(spec.commandsPath, `${spec.handoffCommandName}.md`));
-        if (existsSync18(cmdPath)) {
+        const cmdPath = expandPath(join21(spec.commandsPath, `${spec.handoffCommandName}.md`));
+        if (existsSync19(cmdPath)) {
           unlinkSync7(cmdPath);
           logs.push(`Removed ${cmdPath}`);
         }
@@ -2603,7 +2757,7 @@ function buildHandoffItem(agentKey, spec) {
     name: "Handoff",
     description: "Transfer sessions between terminal and messaging platforms",
     isInstalled() {
-      return existsSync18(join20(hooksDir, "openacp-inject-session.sh")) && existsSync18(join20(hooksDir, "openacp-handoff.sh"));
+      return existsSync19(join21(hooksDir, "openacp-inject-session.sh")) && existsSync19(join21(hooksDir, "openacp-handoff.sh"));
     },
     install: () => installIntegration(agentKey, spec),
     uninstall: () => uninstallIntegration(agentKey, spec)
@@ -2617,20 +2771,20 @@ function getSkillBasePath(spec) {
 function buildTunnelItem(spec) {
   if (!spec.commandsPath) return null;
   function getTunnelPath() {
-    return join20(getSkillBasePath(spec), "openacp-tunnel", "SKILL.md");
+    return join21(getSkillBasePath(spec), "openacp-tunnel", "SKILL.md");
   }
   return {
     id: "tunnel",
     name: "Tunnel",
     description: "Expose local ports to the internet via OpenACP tunnel",
     isInstalled() {
-      return existsSync18(getTunnelPath());
+      return existsSync19(getTunnelPath());
     },
     async install() {
       const logs = [];
       try {
         const skillPath = getTunnelPath();
-        mkdirSync12(dirname11(skillPath), { recursive: true });
+        mkdirSync12(dirname12(skillPath), { recursive: true });
         writeFileSync12(skillPath, generateTunnelCommand());
         logs.push(`Created ${skillPath}`);
         return { success: true, logs };
@@ -2643,10 +2797,10 @@ function buildTunnelItem(spec) {
       const logs = [];
       try {
         const skillPath = getTunnelPath();
-        if (existsSync18(skillPath)) {
+        if (existsSync19(skillPath)) {
           unlinkSync7(skillPath);
           try {
-            rmdirSync(dirname11(skillPath));
+            rmdirSync(dirname12(skillPath));
           } catch {
           }
           logs.push(`Removed ${skillPath}`);
@@ -2688,13 +2842,13 @@ __export(menu_exports, {
   handleHelp: () => handleHelp,
   handleMenu: () => handleMenu
 });
-import { InlineKeyboard as InlineKeyboard4 } from "grammy";
+import { InlineKeyboard as InlineKeyboard5 } from "grammy";
 function buildMenuKeyboard(menuRegistry) {
   if (!menuRegistry) {
-    return new InlineKeyboard4().text("\u{1F195} New Session", "m:core:new").text("\u{1F4CB} Sessions", "m:core:sessions").row().text("\u{1F4CA} Status", "m:core:status").text("\u{1F916} Agents", "m:core:agents").row().text("\u2753 Help", "m:core:help");
+    return new InlineKeyboard5().text("\u{1F195} New Session", "m:core:new").text("\u{1F4CB} Sessions", "m:core:sessions").row().text("\u{1F4CA} Status", "m:core:status").text("\u{1F916} Agents", "m:core:agents").row().text("\u2753 Help", "m:core:help");
   }
   const items = menuRegistry.getItems();
-  const kb = new InlineKeyboard4();
+  const kb = new InlineKeyboard5();
   let currentGroup;
   let rowCount = 0;
   for (const item of items) {
@@ -2712,11 +2866,11 @@ function buildMenuKeyboard(menuRegistry) {
   }
   return kb;
 }
-async function handleMenu(ctx) {
+async function handleMenu(ctx, menuRegistry) {
   await ctx.reply(`<b>OpenACP Menu</b>
 Choose an action:`, {
     parse_mode: "HTML",
-    reply_markup: buildMenuKeyboard()
+    reply_markup: buildMenuKeyboard(menuRegistry)
   });
 }
 async function handleHelp(ctx) {
@@ -2733,7 +2887,7 @@ Each session gets its own topic \u2014 chat there to work with the agent.
 /status \u2014 Show session or system status
 /sessions \u2014 List all sessions
 /agents \u2014 Browse & install agents
-/install <name> \u2014 Install an agent
+/install &lt;name&gt; \u2014 Install an agent
 
 \u2699\uFE0F <b>System</b>
 /restart \u2014 Restart OpenACP
@@ -2803,16 +2957,19 @@ __export(assistant_exports, {
   redirectToAssistant: () => redirectToAssistant
 });
 function buildWelcomeMessage(ctx) {
-  const { activeCount, errorCount, totalCount, agents, defaultAgent } = ctx;
+  const { activeCount, errorCount, totalCount, agents, defaultAgent, workspace } = ctx;
   const agentList = agents.map((a) => `${a}${a === defaultAgent ? " (default)" : ""}`).join(", ");
   if (totalCount === 0) {
     return `\u{1F44B} <b>OpenACP is ready!</b>
 
+\u{1F4C2} ${workspace}
+
 No sessions yet. Tap \u{1F195} New Session to start, or ask me anything!`;
   }
   if (errorCount > 0) {
     return `\u{1F44B} <b>OpenACP is ready!</b>
 
+\u{1F4C2} ${workspace}
 \u{1F4CA} ${activeCount} active, ${errorCount} errors / ${totalCount} total
 \u26A0\uFE0F ${errorCount} session${errorCount > 1 ? "s have" : " has"} errors \u2014 ask me to check if you'd like.
 
@@ -2820,6 +2977,7 @@ Agents: ${agentList}`;
   }
   return `\u{1F44B} <b>OpenACP is ready!</b>
 
+\u{1F4C2} ${workspace}
 \u{1F4CA} ${activeCount} active / ${totalCount} total
 Agents: ${agentList}`;
 }
@@ -2867,13 +3025,13 @@ var ChannelAdapter = class {
 function nodeToWebWritable(nodeStream) {
   return new WritableStream({
     write(chunk) {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         const ok2 = nodeStream.write(chunk);
         if (ok2) {
-          resolve5();
+          resolve6();
           return;
         }
-        nodeStream.once("drain", resolve5);
+        nodeStream.once("drain", resolve6);
         nodeStream.once("error", reject);
       });
     },
@@ -3113,9 +3271,9 @@ var TerminalManager = class {
         signal: state.exitStatus.signal
       };
     }
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       state.process.on("exit", (code, signal) => {
-        resolve5({ exitCode: code, signal });
+        resolve6({ exitCode: code, signal });
       });
     });
   }
@@ -3292,7 +3450,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
         env: { ...process.env, ...agentDef.env }
       }
     );
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       instance.child.on("error", (err) => {
         reject(
           new Error(
@@ -3300,7 +3458,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
           )
         );
       });
-      instance.child.on("spawn", () => resolve5());
+      instance.child.on("spawn", () => resolve6());
     });
     instance.stderrCapture = new StderrCapture(50);
     instance.child.stderr.on("data", (chunk) => {
@@ -3726,15 +3884,15 @@ ${stderr}`
     this._destroying = true;
     this.terminalManager.destroyAll();
     if (this.child.exitCode !== null) return;
-    await new Promise((resolve5) => {
+    await new Promise((resolve6) => {
       this.child.on("exit", () => {
         clearTimeout(forceKillTimer);
-        resolve5();
+        resolve6();
       });
       this.child.kill("SIGTERM");
       const forceKillTimer = setTimeout(() => {
         if (this.child.exitCode === null) this.child.kill("SIGKILL");
-        resolve5();
+        resolve6();
       }, 1e4);
       if (typeof forceKillTimer === "object" && forceKillTimer !== null && "unref" in forceKillTimer) {
         forceKillTimer.unref();
@@ -3786,8 +3944,8 @@ var PromptQueue = class {
   abortController = null;
   async enqueue(text3, attachments) {
     if (this.processing) {
-      return new Promise((resolve5) => {
-        this.queue.push({ text: text3, attachments, resolve: resolve5 });
+      return new Promise((resolve6) => {
+        this.queue.push({ text: text3, attachments, resolve: resolve6 });
       });
     }
     await this.process(text3, attachments);
@@ -3855,8 +4013,8 @@ var PermissionGate = class {
     this.request = request;
     this.settled = false;
     this.clearTimeout();
-    return new Promise((resolve5, reject) => {
-      this.resolveFn = resolve5;
+    return new Promise((resolve6, reject) => {
+      this.resolveFn = resolve6;
       this.rejectFn = reject;
       this.timeoutTimer = setTimeout(() => {
         this.reject("Permission request timed out (no response received)");
@@ -6847,13 +7005,13 @@ function createPluginContext(opts) {
 var SETUP_TIMEOUT_MS = 3e4;
 var TEARDOWN_TIMEOUT_MS = 1e4;
 function withTimeout(promise, ms, label) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const timer = setTimeout(() => reject(new Error(`Timeout: ${label} exceeded ${ms}ms`)), ms);
     if (typeof timer === "object" && timer !== null && "unref" in timer) {
       ;
       timer.unref();
     }
-    promise.then(resolve5, reject).finally(() => clearTimeout(timer));
+    promise.then(resolve6, reject).finally(() => clearTimeout(timer));
   });
 }
 function resolvePluginConfig(pluginName, configManager) {
@@ -7242,8 +7400,8 @@ var AssistantManager = class {
     this.registry = registry;
   }
   sessions = /* @__PURE__ */ new Map();
-  readyState = /* @__PURE__ */ new Map();
   respawning = /* @__PURE__ */ new Set();
+  pendingSystemPrompts = /* @__PURE__ */ new Map();
   async spawn(channelId, threadId) {
     const session = await this.core.createSession({
       channelId,
@@ -7255,17 +7413,22 @@ var AssistantManager = class {
     session.threadId = threadId;
     this.sessions.set(channelId, session);
     const systemPrompt = this.registry.buildSystemPrompt(channelId);
-    const ready = session.enqueuePrompt(systemPrompt).then(() => {
-      log15.info({ sessionId: session.id, channelId }, "Assistant ready");
-    }).catch((err) => {
-      log15.warn({ err, channelId }, "Assistant system prompt failed");
-    });
-    this.readyState.set(channelId, ready);
+    this.pendingSystemPrompts.set(channelId, systemPrompt);
+    log15.info({ sessionId: session.id, channelId }, "Assistant spawned (system prompt deferred)");
     return session;
   }
   get(channelId) {
     return this.sessions.get(channelId) ?? null;
   }
+  /**
+   * Consume and return any pending system prompt for a channel.
+   * Should be prepended to the first real user message.
+   */
+  consumePendingSystemPrompt(channelId) {
+    const prompt = this.pendingSystemPrompts.get(channelId);
+    if (prompt) this.pendingSystemPrompts.delete(channelId);
+    return prompt;
+  }
   isAssistant(sessionId) {
     for (const s of this.sessions.values()) {
       if (s.id === sessionId) return true;
@@ -7285,9 +7448,6 @@ var AssistantManager = class {
       this.respawning.delete(channelId);
     }
   }
-  async waitReady(channelId) {
-    await this.readyState.get(channelId);
-  }
 };
 
 // src/core/assistant/sections/sessions.ts
@@ -7706,7 +7866,19 @@ var OpenACPCore = class {
     this.sessionManager.patchRecord(session.id, {
       lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
     });
-    await session.enqueuePrompt(message.text, message.attachments);
+    let text3 = message.text;
+    if (this.assistantManager?.isAssistant(session.id)) {
+      const pending = this.assistantManager.consumePendingSystemPrompt(message.channelId);
+      if (pending) {
+        text3 = `${pending}
+
+---
+
+User message:
+${text3}`;
+      }
+    }
+    await session.enqueuePrompt(text3, message.attachments);
   }
   // --- Unified Session Creation Pipeline ---
   async createSession(params) {
@@ -7813,8 +7985,8 @@ var OpenACPCore = class {
         message: `Agent '${agentName}' not found`
       };
     }
-    const { existsSync: existsSync19 } = await import("fs");
-    if (!existsSync19(cwd)) {
+    const { existsSync: existsSync20 } = await import("fs");
+    if (!existsSync20(cwd)) {
       return {
         ok: false,
         error: "invalid_cwd",
@@ -8468,12 +8640,12 @@ function isProcessAlive(pid) {
   }
 }
 function checkPortInUse(port) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const server = net.createServer();
-    server.once("error", () => resolve5(true));
+    server.once("error", () => resolve6(true));
     server.once("listening", () => {
       server.close();
-      resolve5(false);
+      resolve6(false);
     });
     server.listen(port, "127.0.0.1");
   });
@@ -9614,7 +9786,7 @@ function startDaemon(pidPath = getPidPath(), logDir2, instanceRoot) {
   return { pid: child.pid };
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function isProcessAlive2(pid) {
   try {
@@ -11426,10 +11598,10 @@ var SendQueue = class {
     const type = opts?.type ?? "other";
     const key = opts?.key;
     const category = opts?.category;
-    let resolve5;
+    let resolve6;
     let reject;
     const promise = new Promise((res, rej) => {
-      resolve5 = res;
+      resolve6 = res;
       reject = rej;
     });
     promise.catch(() => {
@@ -11440,12 +11612,12 @@ var SendQueue = class {
       );
       if (idx !== -1) {
         this.items[idx].resolve(void 0);
-        this.items[idx] = { fn, type, key, category, resolve: resolve5, reject, promise };
+        this.items[idx] = { fn, type, key, category, resolve: resolve6, reject, promise };
         this.scheduleProcess();
         return promise;
       }
     }
-    this.items.push({ fn, type, key, category, resolve: resolve5, reject, promise });
+    this.items.push({ fn, type, key, category, resolve: resolve6, reject, promise });
     this.scheduleProcess();
     return promise;
   }
@@ -12495,44 +12667,11 @@ Session logs auto-cleanup: 30 days (configurable via \`logging.sessionLogRetenti
 
 // src/plugins/telegram/adapter.ts
 init_log();
+init_topics();
 import { Bot, InputFile } from "grammy";
 
-// src/plugins/telegram/topics.ts
-async function ensureTopics(bot, chatId, config, saveConfig) {
-  let notificationTopicId = config.notificationTopicId;
-  let assistantTopicId = config.assistantTopicId;
-  if (notificationTopicId === null) {
-    const topic = await bot.api.createForumTopic(chatId, "\u{1F4CB} Notifications");
-    notificationTopicId = topic.message_thread_id;
-    await saveConfig({ notificationTopicId });
-  }
-  if (assistantTopicId === null) {
-    const topic = await bot.api.createForumTopic(chatId, "\u{1F916} Assistant");
-    assistantTopicId = topic.message_thread_id;
-    await saveConfig({ assistantTopicId });
-  }
-  return { notificationTopicId, assistantTopicId };
-}
-async function createSessionTopic(bot, chatId, name) {
-  const topic = await bot.api.createForumTopic(chatId, name);
-  return topic.message_thread_id;
-}
-async function renameSessionTopic(bot, chatId, threadId, name) {
-  try {
-    await bot.api.editForumTopic(chatId, threadId, { name });
-  } catch {
-  }
-}
-async function deleteSessionTopic(bot, chatId, threadId) {
-  await bot.api.deleteForumTopic(chatId, threadId);
-}
-function buildDeepLink(chatId, threadId, messageId) {
-  const cleanId = String(chatId).replace("-100", "");
-  if (messageId && messageId !== threadId) {
-    return `https://t.me/c/${cleanId}/${threadId}/${messageId}`;
-  }
-  return `https://t.me/c/${cleanId}/${threadId}`;
-}
+// src/plugins/telegram/commands/new-session.ts
+import { InlineKeyboard as InlineKeyboard2 } from "grammy";
 
 // src/plugins/telegram/formatting.ts
 function escapeHtml(text3) {
@@ -12747,6 +12886,7 @@ ${safeSection}` : safeSection;
 }
 
 // src/plugins/telegram/commands/new-session.ts
+init_topics();
 init_log();
 
 // src/plugins/telegram/commands/admin.ts
@@ -12920,6 +13060,79 @@ function setupVerbosityCallbacks(bot, core) {
     }
   });
 }
+async function handleUpdate(ctx, core) {
+  if (!core.requestRestart) {
+    await ctx.reply(
+      "\u26A0\uFE0F Update is not available (no restart handler registered).",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  const { getCurrentVersion: getCurrentVersion2, getLatestVersion: getLatestVersion2, compareVersions: compareVersions2, runUpdate: runUpdate2 } = await Promise.resolve().then(() => (init_version(), version_exports));
+  const current = getCurrentVersion2();
+  const statusMsg = await ctx.reply(
+    `\u{1F50D} Checking for updates... (current: v${escapeHtml(current)})`,
+    { parse_mode: "HTML" }
+  );
+  const latest = await getLatestVersion2();
+  if (!latest) {
+    await ctx.api.editMessageText(
+      ctx.chat.id,
+      statusMsg.message_id,
+      "\u274C Could not check for updates.",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  if (compareVersions2(current, latest) >= 0) {
+    await ctx.api.editMessageText(
+      ctx.chat.id,
+      statusMsg.message_id,
+      `\u2705 Already up to date (v${escapeHtml(current)}).`,
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    statusMsg.message_id,
+    `\u2B07\uFE0F Updating v${escapeHtml(current)} \u2192 v${escapeHtml(latest)}...`,
+    { parse_mode: "HTML" }
+  );
+  const ok2 = await runUpdate2();
+  if (!ok2) {
+    await ctx.api.editMessageText(
+      ctx.chat.id,
+      statusMsg.message_id,
+      "\u274C Update failed. Try manually: <code>npm install -g @openacp/cli@latest</code>",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    statusMsg.message_id,
+    `\u2705 Updated to v${escapeHtml(latest)}. Restarting...`,
+    { parse_mode: "HTML" }
+  );
+  await new Promise((r) => setTimeout(r, 500));
+  await core.requestRestart();
+}
+async function handleRestart(ctx, core) {
+  if (!core.requestRestart) {
+    await ctx.reply(
+      "\u26A0\uFE0F Restart is not available (no restart handler registered).",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  await ctx.reply(
+    "\u{1F504} <b>Restarting OpenACP...</b>\nRebuilding and restarting. Be back shortly.",
+    { parse_mode: "HTML" }
+  );
+  await new Promise((r) => setTimeout(r, 500));
+  await core.requestRestart();
+}
 
 // src/plugins/telegram/commands/new-session.ts
 var log22 = createChildLogger({ module: "telegram-cmd-new-session" });
@@ -12968,11 +13181,252 @@ async function createSessionDirect(ctx, core, chatId, agentName, workspace, onCo
     return null;
   }
 }
+var WS_CACHE_MAX = 50;
+var workspaceCache = /* @__PURE__ */ new Map();
+var nextWsId = 0;
+function cacheWorkspace(agentKey, workspace) {
+  const now = Date.now();
+  if (workspaceCache.size > WS_CACHE_MAX) {
+    for (const [id2, entry] of workspaceCache) {
+      if (now - entry.ts > 5 * 6e4 || workspaceCache.size > WS_CACHE_MAX) {
+        workspaceCache.delete(id2);
+      }
+    }
+  }
+  const id = nextWsId++;
+  workspaceCache.set(id, { agentKey, workspace, ts: now });
+  return id;
+}
+function shortenPath2(ws) {
+  const home = process.env.HOME || "";
+  return home && ws.startsWith(home) ? "~" + ws.slice(home.length) : ws;
+}
+async function showAgentPicker(ctx, core, chatId) {
+  const catalog = core.agentCatalog;
+  const installed = catalog.getAvailable().filter((i) => i.installed);
+  if (installed.length === 0) {
+    await ctx.reply("No agents installed. Use /install to add one.", { parse_mode: "HTML" }).catch(() => {
+    });
+    return;
+  }
+  if (installed.length === 1) {
+    await showWorkspacePicker(ctx, core, chatId, installed[0].key, true);
+    return;
+  }
+  const kb = new InlineKeyboard2();
+  for (let i = 0; i < installed.length; i += 2) {
+    const row = installed.slice(i, i + 2);
+    for (const agent of row) {
+      kb.text(agent.name, `ns:agent:${agent.key}`);
+    }
+    kb.row();
+  }
+  await ctx.reply("<b>\u{1F195} New Session</b>\nSelect an agent:", {
+    parse_mode: "HTML",
+    reply_markup: kb
+  }).catch(() => {
+  });
+}
+async function showWorkspacePicker(ctx, core, chatId, agentKey, newMessage = false) {
+  const records = core.sessionManager.listRecords();
+  const recentWorkspaces = [...new Set(records.map((r) => r.workingDir).filter(Boolean))].slice(0, 5);
+  const config = core.configManager.get();
+  const baseDir = config.workspace.baseDir;
+  const resolvedBaseDir = core.configManager.resolveWorkspace(baseDir);
+  const hasBaseDir = recentWorkspaces.some((ws) => ws === baseDir || ws === resolvedBaseDir);
+  const workspaces = hasBaseDir ? recentWorkspaces : [resolvedBaseDir, ...recentWorkspaces].slice(0, 5);
+  const kb = new InlineKeyboard2();
+  for (const ws of workspaces) {
+    const id = cacheWorkspace(agentKey, ws);
+    kb.text(`\u{1F4C1} ${shortenPath2(ws)}`, `ns:ws:${id}`).row();
+  }
+  kb.text("\u{1F4C1} Custom path...", `ns:custom:${agentKey}`).row();
+  const agentLabel = escapeHtml(agentKey);
+  const text3 = `<b>\u{1F195} New Session</b>
+Agent: <code>${agentLabel}</code>
+
+Select workspace:`;
+  const opts = { parse_mode: "HTML", reply_markup: kb };
+  if (newMessage) {
+    await ctx.reply(text3, opts).catch(() => {
+    });
+  } else {
+    try {
+      await ctx.editMessageText(text3, opts);
+    } catch {
+      await ctx.reply(text3, opts).catch(() => {
+      });
+    }
+  }
+}
+function setupNewSessionCallbacks(bot, core, chatId, getAssistantSession) {
+  bot.callbackQuery("ns:start", async (ctx) => {
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    await showAgentPicker(ctx, core, chatId);
+  });
+  bot.callbackQuery(/^ns:agent:/, async (ctx) => {
+    const agentKey = ctx.callbackQuery.data.replace("ns:agent:", "");
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    await showWorkspacePicker(ctx, core, chatId, agentKey);
+  });
+  bot.callbackQuery(/^ns:ws:/, async (ctx) => {
+    const id = parseInt(ctx.callbackQuery.data.replace("ns:ws:", ""), 10);
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    const entry = workspaceCache.get(id);
+    if (!entry) {
+      try {
+        await ctx.editMessageText("\u26A0\uFE0F Session expired. Please try again via /menu.");
+      } catch {
+      }
+      return;
+    }
+    workspaceCache.delete(id);
+    try {
+      await ctx.editMessageText(
+        `<b>\u{1F195} New Session</b>
+Agent: <code>${escapeHtml(entry.agentKey)}</code>
+Workspace: <code>${escapeHtml(shortenPath2(entry.workspace))}</code>
+
+\u23F3 Creating session...`,
+        { parse_mode: "HTML" }
+      );
+    } catch {
+    }
+    const threadId = await createSessionDirect(ctx, core, chatId, entry.agentKey, entry.workspace);
+    if (threadId) {
+      const { buildDeepLink: buildDeepLink2 } = await Promise.resolve().then(() => (init_topics(), topics_exports));
+      const link = buildDeepLink2(chatId, threadId);
+      try {
+        await ctx.editMessageText(
+          `<b>\u2705 Session created</b>
+Agent: <code>${escapeHtml(entry.agentKey)}</code>
+Workspace: <code>${escapeHtml(shortenPath2(entry.workspace))}</code>
+
+<a href="${link}">Open session \u2192</a>`,
+          { parse_mode: "HTML" }
+        );
+      } catch {
+      }
+    } else {
+      try {
+        await ctx.editMessageText(
+          `<b>\u274C Session creation failed</b>
+Agent: <code>${escapeHtml(entry.agentKey)}</code>
+Workspace: <code>${escapeHtml(shortenPath2(entry.workspace))}</code>
+
+Try again with /new or /menu`,
+          { parse_mode: "HTML" }
+        );
+      } catch {
+      }
+    }
+  });
+  bot.callbackQuery(/^ns:custom:/, async (ctx) => {
+    const agentKey = ctx.callbackQuery.data.replace("ns:custom:", "");
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    const assistant = getAssistantSession?.();
+    if (assistant) {
+      try {
+        await ctx.editMessageText(
+          `<b>\u{1F195} New Session</b>
+Agent: <code>${escapeHtml(agentKey)}</code>
+
+\u{1F4AC} Type your workspace path in the chat below.`,
+          { parse_mode: "HTML" }
+        );
+      } catch {
+      }
+      await assistant.enqueuePrompt(
+        `User wants to create a new session with agent "${agentKey}". Ask them for the workspace (project directory) path, then create the session.`
+      );
+    } else {
+      try {
+        await ctx.editMessageText(
+          `Usage: <code>/new ${escapeHtml(agentKey)} &lt;workspace-path&gt;</code>`,
+          { parse_mode: "HTML" }
+        );
+      } catch {
+      }
+    }
+  });
+}
 
 // src/plugins/telegram/commands/session.ts
-import { InlineKeyboard as InlineKeyboard2 } from "grammy";
+import { InlineKeyboard as InlineKeyboard3 } from "grammy";
 init_log();
 var log23 = createChildLogger({ module: "telegram-cmd-session" });
+async function handleTopics(ctx, core) {
+  try {
+    const allRecords = core.sessionManager.listRecords();
+    const records = allRecords.filter((r) => {
+      const platform2 = r.platform;
+      return !!platform2?.topicId;
+    });
+    const headlessCount = allRecords.length - records.length;
+    if (records.length === 0) {
+      const extra = headlessCount > 0 ? ` (${headlessCount} headless hidden)` : "";
+      await ctx.reply(`No sessions with topics found.${extra}`, { parse_mode: "HTML" });
+      return;
+    }
+    const statusEmoji = {
+      active: "\u{1F7E2}",
+      initializing: "\u{1F7E1}",
+      finished: "\u2705",
+      error: "\u274C",
+      cancelled: "\u26D4"
+    };
+    const statusOrder = { active: 0, initializing: 1, error: 2, finished: 3, cancelled: 4 };
+    records.sort((a, b) => (statusOrder[a.status] ?? 5) - (statusOrder[b.status] ?? 5));
+    const MAX_DISPLAY = 30;
+    const displayed = records.slice(0, MAX_DISPLAY);
+    const lines = displayed.map((r) => {
+      const emoji = statusEmoji[r.status] || "\u26AA";
+      const name = r.name?.trim();
+      const label = name ? escapeHtml(name) : `<i>${escapeHtml(r.agentName)} session</i>`;
+      return `${emoji} ${label}  <code>[${r.status}]</code>`;
+    });
+    const header2 = `<b>Sessions: ${records.length}</b>` + (headlessCount > 0 ? ` (${headlessCount} headless hidden)` : "");
+    const truncated = records.length > MAX_DISPLAY ? `
+
+<i>...and ${records.length - MAX_DISPLAY} more</i>` : "";
+    const finishedCount = allRecords.filter((r) => r.status === "finished").length;
+    const errorCount = allRecords.filter((r) => r.status === "error" || r.status === "cancelled").length;
+    const keyboard = new InlineKeyboard3();
+    if (finishedCount > 0) {
+      keyboard.text(`Cleanup finished (${finishedCount})`, "m:cleanup:finished").row();
+    }
+    if (errorCount > 0) {
+      keyboard.text(`Cleanup errors (${errorCount})`, "m:cleanup:errors").row();
+    }
+    if (finishedCount + errorCount > 0) {
+      keyboard.text(`Cleanup all non-active (${finishedCount + errorCount})`, "m:cleanup:all").row();
+    }
+    keyboard.text(`\u26A0\uFE0F Cleanup ALL (${allRecords.length})`, "m:cleanup:everything").row();
+    keyboard.text("Refresh", "m:topics");
+    await ctx.reply(
+      `${header2}
+
+${lines.join("\n")}${truncated}`,
+      { parse_mode: "HTML", reply_markup: keyboard }
+    );
+  } catch (err) {
+    log23.error({ err }, "handleTopics error");
+    await ctx.reply("\u274C Failed to list sessions.", { parse_mode: "HTML" }).catch(() => {
+    });
+  }
+}
 async function handleCleanup(ctx, core, chatId, statuses) {
   const allRecords = core.sessionManager.listRecords();
   const cleanable = allRecords.filter((r) => statuses.includes(r.status));
@@ -13031,7 +13485,7 @@ async function handleCleanupEverything(ctx, core, chatId, systemTopicIds) {
   const activeWarning = activeCount > 0 ? `
 
 \u26A0\uFE0F <b>${activeCount} active session(s) will be cancelled and their agents stopped!</b>` : "";
-  const keyboard = new InlineKeyboard2().text("Yes, delete all", "m:cleanup:everything:confirm").text("Cancel", "m:topics");
+  const keyboard = new InlineKeyboard3().text("Yes, delete all", "m:cleanup:everything:confirm").text("Cancel", "m:topics");
   await ctx.reply(
     `<b>Delete ${cleanable.length} topics?</b>
 
@@ -13114,6 +13568,13 @@ function setupSessionCallbacks(bot, core, chatId, systemTopicIds) {
         break;
     }
   });
+  bot.callbackQuery("m:topics", async (ctx) => {
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    await handleTopics(ctx, core);
+  });
 }
 async function handleArchiveConfirm(ctx, core, chatId) {
   const data = ctx.callbackQuery?.data;
@@ -13143,8 +13604,74 @@ async function handleArchiveConfirm(ctx, core, chatId) {
 }
 
 // src/plugins/telegram/commands/agents.ts
-import { InlineKeyboard as InlineKeyboard3 } from "grammy";
+import { InlineKeyboard as InlineKeyboard4 } from "grammy";
 var AGENTS_PER_PAGE = 6;
+async function handleAgents(ctx, core, page = 0) {
+  const catalog = core.agentCatalog;
+  const items = catalog.getAvailable();
+  const installed = items.filter((i) => i.installed);
+  const available = items.filter((i) => !i.installed);
+  let text3 = "<b>\u{1F916} Agents</b>\n\n";
+  if (installed.length > 0) {
+    text3 += "<b>Installed:</b>\n";
+    for (const item of installed) {
+      text3 += `\u2705 <b>${escapeHtml(item.name)}</b>`;
+      if (item.description) {
+        text3 += ` \u2014 <i>${escapeHtml(truncate(item.description, 50))}</i>`;
+      }
+      text3 += "\n";
+    }
+    text3 += "\n";
+  }
+  if (available.length > 0) {
+    const totalPages = Math.ceil(available.length / AGENTS_PER_PAGE);
+    const safePage = Math.max(0, Math.min(page, totalPages - 1));
+    const pageItems = available.slice(safePage * AGENTS_PER_PAGE, (safePage + 1) * AGENTS_PER_PAGE);
+    text3 += `<b>Available to install:</b>`;
+    if (totalPages > 1) {
+      text3 += ` (${safePage + 1}/${totalPages})`;
+    }
+    text3 += "\n";
+    for (const item of pageItems) {
+      if (item.available) {
+        text3 += `\u2B07\uFE0F <b>${escapeHtml(item.name)}</b>`;
+      } else {
+        const deps = item.missingDeps?.join(", ") ?? "requirements not met";
+        text3 += `\u26A0\uFE0F <b>${escapeHtml(item.name)}</b> <i>(needs: ${escapeHtml(deps)})</i>`;
+      }
+      if (item.description) {
+        text3 += `
+    <i>${escapeHtml(truncate(item.description, 60))}</i>`;
+      }
+      text3 += "\n";
+    }
+    const keyboard = new InlineKeyboard4();
+    const installable = pageItems.filter((i) => i.available);
+    for (let i = 0; i < installable.length; i += 2) {
+      const row = installable.slice(i, i + 2);
+      for (const item of row) {
+        keyboard.text(`\u2B07\uFE0F ${item.name}`, `ag:install:${item.key}`);
+      }
+      keyboard.row();
+    }
+    if (totalPages > 1) {
+      if (safePage > 0) {
+        keyboard.text("\u25C0\uFE0F Prev", `ag:page:${safePage - 1}`);
+      }
+      if (safePage < totalPages - 1) {
+        keyboard.text("Next \u25B6\uFE0F", `ag:page:${safePage + 1}`);
+      }
+      keyboard.row();
+    }
+    if (available.some((i) => !i.available)) {
+      text3 += "\n\u{1F4A1} <i>Agents marked \u26A0\uFE0F need additional setup. Use</i> <code>openacp agents info &lt;name&gt;</code> <i>for details.</i>\n";
+    }
+    await ctx.reply(text3, { parse_mode: "HTML", reply_markup: keyboard });
+  } else {
+    text3 += "<i>All agents are already installed!</i>";
+    await ctx.reply(text3, { parse_mode: "HTML" });
+  }
+}
 async function handleAgentCallback(ctx, core) {
   const data = ctx.callbackQuery?.data ?? "";
   await ctx.answerCallbackQuery();
@@ -13193,7 +13720,7 @@ async function handleAgentCallback(ctx, core) {
         }
         text3 += "\n";
       }
-      const keyboard = new InlineKeyboard3();
+      const keyboard = new InlineKeyboard4();
       const installable = pageItems.filter((i) => i.available);
       for (let i = 0; i < installable.length; i += 2) {
         const row = installable.slice(i, i + 2);
@@ -13248,7 +13775,7 @@ Downloading... ${bar} ${percent}%`, { parse_mode: "HTML" });
     },
     async onSuccess(name) {
       try {
-        const keyboard = new InlineKeyboard3().text(`\u{1F680} Start session with ${name}`, `na:${nameOrId}`);
+        const keyboard = new InlineKeyboard4().text(`\u{1F680} Start session with ${name}`, `na:${nameOrId}`);
         await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u2705 <b>${escapeHtml(name)}</b> installed!`, { parse_mode: "HTML", reply_markup: keyboard });
       } catch {
       }
@@ -13333,6 +13860,7 @@ function buildProgressBar(percent) {
 }
 
 // src/plugins/telegram/commands/resume.ts
+init_topics();
 init_log();
 var log24 = createChildLogger({ module: "telegram-cmd-resume" });
 function setupResumeCallbacks(_bot, _core, _chatId, _onControlMessage) {
@@ -13341,12 +13869,12 @@ function setupResumeCallbacks(_bot, _core, _chatId, _onControlMessage) {
 // src/plugins/telegram/commands/settings.ts
 init_config_registry();
 init_log();
-import { InlineKeyboard as InlineKeyboard5 } from "grammy";
+import { InlineKeyboard as InlineKeyboard6 } from "grammy";
 var log25 = createChildLogger({ module: "telegram-settings" });
 function buildSettingsKeyboard(core) {
   const config = core.configManager.get();
   const fields = getSafeFields();
-  const kb = new InlineKeyboard5();
+  const kb = new InlineKeyboard6();
   for (const field of fields) {
     const value = getConfigValue(config, field.path);
     const label = formatFieldLabel(field, value);
@@ -13378,6 +13906,14 @@ function formatFieldLabel(field, value) {
   const displayValue = value === null || value === void 0 ? "Not set" : String(value);
   return `${icon} ${field.displayName}: ${displayValue}`;
 }
+async function handleSettings(ctx, core) {
+  const kb = buildSettingsKeyboard(core);
+  await ctx.reply(`<b>\u2699\uFE0F Settings</b>
+Tap to change:`, {
+    parse_mode: "HTML",
+    reply_markup: kb
+  });
+}
 function setupSettingsCallbacks(bot, core, getAssistantSession) {
   bot.callbackQuery(/^s:toggle:/, async (ctx) => {
     const fieldPath = ctx.callbackQuery.data.replace("s:toggle:", "");
@@ -13411,7 +13947,7 @@ function setupSettingsCallbacks(bot, core, getAssistantSession) {
     if (!fieldDef) return;
     const options = resolveOptions(fieldDef, config) ?? [];
     const currentValue = getConfigValue(config, fieldPath);
-    const kb = new InlineKeyboard5();
+    const kb = new InlineKeyboard6();
     for (const opt of options) {
       const marker = opt === String(currentValue) ? " \u2713" : "";
       kb.text(`${opt}${marker}`, `s:pick:${fieldPath}:${opt}`).row();
@@ -13505,11 +14041,12 @@ Tap to change:`, {
     } catch {
     }
     const { buildMenuKeyboard: buildMenuKeyboard2 } = await Promise.resolve().then(() => (init_menu(), menu_exports));
+    const menuRegistry = core.lifecycleManager?.serviceRegistry?.get("menu-registry");
     try {
       await ctx.editMessageText(`<b>OpenACP Menu</b>
 Choose an action:`, {
         parse_mode: "HTML",
-        reply_markup: buildMenuKeyboard2()
+        reply_markup: buildMenuKeyboard2(menuRegistry)
       });
     } catch {
     }
@@ -13542,7 +14079,7 @@ function buildNestedUpdate(dotPath, value) {
 }
 
 // src/plugins/telegram/commands/doctor.ts
-import { InlineKeyboard as InlineKeyboard6 } from "grammy";
+import { InlineKeyboard as InlineKeyboard7 } from "grammy";
 init_log();
 var log26 = createChildLogger({ module: "telegram-cmd-doctor" });
 var pendingFixesStore = /* @__PURE__ */ new Map();
@@ -13561,7 +14098,7 @@ function renderReport(report) {
   lines.push(`<b>Result:</b> ${passed} passed, ${warnings} warnings, ${failed} failed${fixedStr}`);
   let keyboard;
   if (report.pendingFixes.length > 0) {
-    keyboard = new InlineKeyboard6();
+    keyboard = new InlineKeyboard7();
     for (let i = 0; i < report.pendingFixes.length; i++) {
       const label = `\u{1F527} Fix: ${report.pendingFixes[i].message.slice(0, 30)}`;
       keyboard.text(label, `m:doctor:fix:${i}`).row();
@@ -13649,7 +14186,7 @@ function setupDoctorCallbacks(bot) {
 }
 
 // src/plugins/telegram/commands/tunnel.ts
-import { InlineKeyboard as InlineKeyboard7 } from "grammy";
+import { InlineKeyboard as InlineKeyboard8 } from "grammy";
 init_log();
 var log27 = createChildLogger({ module: "telegram-cmd-tunnel" });
 function setupTunnelCallbacks(bot, core) {
@@ -13678,7 +14215,7 @@ function setupTunnelCallbacks(bot, core) {
         if (remaining.length === 0) {
           await ctx.editMessageText("\u{1F50C} All tunnels stopped.", { parse_mode: "HTML" });
         } else {
-          const kb = new InlineKeyboard7();
+          const kb = new InlineKeyboard8();
           for (const e of remaining) {
             kb.text(`\u{1F50C} Stop ${e.port}${e.label ? ` (${e.label})` : ""}`, `tn:stop:${e.port}`).row();
           }
@@ -13706,7 +14243,7 @@ function setupTunnelCallbacks(bot, core) {
 }
 
 // src/plugins/telegram/commands/switch.ts
-import { InlineKeyboard as InlineKeyboard8 } from "grammy";
+import { InlineKeyboard as InlineKeyboard9 } from "grammy";
 init_log();
 var log28 = createChildLogger({ module: "telegram-cmd-switch" });
 async function executeSwitchAgent(ctx, core, sessionId, agentName) {
@@ -13735,7 +14272,7 @@ function setupSwitchCallbacks(bot, core) {
       return;
     }
     if (session.promptRunning) {
-      const keyboard = new InlineKeyboard8();
+      const keyboard = new InlineKeyboard9();
       keyboard.text("Yes, switch now", `swc:${agentName}`).text("Cancel", "swc:cancel");
       await ctx.reply(
         `A prompt is currently running. Switching will interrupt it.
@@ -13766,14 +14303,29 @@ Switch to <b>${escapeHtml(agentName)}</b> anyway?`,
   });
 }
 
+// src/plugins/telegram/commands/telegram-overrides.ts
+init_menu();
+var TELEGRAM_OVERRIDES = {
+  agents: (ctx, core) => handleAgents(ctx, core),
+  sessions: (ctx, core) => handleTopics(ctx, core),
+  doctor: (ctx) => handleDoctor(ctx),
+  update: (ctx, core) => handleUpdate(ctx, core),
+  restart: (ctx, core) => handleRestart(ctx, core),
+  help: (ctx) => handleHelp(ctx),
+  menu: (ctx, core) => {
+    const menuRegistry = core.lifecycleManager?.serviceRegistry?.get("menu-registry");
+    return handleMenu(ctx, menuRegistry);
+  }
+};
+
 // src/plugins/telegram/commands/index.ts
 init_menu();
 init_menu();
 
 // src/plugins/telegram/commands/integrate.ts
-import { InlineKeyboard as InlineKeyboard9 } from "grammy";
+import { InlineKeyboard as InlineKeyboard10 } from "grammy";
 function buildAgentItemsKeyboard(agentName, items) {
-  const keyboard = new InlineKeyboard9();
+  const keyboard = new InlineKeyboard10();
   for (const item of items) {
     const installed = item.isInstalled();
     keyboard.text(
@@ -13794,7 +14346,7 @@ function setupIntegrateCallbacks(bot, core) {
     if (data === "i:back") {
       const { listIntegrations: listIntegrations2 } = await Promise.resolve().then(() => (init_integrate(), integrate_exports));
       const agents = listIntegrations2();
-      const keyboard2 = new InlineKeyboard9();
+      const keyboard2 = new InlineKeyboard10();
       for (const agent of agents) {
         keyboard2.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
       }
@@ -13894,6 +14446,7 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
       core.configManager.get().workspace.baseDir
     );
   });
+  setupNewSessionCallbacks(bot, core, chatId, getAssistantSession);
   bot.callbackQuery(/^ar:/, (ctx) => handleArchiveConfirm(ctx, core, chatId));
   bot.callbackQuery(/^m:/, async (ctx) => {
     const itemId = ctx.callbackQuery.data.replace("m:", "");
@@ -13909,6 +14462,17 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
     const registry = core.lifecycleManager?.serviceRegistry?.get("command-registry");
     switch (item.action.type) {
       case "command": {
+        const cmdName = item.action.command.replace(/^\//, "").split(" ")[0];
+        const telegramOverride = TELEGRAM_OVERRIDES[cmdName];
+        if (telegramOverride) {
+          try {
+            await telegramOverride(ctx, core);
+          } catch (err) {
+            await ctx.reply(`\u26A0\uFE0F Command failed: ${String(err)}`).catch(() => {
+            });
+          }
+          break;
+        }
         if (!registry) return;
         const response = await registry.execute(item.action.command, {
           raw: "",
@@ -13931,16 +14495,16 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
 ${lines}`, { parse_mode: "HTML" }).catch(() => {
             });
           } else if (response.type === "menu") {
-            const { InlineKeyboard: InlineKeyboard11 } = await import("grammy");
-            const kb = new InlineKeyboard11();
+            const { InlineKeyboard: InlineKeyboard12 } = await import("grammy");
+            const kb = new InlineKeyboard12();
             for (const opt of response.options) {
               kb.text(opt.label, `c/${opt.command}`).row();
             }
             await ctx.reply(response.title, { parse_mode: "HTML", reply_markup: kb }).catch(() => {
             });
           } else if (response.type === "confirm") {
-            const { InlineKeyboard: InlineKeyboard11 } = await import("grammy");
-            const kb = new InlineKeyboard11().text("\u2705 Yes", `c/${response.onYes}`).text("\u274C No", `c/${response.onNo}`);
+            const { InlineKeyboard: InlineKeyboard12 } = await import("grammy");
+            const kb = new InlineKeyboard12().text("\u2705 Yes", `c/${response.onYes}`).text("\u274C No", `c/${response.onNo}`);
             await ctx.reply(response.question, { reply_markup: kb }).catch(() => {
             });
           }
@@ -13948,6 +14512,10 @@ ${lines}`, { parse_mode: "HTML" }).catch(() => {
         break;
       }
       case "delegate": {
+        if (itemId === "core:new") {
+          await showAgentPicker(ctx, core, chatId);
+          break;
+        }
         const assistant = core.assistantManager?.get("telegram");
         if (assistant) {
           if (topicId && systemTopicIds && topicId !== systemTopicIds.assistantTopicId) {
@@ -13963,8 +14531,13 @@ ${lines}`, { parse_mode: "HTML" }).catch(() => {
         }
         break;
       }
-      case "callback":
+      case "callback": {
+        const cbData = item.action.callbackData;
+        if (cbData === "s:settings") {
+          await handleSettings(ctx, core);
+        }
         break;
+      }
     }
   });
 }
@@ -13999,8 +14572,9 @@ var STATIC_COMMANDS = [
 ];
 
 // src/plugins/telegram/permissions.ts
-import { InlineKeyboard as InlineKeyboard10 } from "grammy";
+import { InlineKeyboard as InlineKeyboard11 } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
+init_topics();
 init_log();
 var log29 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
@@ -14019,7 +14593,7 @@ var PermissionHandler = class {
       requestId: request.id,
       options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow }))
     });
-    const keyboard = new InlineKeyboard10();
+    const keyboard = new InlineKeyboard11();
     for (const option of request.options) {
       const emoji = option.isAllow ? "\u2705" : "\u274C";
       keyboard.text(`${emoji} ${option.label}`, `p:${callbackKey}:${option.id}`);
@@ -15078,6 +15652,15 @@ var TelegramAdapter = class extends MessagingAdapter {
       const commandName = atIdx === -1 ? rawCommand : rawCommand.slice(0, atIdx);
       const def = registry.get(commandName);
       if (!def) return next();
+      const telegramOverride = TELEGRAM_OVERRIDES[commandName];
+      if (telegramOverride) {
+        try {
+          await telegramOverride(ctx, this.core);
+        } catch (err) {
+          await ctx.reply(`\u26A0\uFE0F Command failed: ${String(err)}`);
+        }
+        return;
+      }
       const chatId = ctx.chat.id;
       const topicId = ctx.message.message_thread_id;
       try {
@@ -15183,7 +15766,16 @@ var TelegramAdapter = class extends MessagingAdapter {
         if (!assistant) return void 0;
         return {
           topicId: this.assistantTopicId,
-          enqueuePrompt: (p) => assistant.enqueuePrompt(p)
+          enqueuePrompt: (p) => {
+            const pending = this.core.assistantManager?.consumePendingSystemPrompt("telegram");
+            const text3 = pending ? `${pending}
+
+---
+
+User message:
+${p}` : p;
+            return assistant.enqueuePrompt(text3);
+          }
         };
       },
       (sessionId, msgId) => {
@@ -15244,7 +15836,8 @@ var TelegramAdapter = class extends MessagingAdapter {
         errorCount: allRecords.filter((r) => r.status === "error").length,
         totalCount: allRecords.length,
         agents: agents.map((a) => a.name),
-        defaultAgent: config.defaultAgent
+        defaultAgent: config.defaultAgent,
+        workspace: this.core.configManager.resolveWorkspace()
       });
       await this.bot.api.sendMessage(this.telegramConfig.chatId, welcomeText, {
         message_thread_id: this.assistantTopicId,