cursor-telegram-mcp 0.5.0 → 0.6.0

package/README.md

@@ -15,7 +15,8 @@ Local and bring-your-own-bot: each person installs the package, creates their
 own Telegram bot, and everything runs on their own machine. There is no shared
 server and nothing shared between users. It uses the official
 [Telegram Bot API](https://core.telegram.org/bots/api) over HTTPS - no QR, no
-eSIM, no SIM. Pending questions are kept in memory only.
+eSIM, no SIM. Pending questions are persisted to disk, so a worker restart
+restores any still-open questions instead of dropping them.
 
 ## Add to Cursor (one click)
 
@@ -71,7 +72,7 @@ flowchart TD
   check -->|yes| reuse["reuse running worker"]
   spawn --> worker["worker dist/worker.js"]
   reuse --> worker
-  worker --> store["in-memory question store"]
+  worker --> store["persisted question store (questions.json)"]
   worker -->|"command mode (optional)"| agent["headless Cursor agent (cursor-agent CLI)"]
   worker -->|"Bot API: sendMessage / getUpdates"| tg["Telegram"]
   tg -->|"your reply / texted task"| worker
@@ -120,15 +121,37 @@ worker treats any message that is not answering an open question as a task:
    carries out the plan and texts back a summary.
 
 You can also use `/ask <question>` (read-only Q&A) and `/plan <task>` explicitly,
-and send `status` to see what's running. Command mode needs the Cursor CLI
-(`cursor-agent`) installed:
+send `status` to see what's running, and `/reset` (or `/new`) to start a fresh
+conversation. Command mode needs the Cursor CLI (`cursor-agent`) installed:
 
 - macOS / Linux: `curl https://cursor.com/install -fsS | bash`
 - Windows (PowerShell): `irm 'https://cursor.com/install?win32=true' | iex`
 
 The headless agent runs locally against `TG_AGENT_CWD` (default: the directory
 the worker started in). Every task is gated: nothing changes code until you
-approve the plan. Sessions are in memory only.
+approve the plan.
+
+## Rolling chat (knowledge carries across messages)
+
+By default (`TG_ROLLING=true`) command mode keeps ONE long-lived Cursor agent
+and sends every turn — plan, execute, and `/ask` — to it. That means:
+
+- The executor remembers the plan it just made, and the next prompt remembers
+  the whole conversation, so you can keep building from your phone without
+  re-explaining context.
+- The agent id is persisted to `TG_SESSION_PATH` (default
+  `<configDir>/rolling-session.json`), so the thread survives worker restarts
+  (including the self-update restart) and resumes where you left off.
+- Send `/reset` (or `/new`) to drop the memory and start a fresh thread.
+
+Set `TG_ROLLING=false` to go back to a stateless agent per message.
+
+### See the same chat on your computer
+
+Every turn is also appended to a Markdown transcript at `TG_TRANSCRIPT_PATH`
+(default `<TG_AGENT_CWD>/remote-chat.md`). Open it in Cursor (or any editor) to
+read the same conversation you are driving from your phone. Because it lives in
+the repo, git tracks its history — commit it whenever you want a snapshot.
 
 ## Keeping the worker alive
 
@@ -136,11 +159,25 @@ The worker runs only while your laptop is awake. It auto-starts with the MCP
 server and stays up across Cursor reloads, so for "laptop on the charger, manage
 from my phone" you usually need nothing else.
 
-If you want it to survive reboots without opening Cursor, run it under your OS
-service manager (launchd / systemd / Task Scheduler) calling
-`cursor-telegram-mcp worker`. (Note: on macOS, launchd agents cannot read files
-under `~/Desktop`/`~/Documents`/`~/Downloads`; install the package or project
-outside those folders.)
+If you want it to survive reboots without opening Cursor, install it as an
+always-on background service. On macOS this is one command:
+
+```bash
+cursor-telegram-mcp install     # start now + at every login (launchd)
+cursor-telegram-mcp uninstall   # stop and remove it
+```
+
+`install` writes a per-user launch agent
+(`~/Library/LaunchAgents/com.cursor-telegram.worker.plist`) that points at your
+current Node and the installed CLI — no hardcoded paths — runs the worker under
+`caffeinate` so idle sleep never blocks delivery, and restarts it if it crashes
+(`KeepAlive`). Logs go to `~/Library/Logs/cursor-telegram-worker.log`. Keep the
+Mac on AC power so a closed lid does not fully sleep.
+
+On Linux/Windows, run `cursor-telegram-mcp worker` under your own service
+manager (systemd / Task Scheduler). (Note: on macOS, launchd agents cannot read
+files under `~/Desktop`/`~/Documents`/`~/Downloads`; install the package or
+project outside those folders.)
 
 ## Configuration
 
@@ -162,6 +199,9 @@ defaults.
 | `TG_AGENT_CWD` | worker cwd | Directory the headless command-mode agent works in. |
 | `TG_AGENT_MODEL` | `composer-2.5` | Model id for the headless agent. |
 | `TG_AGENT_LOAD_SETTINGS` | `false` | `true` to load `TG_AGENT_CWD`'s `.cursor` rules/MCP during runs. |
+| `TG_ROLLING` | `true` | Keep one rolling agent thread so knowledge carries across messages. |
+| `TG_TRANSCRIPT_PATH` | `<cwd>/remote-chat.md` | Markdown transcript of the rolling chat. |
+| `TG_SESSION_PATH` | `<configDir>/rolling-session.json` | Where the rolling agent id is persisted. |
 
 ## CLI
 
@@ -170,6 +210,8 @@ cursor-telegram-mcp [mcp]    Start the MCP server (default; Cursor runs this)
 cursor-telegram-mcp setup    First-time setup: create/link your bot
 cursor-telegram-mcp login    Print and save your Telegram chat id
 cursor-telegram-mcp worker   Run the background worker in the foreground
+cursor-telegram-mcp install  Install the always-on worker (macOS launchd)
+cursor-telegram-mcp uninstall Remove the always-on worker
 cursor-telegram-mcp doctor   Diagnose configuration and connectivity
 ```
 
@@ -243,8 +285,8 @@ npm run build       # emit dist/ for publishing
 ## Notes & limitations
 
 - Local-only: if the laptop sleeps or the worker stops, messaging pauses until
-  it is back. Questions are in memory, so a worker restart forgets any
-  unanswered question (by design).
+  it is back. Open questions are persisted to disk and restored on the next
+  worker start, so a restart no longer drops unanswered questions.
 - Per user: each person creates their own bot and runs their own worker (one bot
   token can only be polled by one process).
 - Command mode requires the `cursor-agent` CLI and a Cursor API key; without
@@ -262,8 +304,11 @@ src/
   login.ts      # chat-id discovery helper
   doctor.ts     # diagnostics
   telegram.ts   # Bot API client: long-poll getUpdates, sendText, media
-  agentRunner.ts# command mode: headless Cursor agent (lazy @cursor/sdk)
-  store.ts      # in-memory pending-question store + reply matching
+  agentRunner.ts# command mode: rolling/resumable headless Cursor agent (lazy @cursor/sdk)
+  session.ts    # persist the rolling agent id across worker restarts
+  transcript.ts # append-only remote-chat.md transcript of the rolling chat
+  store.ts      # pending-question store (persisted to disk) + reply matching
+  install.ts    # `install`/`uninstall`: generate a per-user launchd agent (macOS)
   parseInbound.ts / splitMessage.ts / taskQueue.ts / formatTelegram.ts
   answerWaiters.ts  # wake-on-answer for long-polling GET /response/:id
 .cursor/

package/dist/agentRunner.js

@@ -55,15 +55,23 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  *
  * Flow (plan-then-approve, always gated):
  *   1. You text the bot a task.
- *   2. `plan()` runs a read-only Cursor agent that produces a step-by-step PLAN
- *      only (no file changes) and returns it for you to review on your phone.
- *   3. You reply YES -> `approve()` runs a second agent that executes the
- *      approved plan and reports the result. Reply NO -> `reject()` drops it.
+ *   2. `plan()` produces a step-by-step PLAN only (no file changes) and returns
+ *      it for you to review on your phone.
+ *   3. You reply YES -> `approve()` executes the approved plan and reports the
+ *      result. Reply NO -> `reject()` drops it.
+ *
+ * Rolling thread: by default the runner keeps ONE long-lived Cursor agent and
+ * sends every turn (plan, execute, ask) to it, so knowledge carries across
+ * messages — the executor remembers the plan, and the next prompt remembers the
+ * whole conversation. The agent id is persisted (see session.ts) so the thread
+ * survives worker restarts. Set `rolling: false` to fall back to a fresh agent
+ * per call (the old stateless behavior).
  *
  * Everything runs locally on this machine (the laptop on the charger) against
- * `cwd`, using your CURSOR_API_KEY. Sessions live in memory only.
+ * `cwd`, using your CURSOR_API_KEY.
  */
 import { readFileSync } from "node:fs";
+import { clearRollingSession, loadRollingSession, saveRollingSession, } from "./session.js";
 /**
  * Lazily load the optional `@cursor/sdk`. Command mode needs it; if the package
  * is not installed (it is an optionalDependency), surface a clear, actionable
@@ -100,7 +108,8 @@ function buildUserMessage(text, attachments) {
         return text;
     return { text, images };
 }
-async function runAgentPrompt(promptText, opts, attachments) {
+/** Run a single prompt on a fresh, stateless agent (rolling disabled). */
+async function runStatelessPrompt(promptText, opts, attachments) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         const message = buildUserMessage(promptText, attachments);
@@ -163,13 +172,114 @@ export class CommandRunner {
     nextAskId = 1;
     sessions = new Map();
     askSessions = new Map();
+    /** Live rolling agent instance (kept across turns; created lazily). */
+    agent;
+    /** Persisted rolling agent id (may exist before `agent` is reattached). */
+    rollingAgentId;
+    /** Epoch ms the current rolling thread started. */
+    threadStartedAt;
+    /** Serializes turns so two phone messages never share one agent send. */
+    turnChain = Promise.resolve();
     constructor(opts) {
         this.opts = opts;
+        if (opts.rolling) {
+            const saved = loadRollingSession(opts.sessionPath);
+            // Only reuse a saved thread if it matches the current cwd (a different
+            // project should get its own conversation).
+            if (saved && saved.cwd === opts.cwd) {
+                this.rollingAgentId = saved.agentId;
+                this.threadStartedAt = saved.startedAt;
+            }
+        }
     }
     /** True when a Cursor API key is configured. */
     get enabled() {
         return this.opts.apiKey.trim() !== "";
     }
+    /** Info about the active rolling thread, if rolling is on and started. */
+    rollingInfo() {
+        if (!this.opts.rolling)
+            return undefined;
+        if (!this.rollingAgentId)
+            return undefined;
+        return { agentId: this.rollingAgentId, startedAt: this.threadStartedAt ?? 0 };
+    }
+    /**
+     * Get the rolling agent, creating it (first ever turn) or resuming a saved
+     * thread (after a worker restart). Reuses the live instance otherwise.
+     */
+    async getRollingAgent() {
+        if (this.agent)
+            return this.agent;
+        const { Agent } = await loadSdk();
+        const local = { cwd: this.opts.cwd, settingSources: this.opts.settingSources };
+        if (this.rollingAgentId) {
+            try {
+                this.agent = await Agent.resume(this.rollingAgentId, {
+                    apiKey: this.opts.apiKey,
+                    model: { id: this.opts.model },
+                    local,
+                });
+                return this.agent;
+            }
+            catch {
+                // The saved thread could not be resumed (e.g. pruned); start fresh.
+                this.rollingAgentId = undefined;
+                this.threadStartedAt = undefined;
+                clearRollingSession(this.opts.sessionPath);
+            }
+        }
+        this.agent = await Agent.create({
+            apiKey: this.opts.apiKey,
+            model: { id: this.opts.model },
+            local,
+        });
+        this.rollingAgentId = this.agent.agentId;
+        this.threadStartedAt = Date.now();
+        saveRollingSession(this.opts.sessionPath, {
+            agentId: this.rollingAgentId,
+            model: this.opts.model,
+            cwd: this.opts.cwd,
+            startedAt: this.threadStartedAt,
+        });
+        return this.agent;
+    }
+    /**
+     * Run one prompt. In rolling mode this reuses the persistent agent (so the
+     * turn remembers all prior turns); otherwise it uses a fresh stateless agent.
+     * Turns are serialized to keep the single agent consistent.
+     */
+    async runTurn(promptText, attachments) {
+        if (!this.opts.rolling) {
+            return runStatelessPrompt(promptText, this.opts, attachments);
+        }
+        const run = this.turnChain.then(async () => {
+            const message = buildUserMessage(promptText, attachments);
+            const agent = await this.getRollingAgent();
+            const r = await agent.send(message);
+            await r.wait();
+            return { status: r.status, result: r.result };
+        });
+        // Keep the chain alive even if this turn rejects, without swallowing the
+        // error for the caller.
+        this.turnChain = run.catch(() => undefined);
+        return run;
+    }
+    /** Start a fresh rolling thread (drops memory of the current conversation). */
+    reset() {
+        if (this.agent) {
+            try {
+                this.agent.close();
+            }
+            catch {
+                // best-effort
+            }
+        }
+        this.agent = undefined;
+        this.rollingAgentId = undefined;
+        this.threadStartedAt = undefined;
+        clearRollingSession(this.opts.sessionPath);
+    }
     /** Most recent session waiting for a YES/NO approval, if any. */
     latestAwaitingApproval() {
         let latest;
@@ -223,7 +333,7 @@ export class CommandRunner {
         this.sessions.set(session.id, session);
         onSession?.(session);
         try {
-            const result = await runAgentPrompt(PLAN_PROMPT(task), this.opts, attachments);
+            const result = await this.runTurn(PLAN_PROMPT(task), attachments);
             if (result.status === "error") {
                 session.status = "error";
                 session.error = coerceText(result.result) || "plan run failed";
@@ -254,7 +364,7 @@ export class CommandRunner {
         this.askSessions.set(session.id, session);
         onSession?.(session);
         try {
-            const result = await runAgentPrompt(ASK_PROMPT(question), this.opts, attachments);
+            const result = await this.runTurn(ASK_PROMPT(question), attachments);
             if (result.status === "error") {
                 session.status = "error";
                 session.error = coerceText(result.result) || "ask run failed";
@@ -284,7 +394,7 @@ export class CommandRunner {
         session.updatedAt = Date.now();
         onExecuting?.(session);
         try {
-            const result = await runAgentPrompt(EXECUTE_PROMPT(session.task, session.plan ?? ""), this.opts);
+            const result = await this.runTurn(EXECUTE_PROMPT(session.task, session.plan ?? ""));
             if (result.status === "error") {
                 session.status = "error";
                 session.error = coerceText(result.result) || "execution run failed";

package/dist/cli.js

@@ -7,6 +7,8 @@
  *   cursor-telegram-mcp setup      Interactive first-time setup (bot + chat id).
  *   cursor-telegram-mcp login      Find your chat id (token must be set).
  *   cursor-telegram-mcp worker     Run the background worker in the foreground.
+ *   cursor-telegram-mcp install    Install the always-on worker (macOS launchd).
+ *   cursor-telegram-mcp uninstall  Remove the always-on worker.
  *   cursor-telegram-mcp doctor     Diagnose configuration / connectivity.
  *
  * Each subcommand is a module whose side-effecting `main()` runs on import.
@@ -20,6 +22,8 @@ function printHelp() {
         "  cursor-telegram-mcp setup    First-time setup: create/link your bot",
         "  cursor-telegram-mcp login    Print your Telegram chat id",
         "  cursor-telegram-mcp worker   Run the background worker in the foreground",
+        "  cursor-telegram-mcp install  Install the always-on worker (macOS launchd)",
+        "  cursor-telegram-mcp uninstall Remove the always-on worker",
         "  cursor-telegram-mcp doctor   Diagnose configuration and connectivity",
         "  cursor-telegram-mcp help     Show this help",
         "",
@@ -39,6 +43,10 @@ async function run() {
         case "worker":
             await import("./worker.js");
             break;
+        case "install":
+        case "uninstall":
+            await import("./install.js");
+            break;
         case "setup":
             await import("./setup.js");
             break;

package/dist/config.js

@@ -15,11 +15,21 @@
  * MCP client needs:
  *   TG_WORKER_URL - where the worker listens (default http://127.0.0.1:8787).
  *   TG_PROJECT    - label for this project's messages (default "default").
+ *   TG_AGENT      - optional default per-agent/chat label, shown as
+ *                   [project · agent]. Overridden by the `agent` tool param.
  *   TG_DEFAULT_POLL_WAIT_MS - long-poll chunk size check_human_response uses
  *                             when no explicit waitMs is passed (default 120000).
+ *   TG_STARTUP_PING - set to 0/false to silence the "worker online" message the
+ *                     worker sends after it connects (default on).
  *
  * Command mode (optional, worker-side) needs:
  *   CURSOR_API_KEY - enables texting tasks to the bot to run headless agents.
+ *   TG_COMMAND_MODE - set to 0/false to hard-disable command mode even when a
+ *                     CURSOR_API_KEY is present (inbound text won't spawn tasks).
+ *   TG_SELF_UPDATE  - set to 0/false so the worker never auto-restarts itself when
+ *                     its own source changes (prevents wiping in-flight state).
+ *   TG_AGENT_CWD    - point command-mode agents at a SEPARATE repo so their edits
+ *                     never touch the worker's own source (avoids self-restarts).
  *   TG_AGENT_CWD   - directory the headless agent works in (default cwd).
  *   TG_AGENT_MODEL - model id for the headless agent (default composer-2.5).
  *   TG_AGENT_LOAD_SETTINGS - "1"/"true" to load this repo's .cursor settings.
@@ -141,6 +151,7 @@ export function getConfig(requireToken = true) {
     }
     const workerHost = strOr("TG_WORKER_HOST", "127.0.0.1");
     const workerPort = intOr("TG_WORKER_PORT", 8787);
+    const agentCwd = strOr("TG_AGENT_CWD", process.cwd());
     cached = {
         botToken,
         chatId: strOr("TELEGRAM_CHAT_ID", ""),
@@ -150,11 +161,18 @@ export function getConfig(requireToken = true) {
         workerPort,
         workerUrl: strOr("TG_WORKER_URL", `http://${workerHost}:${workerPort}`).replace(/\/+$/, ""),
         project: strOr("TG_PROJECT", "default"),
+        agentLabel: strOr("TG_AGENT", ""),
         defaultPollWaitMs: intOr("TG_DEFAULT_POLL_WAIT_MS", 120_000),
+        startupPing: boolOr("TG_STARTUP_PING", true),
         cursorApiKey: strOr("CURSOR_API_KEY", ""),
-        agentCwd: strOr("TG_AGENT_CWD", process.cwd()),
+        commandModeEnabled: boolOr("TG_COMMAND_MODE", true),
+        selfUpdateEnabled: boolOr("TG_SELF_UPDATE", true),
+        agentCwd,
         agentModel: strOr("TG_AGENT_MODEL", "composer-2.5"),
         agentLoadSettings: boolOr("TG_AGENT_LOAD_SETTINGS", false),
+        rolling: boolOr("TG_ROLLING", true),
+        transcriptPath: strOr("TG_TRANSCRIPT_PATH", join(agentCwd, "remote-chat.md")),
+        sessionPath: strOr("TG_SESSION_PATH", join(configDir(), "rolling-session.json")),
     };
     return cached;
 }

