polygram 0.8.0-rc.20 → 0.8.0-rc.22

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.20",
+  "version": "0.8.0-rc.22",
   "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/history-preload.js

@@ -0,0 +1,160 @@
+/**
+ * SessionStart hook factory: preloads recent chat history into a
+ * fresh SDK Query so the agent has context on day-zero.
+ *
+ * Why: when polygram spawns a brand-new Query for a chat (daemon
+ * boot, /new, /reset), the SDK has no transcript — the model
+ * starts blank even though the chat has been running for weeks.
+ * The user has to re-explain context every time. This hook injects
+ * the last N polygram-stored messages into the new session's
+ * `additionalContext`, plus a hint that the agent can query the
+ * history skill for older messages it didn't get preloaded.
+ *
+ * Fires only when SessionStart's `source` is 'startup' or 'clear'
+ * (genuinely fresh sessions). Skips on 'resume' (SDK is restoring
+ * the prior transcript) and 'compact' (SDK just compacted; history
+ * is already in the post-compact summary).
+ *
+ * Reuses lib/history.js's `recent()` helper — same DB query the
+ * polygram history skill exposes via CLI, so the agent's skill
+ * invocations and our preload return consistent shapes.
+ */
+
+'use strict';
+
+const history = require('./history');
+
+const DEFAULT_PRELOAD_LIMIT = 15;
+const DEFAULT_PRELOAD_SINCE = '7d';
+
+/**
+ * Format a single message row as a transcript line.
+ *
+ *   [2026-04-30 09:15] Ivan Shumkov: hello
+ *   [2026-04-30 09:16] bot: hey
+ *
+ * Schema notes: messages table uses `direction` = 'in'|'out',
+ * `user` for the sender display name (inbound) or bot identity
+ * (outbound). reply_to_id is on the row directly. Attachment and
+ * voice flags live on the attachments table via JOIN — not
+ * surfaced here in the preload (operator-curated history docs are
+ * the place for that level of detail).
+ */
+function formatRow(row) {
+  const ts = new Date(row.ts).toISOString().replace('T', ' ').slice(0, 16);
+  const who = row.direction === 'in'
+    ? (row.user || row.user_id || 'user')
+    : (row.user || row.bot_name || 'bot');
+  const prefix = row.reply_to_id ? `[reply→#${row.reply_to_id}] ` : '';
+  const text = (row.text || '').replace(/\s+/g, ' ').slice(0, 600);
+  return `[${ts}] ${who}: ${prefix}${text}`;
+}
+
+/**
+ * Build the SessionStart hook callback.
+ *
+ * @param {object} opts
+ * @param {object} opts.db                     polygram db wrapper (has .raw better-sqlite3 instance)
+ * @param {string} opts.chatId                 the chat being spawned
+ * @param {string|null} [opts.threadId]
+ * @param {string[]} [opts.allowedChatIds]     scope-narrowing safety; defaults to [chatId]
+ * @param {number} [opts.limit]                max messages to preload (default 15)
+ * @param {string} [opts.since]                cutoff window (default '7d')
+ * @param {(kind: string, detail: object) => void} [opts.logEvent]
+ * @param {object} [opts.logger]
+ *
+ * @returns {async (input) => Promise<HookJSONOutput>}
+ */
+function makeSessionStartHook({
+  db,
+  chatId,
+  threadId = null,
+  allowedChatIds = null,
+  limit = DEFAULT_PRELOAD_LIMIT,
+  since = DEFAULT_PRELOAD_SINCE,
+  logEvent = null,
+  logger = console,
+} = {}) {
+  if (!db || !db.raw) throw new TypeError('db (with .raw better-sqlite3) required');
+  if (!chatId) throw new TypeError('chatId required');
+
+  return async (input) => {
+    try {
+      // Skip on resume / compact — transcript already has history.
+      if (input?.source === 'resume' || input?.source === 'compact') {
+        return { continue: true };
+      }
+
+      const scope = allowedChatIds || [String(chatId)];
+      let rows;
+      try {
+        // history.recent() expects the polygram db wrapper (it
+        // calls db.raw.prepare internally), not the raw bsqlite3.
+        rows = history.recent(db, {
+          chatId: String(chatId),
+          threadId: threadId ?? null,
+          limit,
+          since,
+          includeOutbound: true,
+          allowedChatIds: scope,
+        }) || [];
+      } catch (err) {
+        logger?.error?.(`[history-preload] recent() failed: ${err?.message || err}`);
+        return { continue: true };
+      }
+
+      if (rows.length === 0) {
+        return { continue: true };
+      }
+
+      // history.recent() returns rows in chronological order
+      // already (it does `ORDER BY ts DESC LIMIT N` then `.reverse()`
+      // internally — see lib/history.js:69).
+      const lines = rows.map(formatRow).join('\n');
+
+      const additionalContext = [
+        `<polygram-history chat_id="${chatId}"${threadId ? ` thread_id="${threadId}"` : ''} preloaded="${rows.length}" since="${since}">`,
+        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');
+
+      if (typeof logEvent === 'function') {
+        try {
+          logEvent('history-preloaded', {
+            chat_id: chatId,
+            session_source: input?.source ?? 'startup',
+            row_count: rows.length,
+            text_len: additionalContext.length,
+          });
+        } catch { /* swallow logger errors */ }
+      }
+
+      return {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: 'SessionStart',
+          additionalContext,
+        },
+      };
+    } catch (err) {
+      logger?.error?.(`[history-preload] hook error: ${err?.message || err}`);
+      // Never throw out of a hook.
+      return { continue: true };
+    }
+  };
+}
+
+module.exports = {
+  makeSessionStartHook,
+  // Internals for tests
+  _formatRow: formatRow,
+  DEFAULT_PRELOAD_LIMIT,
+  DEFAULT_PRELOAD_SINCE,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.8.0-rc.20",
+  "version": "0.8.0-rc.22",
   "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

@@ -40,6 +40,7 @@ const {
   formatToolInputForCard,
   approvalCardText,
 } = require('./lib/approval-ui');
+const { makeSessionStartHook } = require('./lib/history-preload');
 const agentLoader = require('./lib/agent-loader');
 const USE_SDK = process.env.POLYGRAM_USE_SDK === '1';
 const { createSender } = require('./lib/telegram');
@@ -929,6 +930,21 @@ function buildSdkOptions(sessionKey, ctx) {
     logger: console,
   });
 
