polygram 0.10.0-rc.2 → 0.10.0-rc.21

package/polygram.js

@@ -24,7 +24,9 @@ const fs = require('fs');
 const path = require('path');
 const processGuard = require('./lib/process-guard');
 const dbClient = require('./lib/db');
-const { migrateJsonToDb, getClaudeSessionId } = require('./lib/db/sessions');
+const {
+  migrateJsonToDb, getClaudeSessionId, resolveSessionForSpawn,
+} = require('./lib/db/sessions');
 const { buildPrompt } = require('./lib/prompt');
 const { filterAttachments } = require('./lib/attachments');
 // 0.9.0: SDK ProcessManager is the only pm. CLI pm
@@ -38,7 +40,7 @@ const { filterAttachments } = require('./lib/attachments');
 // per-session mechanics. The pre-0.10.0 monolithic ProcessManagerSdk
 // is deleted; SdkProcess inherits its per-entry guts.
 const { ProcessManager } = require('./lib/process-manager');
-const { createProcessFactory } = require('./lib/process/factory');
+const { createProcessFactory, pickBackend } = require('./lib/process/factory');
 const { extractAssistantText } = require('./lib/process/sdk-process');
 const { createTmuxRunner } = require('./lib/tmux/tmux-runner');
 const { sweepTmuxOrphans } = require('./lib/tmux/orphan-sweep');
@@ -396,12 +398,56 @@ function buildSpawnContext(sessionKey) {
   const chatConfig = config.chats[chatId];
   if (!chatConfig) return null;
   const threadId = sessionKey.includes(':') ? sessionKey.split(':')[1] : null;
+
+  // S2: a stored session is valid ONLY for the config it was spawned
+  // under. agent / cwd / pm_backend are spawn-identity — baked into
+  // the process at spawn time, never mutable on a live session.
+  // Resolve them the same way the backends do (topic override merged
+  // over chat-level) and compare to the stored `sessions` row. On
+  // drift, resolveSessionForSpawn drops the stale row and returns
+  // existingSessionId:null → the spawn starts fresh under the correct
+  // config instead of `--resume`-ing a stale one. This self-heals the
+  // pre-per-topic-config rows (e.g. shumorobot's Music topic :3,
+  // stored agent=shumabit / cwd=$HOME / sdk vs the current
+  // music-curation:music-curator / .../Music/rekordbox / tmux).
+  // model/effort are NOT compared — they apply live via setModel /
+  // applyFlagSettings with no respawn.
+  //
+  // The drift check runs only at COLD spawn (no warm process). A warm
+  // process already runs under its spawn-time config; getOrSpawn
+  // returns it without using this context, so dropping its row here
+  // would be premature — defer to the next cold spawn.
+  const isColdSpawn = !pm || !pm.has(sessionKey) || pm.get(sessionKey)?.closed;
+  let existingSessionId;
+  if (isColdSpawn) {
+    const topicConfig = getTopicConfig(chatConfig, threadId || null);
+    const resolved = {
+      agent: topicConfig.agent || chatConfig.agent || null,
+      cwd: topicConfig.cwd || chatConfig.cwd || null,
+      backend: pickBackend({ config, chatId, threadId: threadId || null }),
+    };
+    const r = resolveSessionForSpawn(db, sessionKey, resolved);
+    existingSessionId = r.existingSessionId;
+    if (r.drift) {
+      logEvent('session-config-drift', {
+        chat_id: chatId,
+        thread_id: threadId || null,
+        session_key: sessionKey,
+        fields: r.drift.fields,
+        before: r.drift.before,
+        after: r.drift.after,
+      });
+    }
+  } else {
+    existingSessionId = getClaudeSessionId(db, sessionKey);
+  }
+
   return {
     chatConfig,
     chatId,
     threadId: threadId || null,
     label: getSessionLabel(chatConfig, threadId),
-    existingSessionId: getClaudeSessionId(db, sessionKey),
+    existingSessionId,
   };
 }
 
@@ -411,7 +457,7 @@ async function getOrSpawnForChat(sessionKey) {
   return pm.getOrSpawn(sessionKey, ctx);
 }
 
