@0xmaxma/claude-gateway 1.7.9 → 1.8.0

package/mcp/tools/memory/module.ts

@@ -10,11 +10,22 @@
  */
 
 import type { ToolModule, McpToolDefinition, McpToolResult, ToolVisibility } from '../../types';
-import { searchArchive, getExcerpt, archiveDbPath, sharedDbPathFromEnv, mergeHits } from './archive-reader';
+import { searchArchive, findSimilarSharedNotes, getExcerpt, archiveDbPath, sharedDbPathFromEnv, mergeHits, recordSharedPathRetrieval } from './archive-reader';
+import { sharedNoteExists, readSharedNote, writeSharedNoteAtomic, deleteSharedNote, contentLossPercent, triggerSharedReindex, sharedNoteFilename } from './archive-writer';
+
+/** memory_shared_update: below this line-loss %, an update just applies — no confirm needed. */
+const UPDATE_LOSS_CONFIRM_THRESHOLD = 50;
 
 /** Corpora the tool can serve. */
 const SUPPORTED_CORPORA = new Set(['memory', 'shared', 'all']);
 
+// Mirrors skill_create's MAX_SKILL_SIZE (mcp/tools/skills/handlers.ts) — the
+// direct structural precedent for a write-capable, scope-aware MCP tool. A
+// shared note lives in a vault SHARED across every agent in the project, so
+// leaving it uncapped would let one agent (a runaway loop, or a prompt
+// injection) exhaust shared disk / bloat the shared FTS5 index for everyone.
+const MAX_SHARED_NOTE_SIZE = 100 * 1024; // 100KB
+
 export class MemoryModule implements ToolModule {
   id = 'memory';
   toolVisibility: ToolVisibility = 'all-configured';
@@ -64,6 +75,60 @@ export class MemoryModule implements ToolModule {
           additionalProperties: false,
         },
       },
+      {
+        name: 'memory_shared_create',
+        description:
+          'Create a NEW note in the shared, cross-agent knowledge base RIGHT NOW, instead of waiting for the nightly automatic promotion. This is an explicit, agent-initiated write (works even when shared-KB mode is "propose"). Notes live in a shared namespace across every agent — pick any "name" you like, there is no agent-id prefix. Fails if a note with this exact name already exists (use memory_shared_update on it instead, after reading it with memory_shared_get). Before writing, this also searches the shared KB for notes with SIMILAR content and, if any are found, returns them instead of creating (to avoid near-duplicate notes cluttering the vault) — pass confirm:true to create anyway once you have checked they are not the same topic; when you do, a `[[link]]` to each similar note found is appended to your content automatically, so the knowledge-graph dashboard stays connected instead of gaining a disconnected duplicate. The note becomes searchable via memory_search (corpus "shared" or "all") shortly after this call returns.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Freeform name identifying this note, e.g. "deploy-runbook". Stable identity — reuse it with memory_shared_update to edit the same note later.' },
+            content: { type: 'string', description: 'Full note body to write into the shared KB. Max 100KB.' },
+            confirm: { type: 'boolean', description: 'Create anyway even though similar existing notes were found. Default: false.' },
+          },
+          required: ['name', 'content'],
+          additionalProperties: false,
+        },
+      },
+      {
+        name: 'memory_shared_get',
+        description: 'Read the full current content of one shared-KB note by its exact "name" (see memory_shared_create). Use this before memory_shared_update so your edit is based on what is actually there — memory_search only returns short snippets, not the full note.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'The note\'s exact name.' },
+          },
+          required: ['name'],
+          additionalProperties: false,
+        },
+      },
+      {
+        name: 'memory_shared_update',
+        description:
+          `Update an EXISTING shared-KB note by its exact "name" — replaces its full content with "content". Fails if no note with this name exists yet (use memory_shared_create instead). Read the note first with memory_shared_get and edit it — "content" is what the note becomes, not what gets appended, so anything you drop is gone. As a guard against an update that blindly discards most of the note (rather than an intentional rewrite), if the new content is missing ${UPDATE_LOSS_CONFIRM_THRESHOLD}%+ of the existing note's lines, this returns a warning instead of writing — pass confirm:true once you have checked that is what you intend.`,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'The note\'s exact name (see memory_shared_create).' },
+            content: { type: 'string', description: 'Full replacement body for the note. Max 100KB.' },
+            confirm: { type: 'boolean', description: `Apply the update even though it would remove ${UPDATE_LOSS_CONFIRM_THRESHOLD}%+ of the existing content. Default: false.` },
+          },
+          required: ['name', 'content'],
+          additionalProperties: false,
+        },
+      },
+      {
+        name: 'memory_shared_delete',
+        description: 'Delete one shared-KB note by its exact "name" (see memory_shared_create). Any agent can delete any note in the shared vault — there is no per-agent ownership. This cannot delete notes the nightly dreaming pipeline promoted (different naming scheme).',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'The note\'s exact name.' },
+          },
+          required: ['name'],
+          additionalProperties: false,
+        },
+      },
     ];
   }
 
