lark-remote 0.5.7 → 0.5.9

package/dist/router/order-exec-dispatch.js

@@ -1,3 +1,4 @@
+import { ORDER_NOT_FOUND_TEXT } from '../order/index.js';
 /**
  * Dispatch an `order.exec` card action as an equivalent queued user message
  * (Plan A): resolve the order text at the enqueue boundary, then enqueue it
@@ -20,7 +21,7 @@ export async function dispatchOrderExecForQueue(args) {
     }
     const resolved = router.resolveOrderExecForQueue(orderId);
     if (!resolved) {
-        await bridge.sendResult({ text: '指令不存在或已被删除' }, ctx);
+        await bridge.sendResult({ text: ORDER_NOT_FOUND_TEXT }, ctx);
         return 'not-found';
     }
     // Step4/入队时刻快照 agent+session，随任务闭包带到执行时刻，

package/dist/router/usage-format.d.ts

@@ -52,4 +52,9 @@ export declare function formatUsageStats(usage?: {
 }, options?: {
     showResult?: boolean;
     result?: string;
+    /**
+     * 首行状态文案。默认 `✅ 已完成`；goal 仍 active 的收尾卡必须换掉它——
+     * 本轮 turn 结束不等于任务结束。
+     */
+    completedLabel?: string;
 }): string;

package/dist/router/usage-format.js