+  // 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;
+
   const baseOpts = {
     model: chatConfig.model || config.defaults.model,
     effort: chatConfig.effort || config.defaults.effort,
@@ -942,6 +958,9 @@ function buildSdkOptions(sessionKey, ctx) {
     ...(useCanUseTool && { canUseTool: makeCanUseTool(sessionKey) }),
     hooks: {
       PostToolBatch: [{ hooks: [postToolBatchHook] }],
+      ...(sessionStartHook && {
+        SessionStart: [{ hooks: [sessionStartHook] }],
+      }),
     },
     executable: 'node',
     ...(existingSessionId && { resume: existingSessionId }),
@@ -1968,6 +1987,51 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     }
     return;
   }
+  // 0.8.0-rc.22: /compact <preserve text> — manual SDK compaction with
+  // user-supplied preservation instructions. The SDK's CLI binary
+  // recognises "/compact" as a slash command via streamInput.push
+  // (verified by scripts/spikes/compact-via-streaminput.mjs: PreCompact
+  // hook fires with trigger:'manual', compact_boundary event lands).
+  // We push the raw text "/compact <instructions>" through the SDK's
+  // input controller; the SDK handles parsing + compaction internally.
+  if (botAllowsCommands && text.startsWith('/compact')) {
+    if (!pm.isSdkFor(sessionKey)) {
+      await sendReply('🗜️ /compact requires the SDK pm. This chat is on the CLI pm path.');
+      return;
+    }
+    if (!pm.has(sessionKey)) {
+      await sendReply('🗜️ No active session — /compact only works once a turn has started.');
+      return;
+    }
+    const entry = pm.get(sessionKey);
+    if (!entry?.inputController?.push) {
+      await sendReply('🗜️ Session not ready for /compact (no input controller).');
+      return;
+    }
+    // Push the literal "/compact ..." text into the input stream.
+    // The SDK parses leading "/" as a slash command and triggers
+    // manual compaction; user's preserve instructions land in
+    // PreCompactHookInput.custom_instructions.
+    try {
+      entry.inputController.push({
+        type: 'user',
+        message: { role: 'user', content: text },
+        parent_tool_use_id: null,
+      });
+      logEvent('compact-command', {
+        chat_id: chatId, text_len: text.length,
+        user: cmdUser, user_id: cmdUserId,
+      });
+      const preserveBit = text.length > '/compact'.length
+        ? ' with your preservation instructions'
+        : '';
+      await sendReply(`🗜️ Compacting${preserveBit}…`);
+    } catch (err) {
+      console.error(`[${label}] /compact push: ${err.message}`);
+      await sendReply(`🗜️ Couldn't trigger compact: ${err.message}`);
+    }
+    return;
+  }
   if (botAllowsCommands && (text === '/new' || text === '/reset')) {
     let drained = 0;
     const target = pm.pickFor(sessionKey);
@@ -2584,9 +2648,22 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
             // context (and fired below the intended 85% threshold).
             const pct = usage?.percentage ?? 0;
             if (pct < 85) return;
+            // rc.22: three-choice hint. The original "send /new"
+            // message implied the only path forward was a hard
+            // reset. Now offer all three options the user actually
+            // has — start fresh, compact with their preserve
+            // instructions, or keep going (auto-compact eventually
+            // fires).
+            const text = [
+              `📚 Context window ${pct.toFixed(0)}% full. Three options:`,
+              '',
+              '• `/new` — start fresh; this conversation ends.',
+              '• `/compact <preserve text>` — summarise older messages, keep what you specify.',
+              '• Keep chatting — I\'ll auto-compact when needed; key context is preserved automatically.',
+            ].join('\n');
             return tg(bot, 'sendMessage', {
               chat_id: chatId,
-              text: `📚 Context window ${pct.toFixed(0)}% full. Send /new to start fresh — older messages will start dropping soon.`,
+              text,
               ...(threadId ? { message_thread_id: threadId } : {}),
             }, { source: 'context-full-hint', botName: BOT_NAME });
           }).catch((err) => {
@@ -2849,7 +2926,7 @@ function createBot(token) {
   // Cached once @botUsername is known — was recompiling per inbound msg.
   let mentionRe = null;
   // Hoisted admin-command matcher; was re-allocated per message.
-  const ADMIN_CMD_RE = /^\/(model|effort|config|pair-code|pairings|unpair|new|reset|context)(\s|$)/;
+  const ADMIN_CMD_RE = /^\/(model|effort|config|pair-code|pairings|unpair|new|reset|context|compact)(\s|$)/;
   const PAIR_CLAIM_RE = /^\/pair\s+\S+/;
 
   // The filter in main() guarantees config.chats only contains chats owned