@@ -94,22 +159,23 @@ export class MemoryModule implements ToolModule {
 
           const personalDb = archiveDbPath(workspaceDir);
           const sharedDb = sharedDbPathFromEnv();
-          // Recall counter (planning-66): record retrievals ONLY against the
-          // per-agent archive (the GC tier). Gated by the gateway via env, mirroring
-          // GATEWAY_SHARED_KB_DIR — off unless dreaming.staleness.recordRetrievals.
+          // Recall counters are append-only, best-effort telemetry. Apply the
+          // same opt-in recording to BOTH KB tiers: shared lifecycle/staleness
+          // (issue #392) needs real `memory_search` reads to retain and restore
+          // notes, not manually seeded DB events in tests.
           const rec = { recordRetrievals: process.env.GATEWAY_RECORD_RETRIEVALS === '1' };
           let results;
           if (corpus === 'memory') {
             results = searchArchive(personalDb, query, maxResults, rec).map((h) => ({ ...h, corpus: 'memory' }));
           } else if (corpus === 'shared') {
             if (!sharedDb) return this.json({ results: [], unavailable: true, warning: 'shared KB is not enabled.' });
-            results = searchArchive(sharedDb, query, maxResults).map((h) => ({ ...h, corpus: 'shared' }));
+            results = searchArchive(sharedDb, query, maxResults, rec).map((h) => ({ ...h, corpus: 'shared' }));
           } else {
             // "all": merge personal + shared, keep the best by bm25.
             type Tagged = ReturnType<typeof searchArchive>[number] & { corpus: string };
             const mine: Tagged[] = searchArchive(personalDb, query, maxResults, rec).map((h) => ({ ...h, corpus: 'memory' }));
             const shared: Tagged[] = sharedDb
-              ? searchArchive(sharedDb, query, maxResults).map((h) => ({ ...h, corpus: 'shared' }))
+              ? searchArchive(sharedDb, query, maxResults, rec).map((h) => ({ ...h, corpus: 'shared' }))
               : [];
             results = mergeHits(mine, shared, maxResults);
           }
@@ -134,6 +200,126 @@ export class MemoryModule implements ToolModule {
           return this.json(excerpt);
         }
 
+        case 'memory_shared_create': {
+          // Same gate memory_search uses for corpus:"shared" — fail closed with a
+          // clear error rather than silently falling back to some default vault.
+          const vaultDir = process.env.GATEWAY_SHARED_KB_DIR;
+          if (!vaultDir || !vaultDir.trim()) {
+            return this.err('memory_shared_create unavailable: shared KB is not enabled.');
+          }
+          const name = typeof args.name === 'string' ? args.name.trim() : '';
+          if (!name) return this.err('memory_shared_create requires non-empty "name".');
+          let content = typeof args.content === 'string' ? args.content : '';
+          if (!content.trim()) return this.err('memory_shared_create requires non-empty "content".');
+          if (content.length > MAX_SHARED_NOTE_SIZE) {
+            return this.err(`memory_shared_create: content exceeds ${MAX_SHARED_NOTE_SIZE / 1024}KB limit (${(content.length / 1024).toFixed(1)}KB).`);
+          }
+          if (sharedNoteExists(vaultDir, name)) {
+            return this.err(`memory_shared_create: a note named "${name}" already exists. Use memory_shared_update to modify it (read it first with memory_shared_get), or pick a different name.`);
+          }
+
+          const confirm = args.confirm === true;
+          const sharedDb = sharedDbPathFromEnv();
+          const similar = sharedDb ? findSimilarSharedNotes(sharedDb, `${name} ${content}`, 3) : [];
+          if (similar.length > 0) {
+            if (!confirm) {
+              return this.json({
+                created: false,
+                needsConfirmation: true,
+                reason: 'similar-notes-found',
+                similar: similar.map((h) => ({ path: h.path, snippet: h.snippet })),
+                message: `Found ${similar.length} existing note(s) with similar content — consider memory_shared_update on one of these instead of creating a new one. Pass confirm:true to create "${name}" anyway.`,
+              });
+            }
+            // Confirmed anyway: link to the related notes instead of leaving a
+            // disconnected duplicate (#386) — wiki.ts already resolves
+            // [[wikilinks]] into real /knowledge/graph edges, no parser change
+            // needed, this is the only writer that needs to start emitting them.
+            const links = similar
+              .map((h) => h.path.replace(/\.md$/i, ''))
+              .filter((n) => n !== name)
+              .map((n) => `[[${n}]]`);
+            if (links.length > 0) {
+              content = `${content.trim()}\n\nRelated: ${links.join(' ')}`;
+              if (content.length > MAX_SHARED_NOTE_SIZE) {
+                return this.err(`memory_shared_create: content plus related-note links exceeds ${MAX_SHARED_NOTE_SIZE / 1024}KB limit.`);
+              }
+            }
+          }
+
+          const notePath = writeSharedNoteAtomic(vaultDir, name, content);
+          triggerSharedReindex(vaultDir);
+          return this.json({ created: true, path: notePath });
+        }
+
+        case 'memory_shared_get': {
+          const vaultDir = process.env.GATEWAY_SHARED_KB_DIR;
+          if (!vaultDir || !vaultDir.trim()) {
+            return this.err('memory_shared_get unavailable: shared KB is not enabled.');
+          }
+          const name = typeof args.name === 'string' ? args.name.trim() : '';
+          if (!name) return this.err('memory_shared_get requires non-empty "name".');
+          const content = readSharedNote(vaultDir, name);
+          if (content === null) {
+            return this.err(`memory_shared_get: no note named "${name}" found.`);
+          }
+          if (process.env.GATEWAY_RECORD_RETRIEVALS === '1' && sharedDb) {
+            // Shared notes are lifecycle-whole-file entries, so record the source
+            // note's indexed entry hash after a successful exact read (#392).
+            recordSharedPathRetrieval(sharedDb, sharedNoteFilename(name));
+          }
+          return this.json({ name, content });
+        }
+
+        case 'memory_shared_update': {
+          const vaultDir = process.env.GATEWAY_SHARED_KB_DIR;
+          if (!vaultDir || !vaultDir.trim()) {
+            return this.err('memory_shared_update unavailable: shared KB is not enabled.');
+          }
+          const name = typeof args.name === 'string' ? args.name.trim() : '';
+          if (!name) return this.err('memory_shared_update requires non-empty "name".');
+          const content = typeof args.content === 'string' ? args.content : '';
+          if (!content.trim()) return this.err('memory_shared_update requires non-empty "content".');
+          if (content.length > MAX_SHARED_NOTE_SIZE) {
+            return this.err(`memory_shared_update: content exceeds ${MAX_SHARED_NOTE_SIZE / 1024}KB limit (${(content.length / 1024).toFixed(1)}KB).`);
+          }
+          const existing = readSharedNote(vaultDir, name);
+          if (existing === null) {
+            return this.err(`memory_shared_update: no note named "${name}" found. Use memory_shared_create instead.`);
+          }
+
+          const lossPercent = contentLossPercent(existing, content);
+          const confirm = args.confirm === true;
+          if (lossPercent >= UPDATE_LOSS_CONFIRM_THRESHOLD && !confirm) {
+            return this.json({
+              updated: false,
+              needsConfirmation: true,
+              reason: 'large-content-loss',
+              lossPercent,
+              message: `This update would remove ~${lossPercent}% of the existing note's lines. Pass confirm:true if that's intentional.`,
+            });
+          }
+
+          const notePath = writeSharedNoteAtomic(vaultDir, name, content);
+          triggerSharedReindex(vaultDir);
+          return this.json({ updated: true, path: notePath, lossPercent });
+        }
+
+        case 'memory_shared_delete': {
+          const vaultDir = process.env.GATEWAY_SHARED_KB_DIR;
+          if (!vaultDir || !vaultDir.trim()) {
+            return this.err('memory_shared_delete unavailable: shared KB is not enabled.');
+          }
+          const name = typeof args.name === 'string' ? args.name.trim() : '';
+          if (!name) return this.err('memory_shared_delete requires non-empty "name".');
+          const deleted = deleteSharedNote(vaultDir, name);
+          if (!deleted) {
+            return this.err(`memory_shared_delete: no note named "${name}" found.`);
+          }
+          triggerSharedReindex(vaultDir);
+          return this.json({ deleted: true, name });
+        }
+
         default:
           return this.err(`Unknown memory tool: ${name}`);
       }

