dsh-rewind-plugin 0.1.0

package/lib/index.js

@@ -0,0 +1,461 @@
+// src/index.ts
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { unlink } from "node:fs/promises";
+
+// src/session-cwd.ts
+import { canonicalPath } from "@deepseek-ai/dsh-sandbox";
+var PARENT_PATH_SEGMENT = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
+function sessionCwd(cwd, requestedPath) {
+  if (cwd === void 0 || !PARENT_PATH_SEGMENT.test(cwd) && !PARENT_PATH_SEGMENT.test(requestedPath)) return cwd;
+  return canonicalPath(cwd);
+}
+function execSessionCwd(exec, requestedPath) {
+  return sessionCwd(exec.agent?.session.header.cwd, requestedPath);
+}
+
+// src/ledger.ts
+var RewindLedger = class {
+  entries = [];
+  /** Record one committed mutation. */
+  record(entry) {
+    this.entries.push(entry);
+  }
+  /**
+   * All entries anchored at or after `targetSeq`, newest first. The boundary
+   * is inclusive: rewinding to a message also reverts the changes its own
+   * turn caused (the rewind cut removes that turn's assistant response and
+   * tool calls), so only changes anchored at earlier messages survive.
+   */
+  changesAfter(targetSeq) {
+    const after = [];
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const entry = this.entries[i];
+      if (entry.anchorSeq >= targetSeq) after.push(entry);
+    }
+    return after;
+  }
+  /**
+   * Unique per-file impact for preview. A file whose earliest affected change
+   * created it (`before === undefined`) is deleted on restore; any other file
+   * is written back to its pre-target content.
+   */
+  impactsAfter(targetSeq) {
+    const byPath = /* @__PURE__ */ new Map();
+    for (const entry of this.entries) {
+      if (entry.anchorSeq < targetSeq) continue;
+      if (byPath.has(entry.path)) continue;
+      byPath.set(entry.path, { path: entry.path, action: entry.before === void 0 ? "delete" : "restore" });
+    }
+    return [...byPath.values()];
+  }
+  /**
+   * Reverse every change anchored at or after `targetSeq`. Each entry writes
+   * its pre-change content back; a file that did not exist before the target
+   * is deleted instead. Failures are collected per file and never abort the pass.
+   * @param fs - the filesystem service (resolve/readText/writeText/processPath).
+   * @param deleteFile - backend-appropriate file deletion by process path.
+   * @param targetSeq - the rewind target; only later changes are reverted.
+   * @param options - session workspace cwd (relative ledger paths resolve
+   *   against it, mirroring the fs tools) and an optional abort signal.
+   */
+  async restoreAfter(fs, deleteFile, targetSeq, options = {}) {
+    const restored = [];
+    const deleted = [];
+    const failed = [];
+    const restoredSet = /* @__PURE__ */ new Set();
+    const deletedSet = /* @__PURE__ */ new Set();
+    for (const entry of this.changesAfter(targetSeq)) {
+      try {
+        const cwd = sessionCwd(options.cwd, entry.path);
+        const target = await fs.resolve(entry.path, {
+          ...cwd !== void 0 ? { cwd } : {},
+          signal: options.signal
+        });
+        if (entry.before === void 0) {
+          await deleteFile(fs.processPath(target));
+          if (!deletedSet.has(entry.path)) {
+            deletedSet.add(entry.path);
+            deleted.push(entry.path);
+          }
+        } else {
+          await fs.writeText(target, entry.before, void 0, options.signal);
+          if (!restoredSet.has(entry.path)) {
+            restoredSet.add(entry.path);
+            restored.push(entry.path);
+          }
+        }
+      } catch (error) {
+        failed.push({
+          path: entry.path,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return { restored, deleted, failed };
+  }
+};
+
+// src/rewind.ts
+var RewindError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "RewindError";
+  }
+  code;
+};
+var CANDIDATE_PREVIEW_CHARS = 80;
+function isUserMessageEvent(event) {
+  return event.type === "user/message";
+}
+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`;
+}
+function parseRewindTarget(raw) {
+  const token = raw.trim();
+  if (token === "") return void 0;
+  if (token.startsWith("@")) {
+    const seq = Number(token.slice(1));
+    return Number.isSafeInteger(seq) && seq >= 0 ? { kind: "seq", seq } : void 0;
+  }
+  const index = Number(token);
+  return Number.isSafeInteger(index) && index >= 1 ? { kind: "index", index } : void 0;
+}
+function listRewindCandidates(events, surface, limit = 10) {
+  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 (!surfaceIndexes.has(event.seq)) continue;
+    candidates.push({
+      seq: event.seq,
+      time: event.time,
+      preview: messagePreview(event.data),
+      index: candidates.length + 1
+    });
+  }
+  return candidates;
+}
+function planRewind(events, surface, target) {
+  let targetSeq;
+  if (target.kind === "seq") {
+    targetSeq = target.seq;
+  } else {
+    const candidate = listRewindCandidates(events, surface, target.index)[target.index - 1];
+    if (candidate === void 0) {
+      throw new RewindError("invalid-index", `rewind index ${target.index} has no candidate`);
+    }
+    targetSeq = candidate.seq;
+  }
+  const targetEvent = events.find((event) => event.seq === targetSeq);
+  if (targetEvent === void 0) {
+    throw new RewindError("not-a-user-message", `no session event at seq ${targetSeq}`);
+  }
+  if (!isUserMessageEvent(targetEvent)) {
+    throw new RewindError(
+      "not-a-user-message",
+      `session event at seq ${targetSeq} is not a user message (${targetEvent.type})`
+    );
+  }
+  const targetIndex = surface.indexOf(targetSeq);
+  if (targetIndex === -1) {
+    throw new RewindError(
+      "not-on-surface",
+      `user message at seq ${targetSeq} is no longer in the model context (shadowed by compaction)`
+    );
+  }
+  if (targetIndex === surface.length - 1) {
+    throw new RewindError(
+      "nothing-after",
+      `user message at seq ${targetSeq} is already the last context item; nothing to rewind`
+    );
+  }
+  const shadowedSeqs = surface.slice(targetIndex + 1);
+  return {
+    targetSeq,
+    targetIndex,
+    shadowedSeqs,
+    surfaceStart: shadowedSeqs[0],
+    surfaceEnd: shadowedSeqs[shadowedSeqs.length - 1]
+  };
+}
+function formatCandidate(candidate) {
+  const time = new Date(candidate.time);
+  const hh = String(time.getHours()).padStart(2, "0");
+  const mm = String(time.getMinutes()).padStart(2, "0");
+  return `${candidate.index}. ${hh}:${mm} ${candidate.preview || "(\u65E0\u6587\u672C)"}`;
+}
+
+// src/index.ts
+var name = "dsh-rewind";
+var inject = ["commands", "tools"];
+var TRACKED_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "str_replace_editor"]);
+var MUTATING_EDITOR_COMMANDS = /* @__PURE__ */ new Set(["create", "str_replace", "insert"]);
+var USAGE = [
+  "Usage:",
+  "  /rewind                        list recent user messages to rewind to",
+  "  /rewind <\u5E8F\u53F7|@seq>             choose a mode for that message",
+  "  /rewind <\u5E8F\u53F7|@seq> chat        rewind the conversation only",
+  "  /rewind <\u5E8F\u53F7|@seq> both        rewind conversation and restore files",
+  "  /rewind preview <\u76EE\u6807>           show the impact list without executing"
+].join("\n");
+function mutationPathOf(exec) {
+  const args = exec.arguments;
+  if (exec.name === "write" || exec.name === "edit") {
+    return typeof args.file_path === "string" ? args.file_path : void 0;
+  }
+  if (exec.name === "str_replace_editor") {
+    if (typeof args.command !== "string" || !MUTATING_EDITOR_COMMANDS.has(args.command)) return void 0;
+    return typeof args.path === "string" ? args.path : void 0;
+  }
+  return void 0;
+}
+function anchorSeqOf(session) {
+  for (let i = session.events.length - 1; i >= 0; i--) {
+    const event = session.events[i];
+    if (event.type === "user/message") return event.seq;
+  }
+  return void 0;
+}
+async function resolveTarget(fs, path, cwd, signal) {
+  try {
+    return await fs.resolve(path, {
+      ...cwd !== void 0 ? { cwd } : {},
+      signal
+    });
+  } catch {
+    return void 0;
+  }
+}
+async function readTextOrUndefined(fs, target, signal) {
+  try {
+    return await fs.readText(target, signal);
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT" || code === "FS_NOT_FOUND") return void 0;
+    throw error;
+  }
+}
+async function captureBefore(fs, exec, pending) {
+  if (!TRACKED_TOOLS.has(exec.name)) return;
+  const path = mutationPathOf(exec);
+  if (path === void 0) return;
+  const cwd = execSessionCwd(exec, path);
+  const target = await resolveTarget(fs, path, cwd, exec.signal);
+  if (target === void 0) return;
+  const before = await readTextOrUndefined(fs, target, exec.signal);
+  pending.set(`${exec.agent?.id ?? "anon"}:${exec.callId}`, { path: target.displayPath, cwd, before });
+}
+async function commitEntry(fs, ledgerFor, pending, exec, result) {
+  const key = `${exec.agent?.id ?? "anon"}:${exec.callId}`;
+  const capture = pending.get(key);
+  if (capture === void 0) return;
+  pending.delete(key);
+  if (result.isError) return;
+  const agent = exec.agent;
+  if (agent === void 0) return;
+  const anchorSeq = anchorSeqOf(agent.session);
+  if (anchorSeq === void 0) return;
+  const target = await resolveTarget(fs, capture.path, capture.cwd, exec.signal);
+  if (target === void 0) return;
+  let after;
+  try {
+    after = await readTextOrUndefined(fs, target, exec.signal) ?? "";
+  } catch {
+    return;
+  }
+  ledgerFor(agent.session).record({
+    toolName: exec.name,
+    anchorSeq,
+    path: capture.path,
+    before: capture.before,
+    after
+  });
+}
+function buildMarker(targetSeq) {
+  return createUserMessage({
+    content: [{
+      type: "text",
+      text: `[\u56DE\u9000\u6807\u8BB0 / rewind marker] \u5BF9\u8BDD\u5DF2\u56DE\u9000\u5230 seq ${targetSeq}\uFF0C\u6B64\u6807\u8BB0\u4E4B\u540E\u7684\u5386\u53F2\u5DF2\u4ECE\u6A21\u578B\u4E0A\u4E0B\u6587\u4E2D\u79FB\u9664\u3002\u8BF7\u5FFD\u7565\u6B64\u6807\u8BB0\u672C\u8EAB\uFF0C\u7B49\u5F85\u7528\u6237\u7684\u4E0B\u4E00\u6761\u6D88\u606F\u3002`
+    }],
+    source: { kind: "user" }
+  });
+}
+function describeTarget(target) {
+  return target.kind === "seq" ? `seq ${target.seq}` : `\u7B2C ${target.index} \u6761\u6D88\u606F`;
+}
+function formatPlan(plan, files) {
+  const lines = [
+    `\u5C06\u56DE\u9000\u5230 seq ${plan.targetSeq}\uFF0C\u4ECE\u6A21\u578B\u4E0A\u4E0B\u6587\u79FB\u9664 ${plan.shadowedSeqs.length} \u4E2A\u8282\u70B9\uFF08\u5BF9\u8BDD\u65E5\u5FD7\u4FDD\u7559\uFF09\u3002`
+  ];
+  if (files.length > 0) {
+    lines.push(`\u5C06\u5F71\u54CD ${files.length} \u4E2A\u6587\u4EF6\uFF1A`);
+    for (const file of files) {
+      lines.push(`  ${file.action === "restore" ? "\u8FD8\u539F" : "\u5220\u9664"} ${file.path}`);
+    }
+  } else {
+    lines.push("\u76EE\u6807\u4E4B\u540E\u6CA1\u6709\u53F0\u8D26\u8BB0\u5F55\u7684\u5199\u7C7B\u53D8\u66F4\uFF0C\u65E0\u9700\u8FD8\u539F\u6587\u4EF6\u3002");
+  }
+  return lines.join("\n");
+}
+function resolveOrError(events, surface, raw) {
+  const target = parseRewindTarget(raw);
+  if (target === void 0) {
+    throw new RewindError("invalid-index", `\u65E0\u6CD5\u89E3\u6790\u76EE\u6807 "${raw}"\uFF08\u5E94\u4E3A <\u5E8F\u53F7> \u6216 @<seq>\uFF09`);
+  }
+  return planRewind(events, surface, target);
+}
+function renderFailures(failed) {
+  if (failed.length === 0) return "";
+  return `\uFF1B${failed.length} \u4E2A\u6587\u4EF6\u8FD8\u539F\u5931\u8D25\uFF1A${failed.map((f) => `${f.path}\uFF08${f.message}\uFF09`).join("\u3001")}`;
+}
+async function executeRewind(ctx, ledger, invocation, rawTarget, mode) {
+  const { agent } = invocation;
+  if (agent.status !== "idle") {
+    return { kind: "error", text: "agent \u6B63\u5728\u8FD0\u884C\u4E2D\uFF0C\u65E0\u6CD5\u56DE\u9000\u3002\u8BF7\u7B49\u5F85\u5F53\u524D\u56DE\u5408\u7ED3\u675F\u540E\u518D\u8BD5\u3002" };
+  }
+  let plan;
+  try {
+    plan = resolveOrError(agent.session.events, agent.session.surface.nodes, rawTarget);
+  } catch (error) {
+    return rewindErrorResult(error);
+  }
+  const marker = buildMarker(plan.targetSeq);
+  let event;
+  try {
+    event = agent.session.append("user/message", marker, {
+      surfaceOp: { op: "replace", start: plan.surfaceStart, end: plan.surfaceEnd },
+      sourceEventSeqs: [...plan.shadowedSeqs]
+    });
+  } catch (error) {
+    return {
+      kind: "error",
+      text: `\u56DE\u9000\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}\u3002\u4F1A\u8BDD\u672A\u6539\u53D8\u3002`
+    };
+  }
+  let restore = "";
+  if (mode === "both") {
+    const fs = ctx.get("fs", false);
+    if (fs === void 0) {
+      restore = "\uFF1B\u672A\u627E\u5230\u6587\u4EF6\u7CFB\u7EDF\u670D\u52A1\uFF0C\u672A\u8FD8\u539F\u6587\u4EF6\uFF08\u53EF\u4EC5\u7528 chat \u6A21\u5F0F\u56DE\u9000\u5BF9\u8BDD\uFF09";
+    } else {
+      const outcome = await ledger.restoreAfter(fs, (processPath) => unlink(processPath), plan.targetSeq, {
+        // Relative ledger paths resolve against the session workspace, exactly
+        // as the fs tools resolve them (per-entry in src/ledger.ts).
+        cwd: agent.session.header.cwd,
+        signal: invocation.signal
+      });
+      restore = `\uFF1B\u8FD8\u539F ${outcome.restored.length} \u4E2A\u6587\u4EF6\u3001\u5220\u9664 ${outcome.deleted.length} \u4E2A\u6587\u4EF6${renderFailures(outcome.failed)}`;
+    }
+  }
+  return {
+    kind: "success",
+    text: `\u5DF2\u56DE\u9000\u5230 seq ${plan.targetSeq}\uFF0C\u79FB\u9664 ${plan.shadowedSeqs.length} \u6761\u4E0A\u4E0B\u6587\uFF08\u65E5\u5FD7\u4FDD\u7559\uFF09${restore}\u3002`,
+    sourceEventSeq: event.seq
+  };
+}
+function rewindErrorResult(error) {
+  if (error instanceof RewindError) {
+    const text = {
+      "no-user-messages": "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u53EF\u56DE\u9000\u7684\u7528\u6237\u6D88\u606F\u3002",
+      "invalid-index": error.message,
+      "not-a-user-message": error.message,
+      "not-on-surface": error.message,
+      "nothing-after": error.message
+    }[error.code];
+    return { kind: "error", text };
+  }
+  throw error;
+}
+async function handleRewind(ctx, ledger, invocation) {
+  const session = invocation.agent.session;
+  const input = invocation.rawInput.trim();
+  if (input === "") {
+    const candidates = listRewindCandidates(session.events, session.surface.nodes);
+    if (candidates.length === 0) {
+      return { kind: "error", text: "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u53EF\u56DE\u9000\u7684\u7528\u6237\u6D88\u606F\u3002" };
+    }
+    return {
+      kind: "success",
+      text: `\u9009\u62E9\u8981\u56DE\u9000\u5230\u7684\u7528\u6237\u6D88\u606F\uFF08\u6700\u8FD1\u5728\u4E0A\uFF09\uFF1A
+${candidates.map(formatCandidate).join("\n")}
+
+\u7EE7\u7EED\uFF1A/rewind <\u5E8F\u53F7|@seq>\uFF0C\u6216\u76F4\u63A5 /rewind <\u5E8F\u53F7|@seq> chat|both \u6267\u884C\u3002`
+    };
+  }
+  const parts = input.split(/\s+/);
+  if (parts[0] === "preview") {
+    const target2 = parts[1];
+    if (target2 === void 0) return { kind: "error", text: USAGE };
+    let plan;
+    try {
+      plan = resolveOrError(session.events, session.surface.nodes, target2);
+    } catch (error) {
+      return rewindErrorResult(error);
+    }
+    const impacts = ledger.impactsAfter(plan.targetSeq);
+    return { kind: "success", text: formatPlan(plan, impacts) };
+  }
+  const target = parts[0];
+  const mode = parts[1];
+  if (mode !== void 0 && mode !== "chat" && mode !== "both") {
+    return { kind: "error", text: USAGE };
+  }
+  if (mode === void 0) {
+    const parsed = parseRewindTarget(target);
+    if (parsed === void 0) return { kind: "error", text: USAGE };
+    return {
+      kind: "success",
+      text: `\u5C06\u56DE\u9000\u5230 ${describeTarget(parsed)}\u3002\u9009\u62E9\u6A21\u5F0F\uFF1A
+  /rewind ${target} chat  \u4EC5\u56DE\u9000\u5BF9\u8BDD
+  /rewind ${target} both  \u56DE\u9000\u5BF9\u8BDD\u5E76\u8FD8\u539F\u6587\u4EF6`
+    };
+  }
+  return executeRewind(ctx, ledger, invocation, target, mode);
+}
+function apply(ctx) {
+  const ledgers = /* @__PURE__ */ new Map();
+  const ledgerFor = (session) => {
+    let ledger = ledgers.get(session.id);
+    if (ledger === void 0) {
+      ledger = new RewindLedger();
+      ledgers.set(session.id, ledger);
+    }
+    return ledger;
+  };
+  const pending = /* @__PURE__ */ new Map();
+  ctx.effect(function* () {
+    yield ctx.commands.register({
+      name: "rewind",
+      description: "\u5728\u540C\u7A97\u53E3\u5185\u5C06\u5BF9\u8BDD\u56DE\u9000\u5230\u66F4\u65E9\u7684\u7528\u6237\u6D88\u606F\uFF08\u53EF\u540C\u65F6\u8FD8\u539F\u6587\u4EF6\uFF09",
+      handler: (invocation) => handleRewind(ctx, ledgerFor(invocation.agent.session), invocation)
+    });
+  }, "dsh-rewind command");
+  ctx.inject(["fs"], (scope) => {
+    const fs = scope.fs;
+    scope.on("tools/execute", async (exec, next) => {
+      try {
+        await captureBefore(fs, exec, pending);
+      } catch (error) {
+        ctx.logger.warn(`[dsh-rewind] before-capture failed for ${exec.name}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      return next();
+    });
+    scope.on("tools/post-execute", async (exec, result, next) => {
+      try {
+        await commitEntry(fs, ledgerFor, pending, exec, result);
+      } catch (error) {
+        ctx.logger.warn(`[dsh-rewind] ledger commit failed for ${exec.name}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      return next();
+    });
+  });
+}
+export {
+  apply,
+  inject,
+  name
+};

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "dsh-rewind-plugin",
+  "version": "0.1.0",
+  "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",
+    "dsh",
+    "cordis",
+    "plugin",
+    "rewind",
+    "session",
+    "ui"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SiriLee/dsh-rewind.git"
+  },
+  "homepage": "https://github.com/SiriLee/dsh-rewind#readme",
+  "license": "MIT",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-runtime"
+      ],
+      "platform": "web"
+    }
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.client.json",
+    "test": "vitest run",
+    "verify:host": "node scripts/verify-host.mjs",
+    "prepare": "npm run build"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "*",
+    "@deepseek-ai/dsh-agent": "*",
+    "@deepseek-ai/dsh-client-locale": "*",
+    "@deepseek-ai/dsh-client-runtime": "*",
+    "@deepseek-ai/dsh-client-ui-slots": "*",
+    "@deepseek-ai/dsh-commands": "*",
+    "@deepseek-ai/dsh-fs": "*",
+    "@deepseek-ai/dsh-llm": "*",
+    "@deepseek-ai/dsh-sandbox": "*",
+    "@deepseek-ai/dsh-session": "*",
+    "@deepseek-ai/dsh-tools": "*"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": { "optional": true },
+    "@deepseek-ai/dsh-agent": { "optional": true },
+    "@deepseek-ai/dsh-client-locale": { "optional": true },
+    "@deepseek-ai/dsh-client-runtime": { "optional": true },
+    "@deepseek-ai/dsh-client-ui-slots": { "optional": true },
+    "@deepseek-ai/dsh-commands": { "optional": true },
+    "@deepseek-ai/dsh-fs": { "optional": true },
+    "@deepseek-ai/dsh-llm": { "optional": true },
+    "@deepseek-ai/dsh-sandbox": { "optional": true },
+    "@deepseek-ai/dsh-session": { "optional": true },
+    "@deepseek-ai/dsh-tools": { "optional": true }
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1-rc.4",
+    "@deepseek-ai/dsh-agent": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-locale": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-runtime": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-slots": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-commands": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-fs": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-sandbox": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.6",
+    "@types/node": "^24.0.0",
+    "esbuild": "^0.28.2",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  }
+}

package/scripts/build.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * dsh-rewind build — produces the npm-package artifacts under lib/:
+ *   lib/index.js  — host half: src/index.ts bundled to plain ESM. Every
+ *                   `@deepseek-ai/*` import stays external: the dsh loader
+ *                   resolves those from the harness installation, never from
+ *                   this package.
+ *   lib/client.js — client half: src/client/index.ts bundled to CJS, then
+ *                   wrapped in the web boot handoff
+ *                   `window.__ModuleLoader__.load({ id, factory })`, the
+ *                   closure-factory format every `dsh.client` package's
+ *                   `./client` export must use. The client half is fully
+ *                   self-contained (plain DOM, no React), so nothing is
+ *                   external and the injected `require` is never called.
+ *
+ * Type checking is a separate step (`npm run typecheck`, tsc --noEmit); this
+ * script only transpiles (esbuild) and runs smoke checks: both outputs must
+ * parse, and the host half must import with the expected plugin shape.
+ */
+import { build } from 'esbuild'
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
+const pkg = JSON.parse(await readFile(join(ROOT, 'package.json'), 'utf8'))
+
+await mkdir(join(ROOT, 'lib'), { recursive: true })
+
+// ---- host half: bundled TS -> ESM (@deepseek-ai/* stays external) ----
+await build({
+  entryPoints: [join(ROOT, 'src', 'index.ts')],
+  outfile: join(ROOT, 'lib', 'index.js'),
+  format: 'esm',
+  platform: 'node',
+  target: 'es2024',
+  bundle: true,
+  external: ['@deepseek-ai/*'],
+  sourcemap: false,
+})
+
+// ---- client half: bundled TS -> CJS, then wrapped in the loader handoff ----
+await build({
+  entryPoints: [join(ROOT, 'src', 'client', 'index.ts')],
+  outfile: join(ROOT, 'lib', '_client.js'),
+  format: 'cjs',
+  platform: 'browser',
+  target: 'es2020',
+  bundle: true,
+  external: [],
+  sourcemap: false,
+})
+const clientSource = await readFile(join(ROOT, 'lib', '_client.js'), 'utf8')
+await rm(join(ROOT, 'lib', '_client.js'))
+
+const bundle = [
+  '/* dsh-rewind client bundle — generated by scripts/build.mjs from src/client/ */',
+  'window.__ModuleLoader__.load({',
+  `  id: ${JSON.stringify(pkg.name)},`,
+  '  factory: (require) => {',
+  '    var module = { exports: {} };',
+  '    var exports = module.exports;',
+  clientSource.replace(/\s+$/, '\n'),
+  '    return module.exports;',
+  '  }',
+  '});',
+  '',
+].join('\n')
+await writeFile(join(ROOT, 'lib', 'client.js'), bundle)
+
+// ---- smoke checks ----
+const host = await readFile(join(ROOT, 'lib', 'index.js'), 'utf8')
+const exportBlock = host.slice(host.lastIndexOf('export {'))
+for (const needle of ['name', 'inject', 'apply']) {
+  if (!exportBlock.includes(needle)) throw new Error(`host bundle missing export ${needle}`)
+}
+for (const needle of ['window.__ModuleLoader__.load', `id: ${JSON.stringify(pkg.name)}`]) {
+  if (!bundle.includes(needle)) throw new Error(`client bundle missing ${needle}`)
+}
+console.log('build ok: lib/index.js (host), lib/client.js (client)')