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

package/packages/server/src/__tests__/session-diff-vcs.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Tests for the vcs-regime-aware session-diff dispatcher.
+ *
+ * Per spec scenarios:
+ *   - "Diff in plain git repo is unchanged" — plain-git path is byte-equivalent
+ *   - "Diff in a workspace shows all agent commits, not just the last" —
+ *     non-default workspace selects fork_point(@, trunk()) base
+ *   - "Untracked file in jj path uses native jj diff output" — no synthetic fallback
+ *
+ * See change: add-jj-workspace-plugin.
+ */
+import { describe, it, expect } from "vitest";
+import type { JjState } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+import { selectJjDiffBase } from "../session-diff.js";
+
+describe("selectJjDiffBase", () => {
+  it("returns @- for the default workspace", () => {
+    const state: JjState = {
+      isJjRepo: true,
+      isColocated: true,
+      workspaceName: "default",
+    };
+    expect(selectJjDiffBase(state)).toEqual({ diffBase: "@-", baseLabel: "@-" });
+  });
+
+  it("returns @- when workspaceName is undefined (probe mid-flight)", () => {
+    const state: JjState = { isJjRepo: true, isColocated: true };
+    expect(selectJjDiffBase(state)).toEqual({ diffBase: "@-", baseLabel: "@-" });
+  });
+
+  it("returns trunk() for non-default workspaces", () => {
+    const state: JjState = {
+      isJjRepo: true,
+      isColocated: true,
+      workspaceName: "agent-1",
+    };
+    // Uses the `..` range form on jj-side (--from <base> --to @) — base
+    // is `trunk()` so the diff materializes every agent commit in this
+    // workspace. `fork_point()` was avoided because its signature varies
+    // across jj versions (single-arg in 0.40+, two-arg in older docs).
+    expect(selectJjDiffBase(state)).toEqual({
+      diffBase: "trunk()",
+      baseLabel: "trunk()",
+    });
+  });
+
+  it("returns trunk() for any workspace name except 'default'", () => {
+    for (const name of ["feat-x", "experiment", "ws-2", "shadow-7"]) {
+      const result = selectJjDiffBase({
+        isJjRepo: true,
+        isColocated: true,
+        workspaceName: name,
+      });
+      expect(result.diffBase).toBe("trunk()");
+    }
+  });
+
+  it("returns @- when called with undefined jjState (defensive)", () => {
+    expect(selectJjDiffBase(undefined)).toEqual({ diffBase: "@-", baseLabel: "@-" });
+  });
+});

package/packages/server/src/__tests__/system-routes-restart.test.ts

@@ -25,7 +25,7 @@ function makeNoopDeps() {
 function makeFakeGateway(): { gateway: PiGateway; broadcasts: ServerToExtensionMessage[] } {
   const broadcasts: ServerToExtensionMessage[] = [];
   const gateway: PiGateway = {
-    broadcast(msg) { broadcasts.push(msg); },
+    broadcast(msg: ServerToExtensionMessage) { broadcasts.push(msg); },
     sendToSession() { return false; },
     isSessionConnected() { return false; },
     connectionCount() { return 0; },
@@ -46,7 +46,7 @@ describe("POST /api/restart broadcasts server_restarting", () => {
     const fake = makeFakeGateway();
     broadcasts = fake.broadcasts;
     // process.exit is deferred via setTimeout(...,200); silence it for the test
-    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: number) => undefined as never));
+    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: string | number | null) => undefined as never) as (code?: string | number | null | undefined) => never);
     registerSystemRoutes(fastify, { ...makeNoopDeps(), piGateway: fake.gateway });
   });
 
@@ -82,7 +82,7 @@ describe("POST /api/shutdown broadcasts server_restarting", () => {
     fastify = Fastify();
     const fake = makeFakeGateway();
     broadcasts = fake.broadcasts;
-    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: number) => undefined as never));
+    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: string | number | null) => undefined as never) as (code?: string | number | null | undefined) => never);
     registerSystemRoutes(fastify, { ...makeNoopDeps(), piGateway: fake.gateway });
   });
 
