grok-telegram-bot 2.5.0 → 2.7.0

package/src/bot/telegram-bots.ts

@@ -176,7 +176,8 @@ export class TelegramBotService {
       : `/${cmd}@${username}`;
 
     const extra: Record<string, unknown> = {};
-    if (opts.messageThreadId !== undefined) {
+    // Omit General (1) — Bot API rejects message_thread_id=1.
+    if (opts.messageThreadId !== undefined && opts.messageThreadId !== 1) {
       extra.message_thread_id = opts.messageThreadId;
     }
 

package/src/bot/telegram-io.ts

@@ -183,7 +183,10 @@ export async function sendMarkdownDoc(
   opts?: { loud?: boolean; messageThreadId?: number },
 ): Promise<void> {
   const extra: Record<string, unknown> = opts?.loud ? { disable_notification: false } : {};
-  if (opts?.messageThreadId !== undefined) extra.message_thread_id = opts.messageThreadId;
+  // Omit General (1) — Bot API rejects message_thread_id=1.
+  if (opts?.messageThreadId !== undefined && opts.messageThreadId !== 1) {
+    extra.message_thread_id = opts.messageThreadId;
+  }
   const rendered = toTelegramMarkdown(rawMarkdown);
   const mdChunks = chunkMarkdown(rendered);
   const plainChunks = chunkMarkdown(rawMarkdown);

package/src/cli.ts

@@ -10,16 +10,17 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { listKnownInstances, stripInstanceFlags } from "./app/instance.js";
 import { ENV_PATH, INSTANCE_DIR, PROJECT_ROOT } from "./config.js";
 import { buildLaunchSpec, getController } from "./service/index.js";
 
 const HELP = `Grok Telegram Bot — CLI
 
-Usage: grok-tg <command>
+Usage: grok-tg [--name <slug>] [--instance <dir>] <command>
 
   run                 Run in the foreground
-  setup [--path]      Create/update .env (default ~/.grok/tg/.env, loaded from
-                      any folder); --path just prints the resolved .env location
+  setup [--path]      Create/update .env (default ~/.grok/tg/.env);
+                      --name <slug> writes ~/.grok/tg/instances/<slug>/.env
   install             Install + start a background service (autostart on boot)
   uninstall           Stop + remove the background service
   start               Start the service
@@ -27,12 +28,20 @@ Usage: grok-tg <command>
   restart             Restart the service
   status              Show install + running status
   logs [n]            Show the last n log lines (default 100)
+  instances           List named bot instances on this host
   help                Show this help
+
+Several Telegram bots on one host (one chat per project):
+
+  grok-tg --name work setup <BOT_TOKEN> <YOUR_USER_ID>
+  grok-tg --name work install
+  grok-tg --name work status
 `;
 
 async function main(): Promise<void> {
   const args = process.argv.slice(2);
-  const [cmd, arg] = args;
+  const rest = stripInstanceFlags(args);
+  const [cmd, arg] = rest;
 
   switch (cmd) {
     case "run":
@@ -45,9 +54,9 @@ async function main(): Promise<void> {
       // Run the plain-node setup script, targeting this folder (.env lives in
       // the instance dir). Pass through optional <token> [userId] args.
       const script = join(PROJECT_ROOT, "scripts", "setup.mjs");
-      const r = spawnSync(process.execPath, [script, ...args.slice(1)], {
+      const r = spawnSync(process.execPath, [script, "--instance", INSTANCE_DIR, ...rest.slice(1)], {
         stdio: "inherit",
-        env: { ...process.env, GROK_TG_CWD: INSTANCE_DIR },
+        env: { ...process.env, GROK_TG_DIR: INSTANCE_DIR, GROK_TG_CWD: INSTANCE_DIR },
       });
       process.exit(r.status ?? 0);
       break;
@@ -57,7 +66,11 @@ async function main(): Promise<void> {
       preflight();
       const r = await getController().install(buildLaunchSpec());
       console.log(r.ok ? `✓ ${r.message}` : `✗ ${r.message}`);
-      if (r.ok) console.log("\nManage it with: grok-tg status | stop | restart | logs");
+      if (r.ok) {
+        const spec = buildLaunchSpec();
+        const flag = spec.slug ? `--name ${spec.slug} ` : "";
+        console.log(`\nManage it with: grok-tg ${flag}status | stop | restart | logs`);
+      }
       process.exit(r.ok ? 0 : 1);
       break;
     }
@@ -86,6 +99,11 @@ async function main(): Promise<void> {
       process.exit(0);
       break;
 
+    case "instances":
+      printInstances();
+      process.exit(0);
+      break;
+
     case "help":
     case "--help":
     case "-h":
@@ -112,6 +130,24 @@ function preflight(): void {
   }
 }
 
+function printInstances(): void {
+  const items = listKnownInstances();
+  if (items.length === 0) {
+    console.log("No instances found.");
+    console.log("  grok-tg setup                         # default bot (~/.grok/tg)");
+    console.log("  grok-tg --name work setup <token> <userId>   # second bot");
+    return;
+  }
+  console.log("Instances:\n");
+  for (const it of items) {
+    const manage = it.slug ? `grok-tg --name ${it.slug}` : "grok-tg";
+    console.log(`  ${it.name}`);
+    console.log(`    dir:     ${it.dir}`);
+    console.log(`    service: ${it.identity.id}`);
+    console.log(`    manage:  ${manage} status | restart | logs\n`);
+  }
+}
+
 function printLogs(n: number): void {
   const file = buildLaunchSpec().logFile;
   if (!existsSync(file)) {

package/src/config.ts

@@ -10,51 +10,42 @@ import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+  CANONICAL_DIR,
+  expandHome,
+  resolveInstanceDir as resolveNamedInstanceDir,
+} from "./app/instance.js";
+
+export { CANONICAL_DIR, expandHome };
 
 /** Absolute path to the installed bot code (one level above src/). For a global
  *  npm install this lives inside node_modules — code lives here, never user data. */
 export const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
-/** Canonical, path-independent home for this bot's `.env`, `logs/`, `data/` and
- *  the single-instance locks: `~/.grok/tg`. Used whenever the bot is started
- *  without an explicit instance dir and there's no `.env` in the current folder,
- *  so the SAME configuration is found no matter which directory you launch from. */
-export const CANONICAL_DIR = join(homedir(), ".grok", "tg");
-
 /**
  * Directory holding THIS instance's `.env`, `logs/` and `data/`. Resolution
  * (first match wins):
  *   1. `--instance <dir>` argv — set by the installed background service,
- *   2. `GROK_TG_DIR` env — an explicit override,
- *   3. `GROK_TG_CWD` env — the legacy launcher variable,
- *   4. the current folder, IF it already contains a `.env`,
+ *   2. `--name` / `GROK_TG_NAME` — named instance under `~/.grok/tg/instances/`,
+ *   3. `GROK_TG_DIR` env — an explicit override,
+ *   4. `GROK_TG_CWD` or cwd IF that folder already contains a `.env`,
  *   5. the canonical `~/.grok/tg` home — the path-independent default.
  */
-export const INSTANCE_DIR = resolveInstanceDir();
+export const INSTANCE_DIR = resolveNamedInstanceDir({
+  argv: process.argv,
+  envDir: process.env.GROK_TG_DIR,
+  nameEnv: process.env.GROK_TG_NAME,
+  cwdHint: process.env.GROK_TG_CWD,
+});
 
 /** Absolute path to the `.env` this instance loads (and that `setup` writes). */
 export const ENV_PATH = join(INSTANCE_DIR, ".env");
 
-function resolveInstanceDir(): string {
-  const flag = process.argv.indexOf("--instance");
-  if (flag !== -1 && process.argv[flag + 1]) return resolve(process.argv[flag + 1]!);
-  const envDir = process.env.GROK_TG_DIR?.trim() || process.env.GROK_TG_CWD?.trim();
-  if (envDir) return resolve(expandHome(envDir));
-  if (existsSync(join(process.cwd(), ".env"))) return process.cwd();
-  return CANONICAL_DIR;
-}
-
 // Load .env from the resolved instance directory. Keep the parsed values as
 // well: a machine-wide TELEGRAM_BOT_TOKEN may belong to a sibling bot (Codex,
 // Kiro, etc.) and must never override this Grok instance's identity.
 const instanceEnv = loadDotenv({ path: ENV_PATH }).parsed ?? {};
 
-function expandHome(p: string): string {
-  if (p === "~") return homedir();
-  if (p.startsWith("~/") || p.startsWith("~\\")) return join(homedir(), p.slice(2));
-  return p;
-}
-
 function bool(v: string | undefined, def: boolean): boolean {
   if (v === undefined || v === "") return def;
   return ["1", "true", "yes", "on"].includes(v.toLowerCase());
@@ -142,6 +133,20 @@ export interface AppConfig {
    * Approve/Deny buttons.
    */
   autoApprovePermissions: boolean;
+  /**
+   * Auto-approve Grok plan-mode exit (no Approve/Changes/Abandon buttons).
+   * Default true so unattended/24/7 bots never wait on a TUI. Set false for
+   * interactive review in Telegram.
+   */
+  autoApprovePlan: boolean;
+  /** GROK_SANDBOX profile (workspace-safe, strict, off, …). */
+  sandboxProfile?: string;
+  /** GROK_MEMORY setting forwarded to the agent process. */
+  grokMemory?: string;
+  /** `--agent-profile` for `grok agent`. */
+  agentProfile?: string;
+  /** `--plugin-dir` for `grok agent`. */
+  pluginDir?: string;
   projectRoots: string[];
   streamThrottleMs: number;
   messageBatchMs: number;
@@ -301,6 +306,11 @@ export function loadConfig(): AppConfig {
     trustAllTools: bool(process.env.GROK_TRUST_ALL_TOOLS, true),
     // Default true: auto-approve with session-scope when the agent still asks.
     autoApprovePermissions: bool(process.env.AUTO_APPROVE_PERMISSIONS, true),
+    autoApprovePlan: bool(process.env.AUTO_APPROVE_PLAN, true),
+    sandboxProfile: process.env.GROK_SANDBOX?.trim() || undefined,
+    grokMemory: process.env.GROK_MEMORY?.trim() || undefined,
+    agentProfile: process.env.GROK_AGENT_PROFILE?.trim() || undefined,
+    pluginDir: process.env.GROK_PLUGIN_DIR?.trim() || undefined,
     projectRoots: [...new Set(roots)],
     streamThrottleMs: num(process.env.STREAM_THROTTLE_MS, 1500),
     messageBatchMs: nonNegNum(process.env.MESSAGE_BATCH_MS, 800),

package/src/forum/manager.ts

@@ -265,7 +265,8 @@ export class ForumManager {
       () =>
         this.api.sendMessage(
           this.groupId,
-          `\u{1F916} **AI Chat** — general conversation (workspace).\nPath: \`${this.cfg.workspace}\``,
+          `\u{1F916} **AI Chat** — workspace coding chat.\nPath: \`${this.cfg.workspace}\`\n\n` +
+            `Use **General** to orchestrate projects (manager). Code here or in a project topic.`,
           { message_thread_id: topic.message_thread_id, parse_mode: "Markdown" },
         ),
       "ai-chat-announce",

package/src/forum/thread.ts

@@ -14,3 +14,36 @@ export function batchKey(chatId: number, threadId: number | undefined, isForumGr
 export function forumThreadId(threadId: number | undefined): number {
   return threadId ?? FORUM_GENERAL_THREAD_ID;
 }
+
+/**
+ * True when this forum thread is the General manager topic.
+ * Only exact id `1` — do NOT treat private chats (undefined) as General.
+ * Callers should pass {@link forumThreadId} first when reading raw Telegram ids.
+ */
+export function isGeneralThread(threadId: number | undefined): boolean {
+  return threadId === FORUM_GENERAL_THREAD_ID;
+}
+
+/**
+ * Thread id for **outbound** Telegram API calls (`sendMessage`, `editMessage`, …).
+ *
+ * Critical: Bot API often rejects `message_thread_id: 1` for the General forum
+ * topic with "Bad Request: message thread not found". Omitting the field posts
+ * to General correctly. Real project topics (id > 1) must still pass the id.
+ *
+ * Inbound routing still uses {@link forumThreadId} (undefined → 1).
+ */
+export function outboundMessageThreadId(
+  threadId: number | undefined,
+): number | undefined {
+  if (threadId === undefined || threadId === FORUM_GENERAL_THREAD_ID) return undefined;
+  return threadId;
+}
+
+/** Extra object for send/edit: only includes message_thread_id when safe. */
+export function outboundThreadExtra(
+  threadId: number | undefined,
+): { message_thread_id?: number } {
+  const id = outboundMessageThreadId(threadId);
+  return id !== undefined ? { message_thread_id: id } : {};
+}

package/src/grok/client.ts

@@ -218,6 +218,10 @@ export interface GrokClientOptions {
   autoRestart?: boolean;
   promptIdleTimeoutMs?: number;
   promptMaxMs?: number;
+  sandboxProfile?: string;
+  grokMemory?: string;
+  agentProfile?: string;
+  pluginDir?: string;
 }
 
 interface Pending {
@@ -288,6 +292,10 @@ export class GrokClient extends EventEmitter {
    * outcomes). Must never kill the agent process.
    */
   onSessionCancel?: (sessionId: string) => void;
+  /** Interactive (or auto) plan-mode exit. Default: auto-approve. */
+  planExitHandler?: (params: Record<string, unknown>) => Promise<unknown>;
+  /** Interactive (or skip) ask_user_question. Default: SkipInterview. */
+  askUserHandler?: (params: Record<string, unknown>) => Promise<unknown>;
 
   constructor(private readonly opts: GrokClientOptions) {
     super();
@@ -313,11 +321,15 @@ export class GrokClient extends EventEmitter {
     // the new token. `--no-auto-update` was removed in grok 0.2.x (exit 2).
     const args = ["agent", "--no-leader"];
     if (this.opts.trustAllTools) args.push("--always-approve");
+    if (this.opts.agentProfile) args.push("--agent-profile", this.opts.agentProfile);
+    if (this.opts.pluginDir) args.push("--plugin-dir", this.opts.pluginDir);
     args.push("stdio");
 
     log.info(`spawning: ${this.opts.grokCliPath} ${args.join(" ")}`);
     const env = { ...process.env };
     if (this.opts.apiKey) env.XAI_API_KEY = this.opts.apiKey;
+    if (this.opts.sandboxProfile) env.GROK_SANDBOX = this.opts.sandboxProfile;
+    if (this.opts.grokMemory) env.GROK_MEMORY = this.opts.grokMemory;
     const proc = spawn(this.opts.grokCliPath, args, {
       stdio: ["pipe", "pipe", "pipe"],
       cwd: this.opts.workspace,
@@ -419,7 +431,11 @@ export class GrokClient extends EventEmitter {
   }
 
   async newSession(cwd: string): Promise<string> {
-    const res = (await this.request("session/new", { cwd, mcpServers: [] })) as { sessionId: string };
+    const res = (await this.request("session/new", {
+      cwd,
+      mcpServers: [],
+      ...(this.opts.trustAllTools ? { _meta: { yoloMode: true } } : {}),
+    })) as { sessionId: string };
     this.parseSessionExtras(res);
     this.cwd.set(res.sessionId, cwd);
     this.slog.create(res.sessionId, cwd);
@@ -622,6 +638,12 @@ export class GrokClient extends EventEmitter {
     return this.request("_grok.dev/commands/execute", { sessionId, command });
   }
 
+  /** Update spawn-time agent env (applied on the next `grok agent` restart). */
+  setAgentOptions(opts: { sandboxProfile?: string; grokMemory?: string }): void {
+    if (opts.sandboxProfile !== undefined) this.opts.sandboxProfile = opts.sandboxProfile;
+    if (opts.grokMemory !== undefined) this.opts.grokMemory = opts.grokMemory;
+  }
+
   stop(): void {
     this.stopped = true;
     if (this.restartTimer) {
@@ -780,11 +802,13 @@ export class GrokClient extends EventEmitter {
             (planSnippet ? ` plan=${planSnippet.replace(/\s+/g, " ").slice(0, 80)}` : "") +
             (keys ? ` keys=[${keys}]` : ""),
         );
-        result = autoApproveExitPlanMode(params);
+        result = this.planExitHandler
+          ? await this.planExitHandler(params)
+          : autoApproveExitPlanMode(params);
       } else if (isAskUserQuestionMethod(method)) {
-        // No TUI question form: skip so the agent continues (prefer later Telegram UI).
-        log.info(`auto-skipping ${method} (no interactive question UI in Telegram bridge)`);
-        result = autoSkipAskUserQuestion(params);
+        result = this.askUserHandler
+          ? await this.askUserHandler(params)
+          : autoSkipAskUserQuestion(params);
       } else {
         // We advertise no fs/terminal capabilities, so the agent shouldn't ask.
         // Log at warn — unknown reverse methods used to silently break plan exit

package/src/grok/plan-approval.ts

@@ -24,6 +24,14 @@ export const EXT_EXIT_PLAN_MODE_ALT = "x.ai/exit_plan_mode";
 export const EXT_ASK_USER_QUESTION = "_x.ai/ask_user_question";
 export const EXT_ASK_USER_QUESTION_ALT = "x.ai/ask_user_question";
 
+/** Plan approval outcomes accepted by Grok Build's ExitPlanModeExtResponse. */
+export type PlanExitOutcome = "approved" | "abandoned" | "request_changes";
+
+export interface PlanExitDecision {
+  outcome: PlanExitOutcome;
+  feedback?: string;
+}
+
 /**
  * Auto-approve leaving plan mode so the agent can implement.
  *

package/src/index.ts

@@ -146,6 +146,10 @@ async function main(): Promise<void> {
     model: cfg.grokModel,
     autoRestart: cfg.grokAutoRestart,
     promptIdleTimeoutMs: cfg.promptIdleMs,
+    sandboxProfile: cfg.sandboxProfile,
+    grokMemory: cfg.grokMemory,
+    agentProfile: cfg.agentProfile,
+    pluginDir: cfg.pluginDir,
   });
 
   // Retry ACP connect — agent crash at boot should not kill the Telegram bot.

package/src/render/manager-directive.ts

@@ -0,0 +1,137 @@
+/**
+ * Manager (OpenClaw-style) directive for the Telegram General topic.
+ *
+ * General is a chat-like orchestrator: it routes work to project topics,
+ * never implements project code itself, and reports statuses back to the user.
+ * Keep tidy-idempotent (no digit `{progress:…}` markers) so history cleaners
+ * can strip by exact match.
+ */
+import type { PromptInput } from "../app/types.js";
+
+export const MANAGER_DIRECTIVE_MARKER = "MANAGER MODE (General topic — OpenClaw-style orchestrator):";
+
+/** Marker for child-session completion wakes injected into General. */
+export const MANAGER_WORK_REPORT_MARKER =
+  "MANAGER WORK REPORT (system — analyze and report to the user; do not invent facts):";
+
+/**
+ * First-prompt / steering block for General. Free of real progress digit tokens.
+ */
+export const MANAGER_DIRECTIVE = [
+  MANAGER_DIRECTIVE_MARKER,
+  "You are the global manager of this Telegram forum group — like OpenClaw.",
+  "This topic is a chat control room, not a coding workspace.",
+  "",
+  "How you behave:",
+  "- The user SEES your free-form prose in this chat. Always answer them in short chat text.",
+  "- Keep replies brief (a few sentences). No progress bars, tool dumps, job tables, or",
+  "  \"Dispatching…\" / \"Sending to…\" narration.",
+  "- Use telegram JSON for side effects: search_memory, list_topics, send_prompt, notify.",
+  "- notify is an OPTIONAL extra ping — do NOT rely on it as the only user-facing channel.",
+  "- Example good reply: \"On it — continuing the ship gate in WindowsStoreListingGenerator.\"",
+  "- NEVER emit task-progress markers (no progress percent footers).",
+  "- NEVER enter plan mode, run self-recheck, or dump long tool/trace spam here.",
+  "- NEVER implement app code, edit project files, run builds/tests, or do multi-file work in General.",
+  "- Always DELEGATE real work to the correct project topic via telegram bridge actions.",
+  "",
+  "MEMORY-FIRST (mandatory — do this BEFORE any git/shell/file tools):",
+  "1. Read the auto-injected MANAGER CONTEXT (General history, memory hits, topics, jobs).",
+  "2. Call search_memory with the user's keywords (and list_topics if needed).",
+  "3. Prefer Telegram/bot memory + project topic session history over `git log` / filesystem.",
+  "4. Only use git if the user explicitly asks for git, or after memory has no useful hits.",
+  "5. Order of truth for \"what changed / last work\":",
+  "   (a) General chat + manager memory hits with [age] stamps (newest first),",
+  "   (b) that project's MOST RECENT topic sessions (highest recency / last user prompts / Done notes),",
+  "   (c) ignore older sessions for the same app when a newer session exists,",
+  "   (d) then optional git — never jump to git first.",
+  "6. When summarizing last work: weight last user prompts and assistant Done text by time,",
+  "   not by how many times a keyword appears in an old session.",
+  "",
+  "Dispatch workflow:",
+  "1. Identify the target topic (exact title, #threadId, or create a new project topic).",
+  "2. Build a RICH child prompt from memory (what was done, what remains, acceptance criteria).",
+  "3. Emit one telegram JSON block: create_topic/set_path as needed, then send_prompt,",
+  "   plus optional single notify if the user should hear about it.",
+  "4. After bridge results: silent is fine if dispatch ok; notify only on failure or if user asked.",
+  "5. MANAGER WORK REPORT wakes: notify only for outcomes the user needs (done/fail/important);",
+  "   otherwise process silently (no notify).",
+  "",
+  "RESUME RELATED SESSIONS (critical):",
+  "- When memory/context shows a related session (session=019fc9ec or full UUID) and the user",
+  "  wants a follow-up / continue / fix there, you MUST pass session_id on send_prompt.",
+  "- Without session_id the bridge uses the topic's CURRENT open session — often the wrong one.",
+  "- topic must be the EXACT forum title or #threadId from list_topics / memory — NEVER \"…\" / \"...\" / placeholders.",
+  "- If you only know the session id, omit topic: { \"action\": \"send_prompt\", \"session_id\": \"019fc9ec\", \"prompt\": \"...\" }",
+  "- Example: { \"action\": \"send_prompt\", \"topic\": \"MyApp\", \"session_id\": \"019fc9ec\", \"prompt\": \"...\" }",
+  "- Only omit session_id for brand-new work on the topic's foreground, or use new_session=true for a fresh session.",
+  "- On Topic not found: call list_topics and retry with the exact name or #id (or session_id only).",
+  "",
+  "New projects: create_topic with name + absolute path (folder is created if missing),",
+  "then send_prompt into that topic with the full kickoff instructions.",
+  "",
+  "User message:",
+].join("\n");
+
+/** True when text is a system work-report wake (meta; skip recheck / manager re-wrap noise). */
+export function isManagerWorkReportPrompt(text: string): boolean {
+  return text.trimStart().startsWith(MANAGER_WORK_REPORT_MARKER);
+}
+
+/** Prepend manager directive (idempotent). */
+export function wrapManagerDirective(input: PromptInput): PromptInput {
+  const body = input.text.trim() || "(see attached media / files)";
+  if (body.startsWith(MANAGER_DIRECTIVE_MARKER) || body.includes(MANAGER_DIRECTIVE_MARKER)) {
+    return input;
+  }
+  return {
+    ...input,
+    text: `${MANAGER_DIRECTIVE}\n${body}`,
+  };
+}
+
+/** Build the meta prompt that wakes General after a child topic finishes. */
+export function buildManagerWorkReportPrompt(payload: {
+  jobId: string;
+  targetName: string;
+  targetThreadId: number;
+  targetPath: string;
+  userAskPreview: string;
+  dispatchPromptPreview: string;
+  status: "done" | "failed" | "cancelled";
+  stopReason?: string;
+  error?: string;
+  assistantSummary: string;
+  filesSummary?: string;
+  childSessionId?: string;
+}): string {
+  const lines = [
+    MANAGER_WORK_REPORT_MARKER,
+    "```json",
+    JSON.stringify(
+      {
+        jobId: payload.jobId,
+        status: payload.status,
+        target: {
+          name: payload.targetName,
+          threadId: payload.targetThreadId,
+          path: payload.targetPath,
+        },
+        userAskPreview: payload.userAskPreview.slice(0, 500),
+        dispatchPromptPreview: payload.dispatchPromptPreview.slice(0, 800),
+        stopReason: payload.stopReason,
+        error: payload.error,
+        childSessionId: payload.childSessionId,
+        filesSummary: payload.filesSummary,
+        assistantSummary: payload.assistantSummary.slice(0, 3500),
+      },
+      null,
+      2,
+    ),
+    "```",
+    "If the user needs to know (success, failure, blocked, needs a decision), reply in short prose.",
+    "If this is routine and they did not ask for a status, a one-line note is enough.",
+    "Do not re-emit the same send_prompt unless a retry is clearly useful.",
+    "No progress markers. No job tables or multi-message status spam.",
+  ];
+  return lines.join("\n");
+}

package/src/render/session-comment.ts

@@ -52,6 +52,14 @@ export function cleanCommentLine(raw: string, max = COMMENT_MAX): string {
  */
 export function stripDirectiveWrappers(raw: string): string {
   let t = raw.trim().replace(/^\([^)]*\)\s*/, "");
+  // Manager context + work reports (meta).
+  if (/^MANAGER WORK REPORT \(system/i.test(t)) t = "";
+  if (/MANAGER CONTEXT \(auto/i.test(t)) {
+    t = t.replace(/MANAGER CONTEXT \(auto[\s\S]*?\n---\n\n/i, "");
+  }
+  if (/^MANAGER MODE \(General topic/i.test(t)) {
+    t = t.replace(/^MANAGER MODE \(General topic[\s\S]*?User message:\s*/i, "");
+  }
   const marker = "User's new message:";
   const i = t.lastIndexOf(marker);
   if (i !== -1) t = t.slice(i + marker.length);
@@ -68,6 +76,7 @@ export function stripDirectiveWrappers(raw: string): string {
     }
   }
   if (/^TELEGRAM BRIDGE RESULTS \(system/i.test(t.trim())) t = "";
+  if (/^MANAGER WORK REPORT \(system/i.test(t.trim())) t = "";
   return t.trim();
 }
 
@@ -81,6 +90,7 @@ export function cleanUserPreview(raw: string, max = COMMENT_MAX): string {
   if (/^SELF-RECHECK DECISION \(meta only\)/i.test(t)) return "";
   if (/^FOLLOW-UP SUGGESTIONS \(meta only\)/i.test(t)) return "";
   if (/^TELEGRAM BRIDGE RESULTS \(system/i.test(t)) return "Telegram bridge";
+  if (/^MANAGER WORK REPORT \(system/i.test(t)) return "Manager work report";
   return cleanCommentLine(t, max);
 }