@hienlh/ppm 0.9.33 → 0.9.35

package/src/services/{clawbot/clawbot-session.ts → ppmbot/ppmbot-session.ts}

@@ -1,19 +1,22 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
 import { chatService } from "../chat.service.ts";
 import { configService } from "../config.service.ts";
 import {
-  getActiveClawBotSession,
-  createClawBotSession,
-  deactivateClawBotSession,
-  touchClawBotSession,
-  getRecentClawBotSessions,
+  getActivePPMBotSession,
+  createPPMBotSession,
+  deactivatePPMBotSession,
+  touchPPMBotSession,
+  getRecentPPMBotSessions,
   setSessionTitle,
 } from "../db.service.ts";
-import type { ClawBotActiveSession, ClawBotSessionRow } from "../../types/clawbot.ts";
-import type { ClawBotConfig, ProjectConfig } from "../../types/config.ts";
+import type { PPMBotActiveSession, PPMBotSessionRow } from "../../types/ppmbot.ts";
+import type { PPMBotConfig, ProjectConfig } from "../../types/config.ts";
 
-export class ClawBotSessionManager {
+export class PPMBotSessionManager {
   /** In-memory cache: telegramChatId → active session */
-  private activeSessions = new Map<string, ClawBotActiveSession>();
+  private activeSessions = new Map<string, PPMBotActiveSession>();
 
   /**
    * Get active session for chatId. If none exists, create one for the
@@ -22,21 +25,22 @@ export class ClawBotSessionManager {
   async getOrCreateSession(
     chatId: string,
     projectName?: string,
-  ): Promise<ClawBotActiveSession> {
+  ): Promise<PPMBotActiveSession> {
     const cached = this.activeSessions.get(chatId);
     if (cached && (!projectName || cached.projectName === projectName)) {
-      touchClawBotSession(cached.sessionId);
+      touchPPMBotSession(cached.sessionId);
       return cached;
     }
 
-    const resolvedProject = this.resolveProject(
-      projectName || this.getDefaultProject(),
-    );
+    const input = projectName || this.getDefaultProject();
+    const resolvedProject = input
+      ? this.resolveProject(input)
+      : this.getFallbackProject();
     if (!resolvedProject) {
       throw new Error(`Project not found: "${projectName || "(default)"}"`);
     }
 
-    const dbSession = getActiveClawBotSession(chatId, resolvedProject.name);
+    const dbSession = getActivePPMBotSession(chatId, resolvedProject.name);
     if (dbSession) {
       return this.resumeFromDb(chatId, dbSession, resolvedProject);
     }
@@ -48,7 +52,7 @@ export class ClawBotSessionManager {
   async switchProject(
     chatId: string,
     projectName: string,
-  ): Promise<ClawBotActiveSession> {
+  ): Promise<PPMBotActiveSession> {
     await this.closeSession(chatId);
     return this.getOrCreateSession(chatId, projectName);
   }
@@ -57,27 +61,27 @@ export class ClawBotSessionManager {
   async closeSession(chatId: string): Promise<void> {
     const active = this.activeSessions.get(chatId);
     if (active) {
-      deactivateClawBotSession(active.sessionId);
+      deactivatePPMBotSession(active.sessionId);
       this.activeSessions.delete(chatId);
     }
   }
 
   /** Get active session from cache (no DB hit) */
-  getActiveSession(chatId: string): ClawBotActiveSession | null {
+  getActiveSession(chatId: string): PPMBotActiveSession | null {
     return this.activeSessions.get(chatId) ?? null;
   }
 
   /** List recent sessions for a chat (from DB) */
-  listRecentSessions(chatId: string, limit = 10): ClawBotSessionRow[] {
-    return getRecentClawBotSessions(chatId, limit);
+  listRecentSessions(chatId: string, limit = 10): PPMBotSessionRow[] {
+    return getRecentPPMBotSessions(chatId, limit);
   }
 
   /** Resume a specific session by 1-indexed position in history */
   async resumeSessionById(
     chatId: string,
     sessionIndex: number,
-  ): Promise<ClawBotActiveSession | null> {
-    const sessions = getRecentClawBotSessions(chatId, 20);
+  ): Promise<PPMBotActiveSession | null> {
+    const sessions = getRecentPPMBotSessions(chatId, 20);
     const target = sessions[sessionIndex - 1];
     if (!target) return null;
 
@@ -111,7 +115,7 @@ export class ClawBotSessionManager {
   /** Update session title (e.g. after first message) */
   updateSessionTitle(sessionId: string, firstMessage: string): void {
     const preview = firstMessage.slice(0, 60).replace(/\n/g, " ");
-    const title = `[Claw] ${preview}`;
+    const title = `[PPM] ${preview}`;
     setSessionTitle(sessionId, title);
   }
 
@@ -124,30 +128,37 @@ export class ClawBotSessionManager {
   // ── Private ─────────────────────────────────────────────────────
 
   private getDefaultProject(): string {
-    const clawbot = configService.get("clawbot") as ClawBotConfig | undefined;
-    return clawbot?.default_project || "";
+    const cfg = configService.get("clawbot") as PPMBotConfig | undefined;
+    return cfg?.default_project || "";
+  }
+
+  /** Fallback project when nothing is configured: ~/.ppm/bot/ */
+  private getFallbackProject(): { name: string; path: string } {
+    const botDir = join(homedir(), ".ppm", "bot");
+    if (!existsSync(botDir)) mkdirSync(botDir, { recursive: true });
+    return { name: "bot", path: botDir };
   }
 
   private getDefaultProvider(): string {
-    const clawbot = configService.get("clawbot") as ClawBotConfig | undefined;
-    return clawbot?.default_provider || configService.get("ai").default_provider;
+    const cfg = configService.get("clawbot") as PPMBotConfig | undefined;
+    return cfg?.default_provider || configService.get("ai").default_provider;
   }
 
   private async createNewSession(
     chatId: string,
     project: { name: string; path: string },
-  ): Promise<ClawBotActiveSession> {
+  ): Promise<PPMBotActiveSession> {
     const providerId = this.getDefaultProvider();
 
     const session = await chatService.createSession(providerId, {
       projectName: project.name,
       projectPath: project.path,
-      title: `[Claw] New session`,
+      title: `[PPM] New session`,
     });
 
-    createClawBotSession(chatId, session.id, providerId, project.name, project.path);
+    createPPMBotSession(chatId, session.id, providerId, project.name, project.path);
 
-    const active: ClawBotActiveSession = {
+    const active: PPMBotActiveSession = {
       telegramChatId: chatId,
       sessionId: session.id,
       providerId,
@@ -161,20 +172,20 @@ export class ClawBotSessionManager {
 
   private async resumeFromDb(
     chatId: string,
-    dbSession: ClawBotSessionRow,
+    dbSession: PPMBotSessionRow,
     project: { name: string; path: string },
-  ): Promise<ClawBotActiveSession> {
+  ): Promise<PPMBotActiveSession> {
     try {
       await chatService.resumeSession(dbSession.provider_id, dbSession.session_id);
     } catch {
-      console.warn(`[clawbot] Failed to resume session ${dbSession.session_id}, creating new`);
-      deactivateClawBotSession(dbSession.session_id);
+      console.warn(`[ppmbot] Failed to resume session ${dbSession.session_id}, creating new`);
+      deactivatePPMBotSession(dbSession.session_id);
       return this.createNewSession(chatId, project);
     }
 
-    touchClawBotSession(dbSession.session_id);
+    touchPPMBotSession(dbSession.session_id);
 
-    const active: ClawBotActiveSession = {
+    const active: PPMBotActiveSession = {
       telegramChatId: chatId,
       sessionId: dbSession.session_id,
       providerId: dbSession.provider_id,

package/src/services/{clawbot/clawbot-streamer.ts → ppmbot/ppmbot-streamer.ts}

@@ -1,15 +1,44 @@
 import type { ChatEvent, ResultSubtype } from "../../types/chat.ts";
-import type { ClawBotTelegram } from "./clawbot-telegram.ts";
+import type { PPMBotTelegram } from "./ppmbot-telegram.ts";
 import {
   markdownToTelegramHtml,
   chunkMessage,
   escapeHtml,
-} from "./clawbot-formatter.ts";
+} from "./ppmbot-formatter.ts";
 
 const MAX_MSG_LEN = 4096;
 const TYPING_REFRESH_MS = 4000;
+const EVENT_TIMEOUT_MS = 60_000; // 60s max wait per event
 const PLACEHOLDER = "\u2026"; // ellipsis
 
+/**
+ * Wrap an async iterable with per-event timeout.
+ * If .next() doesn't resolve within timeoutMs, yields a timeout error.
+ */
+async function* withEventTimeout<T>(
+  iterable: AsyncIterable<T>,
+  timeoutMs: number,
+): AsyncGenerator<T> {
+  const iterator = iterable[Symbol.asyncIterator]();
+  try {
+    while (true) {
+      const result = await Promise.race([
+        iterator.next(),
+        new Promise<{ done: true; value: undefined; timedOut: true }>((resolve) =>
+          setTimeout(() => resolve({ done: true, value: undefined, timedOut: true }), timeoutMs),
+        ),
+      ]);
+      if ("timedOut" in result) {
+        throw new Error("No response within 60 seconds");
+      }
+      if (result.done) break;
+      yield result.value;
+    }
+  } finally {
+    iterator.return?.();
+  }
+}
+
 export interface StreamConfig {
   showToolCalls: boolean;
   showThinking: boolean;
@@ -18,30 +47,59 @@ export interface StreamConfig {
 export interface StreamResult {
   contextWindowPct?: number;
   resultSubtype?: ResultSubtype;
-  /** All Telegram message IDs sent during this stream */
   messageIds: number[];
-  /** New session ID if session was migrated */
   newSessionId?: string;
 }
 
 /**
- * Consume a ChatEvent stream and progressively send/edit Telegram messages.
- *
- * Flow:
- * 1. Send placeholder message
- * 2. Accumulate text/tool/thinking events
- * 3. Edit message every time ClawBotTelegram allows (1s throttle)
- * 4. When text exceeds 4096, finalize current msg, start new one
- * 5. On done/error, finalize and return result
+ * Segments of accumulated response.
+ * - "md" = raw markdown from AI (needs conversion)
+ * - "html" = pre-formatted HTML (tool calls, thinking, errors — already escaped)
  */
+type Segment = { type: "md"; text: string } | { type: "html"; text: string };
+
+/** Render segments into Telegram HTML */
+function renderSegments(segments: Segment[]): string {
+  return segments
+    .map((s) => (s.type === "md" ? markdownToTelegramHtml(s.text) : s.text))
+    .join("");
+}
+
+/** Check if segments have meaningful content */
+function hasContent(segments: Segment[]): boolean {
+  return segments.some((s) => s.text.trim().length > 0);
+}
+
+/** Get raw text length (approximation for split decisions) */
+function segmentsLength(segments: Segment[]): number {
+  return segments.reduce((sum, s) => sum + s.text.length, 0);
+}
+
+/** Append markdown text — merges into last segment if also md */
+function appendMd(segments: Segment[], text: string): void {
+  const last = segments[segments.length - 1];
+  if (last?.type === "md") {
+    last.text += text;
+  } else {
+    segments.push({ type: "md", text });
+  }
+}
+
+/** Append pre-formatted HTML */
+function appendHtml(segments: Segment[], html: string): void {
+  segments.push({ type: "html", html: html } as any);
+  // fix: use correct field
+  segments[segments.length - 1] = { type: "html", text: html };
+}
+
 export async function streamToTelegram(
   chatId: number | string,
   events: AsyncIterable<ChatEvent>,
-  telegram: ClawBotTelegram,
+  telegram: PPMBotTelegram,
   config: StreamConfig,
 ): Promise<StreamResult> {
   const result: StreamResult = { messageIds: [] };
-  let accumulated = "";
+  const segments: Segment[] = [];
   let currentMsgId: number | null = null;
   let lastTypingTime = 0;
 
@@ -62,62 +120,49 @@ export async function streamToTelegram(
     result.messageIds.push(currentMsgId);
   }
 
-  const finalizeAndStartNew = async (text: string): Promise<void> => {
-    if (currentMsgId && text.trim()) {
-      const html = markdownToTelegramHtml(text);
-      await telegram.editMessageFinal(chatId, currentMsgId, html);
-    }
-    accumulated = "";
-    currentMsgId = null;
-  };
-
-  const sendNewMessage = async (text: string): Promise<void> => {
-    const html = markdownToTelegramHtml(text);
-    const chunks = chunkMessage(html, MAX_MSG_LEN);
-    for (const chunk of chunks) {
-      const sent = await telegram.sendMessage(chatId, chunk);
-      if (sent) {
-        currentMsgId = sent.message_id;
-        result.messageIds.push(currentMsgId);
-      }
-    }
-  };
-
   const editCurrent = async (): Promise<void> => {
-    if (!currentMsgId || !accumulated.trim()) return;
+    if (!currentMsgId || !hasContent(segments)) return;
 
-    const html = markdownToTelegramHtml(accumulated);
+    const html = renderSegments(segments);
     if (html.length > MAX_MSG_LEN) {
-      const splitPoint = findSplitPoint(accumulated, MAX_MSG_LEN * 0.8);
-      const first = accumulated.slice(0, splitPoint);
-      const rest = accumulated.slice(splitPoint).trimStart();
-
-      await finalizeAndStartNew(first);
-      accumulated = rest;
-      if (rest) {
-        await sendNewMessage(rest);
+      // Finalize current message with what fits, start new one
+      await telegram.editMessageFinal(chatId, currentMsgId, html.slice(0, MAX_MSG_LEN));
+      currentMsgId = null;
+
+      const overflow = html.slice(MAX_MSG_LEN);
+      if (overflow.trim()) {
+        const chunks = chunkMessage(overflow, MAX_MSG_LEN);
+        for (const chunk of chunks) {
+          const sent = await telegram.sendMessage(chatId, chunk);
+          if (sent) {
+            currentMsgId = sent.message_id;
+            result.messageIds.push(currentMsgId);
+          }
+        }
       }
+      // Reset segments — only keep any un-rendered text
+      segments.length = 0;
       return;
     }
 
     await telegram.editMessage(chatId, currentMsgId, html);
   };
 
-  // Process event stream
+  // Process event stream with per-event timeout
   try {
-    for await (const event of events) {
+    for await (const event of withEventTimeout(events, EVENT_TIMEOUT_MS)) {
       await refreshTyping();
 
       switch (event.type) {
         case "text": {
-          accumulated += event.content;
+          appendMd(segments, event.content);
           await editCurrent();
           break;
         }
 
         case "thinking": {
           if (config.showThinking && event.content) {
-            accumulated += `\n<i>${escapeHtml(event.content)}</i>\n`;
+            appendHtml(segments, `\n<i>💭 ${escapeHtml(event.content)}</i>\n`);
             await editCurrent();
           }
           break;
@@ -127,7 +172,10 @@ export async function streamToTelegram(
           if (config.showToolCalls) {
             const toolName = event.tool;
             const inputPreview = formatToolInput(event.input);
-            accumulated += `\n🔧 <code>${escapeHtml(toolName)}</code>(${escapeHtml(inputPreview)})\n`;
+            appendHtml(
+              segments,
+              `\n🔧 <code>${escapeHtml(toolName)}</code>(${escapeHtml(inputPreview)})\n`,
+            );
             await editCurrent();
           }
           break;
@@ -135,14 +183,17 @@ export async function streamToTelegram(
 
         case "tool_result": {
           if (config.showToolCalls && event.isError) {
-            accumulated += `\n⚠️ <code>${escapeHtml(event.output.slice(0, 200))}</code>\n`;
+            appendHtml(
+              segments,
+              `\n⚠️ <code>${escapeHtml(event.output.slice(0, 200))}</code>\n`,
+            );
             await editCurrent();
           }
           break;
         }
 
         case "error": {
-          accumulated += `\n\n❌ <b>Error:</b> ${escapeHtml(event.message)}`;
+          appendHtml(segments, `\n\n❌ <b>Error:</b> ${escapeHtml(event.message)}`);
           await editCurrent();
           break;
         }
@@ -159,23 +210,28 @@ export async function streamToTelegram(
         }
 
         case "account_retry": {
-          accumulated += `\n⏳ <i>Switching account: ${escapeHtml(event.reason)}</i>\n`;
+          appendHtml(
+            segments,
+            `\n⏳ <i>Switching account: ${escapeHtml(event.reason)}</i>\n`,
+          );
           await editCurrent();
           break;
         }
 
         default:
-          // Ignore unknown events (system, team_detected, account_info, etc.)
           break;
       }
     }
   } catch (err) {
-    accumulated += `\n\n❌ <b>Stream error:</b> ${escapeHtml((err as Error).message)}`;
+    appendHtml(
+      segments,
+      `\n\n❌ <b>Stream error:</b> ${escapeHtml((err as Error).message)}`,
+    );
   }
 
   // Final edit with complete content
-  if (currentMsgId && accumulated.trim()) {
-    const html = markdownToTelegramHtml(accumulated);
+  if (currentMsgId && hasContent(segments)) {
+    const html = renderSegments(segments);
     const chunks = chunkMessage(html, MAX_MSG_LEN);
 
     if (chunks.length === 1) {
@@ -187,7 +243,7 @@ export async function streamToTelegram(
         if (sent) result.messageIds.push(sent.message_id);
       }
     }
-  } else if (currentMsgId && !accumulated.trim()) {
+  } else if (currentMsgId && !hasContent(segments)) {
     await telegram.editMessageFinal(
       chatId,
       currentMsgId,
@@ -200,7 +256,6 @@ export async function streamToTelegram(
 
 // ── Helpers ─────────────────────────────────────────────────────
 
-/** Format tool input for compact display */
 function formatToolInput(input: unknown): string {
   if (!input) return "";
   if (typeof input === "string") return input.slice(0, 80);
@@ -222,24 +277,3 @@ function formatToolInput(input: unknown): string {
     return "";
   }
 }
-
-/**
- * Find a good split point in text, aiming for targetLen.
- * Prefers double newline > single newline > space.
- */
-function findSplitPoint(text: string, targetLen: number): number {
-  if (text.length <= targetLen) return text.length;
-
-  const window = text.slice(0, Math.floor(targetLen));
-
-  let point = window.lastIndexOf("\n\n");
-  if (point > targetLen * 0.3) return point;
-
-  point = window.lastIndexOf("\n");
-  if (point > targetLen * 0.3) return point;
-
-  point = window.lastIndexOf(" ");
-  if (point > targetLen * 0.3) return point;
-
-  return Math.floor(targetLen);
-}

package/src/services/{clawbot/clawbot-telegram.ts → ppmbot/ppmbot-telegram.ts}

@@ -2,15 +2,15 @@ import type {
   TelegramUpdate,
   TelegramMessage,
   TelegramSentMessage,
-  ClawBotCommand,
-} from "../../types/clawbot.ts";
+  PPMBotCommand,
+} from "../../types/ppmbot.ts";
 
 const TELEGRAM_API = "https://api.telegram.org/bot";
 const POLL_TIMEOUT = 25;
 const MIN_EDIT_INTERVAL = 1000;
 const BOT_TOKEN_RE = /^\d+:[A-Za-z0-9_-]{30,50}$/;
 
-/** Known ClawBot slash commands */
+/** Known PPMBot slash commands */
 const COMMANDS = new Set([
   "start", "project", "new", "sessions", "resume",
   "status", "stop", "memory", "forget", "remember", "help",
@@ -18,7 +18,7 @@ const COMMANDS = new Set([
 
 export type UpdateHandler = (update: TelegramUpdate) => Promise<void>;
 
-export class ClawBotTelegram {
+export class PPMBotTelegram {
   private token: string;
   private offset = 0;
   private running = false;
@@ -37,12 +37,40 @@ export class ClawBotTelegram {
 
   // ── Polling ─────────────────────────────────────────────────────
 
+  /** Register bot commands with Telegram so they show in the menu */
+  async registerCommands(): Promise<void> {
+    try {
+      await this.callApi("setMyCommands", {
+        commands: [
+          { command: "start", description: "Greeting + list projects" },
+          { command: "project", description: "Switch project" },
+          { command: "new", description: "Fresh session (current project)" },
+          { command: "sessions", description: "List recent sessions" },
+          { command: "resume", description: "Resume a previous session" },
+          { command: "status", description: "Current project/session info" },
+          { command: "stop", description: "End current session" },
+          { command: "memory", description: "Show project memories" },
+          { command: "forget", description: "Remove matching memories" },
+          { command: "remember", description: "Save a fact" },
+          { command: "help", description: "Show all commands" },
+        ],
+      });
+      console.log("[ppmbot] Commands registered");
+    } catch (err) {
+      console.warn("[ppmbot] Failed to register commands:", (err as Error).message);
+    }
+  }
+
   /** Start long-polling loop. Calls handler for each update. */
   async startPolling(handler: UpdateHandler): Promise<void> {
     if (this.running) return;
     this.running = true;
     this.retryCount = 0;
-    console.log("[clawbot] Polling started");
+
+    // Register commands on startup
+    await this.registerCommands();
+
+    console.log("[ppmbot] Polling started");
 
     while (this.running) {
       try {
@@ -51,24 +79,24 @@ export class ClawBotTelegram {
 
         for (const update of updates) {
           this.offset = update.update_id + 1;
-          try {
-            await handler(update);
-          } catch (err) {
-            console.error("[clawbot] Handler error:", (err as Error).message);
-          }
+          // Fire-and-forget: don't block polling on handler execution
+          // Per-chatId serialization is handled by processing lock in service
+          handler(update).catch((err) => {
+            console.error("[ppmbot] Handler error:", (err as Error).message);
+          });
         }
       } catch (err) {
         if (!this.running) break;
         this.retryCount++;
         const delay = Math.min(1000 * 2 ** this.retryCount, 30_000);
         console.error(
-          `[clawbot] Poll error (retry ${this.retryCount}): ${(err as Error).message}. Retrying in ${delay}ms`,
+          `[ppmbot] Poll error (retry ${this.retryCount}): ${(err as Error).message}. Retrying in ${delay}ms`,
         );
         await Bun.sleep(delay);
       }
     }
 
-    console.log("[clawbot] Polling stopped");
+    console.log("[ppmbot] Polling stopped");
   }
 
   /** Stop polling gracefully */
@@ -128,12 +156,12 @@ export class ClawBotTelegram {
       });
       const json = (await res.json()) as { ok: boolean; result?: TelegramSentMessage; description?: string };
       if (!json.ok) {
-        console.error(`[clawbot] sendMessage failed: ${json.description}`);
+        console.error(`[ppmbot] sendMessage failed: ${json.description}`);
         return null;
       }
       return json.result ?? null;
     } catch (err) {
-      console.error(`[clawbot] sendMessage error: ${(err as Error).message}`);
+      console.error(`[ppmbot] sendMessage error: ${(err as Error).message}`);
       return null;
     }
   }
@@ -163,12 +191,12 @@ export class ClawBotTelegram {
       const json = (await res.json()) as { ok: boolean; description?: string };
       if (!json.ok) {
         if (json.description?.includes("not modified")) return true;
-        console.error(`[clawbot] editMessage failed: ${json.description}`);
+        console.error(`[ppmbot] editMessage failed: ${json.description}`);
         return false;
       }
       return true;
     } catch (err) {
-      console.error(`[clawbot] editMessage error: ${(err as Error).message}`);
+      console.error(`[ppmbot] editMessage error: ${(err as Error).message}`);
       return false;
     }
   }
@@ -211,8 +239,8 @@ export class ClawBotTelegram {
 
   // ── Command Parsing ─────────────────────────────────────────────
 
-  /** Parse a Telegram message into a ClawBotCommand if it starts with / */
-  static parseCommand(message: TelegramMessage): ClawBotCommand | null {
+  /** Parse a Telegram message into a PPMBotCommand if it starts with / */
+  static parseCommand(message: TelegramMessage): PPMBotCommand | null {
     const text = message.text ?? message.caption ?? "";
     if (!text.startsWith("/")) return null;
 

package/src/types/config.ts

@@ -9,7 +9,7 @@ export interface TelegramConfig {
   chat_id: string;
 }
 
-export interface ClawBotConfig {
+export interface PPMBotConfig {
   enabled: boolean;
   default_provider: string;
   default_project: string;
@@ -32,7 +32,7 @@ export interface PpmConfig {
   ai: AIConfig;
   push?: PushConfig;
   telegram?: TelegramConfig;
-  clawbot?: ClawBotConfig;
+  clawbot?: PPMBotConfig;
   cloud_url?: string;
 }
 
@@ -105,7 +105,7 @@ export const DEFAULT_CONFIG: PpmConfig = {
     enabled: false,
     default_provider: "claude",
     default_project: "",
-    system_prompt: "",
+    system_prompt: "You are PPMBot, a helpful AI coding assistant on Telegram. Keep responses concise and mobile-friendly. Use short paragraphs. When showing code, use compact examples. Be direct and helpful.",
     show_tool_calls: true,
     show_thinking: false,
     permission_mode: "bypassPermissions",