@@ -40,7 +40,7 @@ function formatTokenK(n) {
 export function formatUsageStats(usage, options) {
     const lines = [];
     // 1. Success 状态（通用格式，无具体结果值）
-    lines.push('✅ 已完成');
+    lines.push(options?.completedLabel ?? '✅ 已完成');
     // 1.4. 实际生效模型（非空字符串才显示）
     if (usage?.model) {
         lines.push(`Model - ${usage.model}`);

package/dist/runner/common/defaults.d.ts

@@ -0,0 +1,2 @@
+/** 默认单请求超时（JSON-RPC 与 DSH HTTP client 共用）。 */
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 60000;

package/dist/runner/common/defaults.js

@@ -0,0 +1,3 @@
+/** 默认单请求超时（JSON-RPC 与 DSH HTTP client 共用）。 */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+//# sourceMappingURL=defaults.js.map

package/dist/runner/common/jsonrpc/connection-manager.js

@@ -17,8 +17,8 @@ import { JsonlRpcTransport } from './transport.js';
 import { JsonRpcClient } from './client.js';
 import { getLogger } from '../../../logger/index.js';
 import { agentStopperRegistry, } from '../../../platform/agent-stopper.js';
+import { DEFAULT_REQUEST_TIMEOUT_MS } from '../defaults.js';
 const DEFAULT_IDLE_TTL_MS = 30 * 60 * 1000; // 30 minutes
-const DEFAULT_REQUEST_TIMEOUT_MS = 60_000; // 60 seconds
 /** acquire() 的轮次上限：防止 slot 被持续释放时无限重建连接。 */
 const MAX_ACQUIRE_ATTEMPTS = 5;
 export class ConnectionManager {

package/dist/runner/dsh/client.d.ts

@@ -20,6 +20,7 @@
  * replay, and seq-based dedup.
  */
 import type { DshApprovalStreamItem, DshCommandResult, DshModelCatalogValue, DshModelSelection, DshOpenTurnState, DshPermissionCatalogValue, DshJobView, DshPresetListValue, DshProjectionItem, DshProjectionSnapshot, DshQuestion, DshRemoteEventOutcome, DshSessionPageValue, DshStreamItem, DshTokenUsage } from './types.js';
+import type { GoalView } from '../types.js';
 interface WebSocketMessageEvent {
     data: unknown;
 }
@@ -193,6 +194,20 @@ export declare class DshClient {
         signal?: AbortSignal;
         timeoutMs?: number;
     }): Promise<DshProjectionSnapshot | null>;
+    /**
+     * Read the session's current goal (one unary, authoritative at call time).
+     *
+     * 收尾判定必须用宿主状态：本轮 turn 结束不代表任务结束——goal 仍 active 时
+     * driver 会在 quiescence 立刻起下一轮。`known:false` 表示读不到，调用方不得
+     * 据此断言"已完成"（探测失败降级为收尾，正是"任务还在跑却写完成"的来源）。
+     */
+    goalState(sessionId: string, opts?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<{
+        known: boolean;
+        goal: GoalView | null;
+    }>;
     /**
      * Find this run's prompt if it is still sitting in the host's inbox.
      *

package/dist/runner/dsh/client.js

@@ -23,6 +23,8 @@ import { randomUUID } from 'node:crypto';
 import WebSocket from 'ws';
 import { getLogger } from '../../logger/index.js';
 import { DSH_COOKIE_LIFETIME_MS, isDshCredentialsNotFound, mintDshBrowserCookie, readDshBrowserSecret, resolveDshCredentialsFile, } from './auth.js';
+import { DEFAULT_REQUEST_TIMEOUT_MS } from '../common/defaults.js';
+import { goalFromProjection } from './goal-view.js';
 function defaultWebSocketFactory(url, options) {
     const socket = new WebSocket(url, {
         ...(options?.headers ? { headers: options.headers } : {}),
@@ -105,8 +107,6 @@ function inboxItemsOf(values) {
     }
     return out;
 }
-/** Default unary timeout: long prompts are unbounded on the server side. */
-const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
 /** Extract the `token` query parameter from a pasted `dsh web` URL. */
 export function extractDshToken(raw) {
     const value = (raw ?? '').trim();
@@ -450,6 +450,32 @@ export class DshClient {
                 : {},
         };
     }
+    /**
+     * Read the session's current goal (one unary, authoritative at call time).
+     *
+     * 收尾判定必须用宿主状态：本轮 turn 结束不代表任务结束——goal 仍 active 时
+     * driver 会在 quiescence 立刻起下一轮。`known:false` 表示读不到，调用方不得
+     * 据此断言"已完成"（探测失败降级为收尾，正是"任务还在跑却写完成"的来源）。
+     */
+    async goalState(sessionId, opts) {
+        let snapshot;
+        try {
+            snapshot = await this.projectionSnapshot(sessionId, opts);
+        }
+        catch (err) {
+            if (opts?.signal?.aborted)
+                throw err;
+            getLogger().warn(`[dsh] goal probe failed session=${sessionId}: ${err.message}`);
+            return { known: false, goal: null };
+        }
+        // 拿不到投影 = 宿主没这个会话的投影，不等于"没有 goal"。
+        if (!snapshot)
+            return { known: false, goal: null };
+        const parsed = goalFromProjection(snapshot.values.goal);
+        if (parsed === undefined)
+            return { known: false, goal: null };
+        return { known: true, goal: parsed };
+    }
     /**
      * Find this run's prompt if it is still sitting in the host's inbox.
      *

package/dist/runner/dsh/goal-view.d.ts

@@ -0,0 +1,36 @@
+/**
+ * DSH `goal` 域 → 卡片用的 {@link GoalView} 解析。
+ *
+ * 两个来源、同一个目标类型：
+ * 1. 投影值：`session/projections` 的 `values.goal` 与 `session/control` 的
+ *    `{key:'goal'}` 帧，宿主状态包一层 `current`（`{current:{goal,roundsStarted
+ *    ,createdAt,updatedAt},seenGoalIds,failure}`）；
+ * 2. 会话事件 `goal/change`：create/edit/pause/resume/complete/block 携带完整
+ *    snapshot + roundsStarted；clear 是墓碑，表示"现在没有 goal"。
+ *
+ * 解析失败返回 `undefined`，表示**读不懂**——它与"没有 goal"（`null`）必须区分：
+ * 把读不懂当成没有 goal，就会在 goal 还在自动续跑时收尾卡片。
+ */
+import type { GoalView } from '../types.js';
+/**
+ * 解析投影里的 goal 状态。
+ *
+ * @returns `GoalView` = 有 goal；`null` = 宿主明确没有 goal；`undefined` = 读不懂。
+ */
+export declare function goalFromProjection(value: unknown): GoalView | null | undefined;
+/**
+ * 解析 `goal/change` 事件 payload。
+ *
+ * @returns `GoalView` = 变更后的 goal；`null` = clear（现在没有 goal）；
+ *   `undefined` = 读不懂。
+ */
+export declare function goalFromChange(data: unknown): GoalView | null | undefined;
+/** 便利构造：把解析结果包成 runner 事件。 */
+export declare function goalStateEvent(goal: GoalView | null, known: boolean): {
+    type: 'goal_state';
+    goal: GoalView | null;
+    known: boolean;
+    timestamp: string;
+};
+/** 两次观测是否等价（用于抑制重复帧，不触发重渲染）。 */
+export declare function sameGoal(a: GoalView | null | undefined, b: GoalView | null | undefined): boolean;

package/dist/runner/dsh/goal-view.js

@@ -0,0 +1,106 @@
+/**
+ * DSH `goal` 域 → 卡片用的 {@link GoalView} 解析。
+ *
+ * 两个来源、同一个目标类型：
+ * 1. 投影值：`session/projections` 的 `values.goal` 与 `session/control` 的
+ *    `{key:'goal'}` 帧，宿主状态包一层 `current`（`{current:{goal,roundsStarted
+ *    ,createdAt,updatedAt},seenGoalIds,failure}`）；
+ * 2. 会话事件 `goal/change`：create/edit/pause/resume/complete/block 携带完整
+ *    snapshot + roundsStarted；clear 是墓碑，表示"现在没有 goal"。
+ *
+ * 解析失败返回 `undefined`，表示**读不懂**——它与"没有 goal"（`null`）必须区分：
+ * 把读不懂当成没有 goal，就会在 goal 还在自动续跑时收尾卡片。
+ */
+const PHASES = new Set(['active', 'paused', 'blocked', 'complete']);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonNegativeInt(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+function parseSnapshot(value, roundsStarted) {
+    if (!isRecord(value))
+        return undefined;
+    const phase = value.phase;
+    if (typeof phase !== 'string' || !PHASES.has(phase))
+        return undefined;
+    if (typeof value.objective !== 'string')
+        return undefined;
+    if (typeof value.id !== 'string' || value.id.length === 0)
+        return undefined;
+    const max = nonNegativeInt(value.maxGoalRounds);
+    if (max === undefined)
+        return undefined;
+    const reason = value.blockedReason;
+    const blockedReason = isRecord(reason) && typeof reason.code === 'string' && typeof reason.message === 'string'
+        ? { code: reason.code, message: reason.message }
+        : undefined;
+    return {
+        id: value.id,
+        objective: value.objective,
+        // 上面已按白名单校验，这里收窄回联合类型。
+        phase: phase,
+        roundsStarted: nonNegativeInt(roundsStarted) ?? 0,
+        maxGoalRounds: max,
+        ...(blockedReason ? { blockedReason } : {}),
+    };
+}
+/**
+ * 解析投影里的 goal 状态。
+ *
+ * @returns `GoalView` = 有 goal；`null` = 宿主明确没有 goal；`undefined` = 读不懂。
+ */
+export function goalFromProjection(value) {
+    if (value === null)
+        return null;
+    if (!isRecord(value))
+        return undefined;
+    // 宿主状态信封：{current:{goal,roundsStarted,...}, seenGoalIds, failure}
+    if ('current' in value) {
+        const current = value.current;
+        if (current === null)
+            return null;
+        if (!isRecord(current))
+            return undefined;
+        if (current.goal === undefined || current.goal === null)
+            return null;
+        return parseSnapshot(current.goal, current.roundsStarted);
+    }
+    // 兼容直接投递 GoalProjection 的形态：{goal, roundsStarted, ...}
+    if (value.goal === undefined || value.goal === null)
+        return null;
+    return parseSnapshot(value.goal, value.roundsStarted);
+}
+/**
+ * 解析 `goal/change` 事件 payload。
+ *
+ * @returns `GoalView` = 变更后的 goal；`null` = clear（现在没有 goal）；
+ *   `undefined` = 读不懂。
+ */
+export function goalFromChange(data) {
+    if (!isRecord(data))
+        return undefined;
+    if (data.operation === 'clear')
+        return null;
+    if (typeof data.operation !== 'string')
+        return undefined;
+    return parseSnapshot(data.goal, data.roundsStarted);
+}
+/** 便利构造：把解析结果包成 runner 事件。 */
+export function goalStateEvent(goal, known) {
+    return { type: 'goal_state', goal, known, timestamp: new Date().toISOString() };
+}
+/** 两次观测是否等价（用于抑制重复帧，不触发重渲染）。 */
+export function sameGoal(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || a === undefined || b === null || b === undefined)
+        return false;
+    return (a.id === b.id &&
+        a.phase === b.phase &&
+        a.roundsStarted === b.roundsStarted &&
+        a.maxGoalRounds === b.maxGoalRounds &&
+        a.objective === b.objective &&
+        a.blockedReason?.code === b.blockedReason?.code);
+}
+//# sourceMappingURL=goal-view.js.map

package/dist/runner/dsh/runner.js

@@ -19,6 +19,7 @@
  */
 import { DshClient, DshError, newPromptRequestId } from './client.js';
 import { DshTranslator } from './translator.js';
+import { goalFromChange, goalFromProjection, goalStateEvent, sameGoal } from './goal-view.js';
 import { DshApprovalTracker } from './approval.js';
 import { mergeAsync } from './merge.js';
 import { getLogger } from '../../logger/index.js';
@@ -81,6 +82,11 @@ function buildQuestionAnswers(questions, response) {
 }
 /** Budget for one session/cancel attempt on stop. */
 const CANCEL_TIMEOUT_MS = 5_000;
+/**
+ * goal 探测的预算。goal 是"增强信息"：读不到就按没有（known:false）继续跑，
+ * 但绝不允许一次慢投影把整个 run 的启动/收尾拖住。
+ */
+const GOAL_PROBE_TIMEOUT_MS = 5_000;
 /** Total stop budget: withdraw + cancel + verify must not hold the lane forever. */
 const STOP_BUDGET_MS = 5_000;
 /** A prompt request that was still in flight can land after stop's abort. */
@@ -434,6 +440,18 @@ export class DshRunner {
                 cwd: opts.cwd,
                 model: this.configuredModel ?? 'DSH',
             };
+            // Goal seed：卡片从第一帧就知道这个会话有没有长期目标。放在 init 之后、
+            // prompt 之前——用户发消息时若是 queued，卡片会长时间停在「运行中」，
+            // 这期间"目标是什么、第几轮"是唯一能解释"为什么还不停"的信息。
+            const seedGoal = await this.client.goalState(sessionId, {
+                signal: abort.signal,
+                timeoutMs: GOAL_PROBE_TIMEOUT_MS,
+            });
+            const lastGoal = seedGoal.known ? seedGoal.goal : undefined;
+            // 只有确实存在 goal 才产事件：没有 goal 的会话保持事件序列不变（少一次
+            // 渲染，也不让"读不到"变成一张多出来的卡片事件）。
+            if (seedGoal.known && seedGoal.goal)
+                yield goalStateEvent(seedGoal.goal, true);
             try {
                 // Snapshot the pre-prompt high-water mark before mutating the session.
                 // DSH session/page returns the whole session, so starting from seq 0
@@ -476,7 +494,7 @@ export class DshRunner {
                     return;
                 }
                 try {
-                    for await (const ev of this.runTurn(sessionId, opts.cwd, prePromptSeq, promptRequestId, abort)) {
+                    for await (const ev of this.runTurn(sessionId, opts.cwd, prePromptSeq, promptRequestId, abort, { last: lastGoal })) {
                         yield ev;
                         if (ev.type === 'result') {
                             terminalEmitted = true;
@@ -550,7 +568,7 @@ export class DshRunner {
      * events; `$events` owns the answerable approval waterfall. The merged
      * stream keeps either transport from starving the other.
      */
-    async *runTurn(sessionId, cwd, prePromptSeq, promptRequestId, abort) {
+    async *runTurn(sessionId, cwd, prePromptSeq, promptRequestId, abort, goal) {
         const streamAbort = new AbortController();
         const signal = AbortSignal.any([abort.signal, streamAbort.signal]);
         const translator = new DshTranslator();
@@ -577,6 +595,16 @@ export class DshRunner {
                     // 扩展的，不能因为多了个 key 就报错）。
                     if (item.sessionId !== sessionId)
                         continue;
+                    // goal 是会话级长期目标，单独成事件：卡片要在 agent 创建目标的当下
+                    // 就显示它（否则用户只会在一小时后看到「完成」才发现有个 40 轮任务）。
+                    if (item.key === 'goal') {
+                        const parsed = goalFromProjection(item.value);
+                        if (parsed !== undefined && !sameGoal(parsed, goal.last)) {
+                            goal.last = parsed;
+                            yield goalStateEvent(parsed, true);
+                        }
+                        continue;
+                    }
                     // 只在消费字段真的变了时才产出事件：投影帧本身按 key 去重推送，
                     // 这里再挡掉"值没变"的重复帧。不需要时间节流——卡片更新本来就有
                     // 100ms 合批窗口，与正文 delta 共用同一条节流路径。
@@ -654,6 +682,16 @@ export class DshRunner {
                     continue;
                 }
                 const event = item.event;
+                if (event.type === 'goal/change') {
+                    // 权威变更（create/edit/pause/resume/complete/block/clear）：不等投影
+                    // 推送，直接按事件更新——agent 刚 create 的那一刻卡片就该显示目标。
+                    const parsed = goalFromChange(event.data);
+                    if (parsed !== undefined && !sameGoal(parsed, goal.last)) {
+                        goal.last = parsed;
+                        yield goalStateEvent(parsed, true);
+                    }
+                    continue;
+                }
                 if (event.type === 'tool/call') {
                     const data = event.data;
                     if (data.callId && data.name) {
@@ -686,6 +724,17 @@ export class DshRunner {
                             for (const jobsEvent of await this.collectBackgroundJobs(sessionId, abort.signal)) {
                                 yield jobsEvent;
                             }
+                            // 收尾复核：这一轮结束时 goal 是否仍 active，决定卡片能不能收尾。
+                            // 必须现读宿主，不能沿用过程中的最后一次观测——goal 可能在本轮
+                            // 最后一个 step 才被 complete，也可能刚被 driver 置为 blocked。
+                            const finalGoal = await this.client.goalState(sessionId, {
+                                signal,
+                                timeoutMs: GOAL_PROBE_TIMEOUT_MS,
+                            });
+                            if (finalGoal.known && !sameGoal(finalGoal.goal, goal.last)) {
+                                goal.last = finalGoal.goal;
+                                yield goalStateEvent(finalGoal.goal, true);
+                            }
                         }
                         yield attachContextLimit(ev, live.contextLimit);
                         return;

package/dist/runner/index.d.ts

@@ -15,6 +15,6 @@ export { KimiAcpRunner } from './kimi/index.js';
 export { DshRunner } from './dsh/index.js';
 export { BashProcessRunner, type BashRunner } from './bash/index.js';
 export { AgentRegistry } from './registry.js';
-export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, SessionSummary, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, NoticeEvent, SessionInfoEvent, ToolHint, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, } from './types.js';
+export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, SessionSummary, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, NoticeEvent, SessionInfoEvent, ToolHint, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, GoalView, GoalStateEvent, } from './types.js';
 export { resolveAgentChoices } from './resolve-agent-choices.js';
 export { syncAgentChoices } from './sync-agent-choices.js';

package/dist/runner/types.d.ts

@@ -347,6 +347,45 @@ export interface RunStatusEvent {
     toolMs?: number;
     timestamp?: string;
 }
+/**
+ * 会话级长期目标（DSH `goal` 投影的渲染快照）。
+ *
+ * 为什么卡片需要它：goal 是**跨 turn** 的自动续跑单元。本轮 turn 结束不等于
+ * 任务结束——`goal-round-driver` 会在 quiescence 立刻起下一轮。缺这一维，
+ * 卡片只能在"这一轮结束了"时收尾，于是出现"任务还在跑、卡片却写完成"
+ * （turn/end 后宿主立刻起 goal round 2，用户点 Compact 被拒）。
+ */
+export interface GoalView {
+    id: string;
+    /** 人类写下的目标全文（可能很长，渲染层负责截断/折叠）。 */
+    objective: string;
+    phase: 'active' | 'paused' | 'blocked' | 'complete';
+    /** 已启动的轮次（最高 admitted round）。 */
+    roundsStarted: number;
+    /** 轮次上限；达到后 driver 把 goal 置为 blocked(round-limit)。 */
+    maxGoalRounds: number;
+    /** 仅在 phase='blocked' 时存在：阻断分类与人类可读原因。 */
+    blockedReason?: {
+        code: string;
+        message: string;
+    };
+    updatedAt?: number;
+}
+/**
+ * 一次 goal 状态观测（seed / 变更事件 / 收尾复核共用）。
+ *
+ * `known=false` 表示**读不到**，与"明确没有 goal"（`goal=null`）是两件事。
+ * 把探测失败降级成"没有 goal"会退回旧行为（goal 还在跑、卡片却收尾），
+ * 所以两者必须分开表达。
+ */
+export interface GoalStateEvent {
+    type: 'goal_state';
+    /** null = 宿主明确表示该会话没有 goal。 */
+    goal: GoalView | null;
+    /** false = 探测失败，`goal` 不具权威性，渲染层不得据此断言"已完成"。 */
+    known: boolean;
+    timestamp?: string;
+}
 /**
  * 运行结束后仍在后台运行的任务（终态卡展示 + 逐个停止入口）。
  *
@@ -431,7 +470,7 @@ export interface TurnDiffEvent {
 export type RunnerLifetime = 'turn' | 'workspace';
 /** 工具渲染 hint：runner 自愿声明，渲染层只消费不推断。 */
 export type ToolHint = 'shell' | 'file' | 'search' | 'web' | 'patch';
-export type AgentEvent = SystemInitEvent | SystemCompactEvent | ApprovalRequestedEvent | ApprovalResolvedEvent | ApprovalViewUpdatedEvent | ApprovalExpiredEvent | AssistantEvent | UserEvent | ResultEvent | PlanEvent | FileChangeEvent | TurnStartedEvent | TurnDiffEvent | NoticeEvent | SessionInfoEvent | RunStatusEvent | BackgroundJobsEvent;
+export type AgentEvent = SystemInitEvent | SystemCompactEvent | ApprovalRequestedEvent | ApprovalResolvedEvent | ApprovalViewUpdatedEvent | ApprovalExpiredEvent | AssistantEvent | UserEvent | ResultEvent | PlanEvent | FileChangeEvent | TurnStartedEvent | TurnDiffEvent | NoticeEvent | SessionInfoEvent | RunStatusEvent | BackgroundJobsEvent | GoalStateEvent;
 export interface SpawnOptions {
     cwd: string;
     sessionId?: string;
@@ -507,6 +546,8 @@ export interface Runner {
  */
 export declare const AGENT_KINDS: readonly ["claude", "codex", "opencode", "pi", "kimi", "dsh"];
 export type AgentKind = (typeof AGENT_KINDS)[number];
+/** 用户可见 agent 显示名单源：启动注册与无 registry 的回退路径共用。 */
+export declare const AGENT_DISPLAY_NAMES: Record<AgentKind, string>;
 /**
  * Compact 能力声明（运行时门控的能力清单，编译期强制完整）。
  *
@@ -529,6 +570,23 @@ export interface AgentSession {
     mtime: number;
     /** DSH：session 创建时固定的 preset；其他 agent 无此概念（undefined）。 */
     agentPreset?: string;
+    /**
+     * 服务端投影已有的会话标题（DSH `projections.values.title`）。
+     *
+     * 与 `summary` 的区别：`summary` 是「首条用户输入」的兜底口径（claude /
+     * codex / pi / kimi 无标题字段），`title` 是 agent 自己起的标题。列表卡
+     * 用它决定标签文案（标题 / 会话摘要），缺省时回退 `summary`。
+     */
+    title?: string;
+    /**
+     * 最后一轮用户输入（服务端投影，单行预览）。
+     *
+     * 只给「列表响应里已顺带返回」的 reader 用（DSH 的 `turnOutline` 末条），
+     * 目的是让列表卡不必为每行做一次全量内容读取。
+     */
+    lastUserMessage?: string;
+    /** 最后一轮助手输出（服务端投影已截断，单行预览）。 */
+    lastAssistantMessage?: string;
 }
 /** A single renderable event from session history. */
 export interface AgentSessionContentEvent {

package/dist/runner/types.js

@@ -16,6 +16,15 @@
  * 新增 agent 只改这里。
  */
 export const AGENT_KINDS = ['claude', 'codex', 'opencode', 'pi', 'kimi', 'dsh'];
+/** 用户可见 agent 显示名单源：启动注册与无 registry 的回退路径共用。 */
+export const AGENT_DISPLAY_NAMES = {
+    claude: 'Claude',
+    codex: 'Codex',
+    opencode: 'Opencode',
+    pi: 'Pi',
+    kimi: 'Kimi',
+    dsh: 'DSH',
+};
 /**
  * Compact 能力声明（运行时门控的能力清单，编译期强制完整）。
  *

package/dist/session/claude/session-index.d.ts

@@ -74,10 +74,6 @@ export declare class SessionIndex {
     private readonly byCwd;
     private lastRefreshAt;
     private built;
-    /** Test-only: count of parseSessionJsonl calls since creation */
-    parseCount: number;
-    /** Test-only: count of directory scan operations */
-    scanCount: number;
     constructor(projectsDir: string, opts?: SessionIndexOptions);
     /** Whether a full scan has ever completed successfully (readdir succeeded). */
     get isBuilt(): boolean;

package/dist/session/claude/session-index.js

@@ -146,10 +146,6 @@ export class SessionIndex {
     byCwd = new Map();
     lastRefreshAt = 0;
     built = false;
-    /** Test-only: count of parseSessionJsonl calls since creation */
-    parseCount = 0;
-    /** Test-only: count of directory scan operations */
-    scanCount = 0;
     constructor(projectsDir, opts = {}) {
         this.projectsDir = projectsDir;
         this.refreshIntervalMs = opts.refreshIntervalMs ?? 5000;
@@ -161,7 +157,6 @@ export class SessionIndex {
     }
     // ── Build (initial full scan) ───────────────────────────
     build() {
-        this.scanCount++;
         this.fullScan();
         this.lastRefreshAt = Date.now();
     }
@@ -171,7 +166,6 @@ export class SessionIndex {
         if (now - this.lastRefreshAt < this.refreshIntervalMs) {
             return; // throttled
         }
-        this.scanCount++;
         this.fullScan();
         this.lastRefreshAt = now;
     }
@@ -232,7 +226,6 @@ export class SessionIndex {
             }
             // Fingerprint changed → re-parse this single file
             const parsed = parseSessionJsonl(p);
-            this.parseCount++;
             try {
                 const st = fs.statSync(p, { bigint: true });
                 const updated = {
@@ -303,7 +296,6 @@ export class SessionIndex {
                 // Concurrent-write guard: stat before and after parse, compare fingerprints
                 const fpBefore = fp;
                 const parsed = parseSessionJsonl(fullPath);
-                this.parseCount++;
                 const fpAfter = buildFingerprint(fullPath);
                 if (fpBefore !== fpAfter) {
                     // File was modified during parse → skip this round, retry next refresh

package/dist/session/dsh/sessions.js

@@ -172,9 +172,9 @@ export class DshSessionReader {
                 .filter((i) => i.cwd !== undefined && samePath(i.cwd, cwd))
                 .map((i) => ({
                 sessionId: String(i.sessionId),
-                summary: '',
                 mtime: i.updatedAt,
                 ...sessionPreset(i),
+                ...sessionPreview(i),
             }));
             sortByRecencyDesc(filtered, (i) => i.mtime, (i) => i.sessionId);
             const { items: page, total } = paginate(filtered, opts ?? {});
@@ -200,6 +200,8 @@ export class DshSessionReader {
                 return { events: [] };
             }
             const throughSeq = this.resolveThroughSeq(sessionId, session);
+            // 服务端投影带来的标题与末轮输入：详情卡头部用它们，不必再从事件里猜。
+            const preview = sessionPreview(session);
             const value = this.unary('session/page', {
                 address: { kind: 'session', sessionId },
                 throughSeq,
@@ -307,12 +309,16 @@ export class DshSessionReader {
             // 中断/仍在执行的调用没有结果：把它当独立事件留下，别让这一条消失。
             if (pendingTool)
                 events.push(pendingTool);
+            // 头部信息口径：最近输入优先用服务端末轮 prompt（事件里可能只是当前 turn
+            // 的一部分），标题用服务端 title；两者都缺时保持原行为。
+            const headerLastInput = preview.lastUserMessage ?? displayTitle;
             return {
                 // 展示仍按 maxEvents 尾截断（默认 50，保持原行为），usage 已在上面基于
                 // 完整 history 累加。
                 events: capEvents(events, opts?.maxEvents ?? 50),
                 ...(sessionUsage ? { usage: sessionUsage } : {}),
-                ...(displayTitle ? { displayTitle } : {}),
+                ...(headerLastInput ? { displayTitle: headerLastInput } : {}),
+                ...(preview.title ? { aiTitle: preview.title } : {}),
             };
         }
         catch (error) {
@@ -353,6 +359,56 @@ function sessionPreset(item) {
     const preset = item.projections?.values?.agentPreset ?? item.agentPreset;
     return preset ? { agentPreset: preset } : {};
 }
+/**
+ * 会话预览（列表卡上的「标题 / 最近输入 / 最后输出」）。
+ *
+ * 全部取自 `session/list` 的 `projections.values`——DSH 0.2.x 已经随列表一起
+ * 返回 title 与 turnOutline（每轮的 prompt/response），所以这里不需要再拉
+ * `session/page`：它按 `maxMessages=10000` 的上限拉整段历史，一页前 5 行就是
+ * 5 次这种大响应（把每行的 cwd 守卫与 projections 一起算，是 15 次同步请求）。
+ *
+ * `turnOutline` 的 prompt/response 由 DSH 侧按长度截断（结尾带 `…`），列表卡
+ * 只做单行预览，直接复用即可。缺字段 / 类型不对时全部留空，不影响列表。
+ */
+function sessionPreview(item) {
+    const values = item.projections?.values;
+    const rawTitle = values?.title;
+    const title = typeof rawTitle === 'string' ? rawTitle.trim() : '';
+    const outline = values?.turnOutline;
+    const lastUserMessage = lastOutlineText(outline, 'prompt');
+    const lastAssistantMessage = lastOutlineText(outline, 'response');
+    return {
+        // summary 同时填标题：只认 summary 的消费方（旧卡片路径、其他 agent 的
+        // 统一逻辑）也能拿到可读文本，不必区分 agent。
+        summary: title,
+        ...(title ? { title } : {}),
+        ...(lastUserMessage ? { lastUserMessage } : {}),
+        ...(lastAssistantMessage ? { lastAssistantMessage } : {}),
+    };
+}
+/**
+ * 从 turnOutline 末条往回找第一个非空文本。
+ *
+ * 在途 turn 已经写进 outline，但 `response` 还是空串（实测末条
+ * `{turn:6, prompt:"…", response:""}`）；直接取末条会让「最后输出」空掉，
+ * 所以回溯到最近一条有内容的结果。
+ */
+function lastOutlineText(outline, key) {
+    if (!Array.isArray(outline))
+        return undefined;
+    for (let i = outline.length - 1; i >= 0; i -= 1) {
+        const entry = outline[i];
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const raw = entry[key];
+        if (typeof raw !== 'string')
+            continue;
+        const text = raw.trim();
+        if (text)
+            return text;
+    }
+    return undefined;
+}
 function emptyUsageTotals() {
     return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",