@goodandready/dsh-messenger-gateway 0.3.13 → 0.3.18

package/lib/content-guard.js

@@ -0,0 +1,14 @@
+/**
+ * Normalize any content value to ContentBlock[].
+ * DSH core (dsh-llm) calls content.some() without Array.isArray guard,
+ * so we must ensure every message we create or copy has array content.
+ * Refs: #51
+ */
+export function ensureContentArray(content) {
+  if (Array.isArray(content)) return content
+  if (typeof content === 'string') {
+    return content ? [{ type: 'text', text: content }] : [{ type: 'text', text: '(пустое сообщение)' }]
+  }
+  if (content && typeof content === 'object' && content.type) return [content]
+  return [{ type: 'text', text: String(content ?? '(пустое сообщение)') }]
+}

package/lib/gateway.js

@@ -33,6 +33,8 @@ import {
   createEditScheduler, startTypingHeartbeat,
 } from './stream.js'
 import { isTopicGoneError } from './telegram-errors.js'
+import { ensureContentArray } from './content-guard.js'
+
 
 function whenIdleWithTimeout(agent, timeoutMs, signal) {
   const idle = agent.whenIdle()
@@ -174,11 +176,10 @@ export class Gateway {
         this.ctx.logger?.warn?.(`dsh-messenger-gateway: ${adapter.name}: ${err.message}`)
       }
     }
-    const idleMs = Number(this.config.agent?.idleTimeoutMs) || 0
-    if (idleMs > 0) {
-      this.idleTimer = setInterval(() => this.reapIdle(), Math.min(idleMs, 60_000))
-      this.idleTimer.unref?.()
-    }
+    const rawIdle = Number(this.config.agent?.idleTimeoutMs)
+    const idleMs = Number.isFinite(rawIdle) && rawIdle > 0 ? rawIdle : 86_400_000
+    this.idleTimer = setInterval(() => this.reapIdle(), Math.min(idleMs, 60_000))
+    this.idleTimer.unref?.()
     this.scheduler.start()
   }
 
@@ -339,8 +340,8 @@ export class Gateway {
           return
         }
         if (action.kind === 'done') {
-          clearTimeout(pending.timer)
           this.pendingAsks.delete(askToken)
+          clearTimeout(pending.timer)
           releaseCallbacks(this.callbackIndex, pending.callbackKeys)
           await cb.answer('OK')
           try { await cb.editMessage(cb.message?.text || 'Выбрано', REMOVE_KEYBOARD) } catch {}
@@ -348,8 +349,8 @@ export class Gateway {
           return
         }
         if (action.kind === 'cancel') {
-          clearTimeout(pending.timer)
           this.pendingAsks.delete(askToken)
+          clearTimeout(pending.timer)
           releaseCallbacks(this.callbackIndex, pending.callbackKeys)
           await cb.answer('Отменено')
           try { await cb.editMessage(cb.message?.text || 'Отменено', REMOVE_KEYBOARD) } catch {}
@@ -357,8 +358,8 @@ export class Gateway {
           return
         }
       }
-      clearTimeout(pending.timer)
       this.pendingAsks.delete(askToken)
+      clearTimeout(pending.timer)
       releaseCallbacks(this.callbackIndex, pending.callbackKeys)
       await cb.answer('OK')
       try { await cb.editMessage(cb.message?.text || 'Выбрано', REMOVE_KEYBOARD) } catch {}
@@ -523,7 +524,7 @@ export class Gateway {
           steer: true,
         }, undefined)
         chat.agent.followup(createUserMessage({
-          content,
+          content: ensureContentArray(content),
           source: { kind: 'plugin', plugin: PLUGIN, form: 'steer' },
         }))
         chat.lastUsed = Date.now()
