@hienlh/ppm 0.9.53 → 0.9.55

package/src/services/ppmbot/ppmbot-service.ts

@@ -1,20 +1,26 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
 import { configService } from "../config.service.ts";
 import { chatService } from "../chat.service.ts";
 import {
   isPairedChat,
   getPairingByChatId,
   createPairingRequest,
-  getSessionTitles,
-  getPinnedSessionIds,
   getApprovedPairedChats,
+  getRecentBotTasks,
+  getRunningBotTasks,
+  updateBotTaskStatus,
+  markBotTaskReported,
 } from "../db.service.ts";
 import { PPMBotTelegram } from "./ppmbot-telegram.ts";
-import { PPMBotSessionManager } from "./ppmbot-session.ts";
+import { PPMBotSessionManager, ensureCoordinatorWorkspace, DEFAULT_COORDINATOR_IDENTITY } from "./ppmbot-session.ts";
 import { PPMBotMemory } from "./ppmbot-memory.ts";
 import { streamToTelegram } from "./ppmbot-streamer.ts";
 import { escapeHtml } from "./ppmbot-formatter.ts";
+import { executeDelegation, getActiveDelegationCount } from "./ppmbot-delegation.ts";
 import type { TelegramUpdate, PPMBotCommand } from "../../types/ppmbot.ts";
-import type { PPMBotConfig, TelegramConfig, PermissionMode } from "../../types/config.ts";
+import type { PPMBotConfig, TelegramConfig, ProjectConfig, PermissionMode } from "../../types/config.ts";
 import type { SendMessageOpts } from "../../types/chat.ts";
 
 const CONTEXT_WINDOW_THRESHOLD = 80;
