polygram 0.8.0-rc.50 → 0.8.0-rc.52

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.8.0-rc.50",
+  "version": "0.8.0-rc.52",
   "description": "Telegram integration for Claude Code that preserves the OpenClaw per-chat session model. Migration target for OpenClaw users. Multi-bot, multi-chat, per-topic isolation; SQLite transcripts; inline-keyboard approvals. Bundles /polygram:status|logs|pair-code|approvals admin commands and a history skill.",
   "keywords": [
     "telegram",

package/lib/db.js

@@ -498,6 +498,27 @@ function wrap(db) {
     // Treating ambiguous states as "replied" costs us occasional missed
     // replies (recoverable: user resends) to prevent duplicates
     // (irrecoverable: user has to mentally dedupe two answers).
+    // rc.51: stricter dedupe than hasOutboundReplyTo for boot-replay.
+    // A `turn_metrics` row is only inserted when a turn definitively
+    // completes (onResult callback). If no row exists for this inbound
+    // msg_id, the turn never finished — even if intermediate ack-bubbles
+    // were already sent. The rc.50 incident's lost msg 12158 had a
+    // partial "I'll write a quick inline script..." outbound but no
+    // turn_metrics, and was being silently skipped by replay-dedupe.
+    //
+    // Caveat: a row whose `error` is set (transient/aborted/timeout)
+    // does NOT count as complete — the turn started but failed. Boot
+    // replay should redispatch within window so the user gets a real
+    // answer.
+    hasCompletedTurnFor({ chat_id, msg_id }) {
+      const row = db.prepare(`
+        SELECT 1 FROM turn_metrics
+         WHERE chat_id = ? AND msg_id = ? AND error IS NULL
+         LIMIT 1
+      `).get(String(chat_id), msg_id);
+      return !!row;
+    },
+
     hasOutboundReplyTo({ chat_id, msg_id }) {
       const row = db.prepare(`
         SELECT 1 FROM messages

package/lib/history-preload.js

@@ -151,8 +151,68 @@ function makeSessionStartHook({
   };
 }
 
+/**
+ * rc.52: synchronous variant of the same preload, returning the
+ * `<polygram-history>` block as a string ready to prepend to the
+ * fresh-session user message. Replaces the SessionStart-hook path
+ * (the SDK's `Options.hooks.SessionStart` is a documented API that
+ * the runtime does not actually dispatch — verified by spike +
+ * SDK source grep, see rc.52 commit).
+ *
+ * Exclude the row corresponding to `excludeMsgId` from the preload
+ * — that's the user message we're about to send, no need to echo
+ * it back to itself in the history block.
+ *
+ * Returns '' (empty string) when there's nothing to inject — caller
+ * just skips the prepend.
+ */
+function buildHistoryBlock({
+  db,
+  chatId,
+  threadId = null,
+  excludeMsgId = null,
+  limit = DEFAULT_PRELOAD_LIMIT,
+  since = DEFAULT_PRELOAD_SINCE,
+  logger = console,
+} = {}) {
+  if (!db?.raw || !chatId) return '';
+  let rows;
+  try {
+    rows = history.recent(db, {
+      chatId: String(chatId),
+      threadId: threadId ?? null,
+      limit,
+      since,
+      includeOutbound: true,
+      allowedChatIds: [String(chatId)],
+    }) || [];
+  } catch (err) {
+    logger?.error?.(`[history-preload] recent() failed: ${err?.message || err}`);
+    return '';
+  }
+  if (excludeMsgId != null) {
+    rows = rows.filter((r) => String(r.msg_id) !== String(excludeMsgId));
+  }
+  if (rows.length === 0) return '';
+  const lines = rows.map(formatRow).join('\n');
+  const attrs = `chat_id="${chatId}"${threadId ? ` thread_id="${threadId}"` : ''} preloaded="${rows.length}" since="${since}"`;
+  return [
+    `<polygram-history ${attrs}>`,
+    lines,
+    `</polygram-history>`,
+    '',
+    '— More history available via `node skills/history/scripts/query.js`:',
+    '    recent <chat_id> [thread_id] --limit N  (older than the preload window)',
+    '    around --chat <id> --msg-id N           (context window around a message)',
+    '    search <term> [chat_id]                 (FTS5 across full transcript)',
+    '    by-user <name> [chat_id] [thread_id]',
+    '  Bot scope is auto-resolved from cwd; no admin flag needed.',
+  ].join('\n');
+}
+
 module.exports = {
   makeSessionStartHook,
+  buildHistoryBlock,
   // Internals for tests
   _formatRow: formatRow,
   DEFAULT_PRELOAD_LIMIT,

package/lib/prompt.js

@@ -164,7 +164,7 @@ function buildVoiceTags(attachments) {
  * @param {Array} params.attachments - downloaded attachments
  * @param {Object} params.replyTo - input for buildReplyToBlock (optional)
  */
-function buildPrompt({ msg, topicName = '', sessionCtx = '', attachments = [], replyTo = null }) {
+function buildPrompt({ msg, topicName = '', sessionCtx = '', attachments = [], replyTo = null, polygramHistory = '' }) {
   const chatId = msg.chat.id.toString();
   const msgId = msg.message_id.toString();
   const user = msg.from?.first_name || msg.from?.username || 'Unknown';
@@ -179,6 +179,15 @@ function buildPrompt({ msg, topicName = '', sessionCtx = '', attachments = [], r
   if (sessionCtx) {
     prompt += `<session-context>\n${sessionCtx}\n</session-context>\n\n`;
   }
+  // rc.52: fresh-session history preload. The caller (polygram.js)
+  // populates polygramHistory ONLY when this is the first message of a
+  // fresh Claude session (no --resume), built via
+  // history-preload.buildHistoryBlock. Empty string for resume-path
+  // turns. Replaces the SDK SessionStart hook which the SDK runtime
+  // doesn't actually dispatch (rc.52 finding).
+  if (polygramHistory) {
+    prompt += polygramHistory + '\n\n';
+  }
   prompt += `<polygram-info>${POLYGRAM_INFO}</polygram-info>\n\n`;
 
   const replyBlock = buildReplyToBlock(replyTo);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.8.0-rc.50",
+  "version": "0.8.0-rc.52",
   "description": "Telegram daemon for Claude Code that preserves the OpenClaw per-chat session model. Migration path for OpenClaw users moving to Claude Code.",
   "main": "lib/ipc-client.js",
   "bin": {

package/polygram.js

@@ -43,7 +43,7 @@ const {
   formatToolInputForCard,
   approvalCardText,
 } = require('./lib/approval-ui');
-const { makeSessionStartHook } = require('./lib/history-preload');
+const { buildHistoryBlock } = require('./lib/history-preload');
 const { formatContextReply, maybeContextFullHint } = require('./lib/context-format');
 const { appendDisplayHint, appendDisplayHintCliArgs } = require('./lib/telegram-prompt');
 const { createAbortGrace } = require('./lib/abort-grace');
@@ -698,17 +698,53 @@ function resolveReplyTo(msg) {
   return { replyToId };
 }
 
-function formatPrompt(msg, sessionCtx, attachments = []) {
+function formatPrompt(msg, sessionCtx, attachments = [], { sessionKey = null } = {}) {
   const chatId = msg.chat.id.toString();
   const threadId = msg.message_thread_id?.toString() || '';
   const chatConfig = config.chats[chatId];
   const topicName = threadId ? getTopicName(chatConfig, threadId) : '';
+
+  // rc.52: when the upcoming Query has no resume target (fresh
+  // session — daemon boot, /new, /reset, first-ever message in a
+  // chat/topic), prepend a `<polygram-history>` block so the fresh
+  // session has continuity instead of starting blank. Replaces the
+  // dead SessionStart hook (registered into `Options.hooks.SessionStart`
+  // since rc.21 but never fired — the SDK runtime doesn't dispatch
+  // user-defined hooks for that event, only CLI settings.json shell
+  // hooks).
+  let polygramHistory = '';
+  if (sessionKey && db) {
+    const existingSessionId = getClaudeSessionId(db, sessionKey);
+    if (!existingSessionId) {
+      try {
+        polygramHistory = buildHistoryBlock({
+          db,
+          chatId,
+          threadId: threadId || null,
+          excludeMsgId: msg.message_id,
+          logger: console,
+        });
+        if (polygramHistory) {
+          logEvent('history-preloaded', {
+            chat_id: chatId,
+            thread_id: threadId || null,
+            text_len: polygramHistory.length,
+            session_source: 'fresh',
+          });
+        }
+      } catch (err) {
+        console.error(`[history-preload] buildHistoryBlock failed: ${err?.message || err}`);
+      }
+    }
+  }
+
   return buildPrompt({
     msg,
     topicName,
     sessionCtx,
     attachments,
     replyTo: resolveReplyTo(msg),
+    polygramHistory,
   });
 }
 
@@ -903,21 +939,13 @@ function buildSdkOptions(sessionKey, ctx) {
   // turn-end path (handleMessage finally + success branches —
   // existing rc.38 cleanup).
 
-  // 0.8.0-rc.21: SessionStart hook preloads recent polygram-DB
-  // history into a fresh Query (no resume). Without this, every
-  // /new or daemon-boot starts the agent blank — even though the
-  // chat has been running for weeks. Skips when source is
-  // 'resume' or 'compact' (transcript already populated).
-  const sessionStartHook = ctx?.chatId
-    ? makeSessionStartHook({
-        db,
-        chatId: ctx.chatId,
-        threadId: ctx.threadId ?? null,
-        logEvent,
-        logger: console,
-      })
-    : null;
-
+  // rc.52: dropped the SDK SessionStart hook registration. The hook
+  // never fired in production (verified: zero history-preloaded events
+  // across both production DBs since rc.21; SDK runtime grep showed
+  // exactly one occurrence of "SessionStart" — in the type listing,
+  // not in dispatch logic). The history preload is now done inline at
+  // formatPrompt time when the upcoming Query has no resume target,
+  // via lib/history-preload.buildHistoryBlock. See formatPrompt above.
   const baseOpts = {
     model: chatConfig.model || config.defaults.model,
     effort: chatConfig.effort || config.defaults.effort,
@@ -929,11 +957,7 @@ function buildSdkOptions(sessionKey, ctx) {
     permissionMode: useCanUseTool ? 'default' : 'bypassPermissions',
     allowDangerouslySkipPermissions: !useCanUseTool,
     ...(useCanUseTool && { canUseTool: makeCanUseTool(sessionKey) }),
-    hooks: {
-      ...(sessionStartHook && {
-        SessionStart: [{ hooks: [sessionStartHook] }],
-      }),
-    },
+    hooks: {},
     executable: 'node',
     ...(existingSessionId && { resume: existingSessionId }),
     ...(process.env.POLYGRAM_CLAUDE_BIN && {
@@ -2278,7 +2302,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     chatId, msgId: msg.message_id, label, botApi: bot, threadId,
   }) || { ackEmitted: false };
 
-  const prompt = formatPrompt(msg, sessionCtx, downloaded);
+  const prompt = formatPrompt(msg, sessionCtx, downloaded, { sessionKey });
   const stopTyping = startTyping({
     bot, chatId, threadId,
     logger: { error: (m) => console.error(`[${label}] ${m}`) },
@@ -3977,8 +4001,19 @@ async function main() {
       let replayed = 0;
       let skipped = 0;
       for (const row of candidates) {
-        if (db.hasOutboundReplyTo({ chat_id: row.chat_id, msg_id: row.msg_id })) {
-          // Already replied — just mark so we don't look at it again.
+        // rc.51: dedupe on turn_metrics (definitive turn completion),
+        // NOT just on hasOutboundReplyTo. The latter trips on
+        // intermediate ack-bubbles (e.g. "Catching up on history…",
+        // "I'll write a quick inline script…") and silently skips the
+        // replay even when the actual answer never arrived. The rc.50
+        // EIO-orphan incident lost Ivan DM msg 12158 this way: an ack
+        // bubble was sent at 13:20:36, the turn was killed mid-flight,
+        // boot-replay saw the ack and assumed "answered."
+        //
+        // turn_metrics is only inserted by the SDK pm's onResult
+        // callback, which fires only when the turn definitively
+        // completes. No row → no completion → re-dispatch.
+        if (db.hasCompletedTurnFor({ chat_id: row.chat_id, msg_id: row.msg_id })) {
           db.setInboundHandlerStatus({
             chat_id: row.chat_id, msg_id: row.msg_id, status: 'replied',
           });