@@ -533,6 +534,7 @@ export class Gateway {
 
       // Mark busy BEFORE yielding to the poll loop, otherwise steer/stop never see an active turn.
       chat.turnActive = true
+      try { chat.abort?.abort?.() } catch {}
       chat.abort = new AbortController()
       const run = chat.busy.then(() => this.runTurn(chat, turnInput, chat.abort.signal))
       chat.busy = run.catch(() => {})
@@ -565,30 +567,37 @@ export class Gateway {
     if (cmd === '/start') return reply('Шлюз подключён. Пишите сообщение агенту. /help — команды.', { replyMarkup: REMOVE_REPLY_KEYBOARD })
     if (cmd === '/help') {
       return reply([
-        'Команды:',
-        '/help — справка',
-        '/new — новая сессия',
-        '/whoami — ваш id',
-        '/stop — прервать текущий ответ',
-        '/status — статус шлюза',
-        '/model — текущая модель; /model provider model — сменить',
-        '/role [name] — персоны и роли агента (/role list)',
-        '/skills / /tools — список инструментов и навыков',
-        '/fork — ответвление текущей сессии',
-        '/export — выгрузка истории диалога в Markdown',
-        '/rewind [N] — откат последних N сообщений',
-        '/files [dir] — менеджер файлов в рабочей папке агента',
-        '/get <path> — скачать файл из рабочей папки в Telegram',
-        '/pair CODE — одобрить пользователя',
-        '/sethome [name] — этот чат = home (имя опционально)',
-        '/home — список home',
-        '/setalert — назначить этот чат каналом алертов',
-        '/alert [test] — статус канала алертов и тест',
-        '/remind <время> <текст> — напоминание (/remind 10m текст, /remind list)',
-        '/voice on|off|status — голосовые ответы',
-        '/tts on|off|status — озвучка в этом чате',
-        '/mute / /unmute — заглушить уведомления в этот чат',
-        '/keyboard on|off — быстрая клавиатура',
+        '📖 <b>Команды бота:</b>',
+        '',
+        '💬 <b>Диалог:</b>',
+        '• /help — эта справка',
+        '• /new — новая сессия',
+        '• /stop — прервать текущий ответ',
+        '• /model — интерактивный выбор модели (/model list)',
+        '• /role [name] — персоны и роли агента (/role list)',
+        '• /rewind [N] — откат последних N ходов',
+        '• /fork — форк сессии в новую ветку',
+        '• /export — выгрузка истории в Markdown',
+        '',
+        '🛠️ <b>Инструменты и файлы:</b>',
+        '• /skills / /tools — список активных инструментов',
+        '• /files [dir] — проводник рабочей папки',
+        '• /get <path> — скачать файл в Telegram',
+        '• /remind <время> <текст> — напоминание (/remind 10m текст)',
+        '',
+        '⚙️ <b>Настройки:</b>',
+        '• /status — статус шлюза и модели',
+        '• /top — системные ресурсы (RAM, uptime)',
+        '• /keyboard on|off — быстрые кнопки',
+        '• /voice on|off|status — голосовые ответы',
+        '• /tts on|off|status — озвучка в этом чате',
+        '• /mute / /unmute — заглушить уведомления в этот чат',
+        '',
+        '🔒 <b>Доступ и каналы:</b>',
+        '• /whoami — ваш Telegram id',
+        '• /pair CODE — одобрить код сопряжения',
+        '• /sethome [name] — привязать домашний чат',
+        '• /setalert — назначить канал алертов',
       ].join('\n'))
     }
     if (cmd === '/role' || cmd === '/persona') {
@@ -619,9 +628,9 @@ export class Gateway {
       return reply(`🎭 Роль изменена на: ${persona.icon} <b>${persona.name}</b>\n${persona.description}`)
     }
     if (cmd === '/skills' || cmd === '/tools') {
-      const toolsList = []
-      if (this.ctx.tools?.tools) {
-        for (const [name, t] of this.ctx.tools.tools.entries()) {
+      const tools = this.ctx.get?.('tools') || this.ctx.tools
+      if (tools?.tools) {
+        for (const [name, t] of tools.tools.entries()) {
           toolsList.push(`• <b>${name}</b>: ${t.description || '(нет описания)'}`)
         }
       }
@@ -649,7 +658,6 @@ export class Gateway {
           mime: 'text/markdown',
           kind: 'document',
           bytes: buffer,
-          dataBase64: buffer.toString('base64'),
         }
         return reply({ text: `📄 Экспорт диалога (${messagesCount} сообщений):`, files: [file] })
       } catch (err) {
@@ -666,7 +674,8 @@ export class Gateway {
       if (!res.removed) {
         return reply('В истории сессии нет сообщений для отката.')
       }
-      try { await this.ctx.sessions?.flush(chat.agent.session) } catch {}
+      const sessions = this.ctx.get?.('sessions') || this.ctx.sessions
+      try { await sessions?.flush(chat.agent.session) } catch {}
       return reply(`⏪ Откачено сообщений: ${res.removed}. Осталось в контексте: ${res.remaining}.`)
     }
     if (cmd === '/fork') {
@@ -676,11 +685,14 @@ export class Gateway {
       }
       try {
         const oldSession = chat.agent.session
-        const oldMessages = Array.isArray(oldSession.messages) ? [...oldSession.messages] : []
+        const oldMessages = Array.isArray(oldSession.messages)
+          ? oldSession.messages.map(m => ({ ...m, content: ensureContentArray(m.content) }))
+          : []
         const newChat = await this.createChat(key, input)
         if (newChat.agent?.session && oldMessages.length) {
           newChat.agent.session.messages = oldMessages
-          try { await this.ctx.sessions?.flush(newChat.agent.session) } catch {}
+          const sessions = this.ctx.get?.('sessions') || this.ctx.sessions
+          try { await sessions?.flush(newChat.agent.session) } catch {}
         }
         this.chats.set(key, newChat)
         return reply(`🔀 Создан форк сессии!\nСтарая сессия: ${oldSession.id}\nНовая активная сессия: ${newChat.agent.session.id}\nКонтекст сохранён (${oldMessages.length} сообщений).`)
@@ -1068,7 +1080,8 @@ export class Gateway {
     const agentCfg = this.config.agent || {}
     const cwd = agentCfg.cwd || process.cwd()
     const self = this
-    const handle = await this.ctx.agents.create({
+    const agents = this.ctx.get?.('agents') || this.ctx.agents
+    const handle = await agents.create({
       sessionId: SessionId(`msgw-${randomUUID()}`),
       meta: { cwd },
       agentOptions: { provider, model },
@@ -1218,7 +1231,7 @@ export class Gateway {
 
       const content = await this.buildUserContent(input, signal)
       chat.agent.followup(createUserMessage({
-        content,
+        content: ensureContentArray(content),
         source: { kind: 'plugin', plugin: PLUGIN, form: 'relay' },
       }))
       const turnTimeoutMs = Number(this.config.agent?.turnTimeoutMs) || 600_000
@@ -1230,7 +1243,8 @@ export class Gateway {
         else return reply('Прервано.')
         return
       }
-      await this.ctx.sessions.flush(chat.agent.session)
+      const sessions = this.ctx.get?.('sessions') || this.ctx.sessions
+      await sessions?.flush?.(chat.agent.session)
       if (progress) try { await progress.remove() } catch {}
       progress = null
       if (typeof react === 'function') react('').catch?.(() => {})
@@ -1318,8 +1332,8 @@ export class Gateway {
   }
 
   reapIdle() {
-    const timeout = Number(this.config.agent?.idleTimeoutMs) || 0
-    if (timeout <= 0) return
+    const rawTimeout = Number(this.config.agent?.idleTimeoutMs)
+    const timeout = Number.isFinite(rawTimeout) && rawTimeout > 0 ? rawTimeout : 86_400_000
     const now = Date.now()
     for (const [key, chat] of this.chats) {
       if (!chat.turnActive && now - chat.lastUsed > timeout) {
@@ -1347,6 +1361,26 @@ export class Gateway {
     return this.pairing.rejectCode(code)
   }
 
+  async probeTelegram(timeoutMs = 10000) {
+    const adapter = this.getAdapter('telegram')
+    if (!adapter) {
+      return { ok: false, error: 'Telegram adapter not initialized' }
+    }
+    if (typeof adapter.probeHealth === 'function') {
+      return adapter.probeHealth(timeoutMs)
+    }
+    return { ok: false, error: 'probeHealth not implemented on adapter' }
+  }
+
+  getBotInfo() {
+    const adapter = this.getAdapter('telegram')
+    return {
+      botId: adapter?.botId || 0,
+      botUsername: adapter?.botUsername || '',
+      pollingConflict: Boolean(adapter?.pollingConflict),
+    }
+  }
+
   async messengerAskFromAgent(agent, payload, timeoutMs) {
     const sessionId = String(agent?.session?.id || '')
     const key = this.sessionToChat.get(sessionId)
@@ -1366,6 +1400,8 @@ export class Gateway {
       send: (target, payload) => this.messengerSend(target, payload),
       ask: (target, payload, timeoutMs) => this.messengerAsk(target, payload, timeoutMs),
       progress: (target, payload) => this.messengerProgress(target, payload),
+      probeTelegram: (timeoutMs) => this.probeTelegram(timeoutMs),
+      getBotInfo: () => this.getBotInfo(),
     }
   }
 }

package/lib/index.js

@@ -78,7 +78,7 @@ function publicConfig(cfg) {
 }
 
 function registerMessengerRoute(ctx, getGw, path, action) {
-  ctx.effect(() => ctx.webServer.register({
+  ctx.effect(() => (ctx.get?.('webServer') || ctx.webServer).register({
     kind: 'exact', path,
     handler: async (req, res) => {
       if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
@@ -112,6 +112,7 @@ export function apply(ctx, config) {
   let source = () => entry
   let settingsApi
   const turnStarts = new Map()
+  const getWebServer = () => ctx.get?.('webServer') || ctx.webServer
 
   const sync = () => {
     if (gateway) { gateway.stop(); gateway = undefined }
@@ -154,8 +155,9 @@ export function apply(ctx, config) {
     gateway.start().catch((err) => ctx.logger?.warn?.(`dsh-messenger-gateway: ${err.message}`))
   }
 
-  if (ctx.settings?.register) {
-    settingsApi = ctx.settings.register(SETTINGS_NAMESPACE, Config, { base: config || {} })
+  const settings = ctx.get?.('settings') || ctx.settings
+  if (settings?.register) {
+    settingsApi = settings.register(SETTINGS_NAMESPACE, Config, { base: config || {} })
     source = () => resolveConfig(settingsApi.get() ?? config ?? {})
     ctx.effect(() => settingsApi.watch(sync), 'dsh-messenger-gateway: settings')
   }
@@ -165,8 +167,9 @@ export function apply(ctx, config) {
   ctx.effect(() => ctx.provide('messenger', createMessengerService(getGw)), 'dsh-messenger-gateway: messenger service')
 
   // Agent tool: inline buttons in the telegram chat bound to this msgw session
-  if (ctx.tools?.register) {
-    ctx.effect(() => ctx.tools.register(defineTool({
+  const tools = ctx.get?.('tools') || ctx.tools
+  if (tools?.register) {
+    ctx.effect(() => tools.register(defineTool({
       name: 'messenger_ask',
       description:
         'Ask the Telegram user a single or multiple-choice question with inline buttons/checkboxes and wait for their choice. '
@@ -267,11 +270,13 @@ export function apply(ctx, config) {
       .catch((e) => ctx.logger?.warn?.(`notify bridge: ${e.message}`))
   }), 'dsh-messenger-gateway: notify bridge')
 
-  ctx.effect(() => ctx.webServer.register({
+  ctx.effect(() => getWebServer().register({
     kind: 'exact', path: '/dsh-messenger-gateway/status',
     handler: async (req, res) => {
       if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' })
       const gw = getGw()
+      const botInfo = gw?.getBotInfo?.() || {}
+      const uptimeSec = gw?.stats?.startedAt ? Math.max(0, Math.round((Date.now() - gw.stats.startedAt) / 1000)) : 0
       writeJson(res, 200, {
         ok: true,
         running: Boolean(gw),
@@ -279,15 +284,44 @@ export function apply(ctx, config) {
         activeChats: gw?.messenger.activeChats() || 0,
         ttsEnabled: Boolean(source().tts?.enabled),
         messengerService: 'messenger',
-        home: gateway?.messenger.home?.() || null,
-        homes: gateway?.messenger.homes?.() || [],
+        home: gw?.messenger.home?.() || null,
+        homes: gw?.messenger.homes?.() || [],
         pairingPending: gw?.messenger.pairingPending?.()?.length || 0,
+        botId: botInfo.botId || 0,
+        botUsername: botInfo.botUsername || '',
+        pollingConflict: Boolean(botInfo.pollingConflict),
+        uptimeSec,
+        stats: {
+          sent: gw?.stats?.sent || 0,
+          errors: gw?.stats?.errors || 0,
+          startedAt: gw?.stats?.startedAt || 0,
+        },
         config: publicConfig(source()),
       })
     },
   }), 'dsh-messenger-gateway: status')
 
-  ctx.effect(() => ctx.webServer.register({
+  ctx.effect(() => getWebServer().register({
+    kind: 'exact', path: '/dsh-messenger-gateway/smoke',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
+      if (!isTrustedSettingsRequest(req)) return writeJson(res, 403, { ok: false, error: 'forbidden' })
+      const gw = getGw()
+      if (!gw) return writeJson(res, 503, { ok: false, error: 'gateway not running' })
+      let payload = {}
+      try {
+        const raw = (await readBody(req)).toString('utf8').trim()
+        if (raw) payload = JSON.parse(raw)
+      } catch {
+        return writeJson(res, 400, { ok: false, error: 'invalid json' })
+      }
+      const timeoutMs = Number(payload.timeoutMs) || 10000
+      const result = await gw.probeTelegram(timeoutMs)
+      writeJson(res, result.ok ? 200 : 502, result)
+    },
+  }), 'dsh-messenger-gateway: smoke test')
+
+  ctx.effect(() => getWebServer().register({
     kind: 'exact', path: '/dsh-messenger-gateway/messenger',
     handler: async (req, res) => {
       if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' })
@@ -295,7 +329,7 @@ export function apply(ctx, config) {
     },
   }), 'dsh-messenger-gateway: messenger schema')
 
-  ctx.effect(() => ctx.webServer.register({
+  ctx.effect(() => getWebServer().register({
     kind: 'exact', path: '/dsh-messenger-gateway/events',
     handler: async (req, res) => {
       if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
@@ -334,7 +368,7 @@ export function apply(ctx, config) {
     },
   }), 'dsh-messenger-gateway: webhook events')
 
-  ctx.effect(() => ctx.webServer.register({
+  ctx.effect(() => getWebServer().register({
     kind: 'exact', path: '/dsh-messenger-gateway/config',
     handler: async (req, res) => {
       if (req.method === 'GET') return writeJson(res, 200, { ok: true, config: publicConfig(source()) })
@@ -370,7 +404,7 @@ export function apply(ctx, config) {
     },
   }), 'dsh-messenger-gateway: config')
 
-  ctx.effect(() => ctx.webServer.register({
+  ctx.effect(() => getWebServer().register({
     kind: 'exact', path: '/dsh-messenger-gateway/pairing',
     handler: async (req, res) => {
       if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' })
@@ -385,7 +419,7 @@ export function apply(ctx, config) {
     },
   }), 'dsh-messenger-gateway: pairing list')
 
-  ctx.effect(() => ctx.webServer.register({
+  ctx.effect(() => getWebServer().register({
     kind: 'exact', path: '/dsh-messenger-gateway/pairing/approve',
     handler: async (req, res) => {
       if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
@@ -399,7 +433,7 @@ export function apply(ctx, config) {
     },
   }), 'dsh-messenger-gateway: pairing approve')
 
-  ctx.effect(() => ctx.webServer.register({
+  ctx.effect(() => getWebServer().register({
     kind: 'exact', path: '/dsh-messenger-gateway/pairing/reject',
     handler: async (req, res) => {
       if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
@@ -418,7 +452,7 @@ export function apply(ctx, config) {
     return p || '/dsh-messenger-gateway/telegram/webhook'
   }
 
-  ctx.effect(() => ctx.webServer.register({
+  ctx.effect(() => getWebServer().register({
     kind: 'exact', path: webhookPath(),
     handler: async (req, res) => {
       if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })

package/lib/models.js

@@ -7,14 +7,15 @@ export async function listModelCatalog(ctx, fallback = {}) {
   }
 
   // 1. Try ctx.llm if available
-  if (ctx?.llm?.listProviders) {
+  const llm = ctx?.get?.('llm') || ctx?.llm
+  if (llm?.listProviders) {
     try {
-      const providers = await ctx.llm.listProviders()
+      const providers = await llm.listProviders()
       for (const p of providers || []) {
         const pId = p.id || p
         result.providers.push({ id: pId, name: p.name || pId })
         try {
-          const models = await ctx.llm.listModels(pId)
+          const models = await llm.listModels(pId)
           result.modelsByProvider.set(
             pId,
             (models || []).map((m) => ({ id: m.id || m, name: m.name || m.id || m }))

package/lib/outbound.js

@@ -62,7 +62,8 @@ export function fileNameForRef(ref) {
 }
 
 export async function readAttachmentBytes(ctx, ref) {
-  const stored = await ctx.attachments.readImage(ref)
+  const attachments = ctx.get?.('attachments') || ctx.attachments
+  const stored = await attachments.readImage(ref)
   return {
     bytes: stored.data,
     mime: ref.mediaType || stored.ref?.mediaType || 'image/png',

package/lib/pairing.js

@@ -1,5 +1,5 @@
-import { randomBytes } from 'node:crypto'
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { randomBytes, randomUUID } from 'node:crypto'
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, unlinkSync } from 'node:fs'
 import { dirname } from 'node:path'
 
 const ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'
@@ -11,6 +11,19 @@ export function generatePairingCode(length = 8) {
   return out
 }
 
+function writeJsonAtomicSync(filePath, data) {
+  const dir = dirname(filePath)
+  mkdirSync(dir, { recursive: true })
+  const tmpPath = `${filePath}.${randomUUID().slice(0, 8)}.tmp`
+  try {
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf8')
+    renameSync(tmpPath, filePath)
+  } catch (err) {
+    try { unlinkSync(tmpPath) } catch {}
+    throw err
+  }
+}
+
 export function createPairingStore(filePath) {
   const state = { pending: {}, /** @type {number[]} */ approved: [] }
   if (filePath && existsSync(filePath)) {
@@ -22,8 +35,9 @@ export function createPairingStore(filePath) {
   }
   const persist = () => {
     if (!filePath) return
-    mkdirSync(dirname(filePath), { recursive: true })
-    writeFileSync(filePath, JSON.stringify({ approved: state.approved, pending: state.pending }, null, 2))
+    try {
+      writeJsonAtomicSync(filePath, { approved: state.approved, pending: state.pending })
+    } catch {}
   }
   const prune = () => {
     const now = Date.now()
@@ -107,4 +121,4 @@ export function createPairingStore(filePath) {
       return { ok: true, userId: row.userId, username: row.username }
     },
   }
-}
+}

package/lib/photos.js

@@ -12,7 +12,8 @@ export async function attachInboundPhoto(ctx, att, opts = {}) {
   if (maxBytes > 0 && bytes.length > maxBytes) {
     throw new Error(`image too large (${bytes.length} bytes, max ${maxBytes})`)
   }
-  const ref = await ctx.attachments.saveImage({
+  const attachments = ctx.get?.('attachments') || ctx.attachments
+  const ref = await attachments.saveImage({
     data: bytes,
     mediaType: att.mime || 'image/jpeg',
     ...(att.name ? { name: att.name } : {}),

package/lib/scheduler.js

@@ -1,6 +1,6 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises'
-import { dirname } from 'node:path'
+import { readFile } from 'node:fs/promises'
 import { randomUUID } from 'node:crypto'
+import { writeJsonAtomic } from './storage-atomic.js'
 
 export function parseRelativeTime(input) {
   if (!input) return null
@@ -49,6 +49,7 @@ export function createScheduler(filePath, onDue) {
   const RETENTION_MS = 7 * 86400 * 1000
 
   async function save() {
+    if (!filePath) return
     try {
       const now = Date.now()
       tasks = tasks.filter((t) => {
@@ -56,8 +57,7 @@ export function createScheduler(filePath, onDue) {
         const finishTime = t.firedAt || t.createdAt || 0
         return (now - finishTime) < RETENTION_MS
       })
-      await mkdir(dirname(filePath), { recursive: true })
-      await writeFile(filePath, JSON.stringify(tasks, null, 2), 'utf8')
+      await writeJsonAtomic(filePath, tasks)
     } catch {}
   }
 
@@ -140,4 +140,4 @@ export function createScheduler(filePath, onDue) {
     checkDue,
     getTasks: () => tasks,
   }
-}
+}

package/lib/session-ops.js

@@ -87,9 +87,19 @@ export function rewindSession(session, turnsCount = 1) {
     }
   }
 
-  const removed = messages.splice(messages.length - toRemove, toRemove)
+  const keepCount = Math.max(0, messages.length - toRemove)
+  const kept = messages.slice(0, keepCount).map(m => {
+    // Only wrap non-string invalid/nullish/object content to array
+    if (m && m.content && typeof m.content === 'object' && !Array.isArray(m.content) && m.content.type) {
+      return { ...m, content: [m.content] }
+    }
+    return m
+  })
+  const removedCount = messages.length - keepCount
+  session.messages = kept
+
   return {
-    removed: removed.length,
-    remaining: messages.length,
+    removed: removedCount,
+    remaining: session.messages.length,
   }
-}
+}

package/lib/storage-atomic.js

@@ -0,0 +1,21 @@
+import { writeFile, rename, mkdir, unlink } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import { randomUUID } from 'node:crypto'
+
+/**
+ * Write JSON atomically via temporary file and rename.
+ * Guarantees that readers never observe partially written files.
+ */
+export async function writeJsonAtomic(filePath, data) {
+  const dir = dirname(filePath)
+  await mkdir(dir, { recursive: true })
+  const tmpPath = `${filePath}.${randomUUID().slice(0, 8)}.tmp`
+  const serialized = JSON.stringify(data, null, 2)
+  try {
+    await writeFile(tmpPath, serialized, 'utf8')
+    await rename(tmpPath, filePath)
+  } catch (err) {
+    await unlink(tmpPath).catch(() => {})
+    throw err
+  }
+}

package/lib/stream.js

@@ -24,22 +24,48 @@ export function buildStreamPreview(streamText, toolName, maxLen = 3500) {
   return combined.slice(0, maxLen - 1) + '…'
 }
 
+export function parseRetryAfter(err) {
+  if (!err) return 0
+  const msg = err.message || String(err)
+  const match = /retry after (\d+)/i.exec(msg)
+  if (match) return parseInt(match[1], 10) * 1000
+  return 0
+}
+
 export function createEditScheduler(editFn, intervalMs = 1200) {
   let pending = null
   let timer = null
   let lastSent = ''
   let inFlight = Promise.resolve()
+  let retryDelayMs = 0
+
   const flush = () => {
     timer = null
     if (pending === null || pending === lastSent) return
     const text = pending
     inFlight = inFlight.then(async () => {
       try {
+        if (retryDelayMs > 0) {
+          const delay = retryDelayMs
+          retryDelayMs = 0
+          await new Promise((r) => setTimeout(r, delay))
+        }
         await editFn(text)
         lastSent = text
-      } catch {}
+      } catch (err) {
+        const retry = parseRetryAfter(err)
+        if (retry > 0) {
+          retryDelayMs = retry
+          // Re-schedule flush with retry delay
+          if (!timer) {
+            timer = setTimeout(flush, retry + 100)
+            timer.unref?.()
+          }
+        }
+      }
     })
   }
+
   return {
     push(text) {
       pending = text
@@ -51,6 +77,17 @@ export function createEditScheduler(editFn, intervalMs = 1200) {
       if (timer) { clearTimeout(timer); timer = null }
       flush()
       await inFlight
+      // If there's still a pending difference (e.g. rate limit delay happened), wait and retry
+      if (pending !== null && pending !== lastSent) {
+        if (retryDelayMs > 0) {
+          await new Promise((r) => setTimeout(r, retryDelayMs + 50))
+          retryDelayMs = 0
+        }
+        try {
+          await editFn(pending)
+          lastSent = pending
+        } catch {}
+      }
     },
   }
 }
@@ -61,4 +98,4 @@ export function startTypingHeartbeat(typingFn, intervalMs = 4000) {
   const timer = setInterval(() => { typingFn().catch?.(() => {}) }, intervalMs)
   timer.unref?.()
   return () => clearInterval(timer)
-}
+}