paseo-dsh-direct 0.2.9 → 0.2.11

package/README.md

@@ -33,7 +33,7 @@ Most dsh integrations go through ACP, a generic protocol that every agent can sp
 - Your existing dsh sessions can be imported and resumed in Paseo.
 - dsh's slash commands (`/compact`, `/plan`, ...) appear in Paseo's `/` menu.
 - Paseo's usage meter shows dsh's token counts and how full the context window is.
-- Goal changes, plan mode switches and permission preset changes show up in the conversation as small timeline cards.
+- Goal changes that dsh does not already report in a `/goal` command's own output, plan mode switches and permission preset changes show up in the conversation as small timeline cards.
 
 ## Versioning
 

package/README.zh.md

@@ -33,7 +33,7 @@ paseo plugin update paseo-dsh-direct --yes     # 更新到最新
 - 已有的 dsh 会话可以导入 Paseo 接着用。
 - dsh 的斜杠命令（`/compact`、`/plan` 等）出现在 Paseo 的 `/` 菜单里。
 - Paseo 的用量表显示 dsh 的 token 用量和上下文占用。
-- 目标变化、计划模式切换和权限预设变化会在对话里显示为小的时间线卡片。
+- 目标变化（dsh 自己在 `/goal` 命令输出里已报告的除外）、计划模式切换和权限预设变化会在对话里显示为小的时间线卡片。
 
 ## 版本号
 

package/client/settings-screen.tsx

@@ -5,9 +5,9 @@ import { useRef } from "react";
 import { DSH_SETTINGS } from "../shared/settings.js";
 
 const EXECUTABLE_HINT =
-  "Path or command of dsh. PASEO_DSH_EXECUTABLE overrides this; leave it empty to use the Paseo provider command or dsh on PATH. Changes apply to new sessions.";
+  "Path or command of dsh. PASEO_DSH_EXECUTABLE overrides this; leave it empty to use the Paseo provider command or dsh on PATH.";
 const PROFILE_HINT =