package/dist/formatTelegram.js

@@ -1,3 +1,11 @@
+/**
+ * Bracketed prefix for outgoing messages: "[project]" or "[project · agent]"
+ * when a per-agent/chat label is present. Lets the human tell which agent a
+ * question/notification came from when several chats are active.
+ */
+export function labelPrefix(project, agent) {
+    return agent && agent !== "" ? `[${project} · ${agent}]` : `[${project}]`;
+}
 /**
  * Convert agent Markdown to plain text suitable for Telegram (no parse_mode).
  */

package/dist/index.js

@@ -173,9 +173,18 @@ async function main() {
                 .string()
                 .min(1)
                 .describe("Short summary of the completed work (what changed / result)."),
+            agent: z
+                .string()
+                .optional()
+                .describe("Optional short label for THIS chat/agent (e.g. \"auth-refactor\"), shown " +
+                "as [project · agent] so multiple agents are distinguishable."),
         },
-    }, async ({ summary }) => {
-        const r = await callWorker("POST", "/notify", { summary, project: config.project });
+    }, async ({ summary, agent }) => {
+        const r = await callWorker("POST", "/notify", {
+            summary,
+            project: config.project,
+            agent: (agent ?? "").trim() || config.agentLabel,
+        });
         if (!r)
             return textResult(WORKER_DOWN, true);
         if (r.status === 200)
@@ -203,9 +212,19 @@ async function main() {
                 .min(1)
                 .describe("The exact question to ask the human. Be specific and include the " +
                 "options/context needed to answer from a phone."),
+            agent: z
+                .string()
+                .optional()
+                .describe("Optional short label for THIS chat/agent (e.g. \"auth-refactor\"), shown " +
+                "as [project · agent] Q-n so the human can tell which agent is asking " +
+                "and route their reply. Keep it stable across the chat."),
         },
-    }, async ({ question }) => {
-        const r = await callWorker("POST", "/ask", { question, project: config.project });
+    }, async ({ question, agent }) => {
+        const r = await callWorker("POST", "/ask", {
+            question,
+            project: config.project,
+            agent: (agent ?? "").trim() || config.agentLabel,
+        });
         if (!r)
             return textResult(WORKER_DOWN, true);
         if (r.status === 200) {
@@ -237,6 +256,12 @@ async function main() {
                 .min(1)
                 .describe("The exact question to ask the human. Be specific and include the " +
                 "options/context needed to answer from a phone."),
+            agent: z
+                .string()
+                .optional()
+                .describe("Optional short label for THIS chat/agent (e.g. \"auth-refactor\"), shown " +
+                "as [project · agent] Q-n so the human can tell which agent is asking " +
+                "and route their reply. Keep it stable across the chat."),
             timeoutMin: z
                 .number()
                 .int()
@@ -245,9 +270,13 @@ async function main() {
                 .describe("Maximum minutes to wait for a reply (default: TG_RESPONSE_TIMEOUT_MIN, " +
                 "usually 30). Returns timed_out if no reply within this window."),
         },
-    }, async ({ question, timeoutMin }) => {
+    }, async ({ question, agent, timeoutMin }) => {
         const maxWaitMin = timeoutMin ?? config.responseTimeoutMin;
-        const askRes = await callWorker("POST", "/ask", { question, project: config.project });
+        const askRes = await callWorker("POST", "/ask", {
+            question,
+            project: config.project,
+            agent: (agent ?? "").trim() || config.agentLabel,
+        });
         if (!askRes)
             return textResult(WORKER_DOWN, true);
         if (askRes.status === 503) {

package/dist/install.js

@@ -0,0 +1,142 @@
+/**
+ * `cursor-telegram-mcp install` / `uninstall` — always-on worker on macOS.
+ *
+ * Generates a per-user launchd agent (no hardcoded paths) so the background
+ * worker starts at login, restarts if it crashes, and keeps the Mac awake
+ * enough to deliver Telegram messages. Designed for the npm-distributed
+ * package: the plist points at the Node that is running this command and the
+ * installed CLI, and config is read from `<configDir>/config.json` (written by
+ * `setup`), so nothing is tied to a checkout location.
+ *
+ * macOS only for now; on other platforms it prints guidance and exits.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const LABEL = "com.cursor-telegram.worker";
+/** Older label used by the in-repo dev scripts; booted out on install to avoid a double-run. */
+const LEGACY_LABEL = "com.cursor-remote-chat.worker";
+function plistPath() {
+    return join(homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+function logPaths() {
+    const dir = join(homedir(), "Library", "Logs");
+    return {
+        out: join(dir, "cursor-telegram-worker.log"),
+        err: join(dir, "cursor-telegram-worker.err.log"),
+    };
+}
+function xmlEscape(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+/** Absolute path to the installed CLI entry (dist/cli.js) running this code. */
+function cliEntry() {
+    return fileURLToPath(import.meta.url).replace(/install\.js$/, "cli.js");
+}
+function buildProgramArguments() {
+    const node = process.execPath;
+    const cli = cliEntry();
+    const caffeinate = "/usr/bin/caffeinate";
+    // caffeinate -ims keeps the system + display awake while the worker runs so
+    // Telegram delivery is never blocked by idle sleep (AC power still required
+    // for a fully closed-lid Mac, which we document in the README).
+    if (existsSync(caffeinate)) {
+        return [caffeinate, "-ims", node, cli, "worker"];
+    }
+    return [node, cli, "worker"];
+}
+function buildPlist() {
+    const args = buildProgramArguments();
+    const { out, err } = logPaths();
+    const nodeDir = dirname(process.execPath);
+    const pathEnv = [nodeDir, "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"].join(":");
+    const argXml = args.map((a) => `    <string>${xmlEscape(a)}</string>`).join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argXml}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(homedir())}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${xmlEscape(pathEnv)}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(out)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(err)}</string>
+</dict>
+</plist>
+`;
+}
+function domain() {
+    return `gui/${process.getuid?.() ?? 501}`;
+}
+function launchctl(args) {
+    try {
+        execFileSync("launchctl", args, { stdio: "ignore" });
+    }
+    catch {
+        // bootout of a non-loaded agent is expected to fail; callers tolerate it
+    }
+}
+function requireMac() {
+    if (platform() !== "darwin") {
+        process.stderr.write("Always-on install is macOS only for now.\n" +
+            "On other systems, run `cursor-telegram-mcp worker` under your own\n" +
+            "process manager (systemd, pm2, a login item, etc.).\n");
+        process.exit(1);
+    }
+}
+function install() {
+    requireMac();
+    const path = plistPath();
+    mkdirSync(dirname(path), { recursive: true });
+    mkdirSync(join(homedir(), "Library", "Logs"), { recursive: true });
+    writeFileSync(path, buildPlist(), "utf8");
+    // Avoid two workers fighting over the port: stop any previous/legacy agent.
+    launchctl(["bootout", domain(), path]);
+    launchctl(["bootout", domain(), join(homedir(), "Library", "LaunchAgents", `${LEGACY_LABEL}.plist`)]);
+    execFileSync("launchctl", ["bootstrap", domain(), path], { stdio: "inherit" });
+    const { out } = logPaths();
+    process.stdout.write([
+        `Installed always-on worker: ${path}`,
+        `Logs: ${out}`,
+        "",
+        "It will start now and at every login. To stop it:",
+        "  cursor-telegram-mcp uninstall",
+        "",
+        "Tip: keep the Mac on AC power so it never fully sleeps.",
+        "",
+    ].join("\n"));
+}
+function uninstall() {
+    requireMac();
+    const path = plistPath();
+    launchctl(["bootout", domain(), path]);
+    if (existsSync(path))
+        rmSync(path);
+    process.stdout.write("Uninstalled always-on worker.\n");
+}
+const action = process.argv[2] === "uninstall" ? uninstall : install;
+action();

package/dist/parseInbound.js

@@ -5,6 +5,18 @@
  * /ask or /plan on any line. Reply-to HITL answers should bypass splitting
  * (caller passes the full text as a single answer).
  */
+/**
+ * Parse an explicit question target prefix like "Q-3 ...", "Q3 ...", "#3 ..."
+ * or "@Q-3 ...". Returns the normalized question id ("Q-3") and the remaining
+ * answer text, or null when the text doesn't start with such a prefix. Used to
+ * let a Telegram reply target a specific pending question when several are open.
+ */
+export function parseTargetId(text) {
+    const m = text.match(/^\s*@?\s*(?:q-?|#)(\d+)\b[\s:.\-]*([\s\S]*)$/i);
+    if (!m)
+        return null;
+    return { id: `Q-${m[1]}`, rest: (m[2] ?? "").trim() };
+}
 /** Standard plan-approval footer sent after Plan (C-n). */
 const APPROVAL_FOOTER_RE = /^\s*reply\s+yes\s+to\s+run\b[\s\S]*\bno\s+to\s+cancel\.?\s*$/i;
 /** True when text is (or ends with) the plan YES/NO footer — not a new task. */
@@ -18,7 +30,9 @@ export function isPlanApprovalFooter(text) {
     const last = lines[lines.length - 1] ?? "";
     return APPROVAL_FOOTER_RE.test(last);
 }
-const STATUS_RE = /^\s*status\s*$/i;
+const STATUS_RE = /^\s*\/?status\s*$/i;
+const PENDING_RE = /^\s*\/?(pending|questions)\s*$/i;
+const RESET_RE = /^\s*\/?(reset|new)\s*$/i;
 const YES_WORDS = "yes|yea|yeah|y|approve|approved|ok|okay|go|do it|כן|אישור|בצע";
 const NO_WORDS = "no|n|cancel|stop|reject|nope|לא|ביטול|עצור";
 const YES_ONLY_RE = new RegExp(`^\\s*(${YES_WORDS})\\s*[!.]?\\s*$`, "i");
@@ -52,6 +66,10 @@ function parseCommandLine(part) {
 function classifyPart(part) {
     if (STATUS_RE.test(part))
         return [{ kind: "status" }];
+    if (PENDING_RE.test(part))
+        return [{ kind: "pending" }];
+    if (RESET_RE.test(part))
+        return [{ kind: "reset" }];
     if (YES_ONLY_RE.test(part))
         return [{ kind: "approve" }];
     if (NO_ONLY_RE.test(part))
@@ -85,9 +103,23 @@ export function splitInboundMessage(text) {
     if (isPlanApprovalFooter(trimmed)) {
         return [{ kind: "approval_footer" }];
     }
-    const segments = [];
+    const raw = [];
     for (const part of splitParts(trimmed)) {
-        segments.push(...classifyPart(part));
+        raw.push(...classifyPart(part));
+    }
+    // Coalesce consecutive plain segments into ONE task. Without this, a single
+    // multi-line free-text paste is split per line into many separate plan tasks
+    // (the cause of a runaway where one paste spawned C-1..C-n). Explicit /ask
+    // and /plan commands and leading approve/reject stay as their own segments.
+    const segments = [];
+    for (const seg of raw) {
+        const prev = segments[segments.length - 1];
+        if (seg.kind === "plain" && prev && prev.kind === "plain") {
+            prev.text = `${prev.text}\n${seg.text}`;
+        }
+        else {
+            segments.push(seg);
+        }
     }
     return segments;
 }

package/dist/store.js

@@ -1,26 +1,49 @@
+/**
+ * Pending-question store with optional disk persistence.
+ *
+ * When a `persistPath` is given, the store is loaded on construction and saved
+ * (debounced) on every change, so pending questions survive a worker restart and
+ * remain answerable. Without a path it behaves as a pure in-memory store.
+ * Answered questions are kept briefly so a poll that arrives after the reply can
+ * still read it, then pruned to bound memory (and to bound the persisted file).
+ */
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 /** Keep answered questions this long after they are answered, then prune. */
 const ANSWERED_TTL_MS = 60 * 60_000;
+/** Debounce window for writing the persisted store to disk. */
+const SAVE_DEBOUNCE_MS = 200;
 export class QuestionStore {
     nextId = 1;
     questions = new Map();
+    persistPath;
+    saveTimer;
+    constructor(opts = {}) {
+        this.persistPath = opts.persistPath;
+        this.load();
+    }
     /** Create a new pending question. */
-    addQuestion(projectLabel, question) {
+    addQuestion(projectLabel, question, agentLabel) {
         this.prune();
         const record = {
             id: `Q-${this.nextId++}`,
             projectLabel,
+            agentLabel: agentLabel && agentLabel !== "" ? agentLabel : undefined,
             question,
             status: "pending",
             createdAt: Date.now(),
         };
         this.questions.set(record.id, record);
+        this.scheduleSave();
         return record;
     }
     /** Attach the outgoing Telegram message id to a question. */
     setSentMessageId(id, messageId) {
         const record = this.questions.get(id);
-        if (record)
+        if (record) {
             record.sentMessageId = messageId;
+            this.scheduleSave();
+        }
     }
     /** Look up a single question by id. */
     get(id) {
@@ -42,40 +65,102 @@ export class QuestionStore {
     }
     /**
      * Match an inbound message to a pending question and record the answer.
-     * Prefers an exact reply-to match; otherwise answers the oldest pending
-     * question (FIFO). Returns the answered record, or null if nothing matched.
+     * Resolution order: an explicit `targetId` > an exact reply-to (swipe) match >
+     * the sole pending question. When more than one question is pending and there
+     * is no target or reply-to, returns null so the caller can disambiguate (we no
+     * longer silently answer the oldest). A `targetId` that is not pending also
+     * returns null. `answerText` overrides the recorded answer (used when the id
+     * prefix has been stripped from the inbound text).
      */
-    matchAndAnswer(incoming) {
+    matchAndAnswer(incoming, opts = {}) {
         const pendings = [...this.questions.values()]
             .filter((q) => q.status === "pending")
             .sort((a, b) => a.createdAt - b.createdAt);
         if (pendings.length === 0)
             return null;
         let target;
-        if (incoming.quotedMessageId) {
+        if (opts.targetId) {
+            target = pendings.find((q) => q.id === opts.targetId);
+            if (!target)
+                return null; // unknown / already-answered target
+        }
+        else if (incoming.quotedMessageId) {
             target = pendings.find((q) => q.sentMessageId && q.sentMessageId === incoming.quotedMessageId);
         }
-        if (!target)
-            target = pendings[0];
+        if (!target) {
+            if (pendings.length === 1)
+                target = pendings[0];
+            else
+                return null; // ambiguous: caller disambiguates
+        }
         target.status = "answered";
-        target.answer = incoming.text;
+        target.answer = opts.answerText ?? incoming.text;
         if (incoming.attachments.length > 0) {
             target.answerAttachments = incoming.attachments;
         }
         target.answeredAt = incoming.timestamp || Date.now();
+        this.scheduleSave();
         return target;
     }
     /** Drop answered questions older than the TTL. */
     prune() {
         const cutoff = Date.now() - ANSWERED_TTL_MS;
+        let removed = false;
         for (const [id, q] of this.questions) {
             if (q.status === "answered" && (q.answeredAt ?? q.createdAt) < cutoff) {
                 this.questions.delete(id);
+                removed = true;
+            }
+        }
+        if (removed)
+            this.scheduleSave();
+    }
+    /** Load persisted questions (best-effort) on startup. */
+    load() {
+        if (!this.persistPath)
+            return;
+        try {
+            const data = JSON.parse(readFileSync(this.persistPath, "utf8"));
+            if (Array.isArray(data.questions)) {
+                for (const q of data.questions) {
+                    if (q && typeof q.id === "string")
+                        this.questions.set(q.id, q);
+                }
             }
+            if (typeof data.nextId === "number" && data.nextId > this.nextId) {
+                this.nextId = data.nextId;
+            }
+            this.prune();
+        }
+        catch {
+            // No (or unreadable) persisted state: start fresh.
+        }
+    }
+    /** Debounced write so bursts of changes coalesce into one disk write. */
+    scheduleSave() {
+        if (!this.persistPath || this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = undefined;
+            this.saveNow();
+        }, SAVE_DEBOUNCE_MS);
+        this.saveTimer.unref?.();
+    }
+    /** Write the current state to disk now (best-effort). */
+    saveNow() {
+        if (!this.persistPath)
+            return;
+        try {
+            mkdirSync(dirname(this.persistPath), { recursive: true });
+            const data = { nextId: this.nextId, questions: [...this.questions.values()] };
+            writeFileSync(this.persistPath, JSON.stringify(data), "utf8");
+        }
+        catch {
+            // Best-effort persistence: a failed write must not break the worker.
         }
     }
 }
-/** Build a fresh in-memory store. */
-export function createStore() {
-    return new QuestionStore();
+/** Build a store, optionally backed by a JSON file at `opts.persistPath`. */
+export function createStore(opts = {}) {
+    return new QuestionStore(opts);
 }

package/dist/worker.js

@@ -18,23 +18,24 @@
  *
  * API (JSON, localhost only):
  *   GET  /health                       -> { ok, connected, target, pending, commandMode, queue }
- *   POST /notify   { summary, project } -> { ok } | 429 { error, waitMs } | 503
- *   POST /ask      { question, project }-> { id } | 429 | 503
- *   POST /mirror   { question, project } -> { id, mirrored } | 429 | 503
+ *   POST /notify   { summary, project, agent? } -> { ok } | 429 { error, waitMs } | 503
+ *   POST /ask      { question, project, agent? }-> { id } | 429 | 503
+ *   POST /mirror   { question, project, agent? } -> { id, mirrored } | 429 | 503
  *   GET  /response/:id                 -> { id, status, answer?, attachments?, elapsedMin } | 404
  *                                      optional ?waitMs=N long-polls until answered or N ms
  */
 import { createServer } from "node:http";
 import { notifyAnswered, waitForAnswer } from "./answerWaiters.js";
-import { readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir, hostname } from "node:os";
 import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { getConfig } from "./config.js";
+import { configDir, getConfig } from "./config.js";
 import { createStore } from "./store.js";
 import { createCommandRunner } from "./agentRunner.js";
-import { toPlainTelegram } from "./formatTelegram.js";
-import { splitInboundMessage } from "./parseInbound.js";
+import { Transcript } from "./transcript.js";
+import { labelPrefix, toPlainTelegram } from "./formatTelegram.js";
+import { parseTargetId, splitInboundMessage } from "./parseInbound.js";
 import { splitMessage } from "./splitMessage.js";
 import { createTaskQueue } from "./taskQueue.js";
 import { TelegramClient, createStderrLogger, } from "./telegram.js";
@@ -44,6 +45,17 @@ const COMMAND_TTL_MS = 60 * 60_000;
 const UPDATE_CHECK_MS = 15_000;
 /** Directory holding this worker's source (for self-update detection). */
 const SRC_DIR = dirname(fileURLToPath(import.meta.url));
+/** Worker version from package.json (one level up from src/ or dist/). */
+function readVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(SRC_DIR, "..", "package.json"), "utf8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+const WORKER_VERSION = readVersion();
 /**
  * Newest mtime among the worker's TypeScript source files. Used to notice when
  * a command-mode task has edited the worker's own code, so it can relaunch on
@@ -77,6 +89,11 @@ function cleanProject(raw) {
     const s = String(raw ?? "").trim().replace(/\s+/g, " ");
     return s === "" ? "default" : s.slice(0, 48);
 }
+/** Sanitize an optional per-agent label; empty string means "no agent label". */
+function cleanAgent(raw) {
+    const s = String(raw ?? "").trim().replace(/\s+/g, " ");
+    return s.slice(0, 48);
+}
 function sendJson(res, status, body) {
     res.writeHead(status, { "content-type": "application/json" });
     res.end(JSON.stringify(body));
@@ -108,16 +125,6 @@ function isReplyToQuestion(msg, store) {
     const pendings = store.listPending();
     return pendings.some((q) => q.sentMessageId && q.sentMessageId === msg.quotedMessageId);
 }
-function isCommandLike(segments) {
-    return segments.some((s) => s.kind === "ask" ||
-        s.kind === "plan" ||
-        s.kind === "ask_empty" ||
-        s.kind === "plan_empty" ||
-        s.kind === "status" ||
-        s.kind === "approve" ||
-        s.kind === "reject" ||
-        s.kind === "approval_footer");
-}
 async function main() {
     // Make sure the Cursor CLI (`cursor-agent`, used by command mode) is findable
     // even when launched by a GUI/launchd context with a minimal PATH.
@@ -130,18 +137,32 @@ async function main() {
     if (config.chatId === "") {
         log("TELEGRAM_CHAT_ID is not set. Run `npm run login` to find it, then set it in .env.");
     }
-    const store = createStore();
+    const store = createStore({ persistPath: join(configDir(), "questions.json") });
     const taskQueue = createTaskQueue();
+    const startedAt = Date.now();
+    let lastError;
+    const restoredPending = store.pendingCount();
     const runner = createCommandRunner({
         apiKey: config.cursorApiKey,
         cwd: config.agentCwd,
         model: config.agentModel,
         settingSources: config.agentLoadSettings ? ["all"] : [],
+        rolling: config.rolling,
+        sessionPath: config.sessionPath,
     });
-    const commandMode = runner.enabled;
+    const commandMode = runner.enabled && config.commandModeEnabled;
+    const transcript = new Transcript(config.transcriptPath);
     log(commandMode
         ? `Command mode ON (model ${config.agentModel}, cwd ${config.agentCwd}). /ask, /plan, or plain text to plan.`
-        : "Command mode OFF (set CURSOR_API_KEY to text tasks to the bot).");
+        : runner.enabled
+            ? "Command mode OFF (disabled via TG_COMMAND_MODE). Inbound text will not spawn tasks."
+            : "Command mode OFF (set CURSOR_API_KEY to text tasks to the bot).");
+    if (commandMode && config.rolling) {
+        const info = runner.rollingInfo();
+        log(info
+            ? `Rolling thread ON (resuming ${info.agentId}). Transcript: ${config.transcriptPath}`
+            : `Rolling thread ON (new thread on first message). Transcript: ${config.transcriptPath}`);
+    }
     const client = new TelegramClient({
         botToken: config.botToken,
         logger: createStderrLogger("warn"),
@@ -208,9 +229,11 @@ async function main() {
             });
             log(`Execution ${id} -> ${session.status}`);
             if (session.status === "done") {
+                transcript.append({ role: "done", id, text: session.result ?? "" });
                 await send(`Done (${id})\n\n${session.result ?? ""}`);
             }
             else if (session.status === "error") {
+                transcript.append({ role: "error", id, text: session.error ?? "unknown error" });
                 await send(`Command ${id} failed:\n${session.error ?? "unknown error"}`);
             }
         }
@@ -218,15 +241,35 @@ async function main() {
             clearHeartbeat();
         }
     }
+    /** One line per pending question: "Q-3 [project · agent]: question…". */
+    function pendingLines() {
+        return store.listPending().map((q) => {
+            const head = `${q.id} ${labelPrefix(q.projectLabel, q.agentLabel)}`;
+            const preview = q.question.replace(/\s+/g, " ").slice(0, 80);
+            return `${head}: ${preview}`;
+        });
+    }
+    /** Full reply to /pending: the list plus how to answer a specific one. */
+    function formatPendingList() {
+        const lines = pendingLines();
+        if (lines.length === 0)
+            return "No pending questions.";
+        const example = store.listPending()[0]?.id ?? "Q-1";
+        return (`Pending questions (${lines.length}):\n${lines.join("\n")}\n\n` +
+            `To answer a specific one, swipe-reply its message, or prefix your answer ` +
+            `with its id, e.g. "${example} your answer".`);
+    }
     function formatStatus() {
         const lines = [];
         lines.push(`Command mode: ${commandMode ? "ON" : "OFF"}`);
-        const pending = store.listPending();
+        const pending = pendingLines();
         if (pending.length === 0) {
             lines.push("Pending questions: none");
         }
         else {
-            lines.push(`Pending questions: ${pending.length} (${pending.map((q) => q.id).join(", ")})`);
+            lines.push(`Pending questions: ${pending.length}`);
+            for (const line of pending)
+                lines.push(`  ${line}`);
         }
         const awaiting = runner.listAwaitingApproval();
         if (awaiting.length === 0) {
@@ -244,13 +287,19 @@ async function main() {
             lines.push(`Active asks: ${activeAsks.map((s) => s.id).join(", ")}`);
         }
         lines.push(`Queued tasks: ${taskQueue.preview()}`);
+        if (commandMode && config.rolling) {
+            const info = runner.rollingInfo();
+            lines.push(`Rolling thread: ${info ? info.agentId : "not started yet"}`);
+            lines.push(`Transcript: ${config.transcriptPath}`);
+        }
         if (commandMode) {
-            lines.push("Commands: /ask question, /plan task, plain text plans too");
+            lines.push("Commands: /ask question, /plan task, plain text plans too, /reset for a new thread");
         }
         return lines.join("\n");
     }
     async function runPlanTask(task, attachments) {
         log(`New task received; planning...`);
+        transcript.append({ role: "you", text: task });
         await send(`Planning your request...`);
         let heartbeat;
         const clearHeartbeat = () => {
@@ -278,14 +327,17 @@ async function main() {
         clearHeartbeat();
         log(`Plan ${session.id} -> ${session.status}`);
         if (session.status === "awaiting_approval") {
+            transcript.append({ role: "plan", id: session.id, text: session.plan ?? "" });
             await send(`Plan (${session.id})\n\n${session.plan ?? ""}\n\nReply YES to run it or NO to cancel.`);
         }
         else {
+            transcript.append({ role: "error", id: session.id, text: session.error ?? "unknown error" });
             await send(`Could not plan that (${session.id}):\n${session.error ?? "unknown error"}`);
         }
     }
     async function runAskQuestion(question, attachments) {
         log(`Ask received; answering...`);
+        transcript.append({ role: "you", text: `/ask ${question}` });
         await send(`Answering...`);
         let heartbeat;
         const clearHeartbeat = () => {
@@ -313,9 +365,11 @@ async function main() {
         clearHeartbeat();
         log(`Ask ${session.id} -> ${session.status}`);
         if (session.status === "done") {
+            transcript.append({ role: "answer", id: session.id, text: session.answer ?? "" });
             await send(`Ask (${session.id})\n\n${session.answer ?? ""}`);
         }
         else {
+            transcript.append({ role: "error", id: session.id, text: session.error ?? "unknown error" });
             await send(`Could not answer (${session.id}):\n${session.error ?? "unknown error"}`);
         }
     }
@@ -359,6 +413,25 @@ async function main() {
             case "status":
                 await send(formatStatus());
                 return;
+            case "pending":
+                await send(formatPendingList());
+                return;
+            case "reset": {
+                if (!commandMode)
+                    return;
+                if (!config.rolling) {
+                    await send("Rolling thread is off; nothing to reset.");
+                    return;
+                }
+                if (isWorkerBusy()) {
+                    await send("BUSY: finish the current work before starting a new thread.");
+                    return;
+                }
+                runner.reset();
+                transcript.append({ role: "system", text: "New rolling thread started (memory cleared)." });
+                await send("Started a fresh thread. The next prompt begins a new conversation.");
+                return;
+            }
             case "approve": {
                 if (!commandMode)
                     return;
@@ -446,22 +519,75 @@ async function main() {
         const text = msg.text.trim();
         if (text === "" && attachments.length === 0)
             return;
+        const recordAnswer = async (matched) => {
+            log(`Recorded answer for ${matched.id} ${labelPrefix(matched.projectLabel, matched.agentLabel)}.`);
+            notifyAnswered(matched.id);
+            await send(`Answer recorded for ${matched.id}.`);
+        };
+        // 1) Explicit target prefix ("Q-3 ...", "#3 ...", "@Q-3 ...") wins over
+        //    everything else, so "Q-3 yes" answers Q-3 rather than reading as a
+        //    command. Only intercept when something is actually pending.
+        if (store.pendingCount() > 0) {
+            const target = parseTargetId(text);
+            if (target) {
+                if (!store.listPending().some((q) => q.id === target.id)) {
+                    await send(`No pending question ${target.id}.\n\n${formatPendingList()}`);
+                    return;
+                }
+                if (target.rest === "" && attachments.length === 0) {
+                    await send(`What's your answer to ${target.id}? Reply: ${target.id} your answer`);
+                    return;
+                }
+                const matched = store.matchAndAnswer(msg, { targetId: target.id, answerText: target.rest });
+                if (matched)
+                    await recordAnswer(matched);
+                return;
+            }
+        }
+        // 2) Swipe-reply to a specific pending question.
         if (isReplyToQuestion(msg, store)) {
             const matched = store.matchAndAnswer(msg);
-            if (matched) {
-                log(`Recorded answer for ${matched.id} [${matched.projectLabel}].`);
-                notifyAnswered(matched.id);
-                await send(`Answer recorded for ${matched.id}.`);
-            }
+            if (matched)
+                await recordAnswer(matched);
             return;
         }
-        if (store.pendingCount() > 0 && !isCommandLike(splitInboundMessage(text))) {
-            const matched = store.matchAndAnswer(msg);
-            if (matched) {
-                log(`Recorded answer for ${matched.id} [${matched.projectLabel}].`);
-                notifyAnswered(matched.id);
-                await send(`Answer recorded for ${matched.id}.`);
-                return;
+        // 3) Bare reply while questions are pending. A yes/no/ok parses as an
+        //    approve/reject COMMAND, but only when command mode is on AND a plan is
+        //    awaiting approval. Otherwise route it to the pending question so answers
+        //    like "Yes" are not silently swallowed.
+        if (store.pendingCount() > 0) {
+            const segs = splitInboundMessage(text);
+            const canApproveNow = commandMode && runner.latestAwaitingApproval() != null;
+            const actionableCommand = segs.some((s) => {
+                switch (s.kind) {
+                    case "ask":
+                    case "ask_empty":
+                    case "plan":
+                    case "plan_empty":
+                    case "status":
+                    case "pending":
+                        return true;
+                    case "reset":
+                        return commandMode;
+                    case "approve":
+                    case "reject":
+                    case "approval_footer":
+                        return canApproveNow;
+                    default:
+                        return false;
+                }
+            });
+            if (!actionableCommand) {
+                if (store.pendingCount() > 1) {
+                    // Ambiguous: don't guess at the oldest. Ask the human to target one.
+                    await send(`You have ${store.pendingCount()} questions waiting — tell me which to answer.\n\n${formatPendingList()}`);
+                    return;
+                }
+                const matched = store.matchAndAnswer(msg);
+                if (matched) {
+                    await recordAnswer(matched);
+                    return;
+                }
             }
         }
         const segments = splitInboundMessage(text);
@@ -481,7 +607,10 @@ async function main() {
             return;
         incomingChain = incomingChain
             .then(() => handleIncoming(msg))
-            .catch((err) => log(`handleIncoming error: ${String(err)}`));
+            .catch((err) => {
+            lastError = `handleIncoming: ${String(err)}`;
+            log(lastError);
+        });
     });
     function rateGuard() {
         const elapsed = Date.now() - lastSendAt;
@@ -492,7 +621,7 @@ async function main() {
     function dedupeMirrorKey(project, question) {
         return `${project}::${question.slice(0, 200)}`;
     }
-    async function mirrorQuestion(project, question) {
+    async function mirrorQuestion(project, question, agent) {
         const key = dedupeMirrorKey(project, question);
         const now = Date.now();
         const last = recentMirrors.get(key);
@@ -501,8 +630,8 @@ async function main() {
             return { id: existing?.id ?? "deduped", mirrored: false };
         }
         recentMirrors.set(key, now);
-        const record = store.addQuestion(project, question);
-        const text = `[${project}] ${record.id}\n${question}\n\nReply to this message to answer.`;
+        const record = store.addQuestion(project, question, agent);
+        const text = `${labelPrefix(project, agent)} ${record.id}\n${question}\n\nReply to this message to answer.`;
         const sentId = await send(text);
         if (sentId)
             store.setSentMessageId(record.id, sentId);
@@ -521,6 +650,9 @@ async function main() {
                     pending: store.pendingCount(),
                     commandMode,
                     queue: taskQueue.length(),
+                    version: WORKER_VERSION,
+                    uptimeSec: Math.floor((Date.now() - startedAt) / 1000),
+                    lastError: lastError ?? null,
                 });
             }
             if (method === "POST" && path === "/notify") {
@@ -534,9 +666,10 @@ async function main() {
                 const body = await readJson(req);
                 const summary = String(body.summary ?? "").trim();
                 const project = cleanProject(body.project);
+                const agent = cleanAgent(body.agent);
                 if (!summary)
                     return sendJson(res, 400, { error: "summary is required" });
-                await send(`[${project}] Task complete\n\n${summary}`);
+                await send(`${labelPrefix(project, agent)} Task complete\n\n${summary}`);
                 return sendJson(res, 200, { ok: true });
             }
             if (method === "POST" && (path === "/ask" || path === "/mirror")) {
@@ -550,9 +683,10 @@ async function main() {
                 const body = await readJson(req);
                 const question = String(body.question ?? "").trim();
                 const project = cleanProject(body.project);
+                const agent = cleanAgent(body.agent);
                 if (!question)
                     return sendJson(res, 400, { error: "question is required" });
-                const { id, mirrored } = await mirrorQuestion(project, question);
+                const { id, mirrored } = await mirrorQuestion(project, question, agent);
                 return sendJson(res, 200, { id, mirrored: path === "/mirror" ? mirrored : true });
             }
             if (method === "GET" && path.startsWith("/response/")) {
@@ -616,6 +750,7 @@ async function main() {
             return sendJson(res, 404, { error: "not found" });
         }
         catch (err) {
+            lastError = `http: ${String(err)}`;
             return sendJson(res, 500, { error: String(err) });
         }
     });
@@ -633,6 +768,13 @@ async function main() {
     const sweep = setInterval(() => runner.sweepStale(COMMAND_TTL_MS), 10 * 60_000);
     sweep.unref?.();
     await client.connect().catch((err) => log(`Telegram connection error: ${String(err)}`));
+    // Startup ping: let the human know the worker is back online (opt-out via
+    // TG_STARTUP_PING=0). Includes restored pending-question count so a restart
+    // that recovered state is visible.
+    if (config.startupPing && client.isOpen() && config.chatId !== "") {
+        const restored = restoredPending > 0 ? `, restored ${restoredPending} pending` : "";
+        await send(`Worker online on ${hostname()} (v${WORKER_VERSION}). Command mode ${commandMode ? "ON" : "OFF"}${restored}.`);
+    }
     const shutdown = () => {
         log("Shutting down...");
         server.close();
@@ -643,23 +785,29 @@ async function main() {
     // Self-update: if a task edits the worker's own source, relaunch on the new
     // code once nothing is in flight. Only effective under a KeepAlive supervisor
     // (launchd `npm run worker:install`), which restarts the process after exit.
-    const startFingerprint = sourceFingerprint();
-    function isIdleForRestart() {
-        return (!isWorkerBusy() &&
+    // Disabled when TG_SELF_UPDATE is off: the worker then never restarts itself on
+    // source changes, so in-flight command-mode state can't be wiped mid-task (you
+    // restart manually to pick up new code).
+    if (config.selfUpdateEnabled) {
+        const startFingerprint = sourceFingerprint();
+        const isIdleForRestart = () => !isWorkerBusy() &&
             !draining &&
             taskQueue.length() === 0 &&
             runner.listAwaitingApproval().length === 0 &&
             runner.listActiveAsks().length === 0 &&
-            store.pendingCount() === 0);
+            store.pendingCount() === 0;
+        const updateCheck = setInterval(() => {
+            if (sourceFingerprint() > startFingerprint && isIdleForRestart()) {
+                log("Source changed and worker idle; restarting to load the latest version...");
+                clearInterval(updateCheck);
+                shutdown();
+            }
+        }, UPDATE_CHECK_MS);
+        updateCheck.unref?.();
+    }
+    else {
+        log("Self-update OFF (TG_SELF_UPDATE). Worker will not auto-restart on source changes.");
     }
-    const updateCheck = setInterval(() => {
-        if (sourceFingerprint() > startFingerprint && isIdleForRestart()) {
-            log("Source changed and worker idle; restarting to load the latest version...");
-            clearInterval(updateCheck);
-            shutdown();
-        }
-    }, UPDATE_CHECK_MS);
-    updateCheck.unref?.();
 }
 main().catch((err) => {
     log(`Fatal: ${err?.stack ?? err}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-telegram-mcp",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Manage Cursor from your phone over Telegram: an MCP server + auto-spawned local worker that notifies you, asks you questions, and (optionally) runs headless Cursor agents you text it. Local, bring-your-own-bot, runs entirely on your machine.",
   "type": "module",
   "license": "MIT",