-async function sendToProcess(sessionKey, prompt, context = {}) {
+async function sendToProcess(sessionKey, prompt, context = {}, { onDispatched } = {}) {
   const entry = await getOrSpawnForChat(sessionKey);
   if (!entry) throw new Error('No process for chat');
   const chatId = getChatIdFromKey(sessionKey);
@@ -437,7 +483,13 @@ async function sendToProcess(sessionKey, prompt, context = {}) {
   // starts, which is the correct UX (and what the user already expects).
   const release = await stdinLock.acquire(sessionKey);
   try {
-    return await pm.send(sessionKey, prompt, { timeoutMs, maxTurnMs, context });
+    const turnP = pm.send(sessionKey, prompt, { timeoutMs, maxTurnMs, context });
+    // Phase 3 §4: pm.send synchronously kicks off the turn — the
+    // process is now inFlight. Signal the committed-intent latch so
+    // it can release; a concurrent handler will then correctly see
+    // the live turn and autosteer instead of racing into a 2nd send.
+    if (typeof onDispatched === 'function') onDispatched();
+    return await turnP;
   } finally {
     release();
   }
@@ -481,6 +533,15 @@ let inFlightHandlers = null;
 // Per-session lock ordering stdin writes. Module is I/O-pure.
 const stdinLock = createAsyncLock();
 
+// 0.10.0 Phase 3 §4: committed-intent latch. Serialises the
+// autosteer-vs-primary decision per session so a burst of concurrent
+// handleMessage calls cannot each independently mis-read `inFlight`
+// and all classify themselves as primary. The first to acquire it
+// for an idle session commits the primary turn and holds the latch
+// until the process is inFlight; later acquirers see the live turn
+// and autosteer.
+const intentLock = createAsyncLock();
+
 // Typing indicator is imported from lib/typing-indicator — it adds a
 // per-chat circuit breaker with exponential backoff so a chat that
 // permanently 401s (bot blocked, chat deleted) doesn't have us
@@ -971,9 +1032,39 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   // standard emoji per core.telegram.org/bots/api#availablereactions).
   // 🛞 is NOT on it (400: REACTION_INVALID). ✍ ("writing/noting")
   // is on the list and conveys "incorporating this".
-  const steered = autosteer.tryAutosteer({
-    sessionKey, chatConfig, chatId, msg, prompt,
-  });
+  // 0.10.0 Phase 3 §4: committed-intent latch. The autosteer-vs-
+  // primary decision AND the turn dispatch happen inside one
+  // per-session critical section. tryAutosteer's `inFlight` read is
+  // now reliable: the previous primary held this latch until its
+  // pm.send made the process inFlight, so a concurrent burst can no
+  // longer mis-classify followups as primary turns.
+  const releaseIntent = await intentLock.acquire(sessionKey);
+  let steered = { autosteered: false };
+  let sendPromise = null;
+  try {
+    steered = autosteer.tryAutosteer({ sessionKey, chatConfig, chatId, msg, prompt });
+    if (!steered.autosteered) {
+      // Primary turn. Kick off the dispatch and hold the latch until
+      // pm.send has made the process inFlight (onDispatched). The
+      // turn RESULT is awaited only AFTER the latch is released — the
+      // latch covers the decision + commitment, never the whole turn
+      // (that would block every autosteer).
+      // Pass streamer + reactor as per-turn context; pm's callbacks
+      // pick them off entry.pendingQueue[0].context.
+      await new Promise((dispatched) => {
+        sendPromise = sendToProcess(sessionKey, prompt, {
+          streamer, reactor, sourceMsgId: msg.message_id,
+          // 0.7.4 (item B): fire THINKING when Claude actually starts
+          // emitting — not the moment we wrote stdin.
+          onFirstStream: () => reactor.setState('THINKING'),
+        }, { onDispatched: dispatched })
+          .catch((e) => ({ __sendError: e }))
+          .finally(dispatched);
+      });
+    }
+  } finally {
+    releaseIntent();
+  }
   if (steered.autosteered) {
     stopTyping();
     // setState('AUTOSTEERED') is terminal — bypasses throttle,
@@ -987,18 +1078,10 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   }
 
   try {
-    // Pass streamer + reactor as per-turn context. pm's callbacks pick
-    // them off entry.pendingQueue[0].context so concurrent pendings each
-    // get routed to their own streamer/reactor.
-    const result = await sendToProcess(sessionKey, prompt, {
-      streamer, reactor, sourceMsgId: msg.message_id,
-      // 0.7.4 (item B): fire THINKING when Claude actually starts
-      // emitting (first assistant text or tool_use). Pre-fix, onActivate
-      // (queue-head transition) flipped to THINKING the moment we wrote
-      // stdin, even though Claude could spend hundreds of ms loading.
-      // Result: long flat 🤔 with nothing happening; users assumed stall.
-      onFirstStream: () => reactor.setState('THINKING'),
-    });
+    const result = await sendPromise;
+    // sendToProcess failures are captured (not thrown) so the latch
+    // always releases; re-throw here into the existing handler.
+    if (result && result.__sendError) throw result.__sendError;
     const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
 
     // 0.7.6 (item F): persist per-turn telemetry. Stream-json result
@@ -1083,15 +1166,16 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       // (→ 'failed', user gets an apology with retry hint).
       if (!result.text) throw new Error(result.error);
     } else {
-      // Clear the progress reaction instead of stamping 👍 — the reply
-      // bubble itself is the "done" signal and a permanent thumbs-up on
-      // every answered message is chat noise (plus triggers reaction
-      // notifications for other group members).
-      reactor.clear().catch(() => {});
-      // 0.8.0-rc.14: also clear ✍ reactions on every follow-up
-      // message that was autosteered into THIS turn — they live in
-      // separate handleMessage scopes whose reactors are already GC'd.
-      clearAutosteeredReactions(sessionKey).catch(() => {});
+      // rc.10: reactor.clear() and clearAutosteeredReactions() moved
+      // to AFTER deliverReplies completes (see just before
+      // markReplied() below). Pre-rc.10 they fired the moment pm.send
+      // returned (JSONL result event), which was ~1-3s BEFORE the
+      // Telegram reply actually landed via the streamer / chunked
+      // delivery path. User saw: 🤔/✍ visible → reactions cleared →
+      // ~1-3s of nothing → reply bubble lands. Ivan caught this on
+      // shumorobot 2026-05-15 ("both reactions disappeared, typing
+      // disappeared, at some point he responded"). Deferring the
+      // clears closes the visual gap.
       // rc.42: tool-less-turn stale-drain DELETED. With native priority
       // push, the SDK's input controller has the followups directly —
       // there's no buffer for us to drain. Tool-less turns just emit
@@ -1385,6 +1469,23 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
 
     await sendInlineStickers();
           await sendInlineReactions();
+    // rc.10: clear progress reactions AFTER the reply has been
+    // delivered so the user doesn't see a "reactions cleared, then
+    // ~1-3s of nothing, then reply bubble" gap. The reply bubble
+    // itself is the "done" signal; clearing the emoji simultaneously
+    // with the delivery completion is the smooth UX path. Both
+    // fire-and-forget — these are best-effort cleanups, not part of
+    // the reply contract.
+    reactor.clear().catch(() => {});
+    // 0.8.0-rc.14: also clear ✍ reactions on every follow-up
+    // message that was autosteered into THIS turn — they live in
+    // separate handleMessage scopes whose reactors are already GC'd.
+    // rc.9 caveat: TmuxProcess.extra-turn-started re-applies ✍ if
+    // there's a pending autosteer dequeue happening (NEW-TURN case),
+    // and extra-turn-reply clears it again when the second reply
+    // lands. So the FOLD path benefits from this deferred clear
+    // without breaking NEW-TURN.
+    clearAutosteeredReactions(sessionKey).catch(() => {});
     console.log(`[${label}] ${elapsed}s | ${result.text.length} chars | ${chatConfig.model}/${chatConfig.effort} | $${result.cost?.toFixed(4) || '?'}`);
     markReplied();
   } catch (err) {
@@ -2027,6 +2128,26 @@ async function main() {
   // instances. Construction is cheap (no system call until first
   // spawn/send). Only used if any chat in config has pm:'tmux'.
   const tmuxRunner = createTmuxRunner({ logger: console });
+  // Verify the pinned claude CLI binary is present. The tmux
+  // backend spawns this exact binary by absolute path (see
+  // lib/claude-bin.js + TmuxProcess.start) — it never resolves
+  // `claude` through $PATH, so the CLI auto-updater can't drift
+  // it. This boot check is informational: it tells the operator
+  // up-front which binary the tmux backend will use, and warns
+  // (non-fatal — SDK-backed chats don't need it) if it's missing.
+  // A missing binary still hard-fails per-chat at TmuxProcess.start.
+  {
+    const { CLAUDE_CLI_PINNED_VERSION } = require('./lib/process/tmux-process');
+    const { verifyPinnedClaudeBin } = require('./lib/claude-bin');
+    const binCheck = verifyPinnedClaudeBin(CLAUDE_CLI_PINNED_VERSION);
+    if (binCheck.ok) {
+      console.log(
+        `[polygram] tmux backend pinned to claude CLI v${CLAUDE_CLI_PINNED_VERSION}: ${binCheck.path}`,
+      );
+    } else {
+      console.warn(`[polygram] WARNING: ${binCheck.reason}`);
+    }
+  }
   // O1 optimization: shared poll-tick scheduler. N TmuxProcess
   // instances share ONE setInterval instead of spawning N independent
   // setTimeout chains. Idle when no chats are in flight (zero timers