@blackbelt-technology/pi-agent-dashboard 0.4.5 → 0.4.6

package/packages/server/src/server.ts

@@ -52,6 +52,7 @@ import { registerPiCoreRoutes } from "./routes/pi-core-routes.js";
 import { PiCoreChecker } from "./pi-core-checker.js";
 import { PiCoreUpdater } from "./pi-core-updater.js";
 import { registerToolRoutes } from "./routes/tool-routes.js";
+import { registerJjRoutes } from "./routes/jj-routes.js";
 import { registerBootstrapRoutes } from "./routes/bootstrap-routes.js";
 import { createBootstrapState, type BootstrapStateStore } from "./bootstrap-state.js";
 import { createBootstrapQueue } from "./bootstrap-queue.js";
@@ -90,6 +91,10 @@ export interface ServerConfig {
   editor: import("@blackbelt-technology/pi-dashboard-shared/config.js").EditorConfig;
   /** OpenSpec polling config (interval, concurrency, change detection, jitter) */
   openspec?: import("@blackbelt-technology/pi-dashboard-shared/config.js").OpenSpecPollConfig;
+  /** Reattach-placement policy applied when a bridge re-registers after
+   *  a dashboard restart. Defaults to `"always"`.
+   *  See change: reattach-move-to-front. */
+  reattachPlacement?: import("@blackbelt-technology/pi-dashboard-shared/config.js").ReattachPlacement;
   /** Merged trusted networks from config */
   resolvedTrustedNetworks?: string[];
   /** CORS allowed origins from config */
@@ -366,7 +371,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
           applyReattachPolicy(
             sessionId,
             session.cwd,
-            config.reattachPlacement,
+            config.reattachPlacement ?? "always",
             { sessionManager, sessionOrderManager, browserGateway },
             ctx.priorStatus,
           );
@@ -416,7 +421,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
         applyReattachPolicy(
           sessionId,
           session.cwd,
-          config.reattachPlacement,
+          config.reattachPlacement ?? "always",
           { sessionManager, sessionOrderManager, browserGateway },
           ctx.priorStatus,
         );
@@ -706,6 +711,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
   });
   registerSystemRoutes(fastify, { sessionManager, preferencesStore, metaPersistence, config, networkGuard, version: pkgVersion, directoryService, piGateway });
   registerToolRoutes(fastify, { registry: getDefaultRegistry(), networkGuard });
+  registerJjRoutes(fastify, { browserGateway, pendingAttachRegistry, networkGuard });
 
   // ── Bootstrap REST routes ────────────────────────────────────────
   // The routes module is registered here; state + queue are declared

package/packages/server/src/session-diff.ts

@@ -5,7 +5,8 @@
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, relative, isAbsolute, sep as pathSep } from "node:path";
 import * as git from "@blackbelt-technology/pi-dashboard-shared/platform/git.js";
-import type { DashboardEvent } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+import * as jj from "@blackbelt-technology/pi-dashboard-shared/platform/jj.js";
+import type { DashboardEvent, JjState } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import type { FileChangeEvent, FileDiffEntry, EditOperation } from "@blackbelt-technology/pi-dashboard-shared/diff-types.js";
 import { isGitRepo } from "./git-operations.js";
 
@@ -176,3 +177,119 @@ export function enrichWithGitDiff(
 
   return { enrichedFiles: enriched, isGitRepo: true };
 }