@@ -111,7 +111,7 @@ describe("/api/restart works without piGateway (no-op broadcast)", () => {
 
   beforeEach(() => {
     fastify = Fastify();
-    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: number) => undefined as never));
+    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: string | number | null) => undefined as never) as (code?: string | number | null | undefined) => never);
     registerSystemRoutes(fastify, makeNoopDeps()); // no piGateway
   });
 

package/packages/server/src/cli.ts

@@ -145,6 +145,7 @@ export function buildConfig(flags: Partial<ServerConfig>): ServerConfig {
     maxWsBufferBytes: fileConfig.memoryLimits.maxWsBufferBytes,
     editor: fileConfig.editor,
     openspec: fileConfig.openspec,
+    reattachPlacement: fileConfig.reattachPlacement,
     resolvedTrustedNetworks: fileConfig.resolvedTrustedNetworks,
     corsAllowedOrigins: fileConfig.cors.allowedOrigins,
   };

package/packages/server/src/event-wiring.ts

@@ -582,6 +582,15 @@ export function wireEvents(deps: EventWiringDeps): void {
       browserGateway.broadcastSessionUpdated(sessionId, gitUpdates);
     }
 
+    if (msg.type === "jj_state_update") {
+      // jjState is intentionally allowed to be `undefined` (no jj) when
+      // the bridge sends `null`; the session-manager update applies the
+      // value verbatim. See change: add-jj-workspace-plugin.
+      const jjUpdates = { jjState: msg.jjState ?? undefined };
+      sessionManager.update(sessionId, jjUpdates);
+      browserGateway.broadcastSessionUpdated(sessionId, jjUpdates);
+    }
+
     if (msg.type === "files_list") {
       browserGateway.sendToSubscribers(sessionId, {
         type: "files_list",

package/packages/server/src/openspec-tasks.ts

@@ -1,16 +1,23 @@
 /**
  * Parser + writer for an OpenSpec change's `tasks.md` file.
  *
- * `tasks.md` uses a rigid line-level format:
- *   ## 1. Group heading
- *   - [ ] 1.1 Task text
- *   - [x] 1.2 Done task
+ * Accepted shapes (top-level only — leading whitespace is rejected):
+ *   ## 1. Group heading            (group context)
+ *   - [ ] 1.1 Task text             (id-ed: numeric `1.1`-style id)
+ *   - [x] 1.2 Done task             (id-ed, ticked)
+ *   - [ ] Verify runner image       (id-less: parser synthesizes `L<line>`)
+ *   - [x] Add matrix row            (id-less, ticked)
  *
- * We parse top-level `- [ ]` / `- [x]` lines only; anything else is ignored
- * (indented sublists, free-form prose, etc.).
+ * Indented sublists and free-form prose are ignored.
  *
- * Writes rewrite exactly one line's checkbox marker and preserve everything
- * else byte-for-byte; atomic via write-then-rename.
+ * The synthesized `L<line>` id (e.g. `L17` for the 7th line of the file) is a
+ * stable opaque token — it round-trips through the toggle endpoint as the
+ * `id` param but is NEVER written to disk. The `line` field is the actual
+ * byte-level optimistic-concurrency token; the id is just a cross-check.
+ *
+ * Writes rewrite exactly one line's checkbox marker character and preserve
+ * everything else byte-for-byte (including the original spacing between `]`
+ * and the id/text); atomic via write-then-rename.
  */
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -46,11 +53,21 @@ export class NotACheckboxError extends Error {
   }
 }
 
-// Top-level checkbox: allow a single leading `- ` with optional `[ ]`/`[x]`/`[X]`,
-// followed by an id-like token (digits and dots) and remaining text.
-const CHECKBOX_RE = /^- \[([ xX])\] +([0-9]+(?:\.[0-9]+)*)\s+(.*)$/;
+// Top-level checkbox with positional groups so the writer can rebuild the line
+// byte-for-byte. Groups (1-indexed):
+//   1: "- ["          (literal prefix)
+//   2: " " | "x" | "X" (the marker char — the only thing the writer flips)
+//   3: "] " plus any extra spaces (literal separator, preserved verbatim)
+//   4: "1.1 " (numeric id + its trailing whitespace) OR "" (id-less)
+//   5: the remainder of the line (the task text)
+const CHECKBOX_RE = /^(- \[)([ xX])(\] +)((?:[0-9]+(?:\.[0-9]+)* +)?)(.*)$/;
 const HEADING_RE = /^##\s+(.*)$/;
 
+/** Synthesize the canonical id for an id-less line: `L<1-indexed-line>`. */
+function synthesizeId(line1Indexed: number): string {
+  return `L${line1Indexed}`;
+}
+
 export function parseTasksMarkdown(content: string): OpenSpecTask[] {
   // Split on \n only; trailing \r is trimmed so we handle CRLF inputs too.
   const lines = content.split("\n");
@@ -66,12 +83,15 @@ export function parseTasksMarkdown(content: string): OpenSpecTask[] {
     }
     const m = CHECKBOX_RE.exec(line);
     if (!m) continue;
-    const done = m[1] === "x" || m[1] === "X";
+    const done = m[2] === "x" || m[2] === "X";
+    const lineNo = i + 1;
+    // m[4] is "" when no numeric id present, "1.1 " otherwise.
+    const id = m[4] ? m[4].trimEnd() : synthesizeId(lineNo);
     out.push({
-      id: m[2],
-      text: m[3].trim(),
+      id,
+      text: m[5].trim(),
       done,
-      line: i + 1,
+      line: lineNo,
       group: currentGroup,
     });
   }
@@ -121,16 +141,27 @@ export async function toggleTask(
 
   const m = CHECKBOX_RE.exec(bare);
   if (!m) throw new NotACheckboxError();
-  if (m[2] !== id) throw new LineMismatchError();
 
-  const currentDone = m[1] === "x" || m[1] === "X";
+  // Resolve the parsed id from the source line (numeric if present, else
+  // synthesized `L<line>`). The caller's `id` MUST match this exactly — a
+  // mismatch (numeric-vs-synthetic, wrong synthetic line number, or genuinely
+  // wrong id) is a line-mismatch.
+  const parsedId = m[4] ? m[4].trimEnd() : synthesizeId(line);
+  if (parsedId !== id) throw new LineMismatchError();
+
+  const currentDone = m[2] === "x" || m[2] === "X";
   // Optimistic concurrency: the caller's `done` is the *target* state; the line
   // must currently hold the opposite state. If it already matches, we treat
   // that as a line-mismatch — the file changed under us.
   if (currentDone === done) throw new LineMismatchError();
 
   const marker = done ? "x" : " ";
-  const rewritten = bare.replace(CHECKBOX_RE, `- [${marker}] ${m[2]} ${m[3]}`);
+  // Byte-for-byte rewrite: swap ONLY the marker char in group 2; preserve
+  // group 1 (prefix), group 3 (separator + any extra spaces), group 4 (id +
+  // trailing space, possibly empty for id-less lines), and group 5 (text).
+  // This guarantees id-less lines do not acquire a synthetic id in the file,
+  // and id-ed lines retain their exact spacing.
+  const rewritten = m[1] + marker + m[3] + m[4] + m[5];
   lines[idx] = hadCR ? rewritten + "\r" : rewritten;
 
   const newContent = lines.join("\n");
@@ -140,7 +171,7 @@ export async function toggleTask(
 
   return {
     id,
-    text: m[3].trim(),
+    text: m[5].trim(),
     done,
     line,
     group: findGroupForLine(lines, idx),

package/packages/server/src/routes/jj-routes.ts

@@ -0,0 +1,386 @@
+/**
+ * Jujutsu (jj) REST API routes (localhost-only).
+ *
+ * Endpoints:
+ *   POST /api/jj/workspace/add       — create workspace + spawn session
+ *   POST /api/jj/workspace/forget    — refuses on unfolded work; force escape
+ *   POST /api/jj/init-colocated      — refuses on dirty git index
+ *   GET  /api/jj/workspace/list      — enumerate workspaces under cwd
+ *
+ * All endpoints are network-guarded. Workspace add reuses the same
+ * pending-attach + spawnPiSession lever as the OpenSpec attach-and-spawn
+ * flow. See changes: add-jj-workspace-plugin, add-folder-task-checker-and-spawn-attach.
+ */
+import path from "node:path";
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import type { FastifyInstance } from "fastify";
+import * as jj from "@blackbelt-technology/pi-dashboard-shared/platform/jj.js";
+import * as git from "@blackbelt-technology/pi-dashboard-shared/platform/git.js";
+import { loadConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
+import type { ApiResponse } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+import type { BrowserGateway } from "../browser-gateway.js";
+import type { PendingAttachRegistry } from "../pending-attach-registry.js";
+import { spawnPiSession } from "../process-manager.js";
+import type { NetworkGuard } from "./route-deps.js";
+import { safeRealpathSync } from "../resolve-path.js";
+
+/** Workspace name regex per spec (filesystem + bookmark safety). */
+const NAME_RE = /^[a-z0-9-]+$/;
+
+export interface JjRoutesDeps {
+  browserGateway: BrowserGateway;
+  pendingAttachRegistry: PendingAttachRegistry;
+  networkGuard: NetworkGuard;
+  /** Optional plugin config accessor (defaults to current dashboard config). */
+  getWorkspaceRoot?: () => string;
+}
+
+/**
+ * Resolve the workspace-root setting for a given repo. Currently global
+ * via the plugin config; per-repo override is explicitly out of scope
+ * (Decision 14). Falls back to `.shadow` when config is absent.
+ */
+function resolveWorkspaceRoot(deps: JjRoutesDeps): string {
+  if (deps.getWorkspaceRoot) return deps.getWorkspaceRoot();
+  // The plugin config is read from the dashboard config blob's `plugins.jj`
+  // namespace. Until the runtime config-validator wires that path here, we
+  // fall back to the documented default.
+  try {
+    const cfg = loadConfig() as unknown as { plugins?: { jj?: { workspaceRoot?: string } } };
+    return cfg.plugins?.jj?.workspaceRoot ?? ".shadow";
+  } catch {
+    return ".shadow";
+  }
+}
+
+/**
+ * Pure preflight checks for `init-colocated`. Returns `null` on OK,
+ * else a `{ code, message }` object the caller can shape into 4xx.
+ */
+export function checkInitColocatedPreconditions(cwd: string):
+  | null
+  | { code: "INVALID_CWD" | "ALREADY_JJ" | "DIRTY_INDEX" | "NOT_GIT_REPO"; message: string } {
+  if (!cwd) return { code: "INVALID_CWD", message: "cwd is required" };
+  if (!existsSync(cwd)) return { code: "INVALID_CWD", message: `cwd does not exist: ${cwd}` };
+  if (existsSync(path.join(cwd, ".jj"))) {
+    return { code: "ALREADY_JJ", message: "cwd is already a jj repo" };
+  }
+  if (!existsSync(path.join(cwd, ".git"))) {
+    return { code: "NOT_GIT_REPO", message: "cwd is not a git repo" };
+  }
+  // git diff --cached --quiet exits 1 when index is dirty. Recipe-based
+  // helper for clarity and consistency with the rest of the codebase.
+  const indexResult = git.statusPorcelain({ cwd });
+  if (indexResult.ok) {
+    // Lines beginning with M, A, D, R, C, U in column 1 indicate INDEX
+    // changes (column 2 is the working tree). We refuse on any column-1
+    // mutation.
+    const dirty = indexResult.value
+      .split("\n")
+      .filter((l) => l.length >= 2 && /[MADRCU]/.test(l[0]!));
+    if (dirty.length > 0) {
+      return {
+        code: "DIRTY_INDEX",
+        message:
+          `git index has staged changes (${dirty.length} entr${dirty.length === 1 ? "y" : "ies"}); ` +
+          `commit or 'git reset' first. See spec scenario "Init refused on dirty index".`,
+      };
+    }
+  }
+  return null;
+}
+
+export function registerJjRoutes(fastify: FastifyInstance, deps: JjRoutesDeps) {
+  const { browserGateway, pendingAttachRegistry, networkGuard } = deps;
+
+  // ── GET /api/jj/workspace/list?cwd=… ────────────────────────────────────
+  fastify.get<{ Querystring: { cwd?: string } }>(
+    "/api/jj/workspace/list",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const cwd = request.query.cwd;
+      if (!cwd) {
+        reply.code(400);
+        return { success: false, error: "cwd is required" } satisfies ApiResponse;
+      }
+      if (!existsSync(path.join(cwd, ".jj"))) {
+        return { success: true, data: { workspaces: [] } } satisfies ApiResponse;
+      }
+      const result = jj.workspaceList({ cwd });
+      if (!result.ok) {
+        reply.code(500);
+        return {
+          success: false,
+          error: `jj workspace list failed: ${describeError(result.error)}`,
+        } satisfies ApiResponse;
+      }
+      const workspaces = jj.parseWorkspaceList(result.value);
+      return { success: true, data: { workspaces } } satisfies ApiResponse;
+    },
+  );
+
+  // ── POST /api/jj/workspace/add ──────────────────────────────────────────
+  fastify.post<{
+    Body: { fromCwd?: string; name?: string; baseRev?: string; taskDescription?: string };
+  }>(
+    "/api/jj/workspace/add",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const { fromCwd, name, baseRev, taskDescription } = request.body ?? {};
+
+      if (!fromCwd) {
+        reply.code(400);
+        return { success: false, error: "fromCwd is required" } satisfies ApiResponse;
+      }
+      if (!name || !NAME_RE.test(name)) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "INVALID_NAME: name must match /^[a-z0-9-]+$/",
+        } satisfies ApiResponse;
+      }
+      if (!existsSync(path.join(fromCwd, ".jj"))) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "fromCwd is not a jj repo",
+        } satisfies ApiResponse;
+      }
+
+      const workspaceRoot = resolveWorkspaceRoot(deps);
+      const destPath = path.join(fromCwd, workspaceRoot, name);
+      if (existsSync(destPath)) {
+        reply.code(409);
+        return {
+          success: false,
+          error: `destination already exists: ${destPath}`,
+        } satisfies ApiResponse;
+      }
+      // Ensure the workspace-root parent directory exists. `jj workspace
+      // add` does NOT create intermediate dirs and fails with
+      // "Cannot access <path>" on a missing parent. mkdir -p is safe and
+      // idempotent. The .shadow root should be in .gitignore (the spec's
+      // FolderOpenSpecSection-style hint is tracked as follow-up).
+      const parentDir = path.dirname(destPath);
+      try {
+        await fs.mkdir(parentDir, { recursive: true });
+      } catch (err) {
+        reply.code(500);
+        return {
+          success: false,
+          error: `failed to create workspace parent dir ${parentDir}: ${err instanceof Error ? err.message : String(err)}`,
+        } satisfies ApiResponse;
+      }
+
+      // Resolve the base revision when omitted: current bookmark of fromCwd's
+      // working copy, falling back to `trunk()` revset.
+      let resolvedBase = baseRev;
+      if (!resolvedBase) {
+        const bookmarksResult = jj.logRevset({
+          cwd: fromCwd,
+          revset: "@",
+          template: 'bookmarks ++ "\\n"',
+        });
+        if (bookmarksResult.ok) {
+          const first = bookmarksResult.value.trim().split("\n")[0]?.trim();
+          if (first) resolvedBase = first;
+        }
+        if (!resolvedBase) resolvedBase = "trunk()";
+      }
+
+      const addResult = jj.workspaceAdd({
+        cwd: fromCwd,
+        destPath,
+        baseRev: resolvedBase,
+      });
+      if (!addResult.ok) {
+        reply.code(500);
+        return {
+          success: false,
+          error: `jj workspace add failed: ${describeError(addResult.error)}`,
+        } satisfies ApiResponse;
+      }
+
+      const realDestPath = safeRealpathSync(destPath);
+      pendingAttachRegistry.enqueue(realDestPath, name);
+
+      // Spawn a session in the new workspace. Mirrors the OpenSpec
+      // attach-and-spawn flow; the bridge's `session_register` will
+      // consume the pending-attach intent and apply the auto-rename.
+      try {
+        const config = loadConfig();
+        const spawnResult = await spawnPiSession(realDestPath, {
+          strategy: config.spawnStrategy,
+        });
+        if (spawnResult.process && spawnResult.pid) {
+          browserGateway.headlessPidRegistry.register(
+            spawnResult.pid,
+            realDestPath,
+            spawnResult.process,
+          );
+        }
+        if (!spawnResult.success) {
+          reply.code(202);
+          return {
+            success: true,
+            data: {
+              workspacePath: realDestPath,
+              spawned: false,
+              spawnMessage: spawnResult.message,
+            },
+          } satisfies ApiResponse;
+        }
+        return {
+          success: true,
+          data: {
+            workspacePath: realDestPath,
+            spawned: true,
+            taskDescription: taskDescription ?? null,
+          },
+        } satisfies ApiResponse;
+      } catch (err) {
+        reply.code(202);
+        return {
+          success: true,
+          data: {
+            workspacePath: realDestPath,
+            spawned: false,
+            spawnMessage: err instanceof Error ? err.message : String(err),
+          },
+        } satisfies ApiResponse;
+      }
+    },
+  );
+
+  // ── POST /api/jj/workspace/forget ───────────────────────────────────────
+  fastify.post<{
+    Body: { cwd?: string; name?: string; force?: boolean };
+  }>(
+    "/api/jj/workspace/forget",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const { cwd, name, force } = request.body ?? {};
+
+      if (!cwd) {
+        reply.code(400);
+        return { success: false, error: "cwd is required" } satisfies ApiResponse;
+      }
+      if (!name || !NAME_RE.test(name)) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "INVALID_NAME: name must match /^[a-z0-9-]+$/",
+        } satisfies ApiResponse;
+      }
+      if (!existsSync(path.join(cwd, ".jj"))) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "cwd is not a jj repo",
+        } satisfies ApiResponse;
+      }
+
+      // Inspect for unfolded commits: anything in the workspace's `@`
+      // that isn't an ancestor of trunk. `trunk()..<name>@` is the
+      // straight-line revset for that; we filter out empty changes
+      // (`~empty()`) so the empty `@` of a freshly-created workspace
+      // doesn't trigger the unfolded-work refusal.
+      // Note: jj 0.40's `fork_point()` takes a single revset; we use
+      // the simpler `..` range form which works on every supported jj.
+      let unfolded: string[] = [];
+      const logResult = jj.logRevset({
+        cwd,
+        revset: `trunk()..${name}@ & ~empty()`,
+        template: 'change_id.short() ++ " " ++ description.first_line() ++ "\\n"',
+      });
+      if (logResult.ok) {
+        unfolded = logResult.value
+          .split("\n")
+          .map((l) => l.trim())
+          .filter(Boolean);
+      }
+      // A failed revset (e.g. unknown bookmark / fork_point unsupported) is
+      // *not* sufficient to skip the safety check — refuse with a generic
+      // error so the user sees the underlying jj message.
+      if (!logResult.ok) {
+        reply.code(500);
+        return {
+          success: false,
+          error: `jj log probe failed: ${describeError(logResult.error)}`,
+        } satisfies ApiResponse;
+      }
+
+      if (unfolded.length > 0 && !force) {
+        reply.code(409);
+        return {
+          success: false,
+          error: "UNFOLDED_WORK",
+          data: { unfolded },
+        } as unknown as ApiResponse;
+      }
+
+      // Forget + remove directory.
+      const forgetResult = jj.workspaceForget({ cwd, name });
+      if (!forgetResult.ok) {
+        reply.code(500);
+        return {
+          success: false,
+          error: `jj workspace forget failed: ${describeError(forgetResult.error)}`,
+        } satisfies ApiResponse;
+      }
+
+      const workspaceRoot = resolveWorkspaceRoot(deps);
+      const dirPath = path.join(cwd, workspaceRoot, name);
+      try {
+        await fs.rm(dirPath, { recursive: true, force: true });
+      } catch (err) {
+        // Forget already succeeded; surface the rm error but don't fail
+        // the operation overall — the workspace is gone from jj's view.
+        request.log.warn(
+          `jj workspace dir cleanup failed (${dirPath}): ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+
+      return { success: true, data: { name, force: Boolean(force) } } satisfies ApiResponse;
+    },
+  );
+
+  // ── POST /api/jj/init-colocated ─────────────────────────────────────────
+  fastify.post<{ Body: { cwd?: string } }>(
+    "/api/jj/init-colocated",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const { cwd } = request.body ?? {};
+      const precheck = checkInitColocatedPreconditions(cwd ?? "");
+      if (precheck) {
+        reply.code(precheck.code === "DIRTY_INDEX" ? 409 : 400);
+        return {
+          success: false,
+          error: precheck.code,
+          data: { message: precheck.message },
+        } as unknown as ApiResponse;
+      }
+      const result = jj.gitInitColocate({ cwd: cwd! });
+      if (!result.ok) {
+        reply.code(500);
+        return {
+          success: false,
+          error: `jj git init --colocate failed: ${describeError(result.error)}`,
+        } satisfies ApiResponse;
+      }
+      return { success: true, data: { cwd } } satisfies ApiResponse;
+    },
+  );
+}
+
+function describeError(error: { kind: string; [k: string]: unknown }): string {
+  if (error.kind === "not-found") return `binary not found: ${String(error.binary ?? "jj")}`;
+  if (error.kind === "timeout") return `timed out after ${String(error.timeoutMs)}ms`;
+  if (error.kind === "exit") {
+    const stderr = typeof error.stderr === "string" ? error.stderr.trim() : "";
+    return stderr.split("\n")[0] || `exited ${String(error.code)}`;
+  }
+  if (error.kind === "spawn-failure") return String(error.message ?? "spawn failed");
+  return error.kind;
+}

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

@@ -8,7 +8,7 @@ import type { SessionManager } from "../memory-session-manager.js";
 import type { EventStore } from "../memory-event-store.js";
 import type { ApiResponse } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import type { NetworkGuard } from "./route-deps.js";
-import { extractFileChanges, enrichWithGitDiff } from "../session-diff.js";
+import { extractFileChanges, enrichWithVcsDiff } from "../session-diff.js";
 
 export function registerSessionRoutes(
   fastify: FastifyInstance,
@@ -52,8 +52,17 @@ export function registerSessionRoutes(
       }
       const events = eventStore.getEvents(sessionId, 0).map((e) => e.event);
       const files = extractFileChanges(events, session.cwd);
-      const { enrichedFiles, isGitRepo: isGit } = enrichWithGitDiff(session.cwd, files);
-      return { success: true, data: { files: enrichedFiles, isGitRepo: isGit } } satisfies ApiResponse;
+      const result = enrichWithVcsDiff(session.cwd, files, session.jjState);
+      return {
+        success: true,
+        data: {
+          files: result.enrichedFiles,
+          isGitRepo: result.isGitRepo,
+          vcsKind: result.vcsKind,
+          diffBase: result.diffBase,
+          baseLabel: result.baseLabel,
+        },
+      } satisfies ApiResponse;
     },
   );