polygram 0.21.0 → 0.23.0

package/lib/handlers/slash-commands.js

@@ -28,6 +28,14 @@
 'use strict';
 
 const { getConfigWriteScope } = require('../session-key');
+const {
+  configuredRuntimeValue,
+  formatCodexSettingsOutcome,
+  getCodexCatalogEfforts,
+  getCodexCatalogModels,
+  isCodexRuntimeView,
+  resolveCodexEffortForModel,
+} = require('./config-ui');
 
 function createSlashCommands({
   config,
@@ -42,6 +50,8 @@ function createSlashCommands({
   getOrSpawnForChat,
   parsePairCodeArgs,
   modelVersionsDesc,
+  resolveRuntimeView = null,
+  intentLock,
   saveConfig = () => {},
   botName,
   logEvent,
@@ -61,6 +71,30 @@ function createSlashCommands({
     // entry.query.getContextUsage directly, which silently said "No
     // active session yet" on tmux even when the chat was alive.
     if (botAllowsCommands && text === '/context') {
+      if (typeof resolveRuntimeView === 'function') {
+        try {
+          const runtimeView = await resolveRuntimeView({
+            sessionKey,
+            chatId,
+            threadId: threadIdStr,
+          });
+          if (isCodexRuntimeView(runtimeView)) {
+            await sendReply(
+              'Codex context usage reporting is not supported yet; the active Codex thread was unchanged.',
+            );
+            return true;
+          }
+        } catch (error) {
+          logger.error?.(
+            `[${label}] /context runtime view failed: `
+              + `${error?.code || error?.name || 'unknown'}`,
+          );
+          await sendReply(
+            'Context status is temporarily unavailable; the active session was not changed.',
+          );
+          return true;
+        }
+      }
       if (!pm.has(sessionKey)) {
         await sendReply('📚 No active session yet — send a message first, then /context.');
         return true;
@@ -85,6 +119,31 @@ function createSlashCommands({
     // was LRU-evicted but DB has a saved session_id, auto-spawn
     // with --resume so /compact has something to work with.
     if (botAllowsCommands && text.startsWith('/compact')) {
+      if (typeof resolveRuntimeView === 'function') {
+        let runtimeView;
+        try {
+          runtimeView = await resolveRuntimeView({
+            sessionKey,
+            chatId,
+            threadId: threadIdStr,
+          });
+        } catch (error) {
+          logger.error?.(
+            `[${label}] /compact runtime view failed: `
+              + `${error?.code || error?.name || 'unknown'}`,
+          );
+          await sendReply(
+            'Compaction status is temporarily unavailable; the active session was not changed.',
+          );
+          return true;
+        }
+        if (isCodexRuntimeView(runtimeView)) {
+          await sendReply(
+            'Codex thread compaction is not supported yet; the active Codex thread was unchanged.',
+          );
+          return true;
+        }
+      }
       let entry = pm.get(sessionKey);
       if (!entry) {
         const savedSessionId = getClaudeSessionId(db, sessionKey);
@@ -145,33 +204,96 @@ function createSlashCommands({
     //   /reload → kill closes Query, session_id preserved → same
     //              conversation continues with fresh agent/skill code
     if (botAllowsCommands && text === '/reload') {
+      let runtimeView = null;
+      if (typeof resolveRuntimeView === 'function') {
+        try {
+          runtimeView = await resolveRuntimeView({
+            sessionKey,
+            chatId,
+            threadId: threadIdStr,
+          });
+        } catch (error) {
+          logger.error?.(
+            `[${label}] /reload runtime view failed: `
+              + `${error?.code || error?.name || 'unknown'}`,
+          );
+          await sendReply(
+            'Runtime status is temporarily unavailable; the active session was not changed.',
+          );
+          return true;
+        }
+      }
+      const codex = isCodexRuntimeView(runtimeView);
       if (pm.has(sessionKey)) {
-        try { await pm.kill(sessionKey); }
-        catch (err) { logger.error?.(`[${label}] kill on /reload: ${err.message}`); }
+        try {
+          await pm.kill(sessionKey);
+        } catch (err) {
+          logger.error?.(`[${label}] kill on /reload: ${err.message}`);
+          await sendReply(
+            codex
+              ? '🔄 Couldn’t reload Codex because cleanup was not proven; the active Codex thread may be unchanged.'
+              : '🔄 Couldn’t reload Claude; the active session may be unchanged.',
+          );
+          return true;
+        }
       }
       logEvent('session-reload-command', {
         chat_id: chatId, command: text,
         user: cmdUser, user_id: cmdUserId,
       });
-      await sendReply('🔄 Reloaded. Next message picks up the conversation with fresh skills/agents.');
+      await sendReply(
+        codex
+          ? '🔄 Reloaded Codex. The next message resumes the same Codex thread with a fresh runtime.'
+          : '🔄 Reloaded. Next message picks up the conversation with fresh skills/agents.',
+      );
       return true;
     }
 
     // /new + /reset + /clear — fresh session (all synonyms)
     if (botAllowsCommands && (text === '/new' || text === '/reset' || text === '/clear')) {
+      let runtimeView = null;
+      if (typeof resolveRuntimeView === 'function') {
+        try {
+          runtimeView = await resolveRuntimeView({
+            sessionKey,
+            chatId,
+            threadId: threadIdStr,
+          });
+        } catch (error) {
+          logger.error?.(
+            `[${label}] ${text} runtime view failed: `
+              + `${error?.code || error?.name || 'unknown'}`,
+          );
+          await sendReply(
+            'Runtime status is temporarily unavailable; the active session was not changed.',
+          );
+          return true;
+        }
+      }
+      const codex = isCodexRuntimeView(runtimeView);
       let drained = 0;
       try {
         const r = await pm.resetSession(sessionKey, { reason: text.slice(1) });
         drained = r?.drainedPendings ?? 0;
       } catch (err) {
         logger.error?.(`[${label}] resetSession ${text}: ${err.message}`);
+        await sendReply(
+          codex
+            ? '✨ Couldn’t start a fresh Codex thread because cleanup was not proven; the prior Codex thread may be unchanged.'
+            : '✨ Couldn’t start a fresh Claude session; the prior session may be unchanged.',
+        );
+        return true;
       }
       contextHintShown.delete(sessionKey);
       logEvent('session-reset-command', {
         chat_id: chatId, command: text, drained_pendings: drained,
         user: cmdUser, user_id: cmdUserId,
       });
-      await sendReply('✨ Started a fresh session.');
+      await sendReply(
+        codex
+          ? '✨ Started a fresh Codex thread.'
+          : '✨ Started a fresh session.',
+      );
       return true;
     }
 
@@ -216,47 +338,331 @@ function createSlashCommands({
     // /model X
     if (botAllowsCommands && text.startsWith('/model ')) {
       const newModel = text.slice(7).trim();
-      if (['opus', 'sonnet', 'haiku'].includes(newModel)) {
-        // Write to the topic when in one (so Music ≠ General) and persist to
-        // config.json so it survives restarts — both were missing (2026-06-12).
-        const { scope: wScope, threadId: wThread } = getConfigWriteScope(chatConfig, threadIdStr);
-        const oldModel = wScope.model != null ? wScope.model : chatConfig.model;
-        wScope.model = newModel;
-        try { saveConfig(); }
-        catch (err) { logger.error?.(`[${botName}] /model saveConfig failed: ${err.message}`); }
-        dbWrite(() => db.logConfigChange({
-          chat_id: chatId, thread_id: wThread, field: 'model',
-          old_value: oldModel, new_value: newModel,
-          user: cmdUser, user_id: cmdUserId, source: 'command',
-        }), 'log model change');
-        const { anyActive } = await applyConfigChange('model', newModel);
-        const ver = (modelVersionsDesc && modelVersionsDesc[newModel]) || newModel;
-        await sendReply(`Model → ${newModel} (${ver})${cliAwareSuffix(anyActive)}`);
-      } else {
-        await sendReply(`Unknown model. Use: opus, sonnet, haiku`);
+      const releaseIntent = await intentLock.acquire(sessionKey);
+      let replyText;
+      try {
+        let runtimeView = null;
+        if (typeof resolveRuntimeView === 'function') {
+          try {
+            runtimeView = await resolveRuntimeView({
+              sessionKey,
+              chatId,
+              threadId: threadIdStr,
+            });
+          } catch (error) {
+            logger.error?.(
+              `[${label}] /model runtime view failed: `
+                + `${error?.code || error?.name || 'unknown'}`,
+            );
+            replyText = 'Model settings are temporarily unavailable.';
+          }
+        }
+        if (!replyText) {
+          const codex = isCodexRuntimeView(runtimeView);
+          const validModels = codex
+            ? getCodexCatalogModels(runtimeView).map((entry) => entry.model)
+            : ['opus', 'sonnet', 'haiku'];
+          if (!validModels.includes(newModel)) {
+            replyText =
+              `Unknown model. Use: ${validModels.join(', ')
+                || 'no authenticated models available'}`;
+          } else {
+            const { scope: wScope, threadId: wThread } =
+              getConfigWriteScope(chatConfig, threadIdStr);
+            const configField = codex ? 'codexModel' : 'model';
+            const oldModel = wScope[configField] != null
+              ? wScope[configField]
+              : chatConfig[configField] != null
+                ? chatConfig[configField]
+                : codex ? runtimeView.model : chatConfig[configField];
+            const snapshots = new Map([
+              [configField, {
+                present: Object.hasOwn(wScope, configField),
+                value: wScope[configField],
+              }],
+              ['codexEffort', {
+                present: Object.hasOwn(wScope, 'codexEffort'),
+                value: wScope.codexEffort,
+              }],
+            ]);
+            let effortAdjustment = null;
+            let nextEffort = null;
+            if (codex) {
+              const oldEffort = wScope.codexEffort != null
+                ? wScope.codexEffort
+                : chatConfig.codexEffort != null
+                  ? chatConfig.codexEffort
+                  : runtimeView.effort;
+              nextEffort = resolveCodexEffortForModel(
+                runtimeView,
+                newModel,
+                oldEffort,
+              );
+              if (nextEffort == null) {
+                replyText =
+                  'Selected model has no authenticated default effort.';
+              } else if (nextEffort !== oldEffort) {
+                effortAdjustment = {
+                  oldValue: oldEffort,
+                  newValue: nextEffort,
+                };
+              }
+            }
+            if (!replyText) {
+              wScope[configField] = newModel;
+              if (effortAdjustment) {
+                wScope.codexEffort = effortAdjustment.newValue;
+              }
+              try {
+                await saveConfig();
+              } catch (error) {
+                for (const [field, snapshot] of snapshots) {
+                  if (snapshot.present) wScope[field] = snapshot.value;
+                  else delete wScope[field];
+                }
+                logger.error?.(
+                  `[${botName}] /model saveConfig failed: ${error.message}`,
+                );
+                replyText =
+                  "Couldn't save the model selection; nothing changed.";
+              }
+            }
+            if (!replyText) {
+              const auditRows = [{
+                  chat_id: chatId, thread_id: wThread, field: 'model',
+                  old_value: oldModel, new_value: newModel,
+                  user: cmdUser, user_id: cmdUserId, source: 'command',
+                }];
+              if (effortAdjustment) {
+                auditRows.push({
+                    chat_id: chatId,
+                    thread_id: wThread,
+                    field: 'effort',
+                    old_value: effortAdjustment.oldValue,
+                    new_value: effortAdjustment.newValue,
+                    user: cmdUser,
+                    user_id: cmdUserId,
+                    source: 'command',
+                });
+              }
+              if (codex) {
+                try {
+                  db.logConfigChanges(auditRows);
+                } catch (error) {
+                  for (const [field, snapshot] of snapshots) {
+                    if (snapshot.present) wScope[field] = snapshot.value;
+                    else delete wScope[field];
+                  }
+                  let rollbackFailed = false;
+                  try {
+                    await saveConfig();
+                  } catch (rollbackError) {
+                    rollbackFailed = true;
+                    logger.error?.(
+                      `[${botName}] /model config rollback failed: `
+                        + rollbackError.message,
+                    );
+                  }
+                  logger.error?.(
+                    `[${botName}] /model audit failed: ${error.message}`,
+                  );
+                  replyText = rollbackFailed
+                    ? "Couldn't audit the model selection; the live process "
+                      + 'was unchanged, but persisted config needs attention.'
+                    : "Couldn't audit the model selection; nothing changed.";
+                }
+              } else {
+                dbWrite(() => {
+                  for (const row of auditRows) db.logConfigChange(row);
+                }, 'log model change');
+              }
+            }
+            if (!replyText) {
+              let settingsResult = null;
+              let anyActive = false;
+              if (codex) {
+                try {
+                  settingsResult = await pm.selectModelSettings(sessionKey, {
+                    model: newModel,
+                    effort: nextEffort,
+                  });
+                } catch (error) {
+                  logger.error?.(
+                    `[${label}] Codex /model live selection failed: `
+                      + `${error?.code || error?.name || 'unknown'}`,
+                  );
+                  settingsResult = {
+                    outcome: 'live-status-unknown',
+                    nextTurn: { model: newModel, effort: nextEffort },
+                  };
+                }
+              } else {
+                ({ anyActive } = await applyConfigChange('model', newModel));
+              }
+              const catalogEntry = codex
+                ? getCodexCatalogModels(runtimeView)
+                  .find((entry) => entry.model === newModel)
+                : null;
+              const ver = codex
+                ? catalogEntry?.displayName || newModel
+                : (modelVersionsDesc && modelVersionsDesc[newModel])
+                  || newModel;
+              const suffix = codex
+                ? formatCodexSettingsOutcome(settingsResult)
+                : cliAwareSuffix(anyActive);
+              const effortNote = effortAdjustment
+                ? `; Effort → ${effortAdjustment.newValue}`
+                : '';
+              replyText =
+                `Model → ${newModel} (${ver})${effortNote}${suffix}`;
+            }
+          }
+        }
+      } finally {
+        releaseIntent();
       }
+      await sendReply(replyText);
       return true;
     }
 
     // /effort X
     if (botAllowsCommands && text.startsWith('/effort ')) {
       const newEffort = text.slice(8).trim();
-      if (['low', 'medium', 'high', 'xhigh', 'max'].includes(newEffort)) {
-        const { scope: wScope, threadId: wThread } = getConfigWriteScope(chatConfig, threadIdStr);
-        const oldEffort = wScope.effort != null ? wScope.effort : chatConfig.effort;
-        wScope.effort = newEffort;
-        try { saveConfig(); }
-        catch (err) { logger.error?.(`[${botName}] /effort saveConfig failed: ${err.message}`); }
-        dbWrite(() => db.logConfigChange({
-          chat_id: chatId, thread_id: wThread, field: 'effort',
-          old_value: oldEffort, new_value: newEffort,
-          user: cmdUser, user_id: cmdUserId, source: 'command',
-        }), 'log effort change');
-        const { anyActive } = await applyConfigChange('effort', newEffort);
-        await sendReply(`Effort → ${newEffort}${cliAwareSuffix(anyActive)}`);
-      } else {
-        await sendReply(`Unknown effort. Use: low, medium, high, xhigh, max`);
+      const releaseIntent = await intentLock.acquire(sessionKey);
+      let replyText;
+      try {
+        let runtimeView = null;
+        if (typeof resolveRuntimeView === 'function') {
+          try {
+            runtimeView = await resolveRuntimeView({
+              sessionKey,
+              chatId,
+              threadId: threadIdStr,
+            });
+          } catch (error) {
+            logger.error?.(
+              `[${label}] /effort runtime view failed: `
+                + `${error?.code || error?.name || 'unknown'}`,
+            );
+            replyText = 'Effort settings are temporarily unavailable.';
+          }
+        }
+        if (!replyText) {
+          const codex = isCodexRuntimeView(runtimeView);
+          const topicConfig = threadIdStr
+            ? chatConfig?.topics?.[threadIdStr]
+            : null;
+          const currentModel = configuredRuntimeValue(
+            chatConfig,
+            topicConfig,
+            runtimeView,
+            'model',
+          );
+          const validEfforts = codex
+            ? getCodexCatalogEfforts(runtimeView, currentModel)
+            : ['low', 'medium', 'high', 'xhigh', 'max'];
+          if (!validEfforts.includes(newEffort)) {
+            replyText =
+              `Unknown effort. Use: ${validEfforts.join(', ')
+                || 'no authenticated efforts available'}`;
+          } else {
+            const { scope: wScope, threadId: wThread } =
+              getConfigWriteScope(chatConfig, threadIdStr);
+            const configField = codex ? 'codexEffort' : 'effort';
+            const oldEffort = wScope[configField] != null
+              ? wScope[configField]
+              : chatConfig[configField] != null
+                ? chatConfig[configField]
+                : codex ? runtimeView.effort : chatConfig[configField];
+            const snapshot = {
+              present: Object.hasOwn(wScope, configField),
+              value: wScope[configField],
+            };
+            wScope[configField] = newEffort;
+            try {
+              await saveConfig();
+            } catch (error) {
+              if (snapshot.present) wScope[configField] = snapshot.value;
+              else delete wScope[configField];
+              logger.error?.(
+                `[${botName}] /effort saveConfig failed: ${error.message}`,
+              );
+              replyText =
+                "Couldn't save the effort selection; nothing changed.";
+            }
+            if (!replyText) {
+              const auditRow = {
+                chat_id: chatId, thread_id: wThread, field: 'effort',
+                old_value: oldEffort, new_value: newEffort,
+                user: cmdUser, user_id: cmdUserId, source: 'command',
+              };
+              if (codex) {
+                try {
+                  db.logConfigChanges([auditRow]);
+                } catch (error) {
+                  if (snapshot.present) wScope[configField] = snapshot.value;
+                  else delete wScope[configField];
+                  let rollbackFailed = false;
+                  try {
+                    await saveConfig();
+                  } catch (rollbackError) {
+                    rollbackFailed = true;
+                    logger.error?.(
+                      `[${botName}] /effort config rollback failed: `
+                        + rollbackError.message,
+                    );
+                  }
+                  logger.error?.(
+                    `[${botName}] /effort audit failed: ${error.message}`,
+                  );
+                  replyText = rollbackFailed
+                    ? "Couldn't audit the effort selection; the live process "
+                      + 'was unchanged, but persisted config needs attention.'
+                    : "Couldn't audit the effort selection; nothing changed.";
+                }
+              } else {
+                dbWrite(
+                  () => db.logConfigChange(auditRow),
+                  'log effort change',
+                );
+              }
+            }
+            if (!replyText) {
+              let settingsResult = null;
+              let anyActive = false;
+              if (codex) {
+                try {
+                  settingsResult = await pm.selectModelSettings(sessionKey, {
+                    model: currentModel,
+                    effort: newEffort,
+                  });
+                } catch (error) {
+                  logger.error?.(
+                    `[${label}] Codex /effort live selection failed: `
+                      + `${error?.code || error?.name || 'unknown'}`,
+                  );
+                  settingsResult = {
+                    outcome: 'live-status-unknown',
+                    nextTurn: { model: currentModel, effort: newEffort },
+                  };
+                }
+              } else {
+                ({ anyActive } = await applyConfigChange(
+                  'effort',
+                  newEffort,
+                ));
+              }
+              const suffix = codex
+                ? formatCodexSettingsOutcome(settingsResult)
+                : cliAwareSuffix(anyActive);
+              replyText = `Effort → ${newEffort}${suffix}`;
+            }
+          }
+        }
+      } finally {
+        releaseIntent();
       }
+      await sendReply(replyText);
       return true;
     }
 

package/lib/ipc/client.js

@@ -8,27 +8,29 @@
 
 const net = require('net');
 const fs = require('fs');
+const {
+  runtimeDirectory,
+  ensureRuntimeDirectory,
+  socketPathFor,
+  secretPathFor,
+  validateBotName,
+} = require('./runtime-directory');
 
 const DEFAULT_CONNECT_TIMEOUT_MS = 5_000;
 const DEFAULT_CALL_TIMEOUT_MS = 5 * 60 * 1000;
 
-function socketPathFor(botName) {
-  return `/tmp/polygram-${botName}.sock`;
-}
-
-function secretPathFor(botName) {
-  return `/tmp/polygram-${botName}.secret`;
-}
-
 /**
  * Read the IPC secret for a bot. Prefers POLYGRAM_IPC_SECRET env var (set by
  * polygram when spawning Claude subprocesses) over the file (used by
  * cron and external callers that aren't polygram children). Missing secret
  * is not an error — caller decides whether to send it.
  */
-function readSecret(botName) {
-  if (process.env.POLYGRAM_IPC_SECRET) return process.env.POLYGRAM_IPC_SECRET;
-  try { return fs.readFileSync(secretPathFor(botName), 'utf8').trim(); }
+function readSecret(botName, options) {
+  validateBotName(botName);
+  const env = options?.env || process.env;
+  if (env.POLYGRAM_IPC_SECRET) return env.POLYGRAM_IPC_SECRET;
+  const secretPath = secretPathFor(botName, options);
+  try { return fs.readFileSync(secretPath, 'utf8').trim(); }
   catch { return null; }
 }
 
@@ -111,4 +113,12 @@ async function tell(bot, method, params = {}, opts = {}) {
   return res.result;
 }
 
-module.exports = { call, tell, socketPathFor, secretPathFor, readSecret };
+module.exports = {
+  call,
+  tell,
+  runtimeDirectory,
+  ensureRuntimeDirectory,
+  socketPathFor,
+  secretPathFor,
+  readSecret,
+};