+
+// ── jj enrichment (regime-aware) ─────────────────────────────────────────
+
+/**
+ * Pure helper: pick the right diff base for a given jj state.
+ *   - default workspace  → `@-`     (equivalent to `git diff HEAD`)
+ *   - non-default        → `fork_point(@, trunk())`
+ *
+ * Exported for unit testing without spawning jj.
+ */
+export function selectJjDiffBase(jjState: JjState | undefined): {
+  diffBase: string;
+  baseLabel: string;
+} {
+  const workspace = jjState?.workspaceName;
+  if (!workspace || workspace === "default") {
+    return { diffBase: "@-", baseLabel: "@-" };
+  }
+  // Use the `..` range form (always-supported) instead of `fork_point()`
+  // (which changed signature across jj versions). `trunk()` returns the
+  // most-recent ancestor on main/master/trunk; the diff base is the
+  // single tip of trunk so that `--from <base> --to @` materializes the
+  // cumulative diff across every agent commit in this workspace.
+  return { diffBase: "trunk()", baseLabel: "trunk()" };
+}
+
+/**
+ * Enrich file entries with `jj diff` output, regime-aware. Runs
+ * `jj diff --from <baseRev> --to @ -- <path>` per file. Handles new
+ * files natively (no synthetic `/dev/null` fallback needed — jj
+ * reports new files in unified diff format directly).
+ */
+export function enrichWithJjDiff(
+  cwd: string,
+  files: FileDiffEntry[],
+  jjState: JjState | undefined,
+): { enrichedFiles: FileDiffEntry[]; vcsKind: "jj"; diffBase: string; baseLabel: string } {
+  const { diffBase, baseLabel } = selectJjDiffBase(jjState);
+  const labelOverride = resolveBaseLabel(cwd, diffBase, baseLabel);
+  const enriched = files.map((file) => {
+    try {
+      const diff = jj.diffOr({
+        cwd,
+        fromRev: diffBase,
+        toRev: "@",
+        path: file.path,
+      }).trim();
+      if (diff) return { ...file, gitDiff: diff };
+      return file;
+    } catch {
+      return file;
+    }
+  });
+  return { enrichedFiles: enriched, vcsKind: "jj", diffBase, baseLabel: labelOverride };
+}
+
+/**
+ * Promote the abstract revset (e.g. `@-` or `fork_point(@, trunk())`) to
+ * a human-friendly bookmark name when one exists. Best effort — falls
+ * back to the abstract label if jj can't resolve it.
+ */
+function resolveBaseLabel(cwd: string, diffBase: string, fallback: string): string {
+  const result = jj.logRevset({
+    cwd,
+    revset: diffBase,
+    template: 'bookmarks ++ "\\n"',
+  });
+  if (!result.ok) return fallback;
+  const first = result.value.trim().split("\n")[0]?.trim();
+  if (first && first.length > 0 && first.length < 100) return first;
+  return fallback;
+}
+
+// ── Unified dispatcher ──────────────────────────────────────────────────
+
+export interface VcsEnrichmentResult {
+  enrichedFiles: FileDiffEntry[];
+  isGitRepo: boolean;
+  vcsKind?: "git" | "jj";
+  diffBase?: string;
+  baseLabel?: string;
+}
+
+/**
+ * Regime-aware dispatcher. When the session has `jjState.isJjRepo`,
+ * route through `enrichWithJjDiff` (which produces the cumulative diff
+ * for non-default workspaces). Otherwise fall back to the existing
+ * `enrichWithGitDiff` behavior unchanged — plain-git regime is byte-
+ * equivalent to the pre-change response shape (modulo the now-optional
+ * `vcsKind` field that older clients ignore).
+ *
+ * See change: add-jj-workspace-plugin.
+ */
+export function enrichWithVcsDiff(
+  cwd: string,
+  files: FileDiffEntry[],
+  jjState: JjState | undefined,
+): VcsEnrichmentResult {
+  if (jjState?.isJjRepo) {
+    const result = enrichWithJjDiff(cwd, files, jjState);
+    return {
+      enrichedFiles: result.enrichedFiles,
+      isGitRepo: jjState.isColocated === true,
+      vcsKind: "jj",
+      diffBase: result.diffBase,
+      baseLabel: result.baseLabel,
+    };
+  }
+  const result = enrichWithGitDiff(cwd, files);
+  return {
+    ...result,
+    vcsKind: result.isGitRepo ? "git" : undefined,
+    diffBase: result.isGitRepo ? "HEAD" : undefined,
+    baseLabel: result.isGitRepo ? "HEAD" : undefined,
+  };
+}