package/mcp/tools/telegram/module.ts

@@ -363,10 +363,18 @@ export class TelegramModule implements ChannelModule {
       }
     }
 
-    // Write .replied marker
+    // Write .replied marker, tagged with the live typing-signal timestamp as
+    // this turn's id — the receiver (typing.ts) only treats a queued
+    // auto-forward as "already replied" when its own turnId matches this one,
+    // so a marker left over from an earlier turn can never suppress a later
+    // turn's forward (see typing.ts's isEntryAlreadyReplied()).
     try {
       fs.mkdirSync(this.typingDir, { recursive: true });
-      fs.writeFileSync(path.join(this.typingDir, `${chat_id}.replied`), sendText);
+      let turnId: string | null = null;
+      try {
+        turnId = fs.readFileSync(path.join(this.typingDir, chat_id), 'utf8').trim() || null;
+      } catch {}
+      fs.writeFileSync(path.join(this.typingDir, `${chat_id}.replied`), JSON.stringify({ text: sendText, turnId }));
     } catch {}
 
     const result = sentIds.length === 1

package/mcp/tools/telegram/receiver-server.ts

@@ -783,10 +783,17 @@ mcp.setRequestHandler(CallToolRequestSchema, async req => {
 
         // Typing persists until agent-runner sees result event + delay.
         // Removed signalReplyDone() — reply does not mean done, agent may continue working.
-        // Write .replied marker so auto-forward in typing.ts skips duplicate send.
+        // Write .replied marker so auto-forward in typing.ts skips duplicate send —
+        // tagged with the live typing-signal timestamp as this turn's id, so a
+        // marker left over from an earlier turn can never suppress a later
+        // turn's forward (see typing.ts's isEntryAlreadyReplied()).
         try {
           mkdirSync(TYPING_DIR, { recursive: true })
-          writeFileSync(join(TYPING_DIR, `${chat_id}.replied`), sendText)
+          let turnId: string | null = null
+          try {
+            turnId = readFileSync(join(TYPING_DIR, chat_id), 'utf8').trim() || null
+          } catch {}
+          writeFileSync(join(TYPING_DIR, `${chat_id}.replied`), JSON.stringify({ text: sendText, turnId }))
         } catch { /* non-fatal */ }
 
         const result =
@@ -871,10 +878,12 @@ const BOT_COMMANDS = [
   { command: 'help', description: 'What this bot can do' },
 ]
 
-// Available AI models for /models command. Fallback only — the picker normally
-// uses the live list from the gateway (get_models); this is shown if that call
-// fails. Keep in sync with DEFAULT_MODELS (src/agent/runner.ts) and
-// config.template.json gateway.models.
+// Available AI models for /models command. Last-resort fallback: the picker
+// normally uses get_models, which itself resolves the live catalog and only
+// then falls back to config.json's gateway.models (issue #409). This copy is
+// reached only when the gateway call itself fails, so it is two fallbacks deep
+// and will drift — keep it roughly in step with DEFAULT_MODELS
+// (src/agent/runner.ts) and config.template.json gateway.models.
 const AVAILABLE_MODELS = [
   { id: 'claude-fable-5[1m]',        label: 'Fable 5 (1M)',     alias: 'fable[1m]' },
   { id: 'claude-opus-5[1m]',         label: 'Opus 5 (1M)',      alias: 'opus[1m]' },

package/mcp/tools/telegram/typing.ts

@@ -173,6 +173,47 @@ export const STATUS_EMOJI: Record<string, string> = {
   error:    '😱',
 }
 
+/**
+ * Telegram reports failures as `description` on a GrammyError; anything else
+ * thrown here (a network error, a plain Error in tests) carries `message`.
+ *
+ * Read structurally rather than with `err instanceof GrammyError &&
+ * err.error_code`, the convention in receiver-server.ts, for two reasons: this
+ * module deliberately has no grammy import — it takes an injected BotApi so
+ * tests can drive it — and the two cases below are both HTTP 400, so the code
+ * alone cannot tell them apart. The description is the only thing that can.
+ */
+function errorText(err: unknown): string {
+  if (typeof err === 'object' && err !== null) {
+    const e = err as { description?: unknown; message?: unknown }
+    if (typeof e.description === 'string') return e.description
+    if (typeof e.message === 'string') return e.message
+  }
+  return String(err)
+}
+
+/**
+ * Telegram rejects an edit whose new text is byte-identical to what the
+ * message already shows. That is not a failure to recover from — the message
+ * is intact and already correct — so the status loop must keep editing it
+ * rather than concluding it is gone and posting a replacement.
+ */
+export function isNotModifiedError(err: unknown): boolean {
+  return /message is not modified/i.test(errorText(err))
+}
+
+/**
+ * The message can never be edited again: deleted, or past Telegram's edit
+ * window. Only these justify dropping the id and sending a fresh message.
+ * A transient failure (network, 429) deliberately does NOT — the message is
+ * still there, and re-sending would leave a duplicate behind.
+ */
+export function isMessageGoneError(err: unknown): boolean {
+  return /message to (?:edit|be edited) not found|message can'?t be edited|message not found/i.test(
+    errorText(err),
+  )
+}
+
 export function parseStatusFile(content: string): { status: string; detail?: string } {
   try {
     const parsed = JSON.parse(content);
@@ -193,6 +234,10 @@ export interface WorkingState {
   currentReaction: string | null
   lastDetail: string | null
   recentDetails: string[]
+  /** Text the status message currently displays. An edit that would rewrite a
+   *  message with the exact text it already has is rejected by Telegram, so it
+   *  is never issued. */
+  lastStatusText: string | null
   /** Last stage an incident was raised for — dedupes the turn-trace watchdog
    *  so one contiguous stalled episode emits a single incident, not one per
    *  15s tick. Reset to null once the turn is no longer stalled. */
@@ -216,6 +261,78 @@ export interface FsApi {
   statSync(path: string): { mtimeMs: number }
 }
 
+/**
+ * A single queued auto-forward. `turnId` identifies the turn that produced it
+ * (the live typing-signal timestamp read at write time) — `null` when no
+ * signal file existed yet (e.g. an orphan forward from an autonomous wake
+ * with no inbound message). Writers: `AgentRunner.writeAutoForward()`.
+ */
+export interface ForwardEntry {
+  text: string
+  format: 'text' | 'html'
+  turnId: string | null
+}
+
+function normalizeForwardEntry(raw: unknown): ForwardEntry | null {
+  if (raw && typeof raw === 'object' && typeof (raw as { text?: unknown }).text === 'string') {
+    const o = raw as { text: string; format?: unknown; turnId?: unknown }
+    return {
+      text: o.text,
+      format: o.format === 'html' ? 'html' : 'text',
+      turnId: typeof o.turnId === 'string' ? o.turnId : null,
+    }
+  }
+  return null
+}
+
+/**
+ * Parse `.forward` file content into an ordered queue of entries. Accepts the
+ * current queue format (a JSON array), the pre-queue single-object format,
+ * and the original plain-text format — so an in-flight file survives a
+ * rolling deploy in either direction instead of losing its content.
+ */
+export function parseForwardQueue(raw: string): ForwardEntry[] {
+  const trimmed = raw.trim()
+  if (!trimmed) return []
+  try {
+    const parsed = JSON.parse(trimmed)
+    if (Array.isArray(parsed)) {
+      return parsed.map(normalizeForwardEntry).filter((e): e is ForwardEntry => e !== null)
+    }
+    const single = normalizeForwardEntry(parsed)
+    return single ? [single] : []
+  } catch {
+    return [{ text: trimmed, format: 'text', turnId: null }]
+  }
+}
+
+/**
+ * Parse `.replied` marker content. Current format is `{ text, turnId }`; a
+ * legacy marker (plain text, or JSON without a `turnId`) parses to
+ * `turnId: null`, which — per `resolveForwardDelivery` below — never
+ * satisfies dedup, so a marker from a version predating this format degrades
+ * to "deliver" rather than risking a silent drop.
+ */
+function parseRepliedTurnId(raw: string): string | null {
+  try {
+    const parsed = JSON.parse(raw.trim()) as { turnId?: unknown }
+    if (parsed && typeof parsed === 'object' && typeof parsed.turnId === 'string') {
+      return parsed.turnId
+    }
+  } catch {}
+  return null
+}
+
+/**
+ * Turn-scoped dedup: an entry is already covered by the reply tool only when
+ * both sides captured the SAME live turn id at write time. A `null` turnId on
+ * either side never matches — favors an extra/duplicate delivery over a
+ * silently dropped one.
+ */
+function isEntryAlreadyReplied(entry: ForwardEntry, repliedTurnId: string | null): boolean {
+  return repliedTurnId !== null && entry.turnId !== null && entry.turnId === repliedTurnId
+}
+
 /**
  * Deliver auto-forwarded turn text to a chat, never silently dropping content.
  * Each chunk that fails as HTML (e.g. Telegram rejects an entity the balancer
@@ -292,22 +409,18 @@ export function drainOrphanForwards(
     // Remove BEFORE sending so a slow/failing send can't double-deliver.
     fsApi.rmSync(forwardPath, { force: true })
     // Mirror stop()'s dedup: a lingering .replied with no typing state means
-    // the agent already sent this turn's text via the reply tool.
+    // the agent already sent SOME turn's text via the reply tool — but only
+    // entries whose turnId matches that marker's turn are actually covered.
     const repliedPath = `${typingDir}/${chatId}.replied`
+    let repliedTurnId: string | null = null
     if (fsApi.existsSync(repliedPath)) {
+      try { repliedTurnId = parseRepliedTurnId(fsApi.readFileSync(repliedPath, 'utf8')) } catch {}
       fsApi.rmSync(repliedPath, { force: true })
-      continue
     }
-    let text = raw
-    let parseMode: 'HTML' | undefined
-    try {
-      const parsed = JSON.parse(raw) as { text: string; format: string }
-      text = parsed.text
-      parseMode = parsed.format === 'html' ? 'HTML' : undefined
-    } catch {
-      // Old format: plain text
+    for (const entry of parseForwardQueue(raw)) {
+      if (!entry.text || isEntryAlreadyReplied(entry, repliedTurnId)) continue
+      void deliverForwardText(botApi, chatId, entry.text, entry.format === 'html' ? 'HTML' : undefined)
     }
-    if (text) void deliverForwardText(botApi, chatId, text, parseMode)
   }
 }
 
@@ -472,30 +585,29 @@ export function createWorkingStateManager(
         }
       } catch {}
     }
-    // Auto-forward result text to Telegram if the agent did not already reply with the same text.
+    // Auto-forward queued turn text to Telegram, skipping only the entries the
+    // reply tool already sent (same turnId as the .replied marker) — turn A's
+    // leftover marker must never suppress turn B's forward. See
+    // isEntryAlreadyReplied() / the module docstring for the race this guards.
     const forwardPath = forwardFilePath(chatId)
     const repliedPath = repliedFilePath(chatId)
     if (fsApi.existsSync(forwardPath)) {
+      let entries: ForwardEntry[] = []
       try {
-        const raw = fsApi.readFileSync(forwardPath, 'utf8').trim()
-        let forwardText: string
-        let parseMode: 'HTML' | undefined
-        try {
-          const parsed = JSON.parse(raw) as { text: string; format: string }
-          forwardText = parsed.text
-          parseMode = parsed.format === 'html' ? 'HTML' : undefined
-        } catch {
-          // Fallback: treat as plain text (old format compatibility)
-          forwardText = raw
-          parseMode = undefined
-        }
-        // Skip if the reply tool already sent a message (agent already replied)
-        const alreadyReplied = fsApi.existsSync(repliedPath)
-        if (!alreadyReplied && forwardText) {
-          await deliverForwardText(botApi, chatId, forwardText, parseMode)
-        }
+        entries = parseForwardQueue(fsApi.readFileSync(forwardPath, 'utf8'))
       } catch {}
+      // Remove BEFORE delivering (mirrors drainOrphanForwards' same comment):
+      // delivery can take a while (multiple chunks, retries), and a
+      // writeAutoForward() append landing mid-delivery must start a fresh
+      // file rather than have this call's cleanup silently discard it.
       fsApi.rmSync(forwardPath, { force: true })
+      const repliedTurnId = fsApi.existsSync(repliedPath)
+        ? parseRepliedTurnId(fsApi.readFileSync(repliedPath, 'utf8'))
+        : null
+      for (const entry of entries) {
+        if (!entry.text || isEntryAlreadyReplied(entry, repliedTurnId)) continue
+        await deliverForwardText(botApi, chatId, entry.text, entry.format === 'html' ? 'HTML' : undefined)
+      }
     }
     // NOTE: interactive-menu (.menu) delivery is handled by an independent poller
     // in receiver-server.ts (drainMenuFiles), NOT here. A menu can be emitted
@@ -551,6 +663,7 @@ export function createWorkingStateManager(
       currentReaction: null,
       lastDetail: null,
       recentDetails: [],
+      lastStatusText: null,
       lastIncidentStage: null,
     }
     states.set(chatId, state)
@@ -583,13 +696,44 @@ export function createWorkingStateManager(
         if (s.statusMessageId === null) {
           try {
             const sent = await botApi.sendMessage(chatId, text)
-            s.statusMessageId = sent.message_id
+            // Re-read rather than writing through the captured `s`: the turn
+            // can end while the send is in flight, and the state this records
+            // against must be the live one or none at all.
+            const current = states.get(chatId)
+            if (current) {
+              current.statusMessageId = sent.message_id
+              current.lastStatusText = text
+            }
           } catch {}
-        } else {
-          await botApi.editMessageText(chatId, s.statusMessageId, text).catch(async () => {
+        } else if (text !== s.lastStatusText) {
+          // Nothing to say, so nothing is sent. The cost is that a status
+          // message deleted by hand is not noticed until the next edit — but
+          // the elapsed line advances every minute even at `Xh Ym`, so that
+          // wait is bounded, and it buys immunity from the duplicate loop.
+          try {
+            await botApi.editMessageText(chatId, s.statusMessageId, text)
+            s.lastStatusText = text
+          } catch (err) {
             const current = states.get(chatId)
-            if (current) current.statusMessageId = null
-          })
+            if (!current) {
+              // The turn ended while the edit was in flight.
+            } else if (isNotModifiedError(err)) {
+              // The message already shows this text — nothing to recover from.
+              current.lastStatusText = text
+            } else if (isMessageGoneError(err)) {
+              current.statusMessageId = null
+              current.lastStatusText = null
+            } else {
+              // Keep the id — the message is still there, and the next tick
+              // edits it again; re-sending would leave a duplicate behind.
+              // Logged because a silently swallowed edit failure is exactly
+              // what let the duplicate loop run unnoticed: if Telegram ever
+              // returns something this does not classify, it should be
+              // visible in the receiver log rather than inferred from
+              // symptoms.
+              console.error(`[typing] status edit failed (retrying next tick): ${errorText(err)}`)
+            }
+          }
         }
       } finally {
         statusUpdatePending = false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xmaxma/claude-gateway",
-  "version": "1.7.9",
+  "version": "1.8.0",
   "description": "Multi-agent gateway for Claude",
   "repository": {
     "type": "git",
@@ -8,7 +8,7 @@
   },
   "main": "dist/index.js",
   "bin": {
-    "claude-gateway": "./dist/index.js"
+    "claude-gateway": "./dist/entry.js"
   },
   "engines": {
     "node": ">=22"
@@ -28,7 +28,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "start": "node --no-warnings=ExperimentalWarning --env-file-if-exists=.env dist/index.js",
+    "start": "node --no-warnings=ExperimentalWarning --env-file-if-exists=.env dist/entry.js gateway start",
     "postinstall": "if command -v bun >/dev/null 2>&1; then bun install --cwd mcp; else echo 'Warning: bun not found. Run `cd mcp && bun install` manually to enable MCP tools.'; fi",
     "pretest": "npm run build",
     "test": "NODE_OPTIONS=--max-old-space-size=2560 jest",
@@ -40,7 +40,9 @@
     "test:manual": "jest --testPathPattern=phase-manual --testTimeout=15000",
     "integration:hb": "jest --testPathPattern=heartbeat-e2e --testTimeout=15000",
     "integration:cs": "jest --testPathPattern=character-system --testTimeout=15000",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "gen-cli": "ts-node scripts/gen-cli.ts",
+    "gen-cli:check": "ts-node scripts/gen-cli.ts --check"
   },
   "dependencies": {
     "@line/bot-sdk": "^11.0.2",