@toddzheng024/dscode-bundle 0.7.21 → 0.7.23

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.21",
+  "version": "0.7.23",
   "type": "module",
   "license": "MIT",
   "author": "Todd Zheng",
@@ -306,9 +306,9 @@
     "@deepseek-ai/schemastery": "3.18.2",
     "@anionex/dsh-computer-use": "0.3.2",
     "chrome-devtools-mcp": "1.9.0",
-    "imapflow": "2.0.2",
-    "mailparser": "3.9.26",
-    "nodemailer": "10.0.9",
+    "imapflow": "2.0.5",
+    "mailparser": "3.9.28",
+    "nodemailer": "10.0.10",
     "react": "18.3.1",
     "commander": "15.0.0",
     "eventsource-parser": "3.1.1"

package/plugins/dscode/index.mjs

@@ -1,3 +1,5 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 export const name = 'dscode-execution-policy';
 export const inject = ['systemPrompt', 'tools', 'agents', 'commands', 'terminals'];
 export const SHELL_POLICY = `Use bash as the persistent shell for reading, searching and modifying files. Prefer rg/rg --files, sed and standard CLI tools. Use apply_patch with a standard unified diff on stdin (git apply format, a/ and b/ paths); apply_patch --check validates before writing. It is not the *** Begin Patch format. Quote heredoc delimiters to avoid shell interpolation.
@@ -23,8 +25,16 @@ export const CHILD_NAME = /^[A-Za-z](?:[A-Za-z0-9_]{0,8}[A-Za-z])?$/;
 export const CHILD_NAME_RULE = 'name must be 1-10 characters of letters, digits or underscores, starting and ending with a letter';
 const DELEGATION_TOOLS = ['subagent', 'subagent_fork', 'workflow', 'ralph'];
 
+// Where the version-matched user guides live. Source and tar installs ship docs/ next
+// to the plugins; the npm/Hub bundle does not, so the section falls back to the public
+// repository there instead of pointing at a path that does not exist.
+const DOCS_DIR = fileURLToPath(new URL('../../docs/', import.meta.url));
+const DOCS_REPO = 'https://github.com/qiz029/dscode/blob/main/docs/';
+export const DOCS_SECTION = `To answer questions about DSCODE itself - what it supports, how a feature is configured, what a command does - treat the bundled user guides as the source of truth instead of guessing: ${existsSync(DOCS_DIR) ? `${DOCS_DIR} plus the repository root README.md (session-bridge.md, session-communication.md, session-cards.md, memory.md, exec.md, email.md, skills.md, tui-commands.md, session-metrics.md, dscode-ultra.md, auto-review.md, demo.md)` : `the repository documentation at ${DOCS_REPO} plus the root README.md (session-bridge.md, session-communication.md, session-cards.md, memory.md, exec.md, email.md, skills.md, tui-commands.md, session-metrics.md, dscode-ultra.md, auto-review.md, demo.md)`}. Read the relevant guide before answering rather than relying on memory of an earlier session. docs/CONTEXT-HANDOFF.md, docs/session-messaging-design.md, docs/cloud-webapp-host.md, docs/verification.md, docs/maintainability.md and docs/vendored-tui-upgrade.md are internal development records, not user documentation: never quote them to a user or treat them as a specification. When the guides do not cover something, describe only what the running installation actually does and say plainly that it is not documented.`;
+
 export function apply(ctx) {
   ctx.systemPrompt.section({ name: 'dscode:shell-policy', order: 1050, text: SHELL_POLICY });
+  ctx.systemPrompt.section({ name: 'dscode:docs', order: 1052, text: DOCS_SECTION });
   ctx.systemPrompt.section({ name: 'dscode:code-discipline', order: 1053, text: CODE_DISCIPLINE });
   ctx.systemPrompt.section({ name: 'dscode:working-discipline', order: 1054, text: WORKING_DISCIPLINE });
   ctx.systemPrompt.section({ name: 'dscode:child-policy', order: 1051, text: ({ scope }) => scope?.session?.header?.origin === 'subagent' && scope.session.header.agentPreset === 'dscode'

package/plugins/i18n/messages.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Types for the DSCODE message tables, for the vendored terminal's TypeScript.
+ * The module is plain JS on purpose (it ships beside the plugins and is read by
+ * both surfaces), so this declares exactly the surface `packages/tui/src` imports:
+ * the language list, the alias normalizer, the lookup and the display name.
+ */
+export interface LanguageEntry {
+  code: string;
+  name: string;
+}
+
+export const LANGUAGES: readonly LanguageEntry[];
+export const ALIASES: Readonly<Record<string, readonly string[]>>;
+export const MESSAGES: Readonly<Record<string, Readonly<Record<string, string>>>>;
+
+/** Resolve a typed or persisted language name to its code, or null when unknown. */
+export function normalizeLanguage(value: unknown): string | null;
+/** The display name of a language code, or the code itself. */
+export function languageName(code: string): string;
+/** One message in one locale, with `{name}` parameters interpolated. */
+export function t(locale: string, key: string, params?: Readonly<Record<string, unknown>>): string;

package/plugins/i18n/messages.mjs

@@ -26,6 +26,7 @@ export const ALIASES = {
 export const MESSAGES = {
   en: {
     'activity.replying': 'Replying', 'activity.thinking': 'Thinking', 'activity.running': 'Running',
+    'communication.sending': 'sending to {peer}', 'communication.waiting': 'waiting for {peer}',
     'activity.turn': 'this turn', 'activity.interrupt': 'Esc to interrupt',
     'agents.running': 'running', 'agents.idle': 'idle', 'agents.done': 'done', 'agents.total': 'total',
     'welcome.model': 'model', 'welcome.effort': 'effort', 'welcome.project': 'project',
@@ -40,10 +41,11 @@ export const MESSAGES = {
     'language.set': 'language → {name}', 'language.title': '/language — interface language', 'language.currentMark': 'current', 'language.unknown': 'Unknown language "{value}". Choose en, zh-CN, zh-TW, ja, ko or es.',
     'language.saveFailed': 'language save failed: {error}',
     'doctor.logs.new': 'Only warnings/errors since this TUI version started are recorded.',
-    'footer.current': 'current', 'footer.average': 'average', 'footer.context': 'context', 'footer.cache': 'cache hit', 'footer.grokUsed': 'used', 'footer.grokResets': 'resets', 'composer.placeholder': 'type a message', 'composer.shellMode': '! shell mode · esc exits',
+    'footer.average': 'avg', 'footer.context': 'ctx', 'footer.cache': 'cache', 'footer.grokUsed': 'used', 'footer.grokResets': 'resets', 'composer.placeholder': 'type a message', 'composer.shellMode': '! shell mode · esc exits',
     'compaction.running': 'Compacting context, please wait', 'compaction.confirm.title': 'Switching to {model} will compact the conversation',
     'compaction.confirm.usage': 'context {used} ≥ compaction threshold {threshold} ({window} × {ratio})', 'compaction.confirm.next': 'the next step compacts older history first',
     'compaction.confirm.overflow': 'it already exceeds the {window} window: the next request compacts and retries', 'compaction.confirm.hint': 'y switch · n/esc back',
+    'budget.confirm.title': 'Session spend {spent} has reached the {limit} budget ({percent})', 'budget.confirm.spent': 'the session has already recorded {spent} of the {limit} limit ({percent})', 'budget.confirm.next': 'confirming runs the next turn anyway; Esc or n cancels it', 'budget.confirm.hint': 'y send anyway · n/esc cancel',
     'doctor.nearTimeout': 'Assessment: {count} Bash calls ended at about 300 seconds, which matches the tool timeout; traces alone cannot prove the root cause. Next, check those calls\' shell completion markers and terminal errors.',
     'doctor.logs.none': 'No log file yet; earlier console logs were not persisted and cannot be recovered.',
     'doctor.evidence': 'Diagnostic evidence: {traces} recent sessions, {logs} warnings/errors.',
@@ -54,6 +56,7 @@ export const MESSAGES = {
   },
   'zh-CN': {
     'activity.replying': '正在回复', 'activity.thinking': '正在思考', 'activity.running': '正在执行',
+    'communication.sending': '正在向 {peer} 发送', 'communication.waiting': '正在等待 {peer} 回应',
     'activity.turn': '本轮', 'activity.interrupt': 'Esc 中断',
     'agents.running': '运行中', 'agents.idle': '空闲', 'agents.done': '已完成', 'agents.total': '总计',
     'welcome.model': '模型', 'welcome.effort': '推理', 'welcome.project': '项目',
@@ -68,10 +71,11 @@ export const MESSAGES = {
     'language.set': '语言 → {name}', 'language.title': '/language — 界面语言', 'language.currentMark': '当前', 'language.unknown': '未知语言 "{value}"。可选 en、zh-CN、zh-TW、ja、ko、es。',
     'language.saveFailed': '语言设置保存失败：{error}',
     'doctor.logs.new': '仅记录新版 TUI 启动后的 warning/error。',
-    'footer.current': '当前', 'footer.average': '平均', 'footer.context': '上下文', 'footer.cache': '缓存命中', 'footer.grokUsed': '已用', 'footer.grokResets': '重置', 'composer.placeholder': '输入消息', 'composer.shellMode': '! shell 模式 · esc 退出',
+    'footer.average': '平均', 'footer.context': 'ctx', 'footer.cache': '缓存', 'footer.grokUsed': '已用', 'footer.grokResets': '重置', 'composer.placeholder': '输入消息', 'composer.shellMode': '! shell 模式 · esc 退出',
     'compaction.running': '正在压缩上下文，请稍后', 'compaction.confirm.title': '切换到 {model} 会触发自动压缩',
     'compaction.confirm.usage': '当前上下文 {used} ≥ 压缩阈值 {threshold}（{window} × {ratio}）', 'compaction.confirm.next': '下一步开始前会先压缩较早的对话',
     'compaction.confirm.overflow': '已超出新模型的 {window} 上下文窗口：下一次请求会先压缩再重试', 'compaction.confirm.hint': 'y 确认切换 · n/esc 返回',
+    'budget.confirm.title': '会话花费 {spent} 已达预算 {limit}（{percent}）', 'budget.confirm.spent': '本会话已记录 {spent} / 上限 {limit}（{percent}）', 'budget.confirm.next': '确认后仍会执行下一轮；esc 或 n 取消', 'budget.confirm.hint': 'y 仍然发送 · n/esc 取消',
     'doctor.nearTimeout': '判断：{count} 次 Bash 调用在约 300 秒结束，符合工具超时特征；trace 不能单独证明触发超时的根因。下一步检查这些调用的 shell 完成标记和终端错误。',
     'doctor.logs.none': '日志文件尚未建立；旧版控制台日志未持久化，无法回溯。',
     'doctor.evidence': '诊断证据：{traces} 个近期会话、{logs} 条 warning/error。',
@@ -82,6 +86,7 @@ export const MESSAGES = {
   },
   'zh-TW': {
     'activity.replying': '正在回覆', 'activity.thinking': '正在思考', 'activity.running': '正在執行',
+    'communication.sending': '正在向 {peer} 傳送', 'communication.waiting': '正在等待 {peer} 回覆',
     'activity.turn': '本輪', 'activity.interrupt': 'Esc 中斷',
     'agents.running': '執行中', 'agents.idle': '閒置', 'agents.done': '已完成', 'agents.total': '總計',
     'welcome.model': '模型', 'welcome.effort': '推理', 'welcome.project': '專案',
@@ -96,10 +101,11 @@ export const MESSAGES = {
     'language.set': '語言 → {name}', 'language.title': '/language — 介面語言', 'language.currentMark': '目前', 'language.unknown': '未知語言 "{value}"。可選 en、zh-CN、zh-TW、ja、ko、es。',
     'language.saveFailed': '語言設定儲存失敗：{error}',
     'doctor.logs.new': '僅記錄新版 TUI 啟動後的 warning/error。',
-    'footer.current': '目前', 'footer.average': '平均', 'footer.context': '上下文', 'footer.cache': '快取命中', 'footer.grokUsed': '已用', 'footer.grokResets': '重置', 'composer.placeholder': '輸入訊息', 'composer.shellMode': '! shell 模式 · esc 離開',
+    'footer.average': '平均', 'footer.context': 'ctx', 'footer.cache': '快取', 'footer.grokUsed': '已用', 'footer.grokResets': '重置', 'composer.placeholder': '輸入訊息', 'composer.shellMode': '! shell 模式 · esc 離開',
     'compaction.running': '正在壓縮上下文，請稍候', 'compaction.confirm.title': '切換到 {model} 會觸發自動壓縮',
     'compaction.confirm.usage': '目前上下文 {used} ≥ 壓縮閾值 {threshold}（{window} × {ratio}）', 'compaction.confirm.next': '下一步開始前會先壓縮較早的對話',
     'compaction.confirm.overflow': '已超出新模型的 {window} 上下文視窗：下一次請求會先壓縮再重試', 'compaction.confirm.hint': 'y 確認切換 · n/esc 返回',
+    'budget.confirm.title': '工作階段花費 {spent} 已達預算 {limit}（{percent}）', 'budget.confirm.spent': '本工作階段已記錄 {spent} / 上限 {limit}（{percent}）', 'budget.confirm.next': '確認後仍會執行下一輪；esc 或 n 取消', 'budget.confirm.hint': 'y 仍然送出 · n/esc 取消',
     'doctor.nearTimeout': '判斷：{count} 次 Bash 呼叫在約 300 秒結束，符合工具逾時特徵；trace 無法單獨證明觸發逾時的根因。下一步檢查這些呼叫的 shell 完成標記和終端錯誤。',
     'doctor.logs.none': '日誌檔尚未建立；舊版主控台日誌未持久化，無法回溯。',
     'doctor.evidence': '診斷證據：{traces} 個近期工作階段、{logs} 筆 warning/error。',
@@ -110,6 +116,7 @@ export const MESSAGES = {
   },
   ja: {
     'activity.replying': '応答中', 'activity.thinking': '思考中', 'activity.running': '実行中',
+    'communication.sending': '{peer} へ送信中', 'communication.waiting': '{peer} の応答を待機中',
     'activity.turn': '今回のターン', 'activity.interrupt': 'Esc で中断',
     'agents.running': '実行中', 'agents.idle': '待機中', 'agents.done': '完了', 'agents.total': '合計',
     'welcome.model': 'モデル', 'welcome.effort': '推論', 'welcome.project': 'プロジェクト',
@@ -124,10 +131,11 @@ export const MESSAGES = {
     'language.set': '言語 → {name}', 'language.title': '/language — 表示言語', 'language.currentMark': '現在', 'language.unknown': '不明な言語 "{value}"。en、zh-CN、zh-TW、ja、ko、es から選んでください。',
     'language.saveFailed': '言語設定の保存に失敗しました：{error}',
     'doctor.logs.new': 'この TUI バージョンの起動以降の warning/error のみ記録されています。',
-    'footer.current': '現在', 'footer.average': '平均', 'footer.context': 'コンテキスト', 'footer.cache': 'キャッシュヒット', 'footer.grokUsed': '使用', 'footer.grokResets': 'リセット', 'composer.placeholder': 'メッセージを入力', 'composer.shellMode': '! shell モード · esc で終了',
+    'footer.average': '平均', 'footer.context': 'ctx', 'footer.cache': 'キャッシュ', 'footer.grokUsed': '使用', 'footer.grokResets': 'リセット', 'composer.placeholder': 'メッセージを入力', 'composer.shellMode': '! shell モード · esc で終了',
     'compaction.running': 'コンテキストを圧縮しています。しばらくお待ちください', 'compaction.confirm.title': '{model} に切り替えると自動圧縮が実行されます',
     'compaction.confirm.usage': '現在のコンテキスト {used} ≥ 圧縮しきい値 {threshold}（{window} × {ratio}）', 'compaction.confirm.next': '次のステップの前に古い履歴を圧縮します',
     'compaction.confirm.overflow': '新しいモデルの {window} ウィンドウを超えています。次のリクエストで圧縮して再試行します', 'compaction.confirm.hint': 'y 切り替え · n/esc 戻る',
+    'budget.confirm.title': 'セッションの支出 {spent} が予算 {limit} に達しました（{percent}）', 'budget.confirm.spent': 'このセッションは {spent} / 上限 {limit}（{percent}）を記録済みです', 'budget.confirm.next': '確認すると次のターンを実行します。esc または n で中止', 'budget.confirm.hint': 'y 送信 · n/esc 中止',
     'doctor.nearTimeout': '判断：Bash 呼び出し {count} 件が約 300 秒で終了しており、ツールのタイムアウトの特徴に一致します。トレースだけでは根本原因を証明できません。次はこれらの呼び出しのシェル完了マーカーと端末エラーを確認してください。',
     'doctor.logs.none': 'ログファイルはまだありません。以前のコンソールログは保存されておらず、遡れません。',
     'doctor.evidence': '診断の根拠：直近のセッション {traces} 件、warning/error {logs} 件。',
@@ -138,6 +146,7 @@ export const MESSAGES = {
   },
   ko: {
     'activity.replying': '응답 중', 'activity.thinking': '생각 중', 'activity.running': '실행 중',
+    'communication.sending': '{peer}에게 전송 중', 'communication.waiting': '{peer}의 응답을 기다리는 중',
     'activity.turn': '이번 턴', 'activity.interrupt': 'Esc 중단',
     'agents.running': '실행 중', 'agents.idle': '대기', 'agents.done': '완료', 'agents.total': '전체',
     'welcome.model': '모델', 'welcome.effort': '추론', 'welcome.project': '프로젝트',
@@ -152,10 +161,11 @@ export const MESSAGES = {
     'language.set': '언어 → {name}', 'language.title': '/language — 인터페이스 언어', 'language.currentMark': '현재', 'language.unknown': '알 수 없는 언어 "{value}". en, zh-CN, zh-TW, ja, ko, es 중에서 선택하세요.',
     'language.saveFailed': '언어 설정 저장 실패: {error}',
     'doctor.logs.new': '이 TUI 버전 시작 이후의 warning/error만 기록됩니다.',
-    'footer.current': '현재', 'footer.average': '평균', 'footer.context': '컨텍스트', 'footer.cache': '캐시 적중', 'footer.grokUsed': '사용', 'footer.grokResets': '재설정', 'composer.placeholder': '메시지를 입력하세요', 'composer.shellMode': '! shell 모드 · esc 종료',
+    'footer.average': '평균', 'footer.context': 'ctx', 'footer.cache': '캐시', 'footer.grokUsed': '사용', 'footer.grokResets': '재설정', 'composer.placeholder': '메시지를 입력하세요', 'composer.shellMode': '! shell 모드 · esc 종료',
     'compaction.running': '컨텍스트를 압축하는 중입니다. 잠시만 기다려 주세요', 'compaction.confirm.title': '{model}(으)로 전환하면 자동 압축이 실행됩니다',
     'compaction.confirm.usage': '현재 컨텍스트 {used} ≥ 압축 임계값 {threshold} ({window} × {ratio})', 'compaction.confirm.next': '다음 단계 전에 이전 대화를 먼저 압축합니다',
     'compaction.confirm.overflow': '새 모델의 {window} 창을 이미 넘었습니다. 다음 요청에서 압축한 뒤 재시도합니다', 'compaction.confirm.hint': 'y 전환 · n/esc 뒤로',
+    'budget.confirm.title': '세션 지출 {spent}이(가) 예산 {limit}에 도달했습니다({percent})', 'budget.confirm.spent': '이 세션은 {spent} / 한도 {limit}({percent})을 기록했습니다', 'budget.confirm.next': '확인하면 다음 턴을 계속 실행합니다. esc 또는 n으로 취소', 'budget.confirm.hint': 'y 그래도 전송 · n/esc 취소',
     'doctor.nearTimeout': '판단: Bash 호출 {count}건이 약 300초에 종료되어 도구 시간 초과 특징과 일치합니다. 트레이스만으로는 근본 원인을 증명할 수 없습니다. 다음으로 해당 호출의 셸 완료 표시와 터미널 오류를 확인하세요.',
     'doctor.logs.none': '아직 로그 파일이 없습니다. 이전 콘솔 로그는 저장되지 않아 복구할 수 없습니다.',
     'doctor.evidence': '진단 근거: 최근 세션 {traces}개, warning/error {logs}건.',
@@ -166,6 +176,7 @@ export const MESSAGES = {
   },
   es: {
     'activity.replying': 'Respondiendo', 'activity.thinking': 'Pensando', 'activity.running': 'Ejecutando',
+    'communication.sending': 'enviando a {peer}', 'communication.waiting': 'esperando a {peer}',
     'activity.turn': 'este turno', 'activity.interrupt': 'Esc para interrumpir',
     'agents.running': 'en ejecución', 'agents.idle': 'inactivo', 'agents.done': 'terminado', 'agents.total': 'en total',
     'welcome.model': 'modelo', 'welcome.effort': 'esfuerzo', 'welcome.project': 'proyecto',
@@ -180,10 +191,11 @@ export const MESSAGES = {
     'language.set': 'idioma → {name}', 'language.title': '/language — idioma de la interfaz', 'language.currentMark': 'actual', 'language.unknown': 'Idioma desconocido "{value}". Elige en, zh-CN, zh-TW, ja, ko o es.',
     'language.saveFailed': 'no se pudo guardar el idioma: {error}',
     'doctor.logs.new': 'Solo se registran los warnings/errores desde que arrancó esta versión del TUI.',
-    'footer.current': 'actual', 'footer.average': 'promedio', 'footer.context': 'contexto', 'footer.cache': 'éxitos de caché', 'footer.grokUsed': 'usado', 'footer.grokResets': 'reinicia', 'composer.placeholder': 'escribe un mensaje', 'composer.shellMode': '! modo shell · esc sale',
+    'footer.average': 'prom', 'footer.context': 'ctx', 'footer.cache': 'caché', 'footer.grokUsed': 'usado', 'footer.grokResets': 'reinicia', 'composer.placeholder': 'escribe un mensaje', 'composer.shellMode': '! modo shell · esc sale',
     'compaction.running': 'Compactando el contexto, espera un momento', 'compaction.confirm.title': 'Cambiar a {model} compactará la conversación',
     'compaction.confirm.usage': 'contexto {used} ≥ umbral de compactación {threshold} ({window} × {ratio})', 'compaction.confirm.next': 'el siguiente paso compacta antes el historial antiguo',
     'compaction.confirm.overflow': 'ya supera la ventana de {window}: la siguiente petición compacta y reintenta', 'compaction.confirm.hint': 'y cambiar · n/esc volver',
+    'budget.confirm.title': 'El gasto de la sesión {spent} alcanzó el presupuesto {limit} ({percent})', 'budget.confirm.spent': 'la sesión ya registró {spent} de un límite de {limit} ({percent})', 'budget.confirm.next': 'confirmar ejecuta el siguiente turno igualmente; esc o n lo cancela', 'budget.confirm.hint': 'y enviar igual · n/esc cancelar',
     'doctor.nearTimeout': 'Valoración: {count} llamadas a Bash terminaron a unos 300 segundos, lo que coincide con el tiempo de espera de la herramienta; las trazas por sí solas no prueban la causa raíz. A continuación, revisa los marcadores de finalización del shell y los errores de terminal de esas llamadas.',
     'doctor.logs.none': 'Aún no hay archivo de registro; los registros de consola anteriores no se conservaron y no se pueden recuperar.',
     'doctor.evidence': 'Evidencia del diagnóstico: {traces} sesiones recientes, {logs} warnings/errores.',

package/plugins/session-bridge/index.mjs

@@ -1,5 +1,6 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { communicationPanel, createCommunicationFeed, foldCommunication } from './tasks.mjs';
 import { SessionBridge } from './server.mjs';
 import { CommunicationService } from './communication.mjs';
 import { defineTool } from '@deepseek-ai/dsh-tools';
@@ -21,6 +22,11 @@ export async function apply(ctx) {
     const value = action === 'cancel' ? await communication.cancel(agent, id, true) : communication.store.list(agent.id);
     return { kind: 'success', text: JSON.stringify(value, null, 2) };
   } });
+  // The same fold the terminal's activity line uses, so the panels agree.
+  ctx.commands.register({ name: 'tasks', description: 'Cross-session messages and what is still awaiting a reply', handler({ agent }) {
+    const view = agent.session.snapshotEvents().reduce((acc, event) => foldCommunication(acc, event), createCommunicationFeed());
+    return { kind: 'success', text: communicationPanel(view) };
+  } });
   ctx.commands.register({ name: 'session-new-task', description: 'Explicitly start a fresh communication budget while idle', handler({ agent }) {
     return { kind: 'success', text: `New task chains: ${communication.newTask(agent).join(', ')}` };
   } });

package/plugins/session-bridge/tasks.mjs

@@ -0,0 +1,227 @@
+// Cross-session traffic as a data fold, for `/tasks` in the terminal's plugin
+// half. This is the same fold the TUI's live activity line and notices use
+// (`packages/tui/src/communication.ts`): the bridge can only import from the
+// shipped `plugins/` tree, because the Hub bundle carries `packages/tui/lib`
+// without `packages/tui/src`. The two must stay in step — the rules are:
+//
+// - a `send_session` / `reply_session` call is an outbound row; its paired
+//   result settles it, and an errored result is `failed`, never `awaiting`;
+// - a settled `request` awaits its answer until a relay whose bridge header
+//   says `reply` arrives from that peer;
+// - a bridge relayed `user/message` is an inbound row;
+// - rows are bounded, and outbound/inbound ids are namespaced apart.
+
+/** Hard row cap for `/tasks`; the newest rows survive. */
+export const MAX_COMMUNICATION_ROWS = 32
+
+/** Bound on outstanding requests tracked at once (display state, not a budget). */
+const MAX_WAITING_REQUESTS = 16
+
+/** Bounded body preview, matching the activity line's display budget. */
+const MAX_PREVIEW_CHARS = 72
+
+/** The plugin name the session bridge stamps on its relayed messages. */
+const BRIDGE_PLUGIN = 'dscode-session-bridge'
+
+/** Tool names that address another session. */
+const SEND_TOOLS = new Set(['send_session', 'reply_session'])
+
+/**
+ * One peer identity across both directions. Outbound rows carry the bare
+ * session id from the tool arguments; an inbound relay's bridge label is
+ * `session:<id>`, so the prefix is stripped before they are compared.
+ */
+function peerKey(peer) {
+  return peer.startsWith('session:') ? peer.slice('session:'.length) : peer
+}
+
+/** Fold one tool-call argument JSON string into the fields a row needs. */
+function callFields(raw) {
+  if (typeof raw !== 'string' || raw.length > 8192) return { preview: '' }
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return { preview: '' }
+  }
+  if (parsed === null || typeof parsed !== 'object') return { preview: '' }
+  const text = value => (typeof value === 'string' ? value.replace(/\s+/gu, ' ').trim() : '')
+  const peer = text(parsed.session_id) || text(parsed.request_message_id)
+  const preview = text(parsed.text)
+  return {
+    ...(peer === '' ? {} : { peer }),
+    ...(text(parsed.kind) === '' ? {} : { kind: text(parsed.kind) }),
+    ...(text(parsed.mode) === '' ? {} : { mode: text(parsed.mode) }),
+    preview: preview.length > MAX_PREVIEW_CHARS ? `${preview.slice(0, MAX_PREVIEW_CHARS - 1)}…` : preview,
+  }
+}
+
+/**
+ * One relayed message's peer, message kind and bounded text. The bridge stamps
+ * the kind only inside the body header (`[External source: …] [kind/mode]`),
+ * which is its documented presentation contract, so an unrecognised header
+ * leaves the kind undefined and the caller stays conservative: an unknown
+ * inbound message never counts as an answer.
+ */
+function relayFields(data) {
+  if (data === null || typeof data !== 'object') return undefined
+  const source = data.source
+  if (source === null || typeof source !== 'object') return undefined
+  if (source.kind !== 'plugin' || source.plugin !== BRIDGE_PLUGIN || source.form !== 'relay') return undefined
+  const label = typeof source.label === 'string' && source.label !== '' ? source.label : undefined
+  const id = typeof source.communicationId === 'string' && source.communicationId !== '' ? source.communicationId : undefined
+  if (label === undefined && id === undefined) return undefined
+  const texts = []
+  if (Array.isArray(data.content)) {
+    for (const block of data.content) {
+      if (typeof block === 'object' && block !== null && block.type === 'text' && typeof block.text === 'string') texts.push(block.text)
+    }
+  }
+  const body = texts.join(' ').replace(/\s+/gu, ' ').trim()
+  const kind = body.match(/\[([a-z]+)\/[a-z]+\]/u)?.[1]
+  const joinLines = texts.join('\n')
+  const joined = joinLines
+    .replace(/^\[External source:[^\]]*\](\s*\[[a-z]+\/[a-z]+\])?\s*/u, '')
+    .replace(/^Message ID:[^\n]*\n?/u, '')
+    .replace(/\s+/gu, ' ')
+    .trim()
+  return {
+    peer: label ?? id ?? 'unknown',
+    ...(kind === undefined ? {} : { kind }),
+    preview: joined.length > MAX_PREVIEW_CHARS ? `${joined.slice(0, MAX_PREVIEW_CHARS - 1)}…` : joined,
+  }
+}
+
+/** Keep only the newest rows. */
+function bound(rows) {
+  return rows.length <= MAX_COMMUNICATION_ROWS ? rows : rows.slice(rows.length - MAX_COMMUNICATION_ROWS)
+}
+
+/** The call id a tool result pairs with. */
+function resultCallId(data) {
+  if (!Array.isArray(data.message?.content)) return undefined
+  for (const block of data.message.content) {
+    if (typeof block === 'object' && block !== null && typeof block.toolCallId === 'string') return block.toolCallId
+  }
+  return undefined
+}
+
+/** True when the tool result's block carries `isError`. */
+function resultFailed(data) {
+  if (!Array.isArray(data.message?.content)) return false
+  return data.message.content.some(block => typeof block === 'object' && block !== null && block.isError === true)
+}
+
+/** The relay's stable message identity, when the bridge stamped one. */
+function relayId(data) {
+  const source = data?.source
+  return typeof source?.communicationId === 'string' && source.communicationId !== '' ? source.communicationId : undefined
+}
+
+/** Outbound row identity, namespaced so an inbound id can never collide with it. */
+function outboundId(callId) {
+  return `sent:${callId}`
+}
+
+/** Inbound row identity, namespaced and falling back to the event sequence. */
+function inboundId(data, seq) {
+  return `recv:${relayId(data) ?? seq}`
+}
+
+/** Record one settled request as awaiting its answer. Keyed by the outbound row. */
+function markWaiting(waiting, request) {
+  if (waiting.some(entry => entry.id === request.id)) return waiting
+  const next = [...waiting, { id: request.id, peer: request.peer, since: request.at }]
+  return next.length <= MAX_WAITING_REQUESTS ? next : next.slice(next.length - MAX_WAITING_REQUESTS)
+}
+
+/** Clear the outstanding requests a reply answers. */
+function clearWaiting(waiting, peer) {
+  const next = waiting.filter(entry => peerKey(entry.peer) !== peerKey(peer))
+  return next.length === waiting.length ? waiting : next
+}
+
+/** The empty view the fold starts from. */
+export function createCommunicationFeed() {
+  return { rows: [], waiting: [] }
+}
+
+/**
+ * Fold one root-session event into the feed, returning the same view identity
+ * when the event is not communication traffic.
+ * @param view - the current view.
+ * @param event - one session event from the root session.
+ * @returns the next view, or the same object when nothing changed.
+ */
+export function foldCommunication(view, event) {
+  if (event.type === 'tool/call') {
+    const data = event.data
+    if (!SEND_TOOLS.has(data.name)) return view
+    const fields = callFields(data.arguments)
+    const row = {
+      id: outboundId(data.callId),
+      direction: 'sent',
+      peer: fields.peer ?? 'unknown',
+      ...(fields.kind === undefined ? {} : { kind: fields.kind }),
+      ...(fields.mode === undefined ? {} : { mode: fields.mode }),
+      preview: fields.preview,
+      at: event.time,
+      pending: true,
+      failed: false,
+    }
+    return { rows: bound([...view.rows, row]), waiting: view.waiting }
+  }
+  if (event.type === 'tool/result') {
+    const data = event.data
+    const callId = resultCallId(data)
+    if (callId === undefined) return view
+    const index = view.rows.findIndex(row => row.id === outboundId(callId))
+    if (index === -1) return view
+    const settled = { ...view.rows[index], pending: false, failed: resultFailed(data) }
+    const rows = view.rows.map((row, at) => (at === index ? settled : row))
+    const answers = settled.kind === 'request' && !settled.failed
+    return { rows, waiting: answers ? markWaiting(view.waiting, settled) : view.waiting }
+  }
+  if (event.type === 'user/message') {
+    const relay = relayFields(event.data)
+    if (relay === undefined) return view
+    const row = {
+      id: inboundId(event.data, event.seq), direction: 'received',
+      ...(relay.kind === undefined ? {} : { kind: relay.kind }),
+      peer: relay.peer, preview: relay.preview, at: event.time, pending: false, failed: false,
+    }
+    return {
+      rows: bound([...view.rows, row]),
+      // Only the single final reply answers a request; a bare notify from the
+      // same peer must not clear a turn that is still blocked on an answer.
+      waiting: relay.kind === 'reply' ? clearWaiting(view.waiting, row.peer) : view.waiting,
+    }
+  }
+  return view
+}
+
+/**
+ * Render the `/tasks` listing: one line per communication, newest last, with
+ * the same arrows the activity line and the notices use.
+ * @param view - the folded view.
+ * @param limit - the newest rows to show.
+ * @returns the panel text, or a short explanation when there is no traffic.
+ */
+export function communicationPanel(view, limit = 20) {
+  if (view.rows.length === 0) return 'No cross-session messages in this session.'
+  const waiting = new Set(view.waiting.map(entry => peerKey(entry.peer)))
+  const shown = view.rows.slice(-limit)
+  const lines = shown.map(row => {
+    const arrow = row.direction === 'received' ? '←' : '→'
+    const state = row.direction === 'received' ? 'received' : row.failed ? 'failed' : row.pending ? 'sending' : waiting.has(peerKey(row.peer)) ? 'awaiting reply' : 'sent'
+    const kind = row.kind === undefined ? '' : ` ${row.kind}`
+    const mode = row.mode === undefined ? '' : `/${row.mode}`
+    const text = row.preview === '' ? '' : ` — ${row.preview}`
+    return `${arrow} ${row.peer}${kind}${mode} · ${state}${text}`
+  })
+  const hidden = view.rows.length - shown.length
+  return [
+    ...(hidden > 0 ? [`(${hidden} older message${hidden === 1 ? '' : 's'} hidden)`] : []),
+    ...lines,
+  ].join('\n')
+}

package/plugins/session-metrics/turns.mjs

@@ -0,0 +1,134 @@
+// Per-turn cost attribution and the session budget gate. The footer reports the
+// whole session's spend and /usage reports tokens per turn; these functions
+// answer what neither does with that ledger: which turn spent the money, so the
+// footer can show the last completed turn and /usage can price each one.
+
+/**
+ * Turn windows from the session's own events. `turn/start` opens a window and
+ * `turn/end` closes it; an unterminated turn stays open to `Infinity` so the
+ * turn in flight still attributes its settled calls. Windows come back in
+ * ascending start order, which the attribution lookup below depends on.
+ */
+export function turnWindows(events = []) {
+  const open = new Map();
+  const windows = [];
+  for (const event of events) {
+    const turn = event.data?.turn;
+    // A boundary without a time cannot place a window or a call inside one. It
+    // is skipped rather than stored: a NaN edge would make the ascending-search
+    // contract false and silently orphan every call of that turn.
+    if (!Number.isFinite(turn) || !Number.isFinite(event.time)) continue;
+    if (event.type === 'turn/start') {
+      const existing = open.get(turn);
+      // A resumed turn can re-emit its start; keep the earliest boundary.
+      open.set(turn, existing === undefined ? event.time : Math.min(existing, event.time));
+    } else if (event.type === 'turn/end') {
+      const start = open.get(turn);
+      if (start === undefined) continue;
+      open.delete(turn);
+      windows.push({ turn, start, end: event.time });
+    }
+  }
+  for (const [turn, start] of open) windows.push({ turn, start, end: Infinity });
+  return windows.sort((left, right) => left.start - right.start || left.turn - right.turn);
+}
+
+/**
+ * The clauses a call is priced against: each turn's window, with an open turn
+ * (no `turn/end`) bounded by the next turn's start. An interrupted turn must not
+ * swallow every later turn, while the turn genuinely in flight keeps running to
+ * `Infinity`. Satisfies {@link attributeCostByTurn}'s ascending-start contract.
+ */
+export function turnBounds(events = []) {
+  return turnWindows(events).map((window, index, windows) => ({
+    turn: window.turn,
+    start: window.start,
+    // Math.max keeps the window non-inverted even for a log whose timestamps
+    // are out of order; an inverted bound would break the ascending search.
+    end: window.end === Infinity && index + 1 < windows.length ? Math.max(window.start, windows[index + 1].start) : window.end,
+  }));
+}
+
+/**
+ * The window containing `time`, by binary search over the ascending bounds. The
+ * index is the FIRST window starting after `time`, so the one before it is the
+ * only candidate that can contain it; `-1` means no turn was running.
+ * @param bounds - ascending {@link turnBounds} rows.
+ * @param time - the call's start time (`time` prices the call, so it is also when the turn ran).
+ * @returns the bounds index, or -1 when `time` falls in no window.
+ */
+export function turnAt(bounds, time) {
+  let low = 0, high = bounds.length;
+  while (low < high) {
+    const mid = (low + high) >> 1;
+    if (bounds[mid].start <= time) low = mid + 1;
+    else high = mid;
+  }
+  const candidate = bounds[low - 1];
+  return candidate !== undefined && time <= candidate.end ? low - 1 : -1;
+}
+
+/**
+ * Cost and call count per turn. Roughly O(calls × log turns), so the footer can
+ * ask for the last turn once a second. A call is attributed by its start time,
+ * and a call outside every window (before the first `turn/start`, in a gap
+ * between two turns, or a backfilled row without one) is reported under
+ * `unattributed` rather than dropped.
+ * @param rows - ledger rows (`{ kind, time, cost, purpose }`).
+ * @param events - the session's events, for the turn windows.
+ * @returns One bucket per turn, plus `lastTurn` (the newest turn that is no
+ *   longer running, undefined while none has stopped), the `unattributed` total
+ *   and whether any of it was unpriceable. A turn that never emitted `turn/end`
+ *   still counts as stopped once the next turn opens its window.
+ */
+export function attributeCostByTurn(rows = [], events = []) {
+  const bounds = turnBounds(events);
+  const turns = bounds.map(bound => ({ turn: bound.turn, cost: 0, calls: 0, unknown: false }));
+  let unattributed = 0;
+  let unattributedUnknown = false;
+  for (const row of rows ?? []) {
+    if (row?.kind !== 'end') continue;
+    const at = turnAt(bounds, row.time);
+    if (at === -1) {
+      // Outside every window the spend still exists: an unpriceable row must be
+      // visible as such rather than counted as nothing.
+      if (Number.isFinite(row.cost)) unattributed += row.cost;
+      else unattributedUnknown = true;
+      continue;
+    }
+    turns[at].calls += 1;
+    if (Number.isFinite(row.cost)) turns[at].cost += row.cost;
+    else turns[at].unknown = true;
+  }
+  let lastTurn;
+  for (let index = bounds.length - 1; index >= 0; index -= 1) {
+    if (bounds[index].end !== Infinity) { lastTurn = turns[index]; break; }
+  }
+  return { turns, lastTurn, unattributed, unattributedUnknown };
+}
+
+/**
+ * The budget gate's verdict. A missing or non-positive limit means no budget is
+ * set, so the gate never fires and the footer shows no budget slot. `warn` is
+ * the alerting share; `over` means the next prompt would spend past the limit.
+ */
+export function evaluateBudget(spent, limit, options = {}) {
+  const warnPercent = Number.isFinite(options.warnPercent) ? options.warnPercent : 80
+  if (!Number.isFinite(limit) || limit <= 0) return { state: 'unset', limit: null, spent, ratio: null, percent: null, warnPercent }
+  const safeSpent = Number.isFinite(spent) ? spent : 0
+  const ratio = safeSpent / limit
+  return {
+    state: ratio >= 1 ? 'over' : ratio * 100 >= warnPercent ? 'warn' : 'ok',
+    limit, spent: safeSpent, ratio,
+    percent: Math.round(ratio * 100),
+    warnPercent,
+  }
+}
+
+/** Parse the `DSCODE_SESSION_BUDGET_USD`-style value; anything else is no budget. */
+export function parseBudget(value) {
+  if (typeof value === 'number') return Number.isFinite(value) && value > 0 ? value : null
+  if (typeof value !== 'string') return null
+  const parsed = Number.parseFloat(value.trim())
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null
+}