package/packages/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-shared",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Shared types and utilities for pi-dashboard",
   "type": "module",
   "repository": {

package/packages/shared/src/__tests__/platform-jj.test.ts

@@ -0,0 +1,339 @@
+/**
+ * Tests for packages/shared/src/platform/jj.ts — Recipe argv shapes
+ * and the pure `parseWorkspaceList` helper.
+ *
+ * Live integration tests (running real `jj` against a temp repo) are
+ * deferred to the integration-test phase; argv shape coverage here
+ * catches the most common refactor mistakes without requiring `jj`
+ * on the test runner's PATH.
+ *
+ * See change: add-jj-workspace-plugin.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  JJ_VERSION,
+  JJ_WORKSPACE_ROOT,
+  JJ_WORKSPACE_LIST,
+  JJ_WORKSPACE_ADD,
+  JJ_WORKSPACE_FORGET,
+  JJ_BOOKMARK_CREATE,
+  JJ_BOOKMARK_LIST,
+  JJ_GIT_INIT_COLOCATE,
+  JJ_GIT_PUSH,
+  JJ_DIFF,
+  JJ_RESOLVE_LIST,
+  JJ_OP_LOG_HEAD,
+  JJ_OP_RESTORE,
+  JJ_REBASE,
+  JJ_LOG_REVSET,
+  JJ_RECIPES,
+  parseWorkspaceList,
+  findWorkspaceByName,
+} from "../platform/jj.js";
+
+// ── Argv shapes ─────────────────────────────────────────────────────────────
+
+describe("JJ_VERSION.argv", () => {
+  it("is `jj --version`", () => {
+    expect(JJ_VERSION.argv({})).toEqual(["jj", "--version"]);
+  });
+
+  it("parses `jj 0.18.0` into `0.18.0`", () => {
+    expect(JJ_VERSION.parse("jj 0.18.0\n", {})).toBe("0.18.0");
+  });
+
+  it("falls back to trimmed string when version regex fails", () => {
+    expect(JJ_VERSION.parse("unknown-format\n", {})).toBe("unknown-format");
+  });
+});
+
+describe("JJ_WORKSPACE_ROOT.argv", () => {
+  it("is `jj workspace root`", () => {
+    expect(JJ_WORKSPACE_ROOT.argv({ cwd: "/tmp" })).toEqual([
+      "jj", "workspace", "root",
+    ]);
+  });
+});
+
+describe("JJ_WORKSPACE_LIST.argv", () => {
+  it("includes --no-pager", () => {
+    expect(JJ_WORKSPACE_LIST.argv({ cwd: "/tmp" })).toEqual([
+      "jj", "workspace", "list", "--no-pager",
+    ]);
+  });
+});
+
+describe("JJ_WORKSPACE_ADD.argv", () => {
+  it("without baseRev", () => {
+    expect(JJ_WORKSPACE_ADD.argv({ cwd: "/repo", destPath: "/repo/.shadow/agent-1" })).toEqual([
+      "jj", "workspace", "add", "/repo/.shadow/agent-1",
+    ]);
+  });
+
+  it("with baseRev", () => {
+    expect(JJ_WORKSPACE_ADD.argv({
+      cwd: "/repo",
+      destPath: "/repo/.shadow/agent-1",
+      baseRev: "develop",
+    })).toEqual([
+      "jj", "workspace", "add", "/repo/.shadow/agent-1", "-r", "develop",
+    ]);
+  });
+
+  it("path with spaces is passed verbatim (argv-array, no shell)", () => {
+    expect(JJ_WORKSPACE_ADD.argv({ cwd: "/repo", destPath: "/repo/my workspace" })).toEqual([
+      "jj", "workspace", "add", "/repo/my workspace",
+    ]);
+  });
+});
+
+describe("JJ_WORKSPACE_FORGET.argv", () => {
+  it("is `jj workspace forget <name>`", () => {
+    expect(JJ_WORKSPACE_FORGET.argv({ cwd: "/repo", name: "agent-1" })).toEqual([
+      "jj", "workspace", "forget", "agent-1",
+    ]);
+  });
+});
+
+describe("JJ_BOOKMARK_CREATE.argv", () => {
+  it("is `jj bookmark create <name> -r <rev>`", () => {
+    expect(JJ_BOOKMARK_CREATE.argv({ cwd: "/repo", name: "feat", rev: "@" })).toEqual([
+      "jj", "bookmark", "create", "feat", "-r", "@",
+    ]);
+  });
+});
+
+describe("JJ_BOOKMARK_LIST.argv", () => {
+  it("includes name template and --no-pager", () => {
+    const argv = JJ_BOOKMARK_LIST.argv({ cwd: "/repo" });
+    expect(argv[0]).toBe("jj");
+    expect(argv).toContain("bookmark");
+    expect(argv).toContain("list");
+    expect(argv).toContain("-T");
+    expect(argv).toContain("--no-pager");
+  });
+});
+
+describe("JJ_GIT_INIT_COLOCATE.argv", () => {
+  it("is `jj git init --colocate`", () => {
+    expect(JJ_GIT_INIT_COLOCATE.argv({ cwd: "/repo" })).toEqual([
+      "jj", "git", "init", "--colocate",
+    ]);
+  });
+});
+
+describe("JJ_GIT_PUSH.argv", () => {
+  it("includes --bookmark <name>", () => {
+    expect(JJ_GIT_PUSH.argv({ cwd: "/repo", bookmark: "feat/agent-1" })).toEqual([
+      "jj", "git", "push", "--bookmark", "feat/agent-1",
+    ]);
+  });
+});
+
+describe("JJ_DIFF.argv", () => {
+  it("default invocation has no --from/--to", () => {
+    expect(JJ_DIFF.argv({ cwd: "/repo" })).toEqual([
+      "jj", "diff", "--no-pager",
+    ]);
+  });
+
+  it("with --from and --to", () => {
+    expect(JJ_DIFF.argv({ cwd: "/repo", fromRev: "develop", toRev: "@" })).toEqual([
+      "jj", "diff", "--no-pager", "--from", "develop", "--to", "@",
+    ]);
+  });
+
+  it("with path filter", () => {
+    expect(JJ_DIFF.argv({
+      cwd: "/repo",
+      fromRev: "develop",
+      toRev: "@",
+      path: "src/auth.ts",
+    })).toEqual([
+      "jj", "diff", "--no-pager",
+      "--from", "develop",
+      "--to", "@",
+      "--", "src/auth.ts",
+    ]);
+  });
+
+  it("path-only diff (working copy)", () => {
+    expect(JJ_DIFF.argv({ cwd: "/repo", path: "src/auth.ts" })).toEqual([
+      "jj", "diff", "--no-pager", "--", "src/auth.ts",
+    ]);
+  });
+});
+
+describe("JJ_RESOLVE_LIST.argv", () => {
+  it("is `jj resolve --list`", () => {
+    expect(JJ_RESOLVE_LIST.argv({ cwd: "/repo" })).toEqual([
+      "jj", "resolve", "--list", "--no-pager",
+    ]);
+  });
+
+  it("tolerates exit code 1 (no conflicts)", () => {
+    expect(JJ_RESOLVE_LIST.tolerate).toContain(1);
+  });
+});
+
+describe("JJ_OP_LOG_HEAD.argv", () => {
+  it("includes --limit 1 and id.short() template", () => {
+    const argv = JJ_OP_LOG_HEAD.argv({ cwd: "/repo" });
+    expect(argv).toContain("op");
+    expect(argv).toContain("log");
+    expect(argv).toContain("--limit");
+    expect(argv).toContain("1");
+    expect(argv).toContain("-T");
+  });
+
+  it("parses single-line short id output", () => {
+    expect(JJ_OP_LOG_HEAD.parse("abc1234\n", { cwd: "/repo" })).toBe("abc1234");
+  });
+
+  it("returns undefined for empty output", () => {
+    expect(JJ_OP_LOG_HEAD.parse("\n", { cwd: "/repo" })).toBeUndefined();
+  });
+});
+
+describe("JJ_OP_RESTORE.argv", () => {
+  it("is `jj op restore <op-id>`", () => {
+    expect(JJ_OP_RESTORE.argv({ cwd: "/repo", opId: "abc1234" })).toEqual([
+      "jj", "op", "restore", "abc1234",
+    ]);
+  });
+});
+
+describe("JJ_REBASE.argv", () => {
+  it("is `jj rebase -d <dest> -s <src>`", () => {
+    expect(JJ_REBASE.argv({ cwd: "/repo", dest: "main", src: "agent-1" })).toEqual([
+      "jj", "rebase", "-d", "main", "-s", "agent-1",
+    ]);
+  });
+});
+
+describe("JJ_LOG_REVSET.argv", () => {
+  it("uses default change_id template", () => {
+    const argv = JJ_LOG_REVSET.argv({ cwd: "/repo", revset: "trunk()..@" });
+    expect(argv).toContain("log");
+    expect(argv).toContain("-r");
+    expect(argv).toContain("trunk()..@");
+    expect(argv).toContain("--no-graph");
+  });
+
+  it("respects custom template", () => {
+    const argv = JJ_LOG_REVSET.argv({
+      cwd: "/repo",
+      revset: "@",
+      template: 'description ++ "\\n"',
+    });
+    expect(argv).toContain('description ++ "\\n"');
+  });
+});
+
+describe("JJ_RECIPES registry", () => {
+  it("enumerates all exported recipes", () => {
+    const keys = Object.keys(JJ_RECIPES).sort();
+    expect(keys).toEqual([
+      "JJ_BOOKMARK_CREATE",
+      "JJ_BOOKMARK_LIST",
+      "JJ_DIFF",
+      "JJ_GIT_INIT_COLOCATE",
+      "JJ_GIT_PUSH",
+      "JJ_LOG_REVSET",
+      "JJ_OP_LOG_HEAD",
+      "JJ_OP_RESTORE",
+      "JJ_REBASE",
+      "JJ_RESOLVE_LIST",
+      "JJ_VERSION",
+      "JJ_WORKSPACE_ADD",
+      "JJ_WORKSPACE_FORGET",
+      "JJ_WORKSPACE_LIST",
+      "JJ_WORKSPACE_ROOT",
+    ]);
+  });
+
+  it("every recipe has argv and parse functions", () => {
+    for (const [name, recipe] of Object.entries(JJ_RECIPES)) {
+      expect(typeof recipe.argv, `${name}.argv`).toBe("function");
+      expect(typeof recipe.parse, `${name}.parse`).toBe("function");
+    }
+  });
+
+  it("every recipe's argv starts with `jj`", () => {
+    for (const [name, recipe] of Object.entries(JJ_RECIPES)) {
+      // Use a forgiving input shape — we only care about the binary name.
+      const argv = (recipe.argv as (i: any) => readonly string[])({
+        cwd: "/tmp",
+        destPath: "/x",
+        baseRev: "@",
+        name: "x",
+        rev: "@",
+        bookmark: "x",
+        opId: "x",
+        dest: "x",
+        src: "x",
+        revset: "@",
+        path: "x",
+      });
+      expect(argv[0], `${name} first arg`).toBe("jj");
+    }
+  });
+});
+
+// ── parseWorkspaceList ──────────────────────────────────────────────────────
+
+describe("parseWorkspaceList", () => {
+  it("parses standard two-workspace output", () => {
+    const out = `default: rxnxoqlk 4f2c1234 (no description set)
+agent-1: tmysxysu 0c4b5678 (empty) (no description set)
+`;
+    expect(parseWorkspaceList(out)).toEqual([
+      { name: "default", changeIdShort: "rxnxoqlk", commitIdShort: "4f2c1234" },
+      { name: "agent-1", changeIdShort: "tmysxysu", commitIdShort: "0c4b5678" },
+    ]);
+  });
+
+  it("captures non-default descriptions", () => {
+    const out = `default: rxnxoqlk 4f2c1234 work in progress on auth\n`;
+    expect(parseWorkspaceList(out)).toEqual([
+      {
+        name: "default",
+        changeIdShort: "rxnxoqlk",
+        commitIdShort: "4f2c1234",
+        description: "work in progress on auth",
+      },
+    ]);
+  });
+
+  it("ignores blank and malformed lines", () => {
+    const out = `\ndefault: rxnxoqlk 4f2c1234 (no description set)\nrandom garbage\n: missing-name 1234 5678\n`;
+    const entries = parseWorkspaceList(out);
+    expect(entries.map((e) => e.name)).toEqual(["default"]);
+  });
+
+  it("yields entry without ids when format is unexpected", () => {
+    const out = `weird-name: this is not an id pair\n`;
+    const entries = parseWorkspaceList(out);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.name).toBe("weird-name");
+    expect(entries[0]?.changeIdShort).toBeUndefined();
+  });
+
+  it("returns empty array for empty input", () => {
+    expect(parseWorkspaceList("")).toEqual([]);
+  });
+});
+
+describe("findWorkspaceByName", () => {
+  const fixtures = parseWorkspaceList(
+    `default: aaaa 1111 (no description set)\nagent-1: bbbb 2222 (no description set)\n`,
+  );
+
+  it("returns the matching entry by name", () => {
+    expect(findWorkspaceByName(fixtures, "agent-1")?.changeIdShort).toBe("bbbb");
+  });
+
+  it("returns undefined for unknown name", () => {
+    expect(findWorkspaceByName(fixtures, "ghost")).toBeUndefined();
+  });
+});

package/packages/shared/src/__tests__/tool-registry-definitions.test.ts

@@ -179,13 +179,29 @@ describe("openspec binary definition", () => {
 });
 
 describe("registered tool set", () => {
-  it("registers pi, pi-coding-agent, openspec, npm, node, git, zrok, wt", () => {
+  it("registers pi, pi-coding-agent, openspec, npm, node, git, jj, zrok, wt", () => {
     const r = freshRegistry({});
-    for (const name of ["pi", "pi-coding-agent", "openspec", "npm", "node", "git", "zrok", "wt"]) {
+    for (const name of ["pi", "pi-coding-agent", "openspec", "npm", "node", "git", "jj", "zrok", "wt"]) {
       expect(r.has(name)).toBe(true);
     }
   });
 
+  it("jj resolves via where when found", () => {
+    const r = freshRegistry({
+      which: (name) => (name === "jj" ? "/usr/local/bin/jj" : null),
+    });
+    const res = r.resolve("jj");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe("/usr/local/bin/jj");
+    expect(res.source).toBe("system");
+  });
+
+  it("jj unavailable returns ok:false without throwing", () => {
+    const r = freshRegistry({ which: () => null });
+    const res = r.resolve("jj");
+    expect(res.ok).toBe(false);
+  });
+
   it("wt resolves via where when found", () => {
     const r = freshRegistry({
       platform: "win32",

package/packages/shared/src/config.ts

@@ -134,6 +134,13 @@ export interface DashboardConfig {
   editor: EditorConfig;
   /** OpenSpec background polling behavior (interval, concurrency, change detection, jitter) */
   openspec: OpenSpecPollConfig;
+  /**
+   * Timeout for ask_user prompts in seconds.
+   * Default: 300 (5 minutes).
+   * Set to -1 (or any value <= 0) for no timeout (waits indefinitely).
+   * If the key is absent from config.json the default of 300 s applies.
+   */
+  askUserPromptTimeoutSeconds: number;
   /** Networks trusted for full access without authentication (CIDR, wildcard, exact IP) */
   trustedNetworks: string[];
   /** Merged trustedNetworks + auth.bypassHosts (deduplicated). Computed at load time. */
@@ -168,6 +175,9 @@ export interface CorsConfig {
 
 const VALID_SPAWN_STRATEGIES: SpawnStrategy[] = ["tmux", "headless"];
 
+/** Default ask_user prompt timeout: 300 seconds (5 minutes). */
+export const DEFAULT_ASK_USER_PROMPT_TIMEOUT_SECONDS = 300;
+
 const DEFAULTS: DashboardConfig = {
   plugins: {},
   port: 8000,
@@ -187,6 +197,7 @@ const DEFAULTS: DashboardConfig = {
   cors: { allowedOrigins: [] },
   electronMode: false,
   knownServers: [],
+  askUserPromptTimeoutSeconds: DEFAULT_ASK_USER_PROMPT_TIMEOUT_SECONDS,
   reattachPlacement: DEFAULT_REATTACH_PLACEMENT,
 };
 
@@ -385,6 +396,9 @@ export function loadConfig(): DashboardConfig {
       knownServers: parseKnownServers(parsed.knownServers),
       reattachPlacement: parseReattachPlacement(parsed.reattachPlacement),
       plugins: parsePluginsConfig(parsed.plugins),
+      askUserPromptTimeoutSeconds: typeof parsed.askUserPromptTimeoutSeconds === "number"
+        ? parsed.askUserPromptTimeoutSeconds
+        : defaults.askUserPromptTimeoutSeconds,
     };
 
     // Compute resolvedTrustedNetworks: merge trustedNetworks + auth.bypassHosts

package/packages/shared/src/diff-types.ts

@@ -38,4 +38,21 @@ export interface SessionDiffResponse {
   files: FileDiffEntry[];
   /** Whether the session cwd is a git repository */
   isGitRepo: boolean;
+  /**
+   * VCS regime used to compute the per-file diffs. Optional for
+   * backwards compatibility — absent on responses produced before
+   * change `add-jj-workspace-plugin`.
+   */
+  vcsKind?: "git" | "jj";
+  /**
+   * The literal revset / ref used as the diff base (e.g. "HEAD",
+   * "@-", "fork_point(@, trunk())"). Optional.
+   */
+  diffBase?: string;
+  /**
+   * Human-readable label for `diffBase` (e.g. "develop", "trunk()",
+   * "HEAD"). Optional. Renders as "Diffing against \<baseLabel\>"
+   * in the client when `vcsKind === "jj"`.
+   */
+  baseLabel?: string;
 }