sintbot 1.4.11 → 1.4.13

package/src/c2console.js

@@ -8,7 +8,7 @@ const { createDurableConsoleSay } = require('./consolesay')
 
 // A host facade over existing v2 authorities, not a second execution engine.
 // The allowlist applies after the existing console's authentication boundary.
-const READ_PATHS = ['/api/state', '/api/events', '/api/inbox', '/api/activity',
+const READ_PATHS = ['/api/state', '/api/events', '/api/inbox', '/api/activity', '/api/activity/detail',
   '/api/changelog', '/api/changelog-en', '/api/codex/models', '/api/usage',
   '/api/plugins', '/api/design/styles', '/api/design/icons', '/api/fs/listdir',
   '/api/feishu/admin-candidates', '/api/feishu/org-users', '/api/feishu/resolve-contact',
@@ -30,7 +30,7 @@ const WRITE_PATHS = ['/api/login', '/api/logout', '/api/logout/all',
   // one-off agent run); it does not take a group concurrency slot.
   '/api/test',
   '/api/inbox/dismiss', '/api/issues/status',
-  // Console injection, first version: an idle group only, the line shown in
+  // Console injection through the ordinary busy-followup ingress, the line shown in
   // the group and the reply delivered there. The posted line is the platform
   // message that drives the turn (see consolesay.createDurableConsoleSay).
   '/api/groups/say',
@@ -38,13 +38,16 @@ const WRITE_PATHS = ['/api/login', '/api/logout', '/api/logout/all',
   // manages this exact entry (the updater refuses every other run mode).
   '/api/update/check', '/api/update/start', '/api/update/ignore']
 const SUPPORTED_RUNNERS = ['claude', 'codex']
+const { modelContext } = require('./modelcontext')
+const { GROUP_COMMANDS } = require('./runtimefacts')
 
-function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld = () => new Map(),
+function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld = () => new Map(), activity = null, store = null,
   assertWriterLock, validateConfig, applyConfig, beforeWrite = () => true,
   appliedResets = () => [], now = Date.now,
   // Console injection reaches a group only through the service's own ingress
   // and that group's real platform adapter. Without them it is refused.
   getPlatform = null, routeMessage = null, isServing = () => false, isFrozen = () => false,
+  acquireCapacity = null,
   log = () => {} } = {}) {
   for (const callback of [getBindings, getCapacity, getConfig, getHeld, assertWriterLock,
     validateConfig, applyConfig, beforeWrite, appliedResets, now, isServing, isFrozen, log]) {
@@ -58,9 +61,12 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     throw new TypeError('C2 console configuration hooks must be synchronous')
   }
   const startedAt = now()
+  const trials = require('./consoletrials').createConsoleTrials({ getCapacity, acquireCapacity,
+    assertWriterLock, isServing, isFrozen })
   const capabilities = Object.freeze({ mode: 'durable-v2',
+    groupCommands: GROUP_COMMANDS,
     reason: '此操作尚未接入当前版本的持久处理流程，未执行。',
-    summary: '实时状态、认证管理、停止任务、空闲群开新会话、空闲群的控制台插话、绑定新群、空闲群的模型切换（Codex / Claude Code）和项目目录修改、模型的添加与设置，以及后台运行时的软件升级已接入；该群有任务或未结记录时不能修改，也不能开新会话或插话；改模型的型号、后端或端点时，用它的群须空闲，并会开始新的一段对话。插话会把这句话（标着「管理员」）和回复都发进群，群忙时不排队、也不加入当前任务；静默插话和不回复的插话暂不支持。解除绑定、移除模型、定时任务和画布暂不可用。',
+    summary: '实时状态、认证管理、停止任务、空闲群开新会话、支持忙时跟进的控制台插话、绑定新群、空闲群的模型切换（Codex / Claude Code）和项目目录修改、模型的添加与设置，以及后台运行时的软件升级已接入；该群有任务或未结记录时不能修改，也不能开新会话；改模型的型号、后端或端点时，用它的群须空闲，并会开始新的一段对话。插话会把这句话（标着「管理员」）和回复都发进群，群忙时按该群的忙时跟进设置尝试加入当前任务，关闭或暂不支持时排队；确认模型读取后才显示已加入；静默插话和不回复的插话暂不支持。解除绑定、移除模型、定时任务和画布暂不可用。',
     allowed: { GET: READ_PATHS, POST: WRITE_PATHS } })
   function held() {
     if (assertWriterLock() !== true) throw new Error('服务写入权限已失效，操作未执行')
@@ -76,7 +82,7 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
   // flight keeps the current session.
   function groupBusy(chatId, binding) {
     const rt = binding.engine?.rts?.get(chatId)
-    const snapshot = binding.journal?.snapshot()
+    const snapshot = binding.journal?.consoleSnapshot?.() || binding.journal?.snapshot()
     return !!(rt?.v2NormalRouteActive || rt?.v2AdmissionPending || rt?.v2Controller ||
       rt?.v2QueueReceiptIds?.length || snapshot?.receipts?.pending?.length ||
       snapshot?.state?.lanes?.queue?.[chatId]?.queue?.length ||
@@ -97,7 +103,7 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     binding.engine.store.resetSessionAndStats(chatId)
     return true
   }
-  // Console injection, first version: an open, idle group only. Checked
+  // Console injection: an open group, idle or running. Checked
   // before the line is posted, so a refused group shows nothing, and again
   // right after; the service ingress remains the final authority.
   function sayGate(chatId) {
@@ -110,8 +116,13 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     const binding = bindings().get(chatId)
     if (!binding || binding.runtime?.closed === true) return 'not-serving'
     const rt = binding.engine?.rts?.get(chatId)
-    if (groupBusy(chatId, binding) || rt?.v2RunningJobs || rt?.v2StopControl || rt?.v2SkipWaiter ||
-        binding.journal?.snapshot()?.state?.lanes?.stopIntent?.[chatId]) return 'busy'
+    const snapshot = binding.journal?.consoleSnapshot?.() || binding.journal?.snapshot()
+    if (rt?.v2StopControl || rt?.v2SkipWaiter || snapshot?.state?.lanes?.stopIntent?.[chatId]) return 'busy'
+    // A normal active turn may accept ordinary messages. Unowned pending work
+    // still refuses; it must not become a new execution path or bypass recovery.
+    if (!rt?.v2NormalRouteActive && !rt?.v2AdmissionPending && (groupBusy(chatId, binding) || rt?.v2RunningJobs)) return 'busy'
+    const queued = snapshot?.state?.lanes?.queue?.[chatId]?.queue?.length || 0
+    if (queued >= (rt?.v2AdmissionPending ? 3 : 2)) return 'queue-full'
     return null
   }
   function receiptState(chatId, receiptId) {
@@ -120,9 +131,22 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     if (receipts?.completed?.some(item => item.id === receiptId)) return 'completed'
     return null
   }
+  function locateSay(chatId, receiptId) {
+    const binding = bindings().get(chatId)
+    const rt = binding?.engine?.rts?.get(chatId)
+    const state = receiptState(chatId, receiptId)
+    if (state === 'completed') return { state: 'done' }
+    const steer = rt?.v2SteerEntries?.get(receiptId)
+    if (steer) return { state: steer.accepted && steer.landed ? 'joined' : 'following' }
+    const queue = (binding?.journal?.consoleSnapshot?.() || binding?.journal?.snapshot())?.state?.lanes?.queue?.[chatId]?.queue || []
+    const index = queue.findIndex(item => item.id === `receipt:job:${receiptId}`)
+    if (index >= 0) return { state: 'queued', ahead: index, join: false }
+    if (rt?.v2RunningJobs?.some(job => job.msg?._c2ReceiptId === receiptId)) return { state: 'started' }
+    return { state: 'accepted' }
+  }
   const say = getPlatform ? createDurableConsoleSay({ getPlatform,
     getGroup: chatId => getConfig().groups?.[chatId] || null,
-    gate: sayGate, route: routeMessage, receiptState, log, now }) : null
+    gate: sayGate, route: routeMessage, receiptState, locate: locateSay, log, now }) : null
   function getLiveState() {
     const cfg = getConfig()
     const capacity = getCapacity()
@@ -133,11 +157,13 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
       const binding = bindings().get(chatId)
       const hold = heldGroups.get(chatId)
       const rt = binding?.engine?.rts.get(chatId)
-      const snapshot = binding?.journal?.snapshot()
+      const snapshot = binding?.journal?.consoleSnapshot?.() || binding?.journal?.snapshot()
       const pending = snapshot?.receipts?.pending || []
       const queued = snapshot?.state?.lanes?.queue?.[chatId]?.queue?.length || 0
       queue += queued
       groups[chatId] = {
+        context: activity?.context(chatId, (binding?.engine?.store || store)?.getSession(chatId),
+          !!rt?.v2NormalRouteActive, rt?.v2RunnerGeneration) || null,
         busy: !!rt?.v2NormalRouteActive,
         finalizing: !!rt?.v2TerminalStarted,
         followups: !!rt?.v2SteerControl && !rt?.v2SteerClosing && !rt?.v2TerminalStarted,
@@ -145,7 +171,7 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
         queueFaulted: !group.paused && (!binding || (!rt?.v2NormalRouteActive && !!binding.gate?.blocked)),
         waitingForCapacity: !!rt?.v2AdmissionPending,
         sinceMs: rt?.v2StartedAt ? Math.max(0, now() - rt.v2StartedAt) : 0,
-        sessionId: binding?.engine?.store?.getSession(chatId) || '',
+        sessionId: (binding?.engine?.store || store)?.getSession(chatId) || '',
         // Why a console injection would be refused right now (null = accepted).
         sayBlocked: say ? sayGate(chatId) : 'not-serving',
         // A held group needs the operator: its last result is unknown.
@@ -163,29 +189,56 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
   function getActivity() {
     const cfg = getConfig(), items = []
     for (const [chatId, binding] of bindings()) {
-      const snap = binding.journal.snapshot()
+      const snap = binding.journal.consoleSnapshot?.() || binding.journal.snapshot()
       const rt = binding.engine.rts.get(chatId)
       const group = cfg.groups[chatId]?.name || chatId.slice(-8)
       for (const receipt of snap.receipts.pending) {
+        if (activity?.has(chatId, receipt.id)) continue
         const running = rt?.v2RunningJobs?.some(job => job.msg?._c2ReceiptId === receipt.id)
         items.push({ id: receipt.id, chatId, group, ts: receipt.acceptedAt,
           kind: running ? 'start' : 'done', status: running ? 'running' : '等待处理',
           text: running ? '正在处理群消息' : '消息已登记，等待处理', sender: '' })
       }
       for (const receipt of snap.receipts.completed.slice(-30)) {
+        if (activity?.has(chatId, receipt.id)) continue
         // A settled receipt alone does not prove successful answer delivery.
         items.push({ id: receipt.id, chatId, group, ts: receipt.settledAt,
           kind: 'done', status: '已结账', text: '消息处理记录已结账', sender: '' })
       }
     }
-    return items.sort((a, b) => b.ts - a.ts).slice(0, 30)
+    const recent = activity?.list({ limit: 100 }).activity || []
+    return [...recent, ...items].filter(item => cfg.groups[item.chatId])
+      .sort((a, b) => Number(a.kind !== 'start') - Number(b.kind !== 'start') || b.ts - a.ts).slice(0, 100)
+  }
+  function activityPage(query = {}) {
+    const cfg = getConfig(), live = getLiveState()
+    const meta = activity?.list({ limit: 1 }) || { epoch: 'receipts', revision: 0 }
+    const groups = Object.entries(cfg.groups || {}).map(([chatId, group]) => {
+      const binding = bindings().get(chatId), groupStore = binding?.engine?.store || store
+      const providerName = groupStore?.getProvider?.(chatId) || group.provider || cfg.defaultProvider
+      const provider = cfg.providers?.[providerName] || {}
+      const stats = groupStore?.getSessionStats?.(chatId), session = groupStore?.getSession?.(chatId)
+      const context = live.groups[chatId].context || (session && stats?.sessionId === session && Number.isFinite(stats.ctx)
+        ? { usedTokens: stats.ctx, windowTokens: null, measuredAt: null, quality: 'historical' } : null)
+      return { chatId, name: group.name || chatId.slice(-8), project: path.basename(group.workdir || '') || '—',
+        workdir: group.workdir || '', runner: provider.runner || 'claude',
+        ...modelContext(group, provider),
+        reasoningEffort: (provider.runner === 'codex' ? provider.reasoningEffort : provider.env?.CLAUDE_CODE_EFFORT_LEVEL) || '',
+        paused: !!group.paused, ...live.groups[chatId], context }
+    })
+    const rows = getActivity().filter(row => (!query.chatId || row.chatId === query.chatId) && (!query.status || row.status === query.status))
+    const offset = Math.max(0, Math.min(100, Number(query.offset) || 0)), limit = Math.max(1, Math.min(100, Number(query.limit) || 30))
+    return { epoch: meta.epoch, revision: meta.revision, storageError: !!meta.storageError, groups,
+      total: rows.length, activity: rows.slice(offset, offset + limit) }
   }
   return {
     capabilities,
+    beginTrial: controller => trials.begin(controller),
     allows: (method, pathname) => (capabilities.allowed[method] || []).includes(pathname),
     // A provider without a runner field is Claude Code, as everywhere else.
     providerSupported: provider => SUPPORTED_RUNNERS.includes(provider?.runner || 'claude'),
-    getLiveState, getActivity,
+    getLiveState, getActivity, activityPage,
+    activityDetail(chatId, id) { return getConfig().groups?.[chatId] ? activity?.detail(chatId, id) || null : null },
     validateConfig(raw) { held(); validateConfig(raw) },
     beforeWrite(raw) { held(); beforeWrite(raw) },
     applyConfig(raw) { held(); applyConfig(raw) },
@@ -193,6 +246,12 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     appliedResets: () => appliedResets(),
     decorateState(state) {
       state.runtimeCapabilities = capabilities
+      for (const group of state.groups || []) {
+        const cfg = getConfig(), source = cfg.groups?.[group.chatId] || {}
+        const provider = cfg.providers?.[group.effectiveProvider || source.provider || cfg.defaultProvider]
+        const model = modelContext(source, provider)
+        Object.assign(group, { configuredModel: model.model, modelSource: model.source, actualModel: model.actualModel })
+      }
       state.previews = (state.previews || []).filter(item => getConfig().groups?.[item.chatId])
       state.leftovers = { supported: false, rows: [], error: null }
     },
@@ -241,7 +300,18 @@ function createC2Console(options = {}) {
     inboxDismissPath: path.join(stateDir, 'inbox-dismissed.json'),
     verifyFile: path.join(stateDir, 'verify.json'),
   })
-  return { ...ui, facade }
+  let previous = null
+  const unsubscribe = options.activity?.subscribe(() => {
+    const page = facade.activityPage({ limit: 100 })
+    const before = new Map((previous?.activity || []).map(row => [row.chatId + ':' + row.id, JSON.stringify(row)]))
+    const current = new Set(page.activity.map(row => row.chatId + ':' + row.id))
+    const changed = page.activity.filter(row => before.get(row.chatId + ':' + row.id) !== JSON.stringify(row))
+    const groups = page.groups.filter(group => JSON.stringify(previous?.groups.find(g => g.chatId === group.chatId)) !== JSON.stringify(group))
+    ui.pushEvent('activity-update', { epoch: page.epoch, revision: page.revision, storageError: page.storageError,
+      activity: changed, groups, removed: [...before.keys()].filter(id => !current.has(id)) })
+    previous = page
+  })
+  return { ...ui, facade, close() { unsubscribe?.(); ui.close() } }
 }
 
 module.exports = { createC2Console, createC2ConsoleFacade }

package/src/c2updater.js

@@ -289,16 +289,24 @@ function createC2Updater({ currentVersion, runMode, stateFile, dataDir, configPa
     const blocked = gate()
     if (blocked.includes('held')) return fail('有暂停的群，升级已取消；先处理暂停的群')
     if (blocked.length) { schedule(); return status() }
-    const prefix = path.join(releasesRoot, job.to)
+    let prefix = job.installed ? job.prefix : path.join(releasesRoot, job.to)
     if (!job.installed) {
       setJob({ state: 'installing', prefix }, `正在安装 v${job.to}`)
       try {
+        let reusable = false
         if (fs.existsSync(prefix)) {
-          // A directory left by an earlier attempt or a manual install is reused
-          // only when it verifies as exactly this version.
-          await verifyInstall({ version: job.to, prefix })
-        } else {
+          // Never repair an existing tree in place: another process may still
+          // use it. A failed check leaves it intact as evidence.
+          try { await verifyInstall({ version: job.to, prefix }); reusable = true }
+          catch { /* retry in an independent installation directory */ }
+        }
+        if (!reusable) {
           fs.mkdirSync(releasesRoot, { recursive: true, mode: 0o700 })
+          // The directory becomes eligible for switching only after validation.
+          // Keeping its unique path also avoids overwriting a concurrently
+          // installed or running release when a download is retried.
+          prefix = fs.mkdtempSync(path.join(releasesRoot, `${job.to}-`))
+          setJob({ prefix })
           await installVersion({ version: job.to, prefix, registry: job.registry })
           await verifyInstall({ version: job.to, prefix })
         }

package/src/consolesay.js

@@ -86,7 +86,7 @@ function createConsoleSay({ getPlatform, getGroup, handle, locate, log = () => {
   }
 }
 
-// ── 持久处理流程(sintbot-v2)的插话,第 1 版:只接「空闲群 · 这句话进群 · 回复进群」 ──
+// ── 持久处理流程(sintbot-v2)的插话,这句话与回复进群，忙时沿用普通群消息的跟进/排队流程 ──
 //
 // 群里那行「【管理员】…」就是驱动这一轮的那条平台消息:它的 om_ 消息 id 就是这笔任务的来源身份
 // (source 'message'),与群成员自己发的一条消息同形 —— 收据、回复锚点、/stop、重启后的中断告知
@@ -97,7 +97,6 @@ function createConsoleSay({ getPlatform, getGroup, handle, locate, log = () => {
 // 第 1 版不做的,都在发群消息**之前**就拒,群里不留痕:
 //   · 静默插话(这句不进群):没有平台消息可锚,需要另一种来源和重启告知路径;
 //   · 不回复的插话(quiet):持久路径还不接静默收据;
-//   · 群正忙:不排队、也不加入当前任务;
 //   · 斜杠命令:群命令不走插话(停止、开新会话在概览里有按钮)。
 //
 // requestId:控制台每次提交带的 32 位十六进制幂等键(经 syntheticSource 校验并折成键)。发出那行字
@@ -128,9 +127,10 @@ function refusalOf(value) {
 //   route(msg, platform)       服务的统一入口(routeMessage):暂停 / 待人工 / 收尾中 / 升级中都在那里把关
 //   receiptState(chatId, id)   该群日志里这笔收据:'pending' | 'completed' | null
 function createDurableConsoleSay({ getPlatform, getGroup, gate, route, receiptState,
+  locate = () => ({ state: 'accepted' }),
   log = () => {}, now = () => Date.now(), sendTimeoutMs = SEND_TIMEOUT_MS,
   confirmMs = CONFIRM_MS, pollMs = POLL_MS, maxRequests = MAX_REQUESTS } = {}) {
-  for (const hook of [getPlatform, getGroup, gate, route, receiptState, log, now]) {
+  for (const hook of [getPlatform, getGroup, gate, route, receiptState, locate, log, now]) {
     if (typeof hook !== 'function') throw new TypeError('durable console say needs explicit hooks')
   }
   const posted = new Map() // 请求键 → 群里那行字的消息 id(按插入顺序,超过上限丢最早的)
@@ -171,7 +171,7 @@ function createDurableConsoleSay({ getPlatform, getGroup, gate, route, receiptSt
         return { ok: false, reason: 'shown-failed' }
       }
       remember(key, shownId)
-      // 发这行字的这会儿群里可能刚开始了别的任务:此时不注入(第 1 版忙时不排队、不加入)
+      // 发送期间再次检查暂停、停止、维护及容量，正常忙时仍走统一入口
       const late = gate(chatId)
       if (late) return { ok: false, reason: late === 'busy' ? 'busy-after-post' : late }
     }
@@ -186,12 +186,12 @@ function createDurableConsoleSay({ getPlatform, getGroup, gate, route, receiptSt
     if (first.admitted || first.timeout) {
       // 这一轮在后台继续;它之后的成败由该群自己的持久路径收尾,这里只留日志
       settled.then(({ error }) => { if (error) log('say: ' + (error && error.message)) })
-      return first.admitted ? { ok: true, where: { state: 'started' } } : { ok: false, reason: 'unconfirmed' }
+      return first.admitted ? { ok: true, where: locate(chatId, receiptId) } : { ok: false, reason: 'unconfirmed' }
     }
     const { value, error } = first
     if (value && value.duplicate) return { ok: true, where: { state: 'duplicate' } }
     const state = receiptState(chatId, receiptId)
-    if (state) return { ok: true, where: { state: state === 'completed' ? 'done' : 'started' } }
+    if (state) return { ok: true, where: state === 'completed' ? { state: 'done' } : locate(chatId, receiptId) }
     if (error) {
       log('say: ' + (error && error.message))
       return { ok: false, reason: 'inject-failed' }

package/src/consoletrials.js

@@ -0,0 +1,43 @@
+'use strict'
+
+// One bounded console trial, sharing the real model capacity. A timeout or
+// lease loss asks the runner to stop; only its close proof releases capacity.
+function createConsoleTrials({ getCapacity, acquireCapacity, assertWriterLock, isServing, isFrozen }) {
+  let active = false
+  function assertWritable() {
+    if (assertWriterLock() !== true) throw new Error('服务写入权限已失效，试运行结果未保存')
+  }
+  function assertAdmission() {
+    assertWritable()
+    if (!isServing() || isFrozen()) throw new Error('服务未就绪或正在维护，暂不能试运行')
+  }
+  async function begin(controller) {
+    assertAdmission()
+    const capacity = getCapacity()
+    if (active || capacity.closed || capacity.active + capacity.waiting >= capacity.maxConcurrent) {
+      throw new Error('试运行或模型并发名额已满，请稍后重试')
+    }
+    if (typeof acquireCapacity !== 'function') throw new Error('当前服务未接入试运行并发准入')
+    active = true
+    let release
+    try {
+      release = await acquireCapacity({ signal: controller.signal })
+      assertAdmission()
+    } catch (error) { active = false; release?.(); throw error }
+    let finished = false
+    const monitor = setInterval(() => {
+      try { assertAdmission() } catch (error) { controller.abort(error) }
+    }, 100)
+    monitor.unref?.()
+    return { assertWritable,
+      finish(closed) {
+        if (finished) return
+        finished = true; clearInterval(monitor)
+        // Unknown closure keeps the shared slot occupied and blocks upgrades.
+        if (closed) { active = false; release() }
+      },
+    }
+  }
+  return { begin, active: () => active }
+}
+module.exports = { createConsoleTrials }

package/src/core/c2cardterminalpath.js

@@ -129,7 +129,7 @@ function prepareCardTerminalPath({ runtime, payloadHandles, platform, replyCtx,
       const nextCtx = landedAnchor(anchor)
       if (phase !== 'open' || !card) return false
       if (activeAnchorCtx.messageId === nextCtx.messageId) return true
-      if (!lastCardText) throw new Error('C2 card move has no visible text to replay')
+      if (!lastCardText) throw new Error('C2 card move has no visible text to preserve')
       phase = 'relocating'
       try {
         if (await card.flush() !== true) throw new Error('C2 old card flush unconfirmed')
@@ -138,6 +138,7 @@ function prepareCardTerminalPath({ runtime, payloadHandles, platform, replyCtx,
         const fresh = await platform.createStreamingCard(nextCtx, {
           operationKey: `${receiptId}:followup:${anchor.receiptId}`,
           operationBoundary,
+          initialText: lastCardText,
         })
         if (!fresh || typeof fresh.update !== 'function' ||
             typeof fresh.flush !== 'function' || typeof fresh.recall !== 'function') {

package/src/core/c2durablejournal.js

@@ -646,6 +646,16 @@ class C2DurableJournal {
       effects: new Map(this.#effects), notices: new Map(this.#notices) }
   }
 
+  // Bounded diagnostics: the console must not clone all effects and history
+  // at progress-event frequency. This is never accepted as recovery authority.
+  consoleSnapshot() {
+    return { cursor: this.#cursor, state: { lanes: {
+      queue: structuredClone(this.#state.lanes?.queue || {}),
+      stopIntent: structuredClone(this.#state.lanes?.stopIntent || {}) } },
+      receipts: { pending: structuredClone(this.#receipts.pending),
+        completed: structuredClone(this.#receipts.completed.slice(-30)) } }
+  }
+
   #settlementAuthority() {
     return { state: this.#state, receipts: this.#receipts, effects: this.#effects,
       attempts: this.#effectAttempts, descriptors: this.#effectDescriptors,