dsh-rewind-plugin 0.3.1 → 0.3.2

package/lib/client.js

@@ -53,6 +53,9 @@ function hasFileImpact(text) {
 function isPreviewCommand(command) {
   return (command.args ?? "").includes("preview");
 }
+function isCandidateCommand(command) {
+  return (command.args ?? "").includes("__candidates");
+}
 function hiddenSeqsOf(snap) {
   const hidden = /* @__PURE__ */ new Set();
   const spans = [];
@@ -61,7 +64,7 @@ function hiddenSeqsOf(snap) {
     if (node === void 0 || node.kind !== "command") continue;
     const command = node.data;
     if (command.name !== "rewind") continue;
-    if (isPreviewCommand(command)) {
+    if (isPreviewCommand(command) || isCandidateCommand(command)) {
       hidden.add(command.seq);
       continue;
     }
@@ -87,6 +90,7 @@ function hiddenSeqsOf(snap) {
 
 // src/client/candidates.ts
 var PREVIEW_CHARS = 80;
+var DEFAULT_CANDIDATE_LIMIT = 50;
 function messagePreviewOf(message) {
   const text = message.content.map((block) => block.type === "text" && typeof block.text === "string" ? block.text : "").join("").replace(/\s+/g, " ").trim();
   return text.length <= PREVIEW_CHARS ? text : `${text.slice(0, PREVIEW_CHARS - 1)}\u2026`;
@@ -97,7 +101,7 @@ function formatCandidateTime(time) {
   const mm = String(d.getMinutes()).padStart(2, "0");
   return `${hh}:${mm}`;
 }
-function rewindCandidatesOf(snap, hidden, limit = 10) {
+function rewindCandidatesOf(snap, hidden, limit = DEFAULT_CANDIDATE_LIMIT) {
   const candidates = [];
   for (let i = snap.order.length - 1; i >= 0 && candidates.length < limit; i--) {
     const key = snap.order[i];
@@ -116,16 +120,30 @@ function rewindCandidatesOf(snap, hidden, limit = 10) {
 function rewindCandidatesOfChat(snap) {
   return rewindCandidatesOf(snap, hiddenSeqsOf(snap));
 }
-function rewindOptionsOf(snap, t) {
-  return rewindCandidatesOfChat(snap).map((candidate) => ({
+var CANDIDATE_LIST_HEADER = "candidates=";
+function rewindCandidatesFromHostText(text) {
+  if (!text.startsWith(CANDIDATE_LIST_HEADER)) return [];
+  const lines = text.split("\n").slice(1);
+  const candidates = [];
+  for (const line of lines) {
+    if (line === "") continue;
+    const parts = line.split("	");
+    if (parts.length !== 3) continue;
+    const seq = Number(parts[0]);
+    const time = Number(parts[1]);
+    const preview = parts[2] ?? "";
+    if (!Number.isSafeInteger(seq) || !Number.isFinite(time)) continue;
+    candidates.push({ seq, time, preview });
+  }
+  return candidates;
+}
+function rewindOptionsFromCandidates(candidates, t) {
+  return candidates.map((candidate) => ({
     id: String(candidate.seq),
     label: candidate.preview || t("popover.noText"),
     detail: formatCandidateTime(candidate.time)
   }));
 }
-function candidateBySeq(snap, seq) {
-  return rewindCandidatesOfChat(snap).find((candidate) => candidate.seq === seq);
-}
 
 // src/client/styles.ts
 var CLASS = {
@@ -823,6 +841,15 @@ function apply(ctx) {
       const chat = chatOf(sessionId);
       return chat !== void 0 && rewindCandidatesOfChat(chat).length > 0;
     };
+    const fetchHostCandidates = async (face) => {
+      const known = knownCommandSeqs(face, (node) => isCandidateCommand(node));
+      const result = await face.command("/rewind __candidates");
+      if (!result.ok || result.value?.matched !== true) return void 0;
+      const outcome = await waitForCommand(face, (node) => isCandidateCommand(node) && !known.has(node.seq));
+      if (outcome === null || outcome.kind !== "success" || outcome.text === void 0) return void 0;
+      return rewindCandidatesFromHostText(outcome.text);
+    };
+    const hostCandidatesCache = /* @__PURE__ */ new Map();
     const composerAnchor = () => {
       const textarea = composerTextarea();
       const card = textarea?.closest("[data-composer-card]");
@@ -837,15 +864,20 @@ function apply(ctx) {
       available: (session) => hasCandidates(session.sessionId),
       ui: {
         kind: "popupSelect",
-        options: (session) => {
-          const chat = chatOf(session.sessionId);
-          return Promise.resolve(chat === void 0 ? [] : rewindOptionsOf(chat, t));
+        options: async (session) => {
+          const face = sessionOf(session.sessionId);
+          if (face === void 0) return [];
+          const candidates = await fetchHostCandidates(face);
+          if (candidates !== void 0) hostCandidatesCache.set(session.sessionId, candidates);
+          return candidates === void 0 ? [] : rewindOptionsFromCandidates(candidates, t);
         },
         onSelect: (option, session) => {
           const face = sessionOf(session.sessionId);
-          const chat = chatOf(session.sessionId);
-          const candidate = chat !== void 0 ? candidateBySeq(chat, Number(option.id)) : void 0;
-          if (face === void 0 || candidate === void 0) return;
+          if (face === void 0) return;
+          const candidate = hostCandidatesCache.get(session.sessionId)?.find(
+            (candidate2) => candidate2.seq === Number(option.id)
+          );
+          if (candidate === void 0) return;
           openPopover({
             session: face,
             seq: candidate.seq,

package/lib/index.js

@@ -80,6 +80,7 @@ var RewindError = class extends Error {
   code;
 };
 var CANDIDATE_PREVIEW_CHARS = 80;
+var DEFAULT_CANDIDATE_LIMIT = 50;
 function markerTurnOf(events) {
   let lastStarted = 0;
   for (const event of events) {
@@ -92,6 +93,9 @@ function markerTurnOf(events) {
 function isUserMessageEvent(event) {
   return event.type === "user/message";
 }
+function isHumanUserMessageEvent(event) {
+  return isUserMessageEvent(event) && event.data.source.kind === "user";
+}
 function messagePreview(message) {
   const text = message.content.map((block) => block.type === "text" && typeof block.text === "string" ? block.text : "").join("").replace(/\s+/g, " ").trim();
   return text.length <= CANDIDATE_PREVIEW_CHARS ? text : `${text.slice(0, CANDIDATE_PREVIEW_CHARS - 1)}\u2026`;
@@ -106,13 +110,13 @@ function parseRewindTarget(raw) {
   const index = Number(token);
   return Number.isSafeInteger(index) && index >= 1 ? { kind: "index", index } : void 0;
 }
-function listRewindCandidates(events, surface, limit = 10) {
+function listRewindCandidates(events, surface, limit = DEFAULT_CANDIDATE_LIMIT) {
   const surfaceIndexes = /* @__PURE__ */ new Map();
   for (let i = 0; i < surface.length; i++) surfaceIndexes.set(surface[i], i);
   const candidates = [];
   for (let i = events.length - 1; i >= 0 && candidates.length < limit; i--) {
     const event = events[i];
-    if (!isUserMessageEvent(event)) continue;
+    if (!isHumanUserMessageEvent(event)) continue;
     if (!surfaceIndexes.has(event.seq)) continue;
     candidates.push({
       seq: event.seq,
@@ -123,6 +127,14 @@ function listRewindCandidates(events, surface, limit = 10) {
   }
   return candidates;
 }
+var CANDIDATE_LIST_HEADER = "candidates=";
+function formatCandidateList(candidates) {
+  const lines = [`${CANDIDATE_LIST_HEADER}${candidates.length}`];
+  for (const candidate of candidates) {
+    lines.push(`${candidate.seq}	${candidate.time}	${candidate.preview}`);
+  }
+  return lines.join("\n");
+}
 function planRewind(events, surface, target) {
   let targetSeq;
   if (target.kind === "seq") {
@@ -138,10 +150,10 @@ function planRewind(events, surface, target) {
   if (targetEvent === void 0) {
     throw new RewindError("not-a-user-message", `no session event at seq ${targetSeq}`);
   }
-  if (!isUserMessageEvent(targetEvent)) {
+  if (!isHumanUserMessageEvent(targetEvent)) {
     throw new RewindError(
       "not-a-user-message",
-      `session event at seq ${targetSeq} is not a user message (${targetEvent.type})`
+      `session event at seq ${targetSeq} is not a human user message (${targetEvent.type})`
     );
   }
   const targetIndex = surface.indexOf(targetSeq);
@@ -733,6 +745,10 @@ async function handleRewind(ctx, store, fs, invocation, inflight) {
     const impacts = await store.impactsAfter(session.id, plan.targetSeq);
     return { kind: "success", text: formatPlan(plan, impacts) };
   }
+  if (parts[0] === "__candidates") {
+    const candidates = listRewindCandidates(session.events, session.surface.nodes);
+    return { kind: "success", text: formatCandidateList(candidates) };
+  }
   const target = parts[0];
   const mode = parts[1];
   if (mode !== void 0 && mode !== "chat" && mode !== "both") {

package/lib/types/client/candidates.d.ts

@@ -15,6 +15,14 @@ import type { RewindKey } from './locales.ts';
 type Translate = (key: RewindKey, params?: Record<string, unknown>) => string;
 /** Preview length cap for candidate rows (matches the host's candidate list). */
 export declare const PREVIEW_CHARS = 80;
+/**
+ * Default cap on how many user messages the rewind picker lists (newest kept).
+ *
+ * A fixed 10 made long sessions look "incomplete" (only the newest 10 shown).
+ * 50 keeps the picker scrollable/searchable via the popupSelect shell while
+ * covering far longer sessions; callers can still pass an explicit `limit`.
+ */
+export declare const DEFAULT_CANDIDATE_LIMIT = 50;
 /** One selectable rewind target. */
 export interface RewindCandidate {
     /** Absolute log seq of the `user/message` event. */
@@ -73,4 +81,21 @@ export declare function rewindCandidatesOfChat(snap: CandidateChat): RewindCandi
 export declare function rewindOptionsOf(snap: CandidateChat, t: Translate): SelectOption[];
 /** Resolve one candidate by log seq (the mode popover's re-entry after a pick). */
 export declare function candidateBySeq(snap: CandidateChat, seq: number): RewindCandidate | undefined;
+/**
+ * Parse the host's candidate-list encoding (see `formatCandidateList` in
+ * src/rewind.ts) into typed candidates. Malformed lines are skipped; a
+ * missing/zero header yields an empty list.
+ */
+export declare function rewindCandidatesFromHostText(text: string): RewindCandidate[];
+/**
+ * Map typed candidates to popupSelect rows (the host-derived path). The
+ * popupSelect sources its options from the FULL host surface via the
+ * `__candidates` channel instead of the windowed chat snapshot.
+ */
+export declare function rewindOptionsFromCandidates(candidates: readonly RewindCandidate[], t: Translate): SelectOption[];
+/**
+ * Parse the host's candidate-list encoding (see `formatCandidateList` in
+ * src/rewind.ts) into popupSelect rows.
+ */
+export declare function rewindOptionsFromHostText(text: string, t: Translate): SelectOption[];
 export {};

package/lib/types/client/hidden.d.ts

@@ -38,6 +38,13 @@ export declare function isExecutedRewindCommand(node: CommandNode, seq: number):
  * always-show so a working option is never hidden on a failed probe.
  */
 export declare function hasFileImpact(text: string | undefined): boolean;
+/**
+ * True when a `/rewind` command node is the internal candidate-list probe
+ * (`/rewind __candidates`) the popupSelect runs to fetch the FULL candidate
+ * list from the host. Like previews, its flow node never surfaces in the
+ * transcript — it only feeds the popup — so it is hidden in every state.
+ */
+export declare function isCandidateCommand(command: CommandNode): boolean;
 /**
  * Anchor seqs that must be hidden from the rendered transcript so the user
  * sees the conversation as the agent sees it: every impact-preview flow node

package/lib/types/rewind.d.ts

@@ -60,6 +60,12 @@ export interface RewindPlan {
 }
 /** Preview length cap for candidate listings. */
 export declare const CANDIDATE_PREVIEW_CHARS = 80;
+/**
+ * Default cap on how many user messages a candidate listing returns (newest
+ * kept). Raised from 10 so long sessions don't look incomplete; callers can
+ * still pass an explicit `limit`.
+ */
+export declare const DEFAULT_CANDIDATE_LIMIT = 50;
 /**
  * Turn number for the rewind marker.
  *
@@ -85,6 +91,18 @@ export declare const CANDIDATE_PREVIEW_CHARS = 80;
 export declare function markerTurnOf(events: readonly SessionEvent[]): number;
 /** Narrow an event to a user message. */
 export declare function isUserMessageEvent(event: SessionEvent): event is SessionEvent<'user/message'>;
+/**
+ * True for a HUMAN user message event — one whose `source.kind` is `'user'`.
+ *
+ * The surface can carry `user/message` events whose source is NOT the user:
+ * plugin/system context injection (including compaction checkpoints) and
+ * tool-result backfill all arrive as `user/message` with a non-`'user'`
+ * source, and the client renders those as `context` nodes, never as a user
+ * bubble. Only genuine user messages (and user steering during a running
+ * turn, which keeps `source.kind: 'user'`) are valid rewind targets — a
+ * rewind boundary must land on a human prompt, not on injected context.
+ */
+export declare function isHumanUserMessageEvent(event: SessionEvent): event is SessionEvent<'user/message'>;
 /** Join the text blocks of a message into one plain string. */
 export declare function messagePreview(message: UserMessage): string;
 /**
@@ -104,6 +122,23 @@ export declare function parseRewindTarget(raw: string): RewindTarget | undefined
  * @returns candidates numbered 1..N by recency.
  */
 export declare function listRewindCandidates(events: readonly SessionEvent[], surface: readonly number[], limit?: number): RewindCandidate[];
+/** Header line of the machine-readable candidate list (locale-independent). */
+export declare const CANDIDATE_LIST_HEADER = "candidates=";
+/**
+ * Encode a candidate list as the host→client machine channel (the same
+ * trailer pattern `formatPlan` uses for `impact=`). The client popupSelect
+ * parses this instead of reading the windowed chat snapshot, so the candidate
+ * list reflects the FULL host surface — not just the already-loaded history.
+ *
+ * Lines (each preview is already whitespace-collapsed and tab-free by
+ * `messagePreview`):
+ *   candidates=<n>
+ *   <seq>\t<time>\t<preview>
+ *   … (one line per candidate, newest first, matching `listRewindCandidates`)
+ *
+ * A list with no candidates is just `candidates=0`.
+ */
+export declare function formatCandidateList(candidates: readonly RewindCandidate[]): string;
 /**
  * Resolve a target against the session log and surface into a validated plan.
  * @param events - the full session event log.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-rewind-plugin",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "DeepSeek Harness plugin: in-place conversation rewind in the same session window (Claude Code /rewind semantics) with optional workspace file restore",
   "keywords": [
     "deepseek-harness",