-  'Name of the dsh profile to launch. PASEO_DSH_PROFILE overrides this; leave it empty to use the "paseo" profile. Changes apply to new sessions.';
+  'Name of the dsh profile to launch. PASEO_DSH_PROFILE overrides this; leave it empty to use the "paseo" profile.';
 
 /** Edits the dsh executable and profile that the server reads when it launches a bridge. */
 export default function DshSettingsScreen() {
@@ -88,8 +88,8 @@ export default function DshSettingsScreen() {
           disabled={settings.saving}
         />
         <SettingsAction
-          label="Save"
-          hint={settings.saveError ?? undefined}
+          label="Apply settings"
+          hint={settings.saveError ?? "Changes apply to new sessions."}
           error={settings.saveError}
           actionLabel={settings.saving ? "Saving" : "Save"}
           onPress={save}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-dsh-direct",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "DeepSeek Harness Direct Provider Plugin for Paseo",
   "repository": {
     "type": "git",

package/server/bridge-client.ts

@@ -17,6 +17,15 @@ import type {
 type Method = keyof BridgeMethods;
 type Notification = keyof BridgeNotifications;
 
+/**
+ * Default deadline for one bridge request. `session.list` title folds decode a
+ * whole session log per row, so callers list large histories with a wider
+ * deadline instead of raising this for every method.
+ */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+/** Deadline for listing sessions: a cold title fold costs seconds per hundred sessions. */
+export const LIST_SESSIONS_TIMEOUT_MS = 120_000;
+
 export interface DshBridge {
   readonly initialized: BridgeInitializeResult;
   /** The resolved `dsh` executable this bridge was launched with (see `resolveDshLaunch`). */
@@ -26,6 +35,7 @@ export interface DshBridge {
   request<Name extends Method>(
     method: Name,
     params: BridgeMethods[Name]["params"],
+    timeoutMs?: number,
   ): Promise<BridgeMethods[Name]["result"]>;
   on<Name extends Notification>(
     method: Name,
@@ -471,6 +481,7 @@ class JsonlBridgeClient implements DshBridge {
   request<Name extends Method>(
     method: Name,
     params: BridgeMethods[Name]["params"],
+    timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
   ): Promise<BridgeMethods[Name]["result"]> {
     if (this.terminalError) return Promise.reject(this.terminalError);
     if (this.closing && method !== "bridge.shutdown") {
@@ -481,7 +492,7 @@ class JsonlBridgeClient implements DshBridge {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`DSH bridge request timed out: ${method}`));
-      }, 30_000);
+      }, timeoutMs);
       this.pending.set(id, { resolve, reject, timeout });
       const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
       this.child.stdin.write(payload, (error) => {

package/server/dsh/service.ts

@@ -140,6 +140,8 @@ export class BridgeService {
   private readonly subscriptions: Array<() => void> = [];
   /** Last usage payload sent per session, so an unchanged fold is not re-sent. */
   private readonly lastUsage = new Map<string, string>();
+  /** Folded titles per session id, so repeated import listings stay cheap. */
+  private readonly titles = new Map<string, string>();
   private stopping = false;
   private stopTask?: Promise<{}>;
 
@@ -262,7 +264,11 @@ export class BridgeService {
         }
       | undefined;
     const pressure = values.contextPressure as
-      | { contextWindow?: number; pressureTokens?: number }
+      | {
+          contextWindow?: number;
+          pressureTokens?: number;
+          projectedTokens?: number;
+        }
       | undefined;
     const usage: BridgeUsage = {};
     if (typeof tokens?.uncachedInputTokens === "number")
@@ -271,8 +277,16 @@ export class BridgeService {
       usage.cachedInputTokens = tokens.cacheReadTokens;
     if (typeof tokens?.outputTokens === "number")
       usage.outputTokens = tokens.outputTokens;
-    if (typeof pressure?.pressureTokens === "number")
-      usage.contextWindowUsedTokens = pressure.pressureTokens;
+    // `projectedTokens` folds the shadow price of an adjacent compaction into
+    // the last request's prompt size, so the meter drops as soon as a
+    // compaction lands instead of waiting for the next request. dsh before
+    // 0.2.1 writes no shadow price and the field is absent: fall back to the
+    // raw prompt size.
+    const used =
+      typeof pressure?.projectedTokens === "number"
+        ? pressure.projectedTokens
+        : pressure?.pressureTokens;
+    if (typeof used === "number") usage.contextWindowUsedTokens = used;
     if (typeof pressure?.contextWindow === "number")
       usage.contextWindowMaxTokens = pressure.contextWindow;
     // The units materialize at zero before any provider usage lands, so a
@@ -453,29 +467,9 @@ export class BridgeService {
         } satisfies BridgeInitializeResult;
         break;
       }
-      case "session.list": {
-        const query = this.ctx.get("sessionQuery");
-        const records = await query.listSessions();
-        const sessions: SessionSummary[] = records.map((record) => ({
-          ...record.header,
-        }));
-        // The official bulk title read owns live/cold source and validation.
-        if (typeof query.readTitleSnapshots === "function") {
-          const titles = await query.readTitleSnapshots(
-            sessions.map((session) => session.id),
-          );
-          for (let i = 0; i < sessions.length; i++) {
-            const result = titles[i];
-            const title =
-              result?.status === "fulfilled"
-                ? result.value.title?.title
-                : undefined;
-            if (typeof title === "string") sessions[i]!.title = title;
-          }
-        }
-        result = { sessions };
+      case "session.list":
+        result = { sessions: await this.listSessions(listParams(params)) };
         break;
-      }
       case "session.read":
         result = await this.ctx
           .get("sessionQuery")
@@ -622,6 +616,72 @@ export class BridgeService {
     );
   }
 
+  /**
+   * List native sessions for Paseo's import picker.
+   *
+   * `readTitleSnapshots` decodes each requested session's log to fold its
+   * title, which costs seconds per hundred sessions on a large history, so
+   * titles are folded only for the rows this call returns: cwd and query
+   * filter first, then newest first, then the limit. Folded titles are cached
+   * for this bridge's lifetime; a title renamed outside Paseo keeps its cached
+   * value until the bridge is replaced, while live sessions carry their header
+   * title regardless.
+   */
+  private async listSessions(
+    params: { cwd?: string; query?: string; limit?: number },
+  ): Promise<SessionSummary[]> {
+    const query = this.ctx.get("sessionQuery");
+    const records = await query.listSessions();
+    let sessions = records
+      .map((record) => ({ ...record.header }))
+      .filter((session) => !params.cwd || session.cwd === params.cwd);
+    if (params.query) {
+      // A title query needs every title, so this path folds the whole history.
+      await this.foldTitles(query, sessions);
+      const needle = params.query.toLowerCase();
+      sessions = sessions.filter(
+        (session) =>
+          session.title?.toLowerCase().includes(needle) ||
+          session.id.toLowerCase().includes(needle),
+      );
+    }
+    sessions.sort((left, right) => right.createdAt - left.createdAt);
+    if (params.limit !== undefined && sessions.length > params.limit)
+      sessions = sessions.slice(0, params.limit);
+    await this.foldTitles(query, sessions);
+    return sessions;
+  }
+
+  /** Fill in cached titles, reading only the sessions this bridge has not folded yet. */
+  private async foldTitles(
+    query: HostServices["sessionQuery"],
+    sessions: SessionSummary[],
+  ): Promise<void> {
+    if (typeof query.readTitleSnapshots !== "function") return;
+    // The official bulk title read owns live/cold source and validation. A
+    // header that already carries a title is live and needs no fold at all.
+    const missing = sessions.filter(
+      (session) => !session.title && !this.titles.has(session.id),
+    );
+    if (missing.length > 0) {
+      const titles = await query.readTitleSnapshots(
+        missing.map((session) => session.id),
+      );
+      for (let i = 0; i < missing.length; i++) {
+        const result = titles[i];
+        const title =
+          result?.status === "fulfilled"
+            ? result.value.title?.title
+            : undefined;
+        if (typeof title === "string") this.titles.set(missing[i]!.id, title);
+      }
+    }
+    for (const session of sessions) {
+      const title = this.titles.get(session.id);
+      if (title !== undefined) session.title = title;
+    }
+  }
+
   /** Registered commands first; a skill never shadows a command of the same name. */
   private async slashCommands(agent: HostAgent): Promise<SlashCommand[]> {
     const commands: SlashCommand[] = (this.ctx.get("commands")?.list(agent) ?? []).map(
@@ -971,6 +1031,31 @@ function validateContent(value: unknown): PromptPart[] {
   return parts;
 }
 
+function listParams(params: Record<string, unknown>): {
+  cwd?: string;
+  query?: string;
+  limit?: number;
+} {
+  const result: { cwd?: string; query?: string; limit?: number } = {};
+  if (params.cwd !== undefined) result.cwd = nonempty(params.cwd, "cwd");
+  if (params.query !== undefined) {
+    if (typeof params.query !== "string")
+      throw new Error("query must be a string");
+    const query = params.query.trim();
+    if (query) result.query = query;
+  }
+  if (params.limit !== undefined) {
+    if (
+      typeof params.limit !== "number" ||
+      !Number.isSafeInteger(params.limit) ||
+      params.limit < 1
+    )
+      throw new Error("limit must be a positive integer");
+    result.limit = params.limit;
+  }
+  return result;
+}
+
 function validateOpen(params: Record<string, unknown>): SessionOpenParams {
   const result: SessionOpenParams = { cwd: nonempty(params.cwd, "cwd") };
   if (params.sessionId !== undefined)

package/server/provider.ts

@@ -27,6 +27,7 @@ import { slashLine } from "../shared/bridge-protocol.js";
 import {
   DEFAULT_PROFILE,
   describeDshLaunch,
+  LIST_SESSIONS_TIMEOUT_MS,
   resolveDshLaunch,
   type BridgeMcpServer,
   type DshBridge,
@@ -404,8 +405,18 @@ async function listSessions(
   input: Extract<ProviderInput, { type: "sessions" }>,
   state: DispatchState,
 ): Promise<void> {
-  const result = await state.discoveryBridge.request("session.list", {});
   const query = input.query?.trim().toLowerCase();
+  // Filtering and truncation run in the bridge so title folds only cover the
+  // rows Paseo will actually show; the local filters stay as a second net.
+  const result = await state.discoveryBridge.request(
+    "session.list",
+    {
+      ...(input.cwd ? { cwd: input.cwd } : {}),
+      ...(query ? { query } : {}),
+      ...(input.limit !== undefined ? { limit: input.limit } : {}),
+    },
+    LIST_SESSIONS_TIMEOUT_MS,
+  );
   const rows = result.sessions
     .filter((session): session is typeof session & { cwd: string } => Boolean(session.cwd))
     .filter((session) => !input.cwd || session.cwd === input.cwd)

package/server/timeline.ts

@@ -35,6 +35,8 @@ export class TimelineProjector {
   private planActive = false;
   private lastPreset: string | undefined;
   private readonly goals = new Map<string, { objective?: string; maxRounds?: number }>();
+  /** Ids of `/goal` commands between their `command/run` and `command/done`; dsh prints their result itself. */
+  private readonly goalCommands = new Set<string>();
 
   /**
    * @param paseoSessionId Paseo session id stamped on every projected event.
@@ -59,6 +61,8 @@ export class TimelineProjector {
     options: { clientMessageId?: string } = {},
   ): SessionEvent[] {
     const timestamp = toTimestamp(event.time);
+    // A `/goal` command whose `command/done` never arrived is over once any of these later events appears.
+    if (["command/run", "user/message", "turn/start", "turn/end"].includes(event.type)) this.goalCommands.clear();
     switch (event.type) {
       case "user/message":
         return [
@@ -149,6 +153,7 @@ export class TimelineProjector {
     const commandId = stringValue(data.commandId);
     const name = stringValue(data.name);
     if (!commandId || !name) return [];
+    if (name === "goal") this.goalCommands.add(commandId);
     const id = `command:${commandId}`;
     // `args` keeps DSH's raw separator whitespace after the command name.
     const text = `/${name}${stringValue(data.args) ?? ""}`;
@@ -165,6 +170,7 @@ export class TimelineProjector {
     const data = event.data;
     const commandId = stringValue(data.commandId);
     const message = stringValue(data.text);
+    if (commandId) this.goalCommands.delete(commandId);
     if (!commandId || !message) return [];
     return [
       this.notice(`command-done:${commandId}`, data.kind === "error" ? "error" : "info", message, timestamp),
@@ -258,7 +264,8 @@ export class TimelineProjector {
       }
     } else if (event.type === "goal/change") {
       const card = this.goalChangeCard(data);
-      if (card) cards.push({ id: `goal:${event.seq}`, kind: CARD_KINDS.goal, data: { ...card } });
+      // A change made while a `/goal` command runs is already reported by that command's own output.
+      if (card && this.goalCommands.size === 0) cards.push({ id: `goal:${event.seq}`, kind: CARD_KINDS.goal, data: { ...card } });
     } else if (event.type === "user/message") {
       const source = objectValue(data.source);
       const round = numberValue(source?.round);

package/shared/bridge-protocol.ts

@@ -160,7 +160,10 @@ export interface CommandResult {
 }
 export interface BridgeMethods {
   "bridge.initialize": { params: {}; result: BridgeInitializeResult };
-  "session.list": { params: {}; result: { sessions: SessionSummary[] } };
+  "session.list": {
+    params: { cwd?: string; query?: string; limit?: number };
+    result: { sessions: SessionSummary[] };
+  };
   "session.read": { params: { sessionId: string }; result: SessionSnapshot };
   "session.open": { params: SessionOpenParams; result: SessionOpenResult };
   "session.prompt": {