polygram 0.38.2 → 0.38.4

package/lib/handlers/slash-commands.js

@@ -55,14 +55,21 @@ function createSlashCommands({
   saveConfig = () => {},
   botName,
   logEvent,
+  // Narrow async hook: retire the question state of a session whose process
+  // this command is retiring. A callback, so this module never learns the
+  // question store.
+  retireQuestionSession = null,
   logger = console,
 } = {}) {
 
   return async function dispatchSlashCommand(ctx) {
     const {
-      text, sessionKey, chatId, threadIdStr, chatConfig,
+      text, msgId, sessionKey, chatId, threadIdStr, chatConfig,
       cmdUser, cmdUserId, label, sendReply,
     } = ctx;
+    // Commands are logged by their recognized verb, never by the typed line:
+    // the arguments are message content and telemetry stays content-free.
+    const commandVerb = () => String(text || '').trim().split(/\s+/)[0] || null;
     const botAllowsCommands = !!config.bot?.allowConfigCommands;
 
     // /context — route through pm.getContextUsage(sessionKey) so the
@@ -184,10 +191,11 @@ function createSlashCommands({
         logEvent('compact-command', {
           chat_id: chatId, thread_id: threadIdStr, session_key: sessionKey,
           text_len: text.length,
-          // rc.65: store full text so boot-time orphan recovery can
-          // silently re-push after a deploy interrupted compaction.
-          text,
-          user: cmdUser, user_id: cmdUserId,
+          // The id of the inbound message carrying the hint. Boot-time orphan
+          // recovery joins it back to the stored row to re-push silently; the
+          // hint itself is message content and never enters telemetry.
+          msg_id: msgId ?? null,
+          user_id: cmdUserId,
         });
         const hasHint = text.length > '/compact'.length + 1;
         await sendReply(hasHint ? '🗜️ Compacting with your hint…' : '🗜️ Compacting…');
@@ -236,10 +244,18 @@ function createSlashCommands({
           );
           return true;
         }
+        // The process that owned any open question is gone; retire its state.
+        // Ordered after the kill so a refused reload leaves the still-live
+        // interaction intact.
+        await retireQuestionSession?.(sessionKey);
+      } else {
+        // No process to retire, but an open question has nothing to deliver to
+        // either.
+        await retireQuestionSession?.(sessionKey);
       }
       logEvent('session-reload-command', {
-        chat_id: chatId, command: text,
-        user: cmdUser, user_id: cmdUserId,
+        chat_id: chatId, command: commandVerb(),
+        user_id: cmdUserId,
       });
       await sendReply(
         codex
@@ -273,6 +289,10 @@ function createSlashCommands({
       const codex = isCodexRuntimeView(runtimeView);
       let drained = 0;
       try {
+        // A fresh session retires the process that owns any open question.
+        // Deliberately before the reset: if the reset then fails, the safe
+        // outcome is still that nothing exact was kept.
+        await retireQuestionSession?.(sessionKey);
         const r = await pm.resetSession(sessionKey, { reason: text.slice(1) });
         drained = r?.drainedPendings ?? 0;
       } catch (err) {
@@ -286,8 +306,8 @@ function createSlashCommands({
       }
       contextHintShown.delete(sessionKey);
       logEvent('session-reset-command', {
-        chat_id: chatId, command: text, drained_pendings: drained,
-        user: cmdUser, user_id: cmdUserId,
+        chat_id: chatId, command: commandVerb(), drained_pendings: drained,
+        user_id: cmdUserId,
       });
       await sendReply(
         codex
@@ -431,7 +451,7 @@ function createSlashCommands({
               const auditRows = [{
                   chat_id: chatId, thread_id: wThread, field: 'model',
                   old_value: oldModel, new_value: newModel,
-                  user: cmdUser, user_id: cmdUserId, source: 'command',
+                  user_id: cmdUserId, source: 'command',
                 }];
               if (effortAdjustment) {
                 auditRows.push({
@@ -594,7 +614,7 @@ function createSlashCommands({
               const auditRow = {
                 chat_id: chatId, thread_id: wThread, field: 'effort',
                 old_value: oldEffort, new_value: newEffort,
-                user: cmdUser, user_id: cmdUserId, source: 'command',
+                user_id: cmdUserId, source: 'command',
               };
               if (codex) {
                 try {
@@ -689,7 +709,9 @@ function createSlashCommands({
         });
         logEvent('pair-code-issued', {
           bot: botName, by: issuerId, scope: out.scope,
-          chat_id: out.chat_id, note: out.note,
+          chat_id: out.chat_id,
+          // The note is operator-typed text; record only that one was given.
+          noticed: Boolean(out.note),
         });
         const ttlLabel = args.ttl || '10m';
         const chatLabel = out.chat_id ? `chat ${out.chat_id}` : 'the chat where it is redeemed';
@@ -765,4 +787,23 @@ function createSlashCommands({
   };
 }
 
-module.exports = { createSlashCommands };
+/**
+ * Normalize a stored line into the exact `/compact [hint]` form, or return
+ * null when it is not a compact command at all.
+ *
+ * Boot-time recovery re-pushes a stored line into a live session, so the line
+ * has to be proven to BE a compact command first: an arbitrary message, or a
+ * different command, must never be fired at the agent as if the user had
+ * asked to compact. Telegram also delivers group commands with the bot's
+ * username attached (`/compact@bot hint`), which the agent's own parser does
+ * not accept — that suffix is stripped here.
+ */
+function normalizeCompactCommand(text) {
+  if (typeof text !== 'string') return null;
+  const match = /^\/compact(?:@[A-Za-z0-9_]+)?(?:\s+([\s\S]*))?$/.exec(text.trim());
+  if (!match) return null;
+  const hint = (match[1] || '').trim();
+  return hint ? `/compact ${hint}` : '/compact';
+}
+
+module.exports = { createSlashCommands, normalizeCompactCommand };

package/lib/handlers/voice.js

@@ -75,7 +75,7 @@ function createTranscribeVoiceAttachments({
       } catch (err) {
         logger.error?.(`[${label}] transcribe failed for ${a.name}: ${err.message}`);
         logEvent('voice-transcribe-failed', {
-          chat_id: chatId, msg_id: msgId, name: a.name, error: err.message,
+          chat_id: chatId, msg_id: msgId, error_class: err.name || 'Error',
         });
       }
     }));

package/lib/ops/clean-shutdown.js

@@ -6,6 +6,7 @@ async function prepareCleanRetirement({
   awaitIngressSettlement,
   awaitHandlerSettlement,
   settlementTimeoutMs = 30_000,
+  continuationAuthorized = false,
   qualificationExpectation,
 } = {}) {
   if (typeof deliveryBarrier?.fenceAndDrain !== 'function'
@@ -21,9 +22,13 @@ async function prepareCleanRetirement({
   if (typeof awaitHandlerSettlement !== 'function') {
     throw new TypeError('clean shutdown requires handler settlement');
   }
+  if (typeof continuationAuthorized !== 'boolean') {
+    throw new TypeError('clean shutdown continuation authorization must be boolean');
+  }
 
   const deliveryDrain = captureSettlement(() => deliveryBarrier.fenceAndDrain());
   const processRetirement = captureSettlement(() => pm.retireForCleanRestart({
+    continuationAuthorized,
     getDeliveryEvidence: (sessionKey, sourceMsgId) => (
       deliveryBarrier.inspect(sessionKey, sourceMsgId)
     ),

package/lib/questions/questions.js

@@ -16,6 +16,8 @@
 
 'use strict';
 
+const { sanitizeForDurableWrite } = require('../secret-detect');
+
 const MAX_LABEL = 40;       // Telegram button labels truncate ~64; keep well under
 const MAX_OTHER = 1000;     // cap on the user's free-text answer entering claude's context
 const MAX_PREVIEW = 500;
@@ -168,6 +170,51 @@ function applyFreeText(state, text) {
   return { state: next, kind: 'advanced', receipt: other, done: isDone(next) };
 }
 
+/**
+ * Whether a recorded answer carries a credential the durable boundary would
+ * mask. It lives beside the answer shape so a new field cannot be added
+ * without this seeing it. Every text-bearing part counts: the header copied
+ * from the agent's question, the selected option labels, and a typed value.
+ * The durable-write sanitizer decides, so its allowlist applies — "password:
+ * required" is ordinary vocabulary, not a secret.
+ */
+function answerIsFlagged(answer) {
+  const parts = [
+    ...(answer?.header != null ? [answer.header] : []),
+    ...(answer?.selected || []),
+    ...(answer?.other != null ? [answer.other] : []),
+  ];
+  return parts.some((part) => sanitizeForDurableWrite(String(part)).changed);
+}
+
+/**
+ * The durable stand-in for an answer whose text is being held live. It carries
+ * no answer text at all — a placeholder string would be indistinguishable from
+ * something the user actually chose, and could be delivered as one. The header
+ * is sanitized because it is copied from the agent's question.
+ */
+function markOmitted(answer) {
+  return {
+    header: sanitizeForDurableWrite(String(answer?.header ?? '')).text,
+    selected: [],
+    secret_omitted: true,
+  };
+}
+
+const isOmitted = (answer) => !!(answer && answer.secret_omitted);
+
+/**
+ * Resolve the answers for delivery. Returns a discriminated result rather than
+ * throwing or substituting: a marker means the exact answer was held live and
+ * the holder is gone, and the caller must cancel instead of sending anything
+ * upstream. No value or marker is ever put in an error.
+ */
+function resolveForDelivery(state) {
+  const answers = Array.isArray(state?.answers) ? state.answers : [];
+  if (answers.some(isOmitted)) return { ok: false, reason: 'live-answer-missing' };
+  return { ok: true, result: { answers } };
+}
+
 /** Final tool result once the set is done. */
 function assemble(state) {
   return { answers: state.answers };
@@ -182,6 +229,10 @@ module.exports = {
   applyTap,
   applyFreeText,
   assemble,
+  answerIsFlagged,
+  markOmitted,
+  isOmitted,
+  resolveForDelivery,
   MAX_LABEL,
   MAX_OTHER,
 };

package/lib/questions/store.js

@@ -10,6 +10,39 @@
 'use strict';
 
 const { newToken, tokensEqual } = require('../approvals/store');
+const { sanitizeDurableStructured, sanitizeDurableJsonText } = require('../secret-detect');
+
+// Two copies of the agent's questions, both durable:
+//
+//   questions_json — the audit copy of what the agent asked.
+//   state_json     — the state machine, which re-reads its own `questions`
+//                    copy on every tap to render the card and to match the
+//                    option the user picked.
+//
+// Both are sanitized. The exact array lives only in the handler's live
+// question context, for as long as the owning process does, and is hydrated
+// back for each live interaction. A typed answer carrying a credential is held
+// the same way: the row keeps a marker with no text, and a marked row that
+// outlives its process is cancelled rather than replayed. Terminal masking of
+// the whole retained state stays as the last line of defense for text no
+// detector flagged.
+
+// Both columns hold JSON, so they are sanitized as structure before
+// serialization — masking a serialized document can splice across its
+// delimiters, and an escaped quote hides a declared value from the detector.
+const maskDurableJson = (value) => JSON.stringify(sanitizeDurableStructured(value));
+const maskDurableJsonText = (json) => sanitizeDurableJsonText(json).text;
+
+// `state.questions` is a second copy of the array `questions_json` holds, and
+// the state machine reads it on every tap. Sanitizing only the column would
+// leave the provider's exact question in the row, so the state's copy is
+// sanitized on every write; the handler hydrates the exact array back for the
+// live interaction.
+const withSanitizedQuestions = (state) => {
+  const value = state && typeof state === 'object' ? state : {};
+  if (!Array.isArray(value.questions)) return value;
+  return { ...value, questions: sanitizeDurableStructured(value.questions) };
+};
 
 // A question waits for the user — the turn no longer times out while an `ask` is open
 // (cli-process defers its ceilings during a question wait, docs/progress-is-not-turn-end-spec.md),
@@ -42,8 +75,19 @@ function createQuestionStore(rawDb, now = () => Date.now()) {
     UPDATE pending_questions SET from_id = @from_id
      WHERE id = @id AND from_id IS NULL AND status = 'pending'`);
   const resolveStmt        = rawDb.prepare(`
-    UPDATE pending_questions SET status = @status, answered_ts = @answered_ts
+    UPDATE pending_questions SET status = @status, answered_ts = @answered_ts,
+           state_json = @state_json
      WHERE id = @id AND status = 'pending'`);
+  const resolveTxn = rawDb.transaction((id, status) => {
+    const current = getByIdStmt.get(id);
+    if (!current || current.status !== 'pending') return 0;
+    return resolveStmt.run({
+      id,
+      status,
+      answered_ts: now(),
+      state_json: maskDurableJsonText(current.state_json ?? '{}'),
+    }).changes;
+  });
   const listTimedOutStmt   = rawDb.prepare(`SELECT * FROM pending_questions WHERE status = 'pending' AND timeout_ts < ?`);
   const listOpenStmt       = rawDb.prepare(`SELECT * FROM pending_questions WHERE bot_name = ? AND status = 'pending'`);
 
@@ -61,8 +105,8 @@ function createQuestionStore(rawDb, now = () => Date.now()) {
         turn_id,
         tool_call_id,
         callback_token: newToken(),
-        questions_json: JSON.stringify(questions ?? []),
-        state_json: JSON.stringify(state ?? {}),
+        questions_json: maskDurableJson(questions ?? []),
+        state_json: JSON.stringify(withSanitizedQuestions(state)),
         created_ts,
         timeout_ts: created_ts + timeoutMs,
       });
@@ -75,7 +119,11 @@ function createQuestionStore(rawDb, now = () => Date.now()) {
     setMessageIds(id, ids) { return setMsgIdsStmt.run(JSON.stringify(ids ?? []), id).changes; },
 
     updateState(id, state, awaitingOther = false) {
-      return updateStateStmt.run({ id, state_json: JSON.stringify(state ?? {}), awaiting_other: awaitingOther ? 1 : 0 }).changes;
+      return updateStateStmt.run({
+        id,
+        state_json: JSON.stringify(withSanitizedQuestions(state)),
+        awaiting_other: awaitingOther ? 1 : 0,
+      }).changes;
     },
 
     /**
@@ -95,7 +143,15 @@ function createQuestionStore(rawDb, now = () => Date.now()) {
       if (!['answered', 'cancelled', 'timeout', 'expired'].includes(status)) {
         throw new Error(`bad status: ${status}`);
       }
-      return resolveStmt.run({ id, status, answered_ts: now() }).changes;
+      // Terminal transition: the answer has already been handed to the agent
+      // and no path replays a non-pending row, so the retained state can be
+      // masked. The row stays for audit; the credential does not.
+      //
+      // Read and write are one transaction. Read-then-write outside one would
+      // let a tap's updateState land in between and be overwritten by the
+      // state this call had already read — the answer state silently rolling
+      // back at the moment the row is sealed.
+      return resolveTxn(id, status);
     },
 
     sweepTimedOut() { return listTimedOutStmt.all(now()); },

package/lib/rewind/execute.js

@@ -26,7 +26,13 @@ function transcriptPathFor(cwd, sessionId) {
  * @param {object} deps { db, pm, tg, bot, botName, logEvent, logger, buildForkImpl }
  * @returns {(req) => Promise<{ok:boolean,error?:string,droppedCount?:number}>}
  */
-function createRewindExecutor({ db, pm, tg, bot, botName = 'bot', logEvent = () => {}, logger = console, buildForkImpl = buildFork } = {}) {
+function createRewindExecutor({
+  db, pm, tg, bot, botName = 'bot', logEvent = () => {}, logger = console,
+  buildForkImpl = buildFork,
+  // Narrow async hook: retire the question state of the session whose process
+  // is being replaced. A callback, so this module never learns the store.
+  retireQuestionSession = null,
+} = {}) {
   // P3: delete the bot's own outbound messages sent after M (it can always delete its own).
   async function deleteBotMessagesAfter({ chatId, threadId, afterMsgId }) {
     let rows;
@@ -74,8 +80,12 @@ function createRewindExecutor({ db, pm, tg, bot, botName = 'bot', logEvent = ()
     catch (e) {
       warning = 'the previous session may still be running — send a new message to confirm the rewind took';
       logger.error?.(`[${botName}] rewind kill: ${e.message}`);
-      logEvent('rewind-kill-failed', { session_key: req.sessionKey, error: e.message });
+      logEvent('rewind-kill-failed', { session_key: req.sessionKey, error_class: e.name || 'Error' });
     }
+    // The replaced process owned any open question. Retire its state whether or
+    // not the kill was clean: the rewound session cannot complete that ask, and
+    // an exact answer must not outlive the process it belonged to.
+    await retireQuestionSession?.(req.sessionKey);
 
     let droppedCount = 0;
     try { droppedCount = await deleteBotMessagesAfter({ chatId: req.chatId, threadId: req.threadId, afterMsgId: req.target.msg_id }); }

package/lib/rewind/rewind.js

@@ -103,7 +103,7 @@ function createRewindHandler({ pm, tg, bot, botName = 'bot', executeRewind, logE
       logEvent('rewind-done', { session_key: req.sessionKey, target_msg_id: req.target.msg_id });
     } else {
       await ack(req.chatId, req.threadId, `↩️ couldn't rewind — ${(result && result.error) || 'unknown error'}`);
-      logEvent('rewind-failed', { session_key: req.sessionKey, target_msg_id: req.target.msg_id, error: result && result.error });
+      logEvent('rewind-failed', { session_key: req.sessionKey, target_msg_id: req.target.msg_id, error_code: (result && result.error) ? 'rewind-failed' : null });
     }
   }
 

package/lib/sdk/build-options.js

@@ -89,8 +89,8 @@ function createBuildSdkOptions({
       } catch (err) {
         logger.error?.(`[${label}] agent-loader: ${err.message}`);
         logEvent('agent-load-failed', {
-          chat_id: chatId, agent: effectiveAgent, error: err.message,
-          topic: threadId || null,
+          chat_id: chatId, agent: effectiveAgent, error_class: err.name || 'Error',
+          thread_id: threadId || null,
         });
       }
     }

package/lib/sdk/callbacks.js

@@ -618,16 +618,22 @@ function createSdkCallbacks({
           stop_hook_active:    payload?.stopHookActive ?? null,
           received_at_ms:      payload?.receivedAtMs ?? null,
         };
-        // `parse-error` and `unknown` carry their raw body so soak
-        // analysis can decide whether they indicate transport
-        // corruption or schema drift. Truncate hard — these are
-        // expected to be rare.
+        // `parse-error` and `unknown` used to carry their raw body so soak
+        // analysis could tell transport corruption from schema drift. The
+        // body is hook payload — tool inputs and assistant text — so what is
+        // recorded now is its shape: an error code where the parser gave one,
+        // and the two sizes. A body that is absent, empty or huge is still
+        // distinguishable; its contents are not persisted.
         if (payload?.type === 'parse-error' || payload?.type === 'unknown') {
           let rawStr;
           try { rawStr = JSON.stringify(payload.raw); }
           catch { rawStr = String(payload.raw); }
-          detail.raw_truncated = (rawStr || '').slice(0, 512);
-          detail.parse_error = payload?.error ?? null;
+          detail.raw_len = (rawStr || '').length;
+          const parseError = payload?.error;
+          detail.parse_error_code = parseError?.code || parseError?.name || null;
+          detail.parse_error_len = typeof parseError === 'string'
+            ? parseError.length
+            : (parseError?.message?.length ?? 0);
         }
         logEvent('hook-event', detail);
 
@@ -758,8 +764,7 @@ function createSdkCallbacks({
           chat_id: getChatIdFromKey(sessionKey),
           session_key: sessionKey,
           backend: payload?.backend ?? 'cli', // Finding 0.12-M3 (fires on the CLI hook tail)
-          message:           (payload?.message || '').slice(0, 200),
-          path:              payload?.path ?? null,
+          error_len:         (payload?.message || '').length,
           claude_session_id: payload?.sessionId ?? null,
         });
       } catch (err) {
@@ -921,7 +926,7 @@ function createSdkCallbacks({
           chat_id: getChatIdFromKey(sessionKey),
           session_key: sessionKey,
           msg_id: msgId ?? null,
-          error: (payload?.err || '').slice(0, 200),
+          error_len: (payload?.err || '').length,
           backend: payload?.backend || 'tmux',
         });
         if (bot && msgId != null) {