lark-remote 0.1.7 → 0.1.9

package/dist/runner/types.d.ts

@@ -25,11 +25,18 @@ export interface ApprovalRequestedEvent {
     type: 'approval_requested';
     /** JSON-RPC id of the server request. Wire type is string | integer — keep raw. */
     requestId: number | string;
-    kind: 'command' | 'file' | 'permissions' | 'question';
+    kind: 'command' | 'file' | 'permissions' | 'question' | 'tool';
     threadId: string;
     turnId: string;
     itemId: string;
     view: ApprovalView;
+    /**
+     * Per-request 审批超时覆盖（毫秒）。由 runner 在翻译时填入
+     * （Codex autoResolutionMs），coordinator 优先使用；
+     * 缺省回落 run 级默认超时。放在事件上而非桥按 agentKind 分支，
+     * 保证公共层无 agent 分支。
+     */
+    timeoutMs?: number;
     timestamp?: string;
 }
 export interface ApprovalResolvedEvent {
@@ -62,27 +69,74 @@ export type ApprovalAction = {
 /** Claude：允许当前请求 + 本会话后续所有权限请求自动放行（允许所有）。 */
  | {
     action: 'accept_all';
+}
+/**
+ * 计划审批「拒绝并附修改意见」：deny + message，Claude 留在 plan 模式
+ * 按意见修订（等价 TUI「Tell Claude what to change」）。
+ */
+ | {
+    action: 'decline_with_feedback';
+    message: string;
+}
+/**
+ * 计划审批「批准并采纳修改意见」：allow + updatedInput.plan（原计划追加
+ * 意见），触发 Claude 侧 planWasEdited → tool_result 回显
+ * "## Approved Plan (edited by user)"（等价 TUI shift+tab approve with feedback）。
+ */
+ | {
+    action: 'accept_with_feedback';
+    plan: string;
 } | {
     action: 'decline';
 } | {
     action: 'cancel';
 }
-/** Claude AskUserQuestion 答案（question → label 或 label[]）。 */
+/**
+ * AskUserQuestion 答案（question → label 或 label[]）。
+ * notes：Codex user_note 补充说明（question → 文本），runner 编码为
+ * "user_note: <text>" 条目；其他 agent 忽略该字段。
+ */
  | {
     action: 'answer';
     answers: Record<string, string | string[]>;
+    notes?: Record<string, string>;
 };
-/** Claude Code AskUserQuestion 的单个选项（control_request input.questions[].options[]）。 */
-export interface ClaudeUserQuestionOption {
+/** AskUserQuestion 公共契约（Agent 无关）的单个选项。 */
+export interface UserQuestionOption {
     label: string;
     description?: string;
 }
-/** Claude Code AskUserQuestion 的单个问题（control_request input.questions[]）。 */
-export interface ClaudeUserQuestion {
+/**
+ * AskUserQuestion 公共契约（Agent 无关）的单个问题。
+ *
+ * 接入约定（新 agent 接入 AskUserQuestion 时在这里扩展，禁止在 coordinator /
+ * renderer / router 里写 agent 分支）：
+ * 1. 各 agent runner 把协议提问翻译为 `ApprovalView{ kind:'question', questions }`；
+ * 2. 用户回答经 ApprovalCoordinator 收集，以 `ApprovalAction{action:'answer',
+ *    answers:{问题文本: string|string[]}}` 回传 runner；
+ * 3. runner 侧把文本 key 答案翻译回自己协议的 shape（Claude 直接用文本 key；
+ *    Codex 需按问题 id 映射）。
+ */
+export interface UserQuestion {
+    /** Agent 侧问题唯一标识（Codex request_user_input 的 id 预留；Claude 无此字段）。 */
+    id?: string;
     question: string;
     header?: string;
     multiSelect?: boolean;
-    options: ClaudeUserQuestionOption[];
+    options: UserQuestionOption[];
+    /** 是否允许自定义答案（Codex isOther 预留；当前单选渲染层恒提供 Other 输入）。 */
+    isOther?: boolean;
+    /** 敏感输入（Codex isSecret 预留）。 */
+    isSecret?: boolean;
+    /** 自由文本题的输入框占位提示（渲染层自由文本题 input）。 */
+    placeholder?: string;
+    /**
+     * 是否渲染「补充说明（可选）」输入（Codex user_note；数据驱动无 agent 分支）。
+     * note 是选项之外的附加文本，随答案提交，不单独构成答案。
+     */
+    allowNote?: boolean;
+    /** 当前已填写的补充说明（卡片回显；coordinator answerNote 回流）。 */
+    note?: string;
     /**
      * 当前已选选项 label（卡片渲染与多选切换用；单选在协调器内即时提交）。
      * 与 permissions.items.selected 同模式：协调器原地更新后以
@@ -92,10 +146,38 @@ export interface ClaudeUserQuestion {
 }
 export interface ApprovalView {
     requestId: number | string;
-    kind: 'command' | 'file' | 'permissions' | 'question';
+    kind: 'command' | 'file' | 'permissions' | 'question' | 'tool';
     reason?: string;
+    /**
+     * 提问卡顶部概要行（数据驱动，无 agent 分支）：Kimi elicitation form 的
+     * 题面只在 form 级 message 里合并出现，逐字段 title 可能只是短 header，
+     * 概要行用于展示完整题干。
+     */
+    intro?: string;
     command?: string;
     commandCwd?: string;
+    /**
+     * 被审批的工具名（kind === 'tool' 时展示，如 ExitPlanMode）。非命令工具的
+     * 权限请求（plan 退出/通知型工具）input 无 command 语义，用工具名 + reason
+     * 表达审批内容，避免落入 command 槽位显示无意义 `{}`。
+     */
+    toolName?: string;
+    /**
+     * 计划全文（kind === 'tool' 且 toolName === 'ExitPlanMode' 时存在）。
+     * 来源：control_request input.plan（CLI normalizeToolInput 从磁盘注入，
+     * 非稳定）→ 计划文件读取（input.planFilePath / 会话内 Write/Edit 跟踪）。
+     */
+    plan?: string;
+    /** 计划文件路径（ExitPlanMode；input.planFilePath 或会话内跟踪所得）。 */
+    planFilePath?: string;
+    /**
+     * 用户已填写的计划修改意见（ExitPlanMode 反馈输入框；coordinator
+     * planFeedback 回流，卡片回显）。供「拒绝并附意见」/「批准并采纳修改」
+     * 两个决策复用。
+     */
+    planFeedback?: string;
+    /** 原始 input 的 JSON 字符串（kind === 'tool' 且 input 非空时展示）。 */
+    toolInput?: string;
     fileChanges?: Array<{
         path: string;
         kind: 'add' | 'update' | 'delete';
@@ -115,7 +197,7 @@ export interface ApprovalView {
         }>;
     };
     /** Claude AskUserQuestion 问题列表（kind === 'question' 时存在）。 */
-    questions?: ClaudeUserQuestion[];
+    questions?: UserQuestion[];
     availableDecisions: string[];
     /** Raw payloads for structured decisions (e.g. acceptWithExecpolicyAmendment). */
     decisionPayloads?: Record<string, unknown>;
@@ -283,12 +365,14 @@ export interface Runner {
      */
     unregisterExitHandlers?(): void;
 }
-export type AgentKind = 'claude' | 'codex' | 'opencode' | 'pi' | 'kimi';
+export type AgentKind = 'claude' | 'codex' | 'opencode' | 'pi' | 'kimi' | 'dsh';
 /** Unified session descriptor returned by every AgentSessionReader. */
 export interface AgentSession {
     sessionId: string;
     summary: string;
     mtime: number;
+    /** DSH：session 创建时固定的 preset；其他 agent 无此概念（undefined）。 */
+    agentPreset?: string;
 }
 /** A single renderable event from session history. */
 export interface AgentSessionContentEvent {

package/dist/session/claude/sessions.js

@@ -154,7 +154,7 @@ function isSessionActive(filePath, mtimeMs, now = Date.now()) {
         // Explicit terminal markers — regardless of mtime. Claude CLI 2.x uses
         // `last-prompt` / `mode` (no `result` event) to mark turn end, so a
         // 24-minute-old session with a last-prompt tail is already done
-        // (regression 2026-06-21: c5e929a7 falsely reported as active).
+        // (regression 2026-06-21: previously falsely reported as active).
         const TERMINAL_TYPES = new Set(['result', 'last-prompt', 'mode', 'permission-mode']);
         if (typeof obj.type === 'string' && TERMINAL_TYPES.has(obj.type))
             return false;
@@ -224,7 +224,16 @@ export function isClaudeSessionActive(sessionId, cwd, opts = {}) {
  */
 function scalarScan(filePath) {
     const acc = new UsageAccumulator();
-    const seenMessageIds = new Set();
+    // Per-message-id best usage record (per-field max). A streaming assistant
+    // message spans multiple jsonl lines sharing the same message id; some
+    // backends (third-party gateways, e.g. DeepSeek) write all-zero usage on
+    // the early placeholder lines (empty thinking block) and the real usage
+    // only on the final line carrying stop_reason. First-occurrence-wins dedup
+    // would pin the zero record and discard the real one (regression
+    // 2026-08-19: auto-resume card per-run stats all 0). Per-field max
+    // reconstructs the full usage regardless of line order — on the official
+    // API every line repeats identical usage, so max is a no-op there.
+    const usageByMessageId = new Map();
     let lastPostTokens = 0;
     let tailOffset = -1;
     let lastAiTitle;
@@ -244,13 +253,13 @@ function scalarScan(filePath) {
             const usage = msg?.usage;
             if (usage) {
                 const msgId = msg?.id;
-                if (msgId && !seenMessageIds.has(msgId)) {
-                    seenMessageIds.add(msgId);
-                    acc.add({
-                        input: usage.input_tokens ?? 0,
-                        output: usage.output_tokens ?? 0,
-                        cacheRead: usage.cache_read_input_tokens ?? 0,
-                        cacheCreation: usage.cache_creation_input_tokens ?? 0,
+                if (msgId) {
+                    const prev = usageByMessageId.get(msgId);
+                    usageByMessageId.set(msgId, {
+                        input: Math.max(prev?.input ?? 0, usage.input_tokens ?? 0),
+                        output: Math.max(prev?.output ?? 0, usage.output_tokens ?? 0),
+                        cacheRead: Math.max(prev?.cacheRead ?? 0, usage.cache_read_input_tokens ?? 0),
+                        cacheCreation: Math.max(prev?.cacheCreation ?? 0, usage.cache_creation_input_tokens ?? 0),
                     });
                 }
             }
@@ -305,6 +314,12 @@ function scalarScan(filePath) {
             }
         }
     });
+    // Feed one best record per message id, in first-appearance order (Map
+    // preserves insertion order), so acc.last is the LAST message's full usage
+    // and totals sum each API response exactly once.
+    for (const record of usageByMessageId.values()) {
+        acc.add(record);
+    }
     // Build usage result (same logic as old aggregateSessionUsage)
     const t = acc.totals;
     const l = acc.last;
@@ -319,14 +334,19 @@ function scalarScan(filePath) {
     if (contextLength === 0 || lastWindow > contextLength) {
         contextLength = lastWindow;
     }
+    // 非累计字段 = 末轮（本 run）scope，累计字段 = session 总和（所有 run）。
+    // 对齐 codex reader 语义（§9.21：`last_token_usage`=单 turn 增量、
+    // `total_token_usage`=session 累计）——否则 jsonl 兜底路径会把 session 累计
+    // 当成"本 run"显示，与卡片"本 run ≤ 累计"不变量冲突（累计反而更小）。
+    const lastTotal = l ? l.input + l.output + l.cacheRead + l.cacheCreation : 0;
     const usage = {
-        inputTokens: t.input,
-        outputTokens: t.output,
+        inputTokens: l ? l.input : 0,
+        outputTokens: l ? l.output : 0,
         contextLength,
         compactCount: acc.compactCount,
-        cacheReadTokens: t.cacheRead > 0 ? t.cacheRead : undefined,
-        cacheCreationTokens: t.cacheCreation > 0 ? t.cacheCreation : undefined,
-        totalTokens: t.input + t.output + t.cacheRead + t.cacheCreation,
+        cacheReadTokens: l && l.cacheRead > 0 ? l.cacheRead : undefined,
+        cacheCreationTokens: l && l.cacheCreation > 0 ? l.cacheCreation : undefined,
+        totalTokens: lastTotal,
         cumulativeTotalTokens: t.input + t.output + t.cacheRead + t.cacheCreation,
         cumulativeInputTokens: t.input,
         cumulativeOutputTokens: t.output,
@@ -435,7 +455,9 @@ export function readSessionContent(sessionId, cwd, opts = {}) {
     // ~3×). Total parse count adds the index-miss fallback guard's fixed
     // early-stop overhead (~2 parses, independent of line count).
     const scan = scalarScan(filePath);
-    const usage = scan.usage.inputTokens + scan.usage.outputTokens > 0 ? scan.usage : undefined;
+    // 有 usage 即返回：非累计字段已是末轮 scope，命中判定用 session 累计兜底
+    // （末轮可能 input/output 为 0 而仍有 cacheRead，累计口径不会被末轮遮挡）。
+    const usage = (scan.usage.cumulativeTotalTokens ?? 0) > 0 ? scan.usage : undefined;
     // Extract events AFTER the last user message by re-reading + re-parsing
     // only the tail. If no user message was found (tailOffset === -1), fall
     // back to re-reading the whole file so the card still has something to

package/dist/session/dsh/index.d.ts

@@ -0,0 +1 @@
+export { DshSessionReader } from './sessions.js';

package/dist/session/dsh/index.js

@@ -0,0 +1,2 @@
+export { DshSessionReader } from './sessions.js';
+//# sourceMappingURL=index.js.map

package/dist/session/dsh/sessions.d.ts

@@ -0,0 +1,44 @@
+/**
+ * DshSessionReader — AgentSessionReader backed by the DSH Web Host over HTTP.
+ *
+ * The AgentSessionReader contract is fully synchronous (file-style readers),
+ * but DSH exposes only async HTTP. The reader therefore bridges with
+ * `spawnSync('curl', ...)` for its unary calls (session.list / session.history)
+ * — a synchronous HTTP round-trip to the local DSH host. This keeps the
+ * router/bridge interface contract intact without touching any upstream logic.
+ *
+ * listSessions: session.list → filter by cwd → sort by updatedAt desc → local
+ *   pagination (DSH v1 has no cursor pagination).
+ * readSessionContent: session.history → map SessionEvents to display events +
+ *   session-wide usage accumulation (assistant/message.usage).
+ */
+import type { AgentSession, AgentSessionReader, SessionContent } from '../../runner/index.js';
+interface DshSessionReaderOptions {
+    host?: string;
+    /** 每次调用时解析当前 host（/config 修改 host 后 runner 重建、reader 也跟随新 host）。
+     *  优先于固定的 `host`。 */
+    hostProvider?: () => string | undefined;
+    /** Injectable synchronous unary transport. Defaults to spawnSync curl. */
+    syncRequest?: (baseUrl: string, method: string, payload: unknown) => unknown;
+}
+export declare class DshSessionReader implements AgentSessionReader {
+    private readonly hostProvider;
+    private readonly syncRequest;
+    constructor(opts?: DshSessionReaderOptions);
+    /** 解析当前 host（hostProvider 优先，允许 /config 热改 host）。 */
+    private resolveBaseUrl;
+    private unary;
+    listSessions(cwd: string, opts?: {
+        limit?: number;
+        offset?: number;
+    }): {
+        sessions: AgentSession[];
+        total: number;
+    };
+    getNewestSession(cwd: string): AgentSession | null;
+    readSessionContent(sessionId: string, cwd: string, opts?: {
+        maxEvents?: number;
+    }): SessionContent;
+    isSessionActive(sessionId: string, cwd: string): boolean;
+}
+export {};

package/dist/session/dsh/sessions.js

@@ -0,0 +1,252 @@
+/**
+ * DshSessionReader — AgentSessionReader backed by the DSH Web Host over HTTP.
+ *
+ * The AgentSessionReader contract is fully synchronous (file-style readers),
+ * but DSH exposes only async HTTP. The reader therefore bridges with
+ * `spawnSync('curl', ...)` for its unary calls (session.list / session.history)
+ * — a synchronous HTTP round-trip to the local DSH host. This keeps the
+ * router/bridge interface contract intact without touching any upstream logic.
+ *
+ * listSessions: session.list → filter by cwd → sort by updatedAt desc → local
+ *   pagination (DSH v1 has no cursor pagination).
+ * readSessionContent: session.history → map SessionEvents to display events +
+ *   session-wide usage accumulation (assistant/message.usage).
+ */
+import { spawnSync } from 'node:child_process';
+import { getLogger } from '../../logger/index.js';
+import { DEFAULT_DSH_HOST } from '../../config/index.js';
+import { capEvents, paginate } from '../common/pagination.js';
+import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
+/**
+ * CC-05: history 拉取上限。DSH session.history 的 maxMessages 同时限制返回条数，
+ * 若用它同时充当展示截断，>50 事件的会话累计 usage 会少算。这里拉取一个足够大的
+ * 上限保证 usage 累加覆盖整个会话；展示仍由 capEvents(opts?.maxEvents ?? 50) 截断。
+ * （若 DSH 支持分页 cursor 可改成分页，当前用有界大拉取，见 review-fix-plan-cc.md）
+ */
+const DSH_HISTORY_FETCH_LIMIT = 10_000;
+/** Synchronous unary POST via curl (the reader interface is synchronous). */
+function defaultSyncRequest(baseUrl, method, payload) {
+    const body = JSON.stringify({
+        type: 'client-request',
+        rpcId: `rpc-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+        method,
+        payload,
+    });
+    const res = spawnSync('curl', [
+        '-s',
+        '-X',
+        'POST',
+        `${baseUrl}/api/${method}`,
+        '-H',
+        'content-type: application/json',
+        '--data',
+        body,
+    ], { encoding: 'utf-8', timeout: 15_000, maxBuffer: 64 * 1024 * 1024 });
+    if (res.error || res.status !== 0) {
+        throw new Error(`DSH ${method} failed: ${(res.error?.message ?? res.stderr) || 'unknown'}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(res.stdout);
+    }
+    catch (err) {
+        throw new Error(`DSH ${method} returned non-JSON: ${err.message}`, {
+            cause: err,
+        });
+    }
+    if (parsed.result?.ok !== true) {
+        throw new Error(parsed.result?.error?.message ?? `DSH ${method} failed`);
+    }
+    return parsed.result.value;
+}
+export class DshSessionReader {
+    hostProvider;
+    syncRequest;
+    constructor(opts = {}) {
+        const fixed = (opts.host ?? DEFAULT_DSH_HOST).replace(/\/$/, '');
+        this.hostProvider = opts.hostProvider ?? (() => fixed);
+        this.syncRequest = opts.syncRequest ?? defaultSyncRequest;
+    }
+    /** 解析当前 host（hostProvider 优先，允许 /config 热改 host）。 */
+    resolveBaseUrl() {
+        const host = this.hostProvider();
+        return (host && host.length > 0 ? host : DEFAULT_DSH_HOST).replace(/\/$/, '');
+    }
+    unary(method, payload) {
+        return this.syncRequest(this.resolveBaseUrl(), method, payload);
+    }
+    listSessions(cwd, opts) {
+        try {
+            const value = this.unary('session.list', {});
+            const items = value.items ?? [];
+            const filtered = items
+                .filter((i) => i.cwd === cwd)
+                .sort((a, b) => b.updatedAt - a.updatedAt || String(a.sessionId).localeCompare(String(b.sessionId)))
+                .map((i) => ({
+                sessionId: String(i.sessionId),
+                summary: '',
+                mtime: i.updatedAt,
+                ...(i.agentPreset ? { agentPreset: i.agentPreset } : {}),
+            }));
+            const { items: page, total } = paginate(filtered, opts ?? {});
+            return { sessions: page, total };
+        }
+        catch (error) {
+            getLogger().error(`[dsh-session-reader] listSessions error: ${error.message}`);
+            return { sessions: [], total: 0 };
+        }
+    }
+    getNewestSession(cwd) {
+        return this.listSessions(cwd, { limit: 1 }).sessions[0] ?? null;
+    }
+    readSessionContent(sessionId, cwd, opts) {
+        try {
+            const value = this.unary('session.history', {
+                sessionId,
+                maxMessages: DSH_HISTORY_FETCH_LIMIT,
+            });
+            const events = [];
+            let displayTitle;
+            let cumInput = 0;
+            let cumOutput = 0;
+            let cumCacheRead = 0;
+            let cumCacheWrite = 0;
+            let lastUsage;
+            for (const entry of value.events ?? []) {
+                const ev = entry.event;
+                if (!ev)
+                    continue;
+                const contentEvents = mapEvent(ev);
+                events.push(...contentEvents.events);
+                if (contentEvents.title)
+                    displayTitle = contentEvents.title;
+                const u = contentEvents.usage;
+                if (u) {
+                    // Cumulative (session-wide): sum across ALL assistant/message usage.
+                    cumInput += u.inputTokens ?? 0;
+                    cumOutput += u.outputTokens ?? 0;
+                    cumCacheRead += u.cacheReadTokens ?? 0;
+                    cumCacheWrite += u.cacheWriteTokens ?? 0;
+                    // Per-turn "current window" fields reflect the LAST assistant/message
+                    // with usage (ccusage/`last_token_usage` 口径, AGENTS.md §9.21) — a
+                    // multi-turn session's current context water-mark is the last turn's,
+                    // not the accumulated total.
+                    lastUsage = u;
+                }
+            }
+            let sessionUsage;
+            if (lastUsage) {
+                const input = lastUsage.inputTokens ?? 0;
+                const output = lastUsage.outputTokens ?? 0;
+                const cacheRead = lastUsage.cacheReadTokens ?? 0;
+                const cacheWrite = lastUsage.cacheWriteTokens ?? 0;
+                sessionUsage = {
+                    inputTokens: input,
+                    outputTokens: output,
+                    contextLength: input + cacheRead + cacheWrite,
+                    cacheReadTokens: cacheRead,
+                    cacheCreationTokens: cacheWrite,
+                    totalTokens: input + output + cacheRead + cacheWrite,
+                    cumulativeTotalTokens: cumInput + cumOutput + cumCacheRead + cumCacheWrite,
+                    cumulativeInputTokens: cumInput,
+                    cumulativeOutputTokens: cumOutput,
+                    cumulativeCacheReadTokens: cumCacheRead,
+                    cumulativeCacheCreationTokens: cumCacheWrite,
+                };
+            }
+            return {
+                // CC-05: 展示仍按 maxEvents 尾截断（默认 50，保持原行为），usage 已在上面基于
+                // 完整 history 累加。
+                events: capEvents(events, opts?.maxEvents ?? 50),
+                ...(sessionUsage ? { usage: sessionUsage } : {}),
+                ...(displayTitle ? { displayTitle } : {}),
+            };
+        }
+        catch (error) {
+            getLogger().error(`[dsh-session-reader] readSessionContent error: ${error.message}`);
+            return { events: [] };
+        }
+    }
+    isSessionActive(sessionId, cwd) {
+        try {
+            const value = this.unary('session.list', {});
+            const found = (value.items ?? []).find((i) => String(i.sessionId) === sessionId && i.cwd === cwd);
+            return found?.running === true;
+        }
+        catch (error) {
+            getLogger().error(`[dsh-session-reader] isSessionActive error: ${error.message}`);
+            return false;
+        }
+    }
+}
+/** Map one DSH SessionEvent to display content events (+ title/usage side effects). */
+function mapEvent(ev) {
+    const out = { events: [] };
+    switch (ev.type) {
+        case 'user/message': {
+            const content = ev.data.content ?? [];
+            const text = content
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text ?? '')
+                .join('');
+            out.events.push({ type: 'user', content: text, timestamp: new Date(ev.time).toISOString() });
+            break;
+        }
+        case 'assistant/message': {
+            const content = ev.data.message
+                ?.content ?? [];
+            const text = content
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text ?? '')
+                .join('');
+            if (text)
+                out.events.push({
+                    type: 'assistant',
+                    content: text,
+                    timestamp: new Date(ev.time).toISOString(),
+                });
+            const usage = ev.data.usage;
+            if (usage && typeof usage === 'object')
+                out.usage = usage;
+            break;
+        }
+        case 'tool/call': {
+            const name = String(ev.data.name ?? '');
+            const args = typeof ev.data.arguments === 'string' ? ev.data.arguments : '';
+            out.events.push({
+                type: 'tool_use',
+                content: `${name}(${truncateUtf8(args, 200)})`,
+                timestamp: new Date(ev.time).toISOString(),
+            });
+            break;
+        }
+        case 'tool/result': {
+            const msg = ev.data.message;
+            const raw = stringifyContent(msg?.content);
+            out.events.push({
+                type: 'tool_result',
+                content: truncateUtf8(raw, TOOL_RESULT_MAX_BYTES),
+                timestamp: new Date(ev.time).toISOString(),
+            });
+            break;
+        }
+        default:
+            break;
+    }
+    return out;
+}
+function stringifyContent(content) {
+    if (content == null)
+        return '[tool result]';
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((c) => c && typeof c === 'object' && 'text' in c
+            ? String(c.text)
+            : JSON.stringify(c))
+            .join('');
+    }
+    return JSON.stringify(content);
+}
+//# sourceMappingURL=sessions.js.map

package/dist/session/index.d.ts

@@ -5,3 +5,4 @@ export { CodexSessionReader } from './codex/index.js';
 export { OpencodeSessionReader } from './opencode/index.js';
 export { PiSessionReader } from './pi/index.js';
 export { KimiSessionReader } from './kimi/index.js';
+export { DshSessionReader } from './dsh/index.js';

package/dist/session/index.js

@@ -8,4 +8,5 @@ export { CodexSessionReader } from './codex/index.js';
 export { OpencodeSessionReader } from './opencode/index.js';
 export { PiSessionReader } from './pi/index.js';
 export { KimiSessionReader } from './kimi/index.js';
+export { DshSessionReader } from './dsh/index.js';
 //# sourceMappingURL=index.js.map

package/dist/workspace/index.d.ts

@@ -11,6 +11,12 @@ export interface WorkspaceEntry {
  * mid-write cannot leave a truncated JSON file. On load, a corrupt file
  * is treated as empty (with a warning) so the bridge can still start.
  *
+ * lastUsedAt 语义（2026-08-19 语义对齐）：保存（save）与使用（use/touch）
+ * 都会把时间戳更新为当前时间。save 内部调用 touch，保证「最近使用」排序
+ * 对新保存的 workspace 同样生效（新条目应排在列表最前，而非沉底）。
+ * 同一毫秒内连续操作时 touch 会用 max+1 保证严格递增，避免 Date.now 相同
+ * 导致最近排序退化为字母序。
+ *
  * Data migration: old format `{ alias: "path" }` is normalized to
  * `{ alias: { path, lastUsedAt: 0 } }` on first load and persisted.
  */
@@ -27,6 +33,12 @@ export declare class WorkspaceStore {
     /**
      * Update lastUsedAt to now for the given alias and persist.
      * No-op if the alias does not exist.
+     *
+     * To keep "recent" ordering stable even for rapid successive saves/uses in
+     * the same millisecond, never allow another entry to share the same
+     * timestamp while this entry is being touched. If a peer already has a
+     * timestamp at or after the current wall-clock time, use max+1 so the
+     * touched entry always becomes the most recently used.
      */
     touch(name: string): void;
     /**

package/dist/workspace/index.js

@@ -10,6 +10,12 @@ import { getLogger } from '../logger/index.js';
  * mid-write cannot leave a truncated JSON file. On load, a corrupt file
  * is treated as empty (with a warning) so the bridge can still start.
  *
+ * lastUsedAt 语义（2026-08-19 语义对齐）：保存（save）与使用（use/touch）
+ * 都会把时间戳更新为当前时间。save 内部调用 touch，保证「最近使用」排序
+ * 对新保存的 workspace 同样生效（新条目应排在列表最前，而非沉底）。
+ * 同一毫秒内连续操作时 touch 会用 max+1 保证严格递增，避免 Date.now 相同
+ * 导致最近排序退化为字母序。
+ *
  * Data migration: old format `{ alias: "path" }` is normalized to
  * `{ alias: { path, lastUsedAt: 0 } }` on first load and persisted.
  */
@@ -60,8 +66,11 @@ export class WorkspaceStore {
         atomicWriteJson(this.filePath, obj);
     }
     save(name, dirPath) {
+        // 保存即视为使用（语义对齐）：新建/覆盖的 workspace 都应拿到当前
+        // lastUsedAt，而不是 0，否则「最近使用」排序下新条目会沉底。
+        // touch() 负责统一写入时间戳并 persist，消除 save 写 0 / use 写 now 的不对称。
         this.data.set(name, { path: dirPath, lastUsedAt: 0 });
-        this.persist();
+        this.touch(name);
     }
     get(name) {
         return this.data.get(name)?.path;
@@ -76,12 +85,29 @@ export class WorkspaceStore {
     /**
      * Update lastUsedAt to now for the given alias and persist.
      * No-op if the alias does not exist.
+     *
+     * To keep "recent" ordering stable even for rapid successive saves/uses in
+     * the same millisecond, never allow another entry to share the same
+     * timestamp while this entry is being touched. If a peer already has a
+     * timestamp at or after the current wall-clock time, use max+1 so the
+     * touched entry always becomes the most recently used.
      */
     touch(name) {
         const entry = this.data.get(name);
         if (!entry)
             return;
-        entry.lastUsedAt = Date.now();
+        const now = Date.now();
+        let max = Math.max(now, entry.lastUsedAt);
+        let hasPeerAtOrAfterNow = false;
+        for (const [otherName, other] of this.data) {
+            if (otherName === name)
+                continue;
+            if (other.lastUsedAt > max)
+                max = other.lastUsedAt;
+            if (other.lastUsedAt >= now)
+                hasPeerAtOrAfterNow = true;
+        }
+        entry.lastUsedAt = hasPeerAtOrAfterNow ? max + 1 : max;
         this.persist();
     }
     /**