@@ -25,6 +31,12 @@ class PPMBotService {
   private memory = new PPMBotMemory();
   private running = false;
 
+  /** Cached coordinator identity from coordinator.md */
+  private coordinatorIdentity = "";
+
+  /** Task polling interval */
+  private taskPoller: ReturnType<typeof setInterval> | null = null;
+
   /** Debounce timers per chatId */
   private debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
   private debouncedTexts = new Map<string, string>();
@@ -35,12 +47,6 @@ class PPMBotService {
   /** Message queue per chatId for concurrent messages */
   private messageQueue = new Map<string, string[]>();
 
-  /** Sessions that already had their title set */
-  private titledSessions = new Set<string>();
-
-  /** Chat IDs that just received identity onboarding prompt */
-  private identityPending = new Set<string>();
-
   // ── Lifecycle ─────────────────────────────────────────────────
 
   async start(): Promise<void> {
@@ -57,13 +63,17 @@ class PPMBotService {
     }
 
     try {
+      ensureCoordinatorWorkspace();
+
       this.telegram = new PPMBotTelegram(telegramConfig.bot_token);
       this.running = true;
 
-      // Start polling (non-blocking)
       this.telegram.startPolling((update) => this.handleUpdate(update));
 
-      // Check if this is a restart and notify users
+      // Task poller for delegation execution
+      this.taskPoller = setInterval(() => this.checkPendingTasks(), 5000);
+      this.cleanupStaleTasks();
+
       await this.checkRestartNotification();
 
       console.log("[ppmbot] Started");
@@ -77,12 +87,16 @@ class PPMBotService {
     this.telegram?.stop();
     this.telegram = null;
 
+    if (this.taskPoller) {
+      clearInterval(this.taskPoller);
+      this.taskPoller = null;
+    }
+
     for (const timer of this.debounceTimers.values()) clearTimeout(timer);
     this.debounceTimers.clear();
     this.debouncedTexts.clear();
     this.processing.clear();
     this.messageQueue.clear();
-    this.identityPending.clear();
 
     console.log("[ppmbot] Stopped");
   }
@@ -114,7 +128,6 @@ class PPMBotService {
     if (!isPairedChat(chatId)) {
       const pairing = getPairingByChatId(chatId);
       if (!pairing) {
-        // First-time user — generate pairing code
         const code = this.generatePairingCode();
         createPairingRequest(chatId, String(userId), displayName, code);
         await this.telegram!.sendMessage(
@@ -130,26 +143,22 @@ class PPMBotService {
         );
         return;
       }
-      if (pairing.status === "revoked") {
-        return; // Silently ignore
-      }
+      if (pairing.status === "revoked") return;
     }
 
-    // Try parsing as command
     const command = PPMBotTelegram.parseCommand(message);
     if (command) {
       await this.handleCommand(command);
       return;
     }
 
-    // Regular message
     const text = message.text ?? message.caption ?? "";
     if (!text.trim()) return;
 
     await this.handleMessage(chatId, text);
   }
 
-  // ── Command Handlers ────────────────────────────────────────────
+  // ── Command Handlers (3 commands + hidden restart) ──────────────
 
   private async handleCommand(cmd: PPMBotCommand): Promise<void> {
     const chatId = String(cmd.chatId);
@@ -158,19 +167,10 @@ class PPMBotService {
     try {
       switch (cmd.command) {
         case "start": await this.cmdStart(chatId); break;
-        case "project": await this.cmdProject(chatId, cmd.args); break;
-        case "new": await this.cmdNew(chatId); break;
-        case "sessions": await this.cmdSessions(chatId, cmd.args); break;
-        case "resume": await this.cmdResume(chatId, cmd.args); break;
         case "status": await this.cmdStatus(chatId); break;
-        case "stop": await this.cmdStop(chatId); break;
-        case "memory": await this.cmdMemory(chatId); break;
-        case "forget": await this.cmdForget(chatId, cmd.args); break;
-        case "remember": await this.cmdRemember(chatId, cmd.args); break;
         case "restart": await this.cmdRestart(chatId); break;
-        case "version": await this.cmdVersion(chatId); break;
         case "help": await this.cmdHelp(chatId); break;
-        default: await tg.sendMessage(Number(chatId), `Unknown command: /${cmd.command}`);
+        default: await tg.sendMessage(Number(chatId), `Just chat naturally — I'll handle it! Try /help`);
       }
     } catch (err) {
       await tg.sendMessage(
@@ -182,348 +182,189 @@ class PPMBotService {
 
   private async cmdStart(chatId: string): Promise<void> {
     const projects = this.sessions.getProjectNames();
-    let text = "<b>🤖 PPMBot</b>\n\n";
-    text += "Hey! I'm your AI coding assistant, right here in Telegram.\n";
-    text += "Ask me anything — code questions, debugging, project tasks.\n\n";
+    let text = "<b>🤖 PPMBot Coordinator</b>\n\n";
+    text += "I'm your AI project coordinator on Telegram.\n";
+    text += "Ask me anything — I'll answer directly or delegate to your projects.\n\n";
     if (projects.length) {
       text += "<b>Your projects:</b>\n";
       for (const name of projects) {
         text += `  • <code>${escapeHtml(name)}</code>\n`;
       }
-      text += "\nSwitch: /project &lt;name&gt;";
-    } else {
-      text += "No projects configured — I'll use a default workspace.";
     }
-    text += "\n\nJust send a message to start chatting, or /help for commands.";
+    text += "\nJust chat naturally — no commands needed!";
+    text += "\nType /help for more info.";
     await this.telegram!.sendMessage(Number(chatId), text);
 
-    // Identity onboarding: if no identity memories exist, ask user
+    // Identity onboarding
     const globalMemories = this.memory.getSummary("_global", 50);
     const hasIdentity = globalMemories.some((m) =>
       m.category === "preference" && /identity|name|role/i.test(m.content),
     );
     if (!hasIdentity) {
-      this.identityPending.add(chatId);
       await this.telegram!.sendMessage(
         Number(chatId),
         "📝 <b>Quick intro?</b>\n\n" +
-          "I don't know much about you yet! Tell me:\n" +
-          "• Your name\n" +
-          "• What you work on (language, stack, role)\n" +
-          "• Preferred response language (English, Vietnamese, etc.)\n\n" +
-          "I'll remember your preferences for future chats.\n" +
-          "Or skip this and just start chatting!",
+          "Tell me your name, what you work on, and preferred language.\n" +
+          "I'll remember for future chats. Or just start chatting!",
       );
     }
   }
 
-  private async cmdProject(chatId: string, args: string): Promise<void> {
-    if (!args) {
-      const active = this.sessions.getActiveSession(chatId);
-      const current = active?.projectName ?? "";
-      const projects = this.sessions.getProjectNames();
-      let text = "<b>Projects</b>\n\n";
-      if (projects.length === 0) {
-        text += "No projects configured.\nUsing default: <code>~/.ppm/bot/</code>\n";
-      } else {
-        for (const name of projects) {
-          const marker = name === current ? " ✓" : "";
-          text += `• <code>${escapeHtml(name)}</code>${marker}\n`;
-        }
-      }
-      text += `\nCurrent: <b>${escapeHtml(current || "bot (default)")}</b>`;
-      text += "\nSwitch: /project &lt;name&gt;";
-      await this.telegram!.sendMessage(Number(chatId), text);
-      return;
-    }
-
-    const session = await this.sessions.switchProject(chatId, args);
-    await this.telegram!.sendMessage(
-      Number(chatId),
-      `Switched to <b>${escapeHtml(session.projectName)}</b> ✓`,
-    );
-  }
-
-  private async cmdNew(chatId: string): Promise<void> {
-    const active = this.sessions.getActiveSession(chatId);
-    const projectName = active?.projectName;
-    await this.sessions.closeSession(chatId);
-    const session = await this.sessions.getOrCreateSession(chatId, projectName ?? undefined);
-    await this.telegram!.sendMessage(
-      Number(chatId),
-      `New session for <b>${escapeHtml(session.projectName)}</b> ✓`,
-    );
-  }
-
-  private async cmdSessions(chatId: string, args: string): Promise<void> {
-    const PAGE_SIZE = 8;
-    const page = Math.max(1, parseInt(args, 10) || 1);
-
-    const active = this.sessions.getActiveSession(chatId);
-    const project = active?.projectName;
-
-    // Fetch all sessions for this chat (enough for pagination)
-    const allSessions = this.sessions.listRecentSessions(chatId, 50);
-    // Filter by current project if one is active
-    const filtered = project
-      ? allSessions.filter((s) => s.project_name === project)
-      : allSessions;
-
-    if (filtered.length === 0) {
-      await this.telegram!.sendMessage(Number(chatId), "No sessions yet. Send a message to start.");
-      return;
-    }
-
-    // Enrich with titles and pin status
-    const titles = getSessionTitles(filtered.map((s) => s.session_id));
-    const pinnedIds = getPinnedSessionIds();
-
-    // Sort: pinned first, then by last_message_at desc
-    const sorted = [...filtered].sort((a, b) => {
-      const aPin = pinnedIds.has(a.session_id) ? 1 : 0;
-      const bPin = pinnedIds.has(b.session_id) ? 1 : 0;
-      if (aPin !== bPin) return bPin - aPin;
-      return b.last_message_at - a.last_message_at;
-    });
-
-    const totalPages = Math.ceil(sorted.length / PAGE_SIZE);
-    const start = (page - 1) * PAGE_SIZE;
-    const pageItems = sorted.slice(start, start + PAGE_SIZE);
-
-    if (pageItems.length === 0) {
-      await this.telegram!.sendMessage(Number(chatId), `No sessions on page ${page}.`);
-      return;
-    }
-
-    const header = project ? escapeHtml(project) : "All Projects";
-    let text = `<b>Sessions — ${header}</b>`;
-    if (totalPages > 1) text += ` <i>(${page}/${totalPages})</i>`;
-    text += "\n\n";
-
-    pageItems.forEach((s, i) => {
-      const pin = pinnedIds.has(s.session_id) ? "📌 " : "";
-      const activeDot = s.is_active ? " ⬤" : "";
-      const rawTitle = titles[s.session_id]?.replace(/^\[PPM\]\s*/, "") || "";
-      const title = rawTitle
-        ? escapeHtml(rawTitle.slice(0, 45))
-        : "<i>untitled</i>";
-      const date = new Date(s.last_message_at * 1000).toLocaleString(undefined, {
-        month: "short", day: "numeric", hour: "2-digit", minute: "2-digit",
-      });
-      const sid = s.session_id.slice(0, 8);
-      const num = start + i + 1;
-
-      text += `${pin}${num}. ${title}${activeDot}\n`;
-      text += `   <code>${sid}</code> · ${date}\n\n`;
-    });
-
-    text += "Resume: /resume &lt;n&gt; or /resume &lt;id&gt;";
-    if (totalPages > 1 && page < totalPages) {
-      text += `\nNext: /sessions ${page + 1}`;
-    }
-
-    await this.telegram!.sendMessage(Number(chatId), text);
-  }
-
-  private async cmdResume(chatId: string, args: string): Promise<void> {
-    if (!args.trim()) {
-      await this.telegram!.sendMessage(Number(chatId), "Usage: /resume &lt;number or session-id&gt;");
-      return;
-    }
-
-    // Support both index (e.g. "2") and session ID prefix (e.g. "fdc4ddaa")
-    const index = parseInt(args, 10);
-    const isIndex = !isNaN(index) && index >= 1 && String(index) === args.trim();
-
-    const session = isIndex
-      ? await this.sessions.resumeSessionById(chatId, index)
-      : await this.sessions.resumeSessionByIdPrefix(chatId, args.trim());
-
-    if (!session) {
-      await this.telegram!.sendMessage(Number(chatId), "Session not found.");
-      return;
-    }
-    await this.telegram!.sendMessage(
-      Number(chatId),
-      `Resumed session for <b>${escapeHtml(session.projectName)}</b> ✓`,
-    );
-  }
-
   private async cmdStatus(chatId: string): Promise<void> {
-    const active = this.sessions.getActiveSession(chatId);
-    if (!active) {
-      await this.telegram!.sendMessage(Number(chatId), "No active session. Send a message to start.");
-      return;
+    const tasks = getRecentBotTasks(chatId, 10);
+    const active = tasks.filter((t) => t.status === "running" || t.status === "pending");
+    const completed = tasks.filter((t) => t.status === "completed");
+    const delegationCount = getActiveDelegationCount();
+
+    let text = "<b>PPMBot Status</b>\n\n";
+    text += `Active delegations: ${delegationCount}\n`;
+
+    if (active.length) {
+      text += "\n<b>Running Tasks:</b>\n";
+      for (const t of active) {
+        const elapsed = Math.round((Date.now() / 1000 - t.createdAt) / 60);
+        text += `  🔄 <code>${t.id.slice(0, 8)}</code> ${escapeHtml(t.projectName)} — ${escapeHtml(t.prompt.slice(0, 50))} (${elapsed}m)\n`;
+      }
     }
-    let text = "<b>Status</b>\n\n";
-    text += `Project: <code>${escapeHtml(active.projectName)}</code>\n`;
-    text += `Provider: <code>${escapeHtml(active.providerId)}</code>\n`;
-    text += `Session: <code>${active.sessionId.slice(0, 12)}…</code>\n`;
-    await this.telegram!.sendMessage(Number(chatId), text);
-  }
-
-  private async cmdStop(chatId: string): Promise<void> {
-    await this.sessions.closeSession(chatId);
-    await this.telegram!.sendMessage(Number(chatId), "Session ended ✓");
-  }
-
-  private async cmdMemory(chatId: string): Promise<void> {
-    const memories = this.memory.getSummary("_global");
-    if (memories.length === 0) {
-      await this.telegram!.sendMessage(Number(chatId), "No memories stored. Use /remember to add.");
-      return;
+    if (completed.length) {
+      text += "\n<b>Recent Completed:</b>\n";
+      for (const t of completed.slice(0, 5)) {
+        text += `  ✅ <code>${t.id.slice(0, 8)}</code> ${escapeHtml(t.projectName)} — ${escapeHtml(t.prompt.slice(0, 50))}\n`;
+      }
     }
-    let text = "<b>Memory</b> (cross-project)\n\n";
-    for (const mem of memories) {
-      text += `• [${mem.category}] ${escapeHtml(mem.content)}\n`;
+    if (!active.length && !completed.length) {
+      text += "No recent tasks.";
     }
     await this.telegram!.sendMessage(Number(chatId), text);
   }
 
-  private async cmdForget(chatId: string, args: string): Promise<void> {
-    if (!args) {
-      await this.telegram!.sendMessage(Number(chatId), "Usage: /forget &lt;topic&gt;");
-      return;
-    }
-    const count = this.memory.forget("_global", args);
-    await this.telegram!.sendMessage(Number(chatId), `Forgot ${count} memor${count === 1 ? "y" : "ies"} ✓`);
-  }
-
-  private async cmdRemember(chatId: string, args: string): Promise<void> {
-    if (!args) {
-      await this.telegram!.sendMessage(Number(chatId), "Usage: /remember &lt;fact&gt;");
-      return;
-    }
-    const active = this.sessions.getActiveSession(chatId);
-    this.memory.saveOne("_global", args, "fact", active?.sessionId);
-    await this.telegram!.sendMessage(Number(chatId), "Remembered ✓ (cross-project)");
-  }
-
   private async cmdRestart(chatId: string): Promise<void> {
     await this.telegram!.sendMessage(Number(chatId), "🔄 Restarting PPM...");
-
-    // Schedule restart after a short delay so the response is sent
     setTimeout(async () => {
-      const { join } = await import("node:path");
       const { writeFileSync } = await import("node:fs");
-      const { homedir } = await import("node:os");
-
       const approvedChats = getApprovedPairedChats();
       const chatIds = approvedChats.map((c) => c.telegram_chat_id);
-
-      // Write restart marker so we can notify after restart
       const markerPath = join(homedir(), ".ppm", "restart-notify.json");
       writeFileSync(markerPath, JSON.stringify({ chatIds, ts: Date.now() }));
-
       console.log("[ppmbot] Restart requested via Telegram, exiting with code 42...");
       process.exit(42);
     }, 500);
   }
 
-  /** Check for restart notification marker and send notification */
-  async checkRestartNotification(): Promise<void> {
+  private async cmdHelp(chatId: string): Promise<void> {
+    const text = `<b>PPMBot Commands</b>
+
+/start — Welcome + list projects
+/status — Running tasks + delegations
+/help — This message
+
+<b>Everything else:</b> just chat naturally!
+I'll answer directly or delegate to your project's AI.`;
+    await this.telegram!.sendMessage(Number(chatId), text);
+  }
+
+  // ── Coordinator Context ─────────────────────────────────────────
+
+  private readCoordinatorIdentity(): string {
+    if (this.coordinatorIdentity) return this.coordinatorIdentity;
+    const identityPath = join(homedir(), ".ppm", "bot", "coordinator.md");
     try {
-      const { join } = await import("node:path");
-      const { existsSync, readFileSync, unlinkSync } = await import("node:fs");
-      const { homedir } = await import("node:os");
+      this.coordinatorIdentity = readFileSync(identityPath, "utf-8");
+    } catch {
+      this.coordinatorIdentity = DEFAULT_COORDINATOR_IDENTITY;
+    }
+    return this.coordinatorIdentity;
+  }
 
-      const markerPath = join(homedir(), ".ppm", "restart-notify.json");
-      if (!existsSync(markerPath)) return;
+  private buildCoordinatorContext(chatId: string): string {
+    const parts: string[] = [];
 
-      const data = JSON.parse(readFileSync(markerPath, "utf-8"));
-      unlinkSync(markerPath);
+    // Identity
+    const identity = this.readCoordinatorIdentity();
+    if (identity) {
+      parts.push("## Identity");
+      parts.push(identity);
+    }
 
-      // Only notify if restart was recent (< 60s)
-      if (Date.now() - data.ts > 60_000) return;
+    // Session info
+    parts.push(`\n## Session Info`);
+    parts.push(`Chat ID: ${chatId}`);
 
-      // Read version from package.json
-      let version = "";
-      try {
-        const pkgPath = join(import.meta.dir, "../../../package.json");
-        const pkg = await Bun.file(pkgPath).json();
-        version = pkg.version ? ` v${pkg.version}` : "";
-      } catch {}
+    // Custom system prompt (user overrides)
+    const config = this.getConfig();
+    if (config?.system_prompt) {
+      parts.push(`\n## Custom Instructions`);
+      parts.push(config.system_prompt);
+    }
 
-      for (const cid of data.chatIds) {
-        await this.telegram?.sendMessage(Number(cid), `✅ PPM${version} restarted successfully.`);
+    // Project list
+    const projects = configService.get("projects") as ProjectConfig[];
+    if (projects?.length) {
+      parts.push("\n## Available Projects");
+      for (const p of projects) {
+        parts.push(`- ${p.name} (${p.path})`);
       }
-    } catch {}
-  }
+    }
 
-  private async cmdVersion(chatId: string): Promise<void> {
-    let version = "unknown";
-    try {
-      const { join } = await import("node:path");
-      const pkgPath = join(import.meta.dir, "../../../package.json");
-      const pkg = await Bun.file(pkgPath).json();
-      version = pkg.version ?? "unknown";
-    } catch {}
-    await this.telegram!.sendMessage(Number(chatId), `<b>PPM</b> v${version}`);
+    // Running/recent tasks
+    const tasks = getRecentBotTasks(chatId, 10);
+    const activeTasks = tasks.filter((t) => t.status === "running" || t.status === "pending");
+    if (activeTasks.length) {
+      parts.push("\n## Running Tasks");
+      for (const t of activeTasks) {
+        const elapsed = Math.round((Date.now() / 1000 - t.createdAt) / 60);
+        parts.push(`- ${t.id.slice(0, 8)}: ${t.projectName} — "${t.prompt.slice(0, 60)}" (${t.status}, ${elapsed}m ago)`);
+      }
+    }
+
+    // Completed tasks not yet reported
+    const completed = tasks.filter((t) => t.status === "completed" && !t.reported);
+    if (completed.length) {
+      parts.push("\n## Completed Tasks (notify user)");
+      for (const t of completed) {
+        parts.push(`- ${t.id.slice(0, 8)}: ${t.projectName} — "${t.prompt.slice(0, 60)}"`);
+        parts.push(`  Summary: ${t.resultSummary ?? "(use ppm bot task-result to get details)"}`);
+        markBotTaskReported(t.id);
+      }
+    }
+
+    // Memory recall
+    const memories = this.memory.getSummary("_global");
+    const memorySection = this.memory.buildRecallPrompt(memories);
+    if (memorySection) parts.push(memorySection);
+
+    return parts.join("\n");
   }
 
-  private async cmdHelp(chatId: string): Promise<void> {
-    const text = `<b>PPMBot Commands</b>
+  // ── Task Delegation Polling ─────────────────────────────────────
 
-/start — Greeting + list projects
-/project &lt;name&gt; — Switch/list projects
-/new — Fresh session (current project)
-/sessions [page] — List sessions (current project)
-/resume &lt;n or id&gt; — Resume session
-/status — Current project/session info
-/stop — End current session
-/memory — Show project memories
-/forget &lt;topic&gt; — Remove matching memories
-/remember &lt;fact&gt; — Save a fact
-/restart — Restart PPM server
-/version — Show PPM version
-/help — This message`;
-    await this.telegram!.sendMessage(Number(chatId), text);
+  private checkPendingTasks(): void {
+    try {
+      const pending = getRunningBotTasks().filter((t) => t.status === "pending");
+      for (const task of pending) {
+        const config = this.getConfig();
+        const providerId = config?.default_provider || configService.get("ai").default_provider;
+        executeDelegation(task.id, this.telegram!, providerId);
+      }
+    } catch (err) {
+      console.error("[ppmbot] checkPendingTasks error:", (err as Error).message);
+    }
   }
 
-  // ── System Prompt: CLI Tools ─────────────────────────────────────
-
-  private buildToolsPrompt(chatId: string): string {
-    return `\n\n## PPMBot CLI Tools (use via Bash tool)
-Your chat ID is: ${chatId}
-
-You can manage the user's session, project, and memories by running CLI commands via the Bash tool.
-The chat ID is auto-detected so you do NOT need --chat flag.
-
-### Project
-  ppm bot project list             — List available projects
-  ppm bot project switch <name>    — Switch to a project
-  ppm bot project current          — Show current project
-
-### Session
-  ppm bot session new              — Start fresh session (current project)
-  ppm bot session list             — List recent sessions
-  ppm bot session resume <n|id>    — Resume a session by index or ID prefix
-  ppm bot session stop             — End current session
-
-### Memory (cross-project, persists across all projects)
-  ppm bot memory save "<content>" --category <category>
-  Categories: preference, fact, decision, architecture, issue
-  ppm bot memory list              — List saved memories
-  ppm bot memory forget "<topic>"  — Delete matching memories
-
-### Server
-  ppm bot status                   — Current project/session info
-  ppm bot version                  — Show PPM version
-  ppm bot restart                  — Restart PPM server
-
-### Natural Language Understanding
-When the user says something like:
-- "chuyển sang project X" or "switch to X" → ppm bot project switch X
-- "tạo session mới" or "new session" → ppm bot session new
-- "liệt kê sessions" or "show sessions" → ppm bot session list
-- "quay lại session cũ" or "resume session 2" → ppm bot session resume 2
-- "kết thúc session" or "stop" → ppm bot session stop
-- "đang ở project nào?" or "current project?" → ppm bot project current
-- "nhớ rằng..." or "remember that..." → ppm bot memory save "..." --category preference
-- "quên đi..." or "forget about..." → ppm bot memory forget "..."
-- "restart server" or "khởi động lại" → ppm bot restart
-
-Always execute the appropriate CLI command — do NOT just describe what you would do.`;
+  private cleanupStaleTasks(): void {
+    try {
+      const stale = getRunningBotTasks().filter((t) => t.status === "running");
+      for (const task of stale) {
+        updateBotTaskStatus(task.id, "failed", { error: "Server restarted during execution" });
+        this.telegram?.sendMessage(
+          Number(task.chatId),
+          `⚠️ Task interrupted by server restart: <i>${escapeHtml(task.prompt.slice(0, 80))}</i>`,
+        );
+      }
+      if (stale.length) console.log(`[ppmbot] Cleaned up ${stale.length} stale task(s)`);
+    } catch (err) {
+      console.error("[ppmbot] cleanupStaleTasks error:", (err as Error).message);
+    }
   }
 
   // ── Chat Message Pipeline ───────────────────────────────────────
@@ -551,7 +392,6 @@ Always execute the appropriate CLI command — do NOT just describe what you wou
     this.debouncedTexts.delete(chatId);
     if (!text.trim()) return;
 
-    // Queue if already processing
     if (this.processing.has(chatId)) {
       const queue = this.messageQueue.get(chatId) ?? [];
       queue.push(text);
@@ -562,48 +402,16 @@ Always execute the appropriate CLI command — do NOT just describe what you wou
 
     try {
       const config = this.getConfig();
+      const session = await this.sessions.getCoordinatorSession(chatId);
 
-      const session = await this.sessions.getOrCreateSession(chatId);
-
-      // Update title on first message only
-      if (!this.titledSessions.has(session.sessionId)) {
-        this.sessions.updateSessionTitle(session.sessionId, text);
-        this.titledSessions.add(session.sessionId);
-      }
-
-      // Recall identity & preferences (global + project)
-      const memories = this.memory.getSummary(session.projectName);
-
-      // Build system prompt with identity/preferences
-      let systemPrompt = config?.system_prompt ?? "";
-      const memorySection = this.memory.buildRecallPrompt(memories);
-      if (memorySection) {
-        systemPrompt += memorySection;
-      }
-
-      // Instruct AI to use CLI tools for session/project/memory management
-      systemPrompt += this.buildToolsPrompt(chatId);
+      // Build coordinator context (identity + projects + tasks + memories)
+      const context = this.buildCoordinatorContext(chatId);
+      const fullMessage = `<coordinator-context>\n${context}\n</coordinator-context>\n\n${text}`;
 
-      // Send message to AI (prepend system prompt + memory context)
       const opts: SendMessageOpts = {
         permissionMode: (config?.permission_mode ?? "bypassPermissions") as PermissionMode,
       };
 
-      // Save identity BEFORE streaming — must persist even if streaming times out
-      let messageForAI = text;
-      if (this.identityPending.has(chatId)) {
-        this.identityPending.delete(chatId);
-        this.memory.saveOne("_global", `User identity: ${text}`, "preference", session.sessionId);
-        console.log("[ppmbot] Saved identity memory from onboarding");
-        // Tell AI this is an identity intro so it acknowledges warmly
-        messageForAI = `[User just introduced themselves in response to onboarding prompt. Acknowledge warmly and briefly.]\n\n${text}`;
-      }
-
-      let fullMessage = messageForAI;
-      if (systemPrompt) {
-        fullMessage = `<system-context>\n${systemPrompt}\n</system-context>\n\n${messageForAI}`;
-      }
-
       const events = chatService.sendMessage(
         session.providerId,
         session.sessionId,
@@ -611,7 +419,6 @@ Always execute the appropriate CLI command — do NOT just describe what you wou
         opts,
       );
 
-      // Stream response to Telegram
       const result = await streamToTelegram(
         Number(chatId),
         events,
@@ -622,12 +429,16 @@ Always execute the appropriate CLI command — do NOT just describe what you wou
         },
       );
 
-      // Check context window — auto-rotate if near limit
+      // Context rotation
       if (
         result.contextWindowPct != null &&
         result.contextWindowPct > CONTEXT_WINDOW_THRESHOLD
       ) {
-        await this.rotateSession(chatId, session.projectName);
+        await this.sessions.rotateCoordinatorSession(chatId);
+        await this.telegram?.sendMessage(
+          Number(chatId),
+          "<i>Context refreshed.</i>",
+        );
       }
     } catch (err) {
       console.error(`[ppmbot] processMessage error for ${chatId}:`, (err as Error).message);
@@ -638,7 +449,6 @@ Always execute the appropriate CLI command — do NOT just describe what you wou
     } finally {
       this.processing.delete(chatId);
 
-      // Process queued messages
       const queued = this.messageQueue.get(chatId);
       if (queued && queued.length > 0) {
         this.messageQueue.delete(chatId);
@@ -648,21 +458,36 @@ Always execute the appropriate CLI command — do NOT just describe what you wou
     }
   }
 
-  // ── Session Rotate ──────────────────────────────────────────────
+  // ── Restart Notification ────────────────────────────────────────
 
-  private async rotateSession(chatId: string, projectName: string): Promise<void> {
-    await this.sessions.closeSession(chatId);
-    await this.sessions.getOrCreateSession(chatId, projectName);
-    await this.telegram?.sendMessage(
-      Number(chatId),
-      "<i>Context window near limit — starting fresh session.</i>",
-    );
+  async checkRestartNotification(): Promise<void> {
+    try {
+      const { existsSync, readFileSync: fsRead, unlinkSync } = await import("node:fs");
+      const markerPath = join(homedir(), ".ppm", "restart-notify.json");
+      if (!existsSync(markerPath)) return;
+
+      const data = JSON.parse(fsRead(markerPath, "utf-8"));
+      unlinkSync(markerPath);
+
+      if (Date.now() - data.ts > 60_000) return;
+
+      let version = "";
+      try {
+        const pkgPath = join(import.meta.dir, "../../../package.json");
+        const pkg = await Bun.file(pkgPath).json();
+        version = pkg.version ? ` v${pkg.version}` : "";
+      } catch {}
+
+      for (const cid of data.chatIds) {
+        await this.telegram?.sendMessage(Number(cid), `✅ PPM${version} restarted successfully.`);
+      }
+    } catch {}
   }
 
   // ── Helpers ─────────────────────────────────────────────────────
 
   private generatePairingCode(): string {
-    const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"; // no I,O,0,1 (ambiguous)
+    const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
     const bytes = crypto.getRandomValues(new Uint8Array(6));
     return Array.from(bytes, (b) => chars[b % chars.length]).join("");
   }