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

package/packages/shared/src/__tests__/managed-runtime-strategy.test.ts

@@ -0,0 +1,74 @@
+/**
+ * Unit tests for `managedRuntimeStrategy` in isolation.
+ *
+ * Strategy receives a `StrategyCtx` (overrides + platform + env). We
+ * inject a fake `exists` so no real filesystem is touched.
+ *
+ * See change: embed-managed-node-runtime (task 2.6).
+ */
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { managedRuntimeStrategy } from "../tool-registry/strategies.js";
+import type { StrategyCtx } from "../tool-registry/types.js";
+
+function ctx(opts: Partial<StrategyCtx> = {}): StrategyCtx {
+  return {
+    overrides: {},
+    platform: opts.platform ?? "linux",
+    env: opts.env ?? { homedir: "/fake/home" },
+  };
+}
+
+describe("managedRuntimeStrategy", () => {
+  it("Unix node: returns <managedDir>/node/bin/node when present", () => {
+    const expected = path.join("/fake/home", ".pi-dashboard", "node", "bin", "node");
+    const s = managedRuntimeStrategy("node", { exists: (p) => p === expected });
+    const r = s.run(ctx({ platform: "linux" }));
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.path).toBe(expected);
+  });
+
+  it("Unix npm: returns <managedDir>/node/bin/npm when present", () => {
+    const expected = path.join("/fake/home", ".pi-dashboard", "node", "bin", "npm");
+    const s = managedRuntimeStrategy("npm", { exists: (p) => p === expected });
+    const r = s.run(ctx({ platform: "linux" }));
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.path).toBe(expected);
+  });
+
+  it("Windows node: returns <managedDir>/node/node.exe when present", () => {
+    const expected = path.join("/fake/home", ".pi-dashboard", "node", "node.exe");
+    const s = managedRuntimeStrategy("node", { exists: (p) => p === expected });
+    const r = s.run(ctx({ platform: "win32" }));
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.path).toBe(expected);
+  });
+
+  it("Windows npm: returns <managedDir>/node/npm.cmd when present", () => {
+    const expected = path.join("/fake/home", ".pi-dashboard", "node", "npm.cmd");
+    const s = managedRuntimeStrategy("npm", { exists: (p) => p === expected });
+    const r = s.run(ctx({ platform: "win32" }));
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.path).toBe(expected);
+  });
+
+  it("Windows npx: returns <managedDir>/node/npx.cmd when present", () => {
+    const expected = path.join("/fake/home", ".pi-dashboard", "node", "npx.cmd");
+    const s = managedRuntimeStrategy("npx", { exists: (p) => p === expected });
+    const r = s.run(ctx({ platform: "win32" }));
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.path).toBe(expected);
+  });
+
+  it("returns failure with reason when binary absent", () => {
+    const s = managedRuntimeStrategy("node", { exists: () => false });
+    const r = s.run(ctx({ platform: "linux" }));
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.reason).toMatch(/missing:/);
+  });
+
+  it("strategy is named 'managed' (classifies as managed source)", () => {
+    const s = managedRuntimeStrategy("node");
+    expect(s.name).toBe("managed");
+  });
+});

package/packages/shared/src/__tests__/no-installable-list-in-bridge.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Contract test: the bridge auto-spawn code path (server-launcher.ts) must
+ * NOT import from `installable-list`. Only Electron seeds `installable.json`
+ * on first run; Bridge and Standalone starters must not produce or consume
+ * that file.
+ *
+ * This is a static source scan — no runtime execution. If this test fails,
+ * a dependency on installable-list was accidentally added to the bridge
+ * launcher which would break the "file-absent is a no-op" contract on
+ * Bridge/Standalone bootstraps.
+ *
+ * See change: simplify-electron-bootstrap-derived-state (task 5.7).
+ */
+import { describe, expect, it } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import url from "node:url";
+
+const here = path.dirname(url.fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(here, "..", "..", "..", "..");
+
+/** Files that form the bridge auto-spawn contract. */
+const BRIDGE_SPAWN_FILES: readonly string[] = [
+  "packages/extension/src/server-launcher.ts",
+  "packages/extension/src/server-auto-start.ts",
+  "packages/extension/src/connection.ts",
+];
+
+describe("bridge auto-spawn does not reference installable-list", () => {
+  for (const rel of BRIDGE_SPAWN_FILES) {
+    it(`${rel} does not import from installable-list`, () => {
+      const file = path.resolve(repoRoot, rel);
+      if (!fs.existsSync(file)) {
+        // File absent (optional extension file) — contract trivially satisfied.
+        return;
+      }
+      const source = fs.readFileSync(file, "utf-8");
+
+      // Strip line comments before checking so a commented-out import
+      // does not trigger a false positive.
+      const stripped = source
+        .replace(/\/\/[^\n]*/g, "")
+        .replace(/\/\*[\s\S]*?\*\//g, "");
+
+      expect(
+        stripped,
+        `${rel} must not import from "installable-list" — only Electron seeds installable.json. ` +
+          `Bridge/Standalone starters must not produce or consume that file.`,
+      ).not.toMatch(/installable-list/);
+    });
+  }
+});

package/packages/shared/src/__tests__/no-raw-openspec-status-in-skills.test.ts

@@ -38,7 +38,12 @@ const GOVERNED_SKILLS = [
 ];
 
 describe("OpenSpec workflow skills must use effective-status.sh", () => {
-  it("no raw `openspec status --json` outside the wrapper script", async () => {
+  // SKIPPED: the .pi/skills/openspec-*/SKILL.md files this lint targets are
+  // vendored from upstream and gitignored (see .pi/.gitignore) — they get
+  // overwritten on every install, so we can't enforce dashboard-local
+  // semantics on them from here. Re-enable if/when those skills are
+  // forked into the repo, or move the wrapper-enforcement upstream.
+  it.skip("no raw `openspec status --json` outside the wrapper script", async () => {
     const here = path.dirname(url.fileURLToPath(import.meta.url));
     const repoRoot = path.resolve(here, "..", "..", "..", "..");
     const skillsRoot = path.resolve(repoRoot, ".pi", "skills");

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__/skill-block-parser.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect } from "vitest";
+import { parseSkillBlock, buildSkillBlock } from "../skill-block-parser.js";
+
+describe("parseSkillBlock", () => {
+  it("matches a well-formed wrapper with args", () => {
+    const text =
+      `<skill name="foo" location="/x/SKILL.md">\nReferences are relative to /x.\n\nbody\n</skill>\n\nargs here`;
+    const block = parseSkillBlock(text);
+    expect(block).not.toBeNull();
+    expect(block!.name).toBe("foo");
+    expect(block!.location).toBe("/x/SKILL.md");
+    expect(block!.body).toBe("body");
+    expect(block!.args).toBe("args here");
+    expect(block!.condensed).toBe("/skill:foo args here");
+  });
+
+  it("strips the 'References are relative to <baseDir>.\\n\\n' preamble from body", () => {
+    const text =
+      `<skill name="foo" location="/x/SKILL.md">\nReferences are relative to /x.\n\nfirst body line\nsecond body line\n</skill>`;
+    const block = parseSkillBlock(text);
+    expect(block!.body).toBe("first body line\nsecond body line");
+    expect(block!.body.startsWith("References are relative")).toBe(false);
+  });
+
+  it("falls back to verbatim content when preamble is absent", () => {
+    // Hand-crafted wrapper without the standard preamble (defensive: pi may evolve).
+    const text = `<skill name="foo" location="/x">\nbody only\n</skill>`;
+    expect(parseSkillBlock(text)!.body).toBe("body only");
+  });
+
+  it("matches a wrapper without args (no preamble)", () => {
+    const text = `<skill name="foo" location="/x">\nbody\n</skill>`;
+    const block = parseSkillBlock(text);
+    expect(block).not.toBeNull();
+    expect(block!.args).toBeUndefined();
+    expect(block!.condensed).toBe("/skill:foo");
+    expect(block!.body).toBe("body");
+  });
+
+  it("preserves multi-line user args verbatim", () => {
+    const text =
+      `<skill name="foo" location="/x">\nbody\n</skill>\n\nline1\nline2\nline3`;
+    const block = parseSkillBlock(text);
+    expect(block!.args).toBe("line1\nline2\nline3");
+    expect(block!.condensed).toBe("/skill:foo line1\nline2\nline3");
+  });
+
+  it("returns null for plain text", () => {
+    expect(parseSkillBlock("Hello, this is just text.")).toBeNull();
+    expect(parseSkillBlock("")).toBeNull();
+    expect(parseSkillBlock("/skill:foo args (unexpanded)")).toBeNull();
+  });
+
+  it("returns null for mid-document <skill> (anchor enforcement)", () => {
+    const text = `prefix\n<skill name="foo" location="/x">\nbody\n</skill>`;
+    expect(parseSkillBlock(text)).toBeNull();
+  });
+
+  it("returns null for trailing whitespace after </skill>", () => {
+    // Anchor end-of-string: a stray newline after </skill> with no args fails the optional-args group.
+    const text = `<skill name="foo" location="/x">\nbody\n</skill>\n`;
+    expect(parseSkillBlock(text)).toBeNull();
+  });
+
+  it("does not terminate prematurely on body containing literal <skill> text", () => {
+    const text =
+      `<skill name="real" location="/x">\nReferences are relative to /x.\n\nDocumented like: <skill name="example">…</skill>\nThat ended.\n</skill>`;
+    const block = parseSkillBlock(text);
+    expect(block).not.toBeNull();
+    expect(block!.name).toBe("real");
+    expect(block!.body).toContain('Documented like: <skill name="example">…</skill>');
+    expect(block!.body).toContain("That ended.");
+    // preamble was stripped — body starts with the user-visible content
+    expect(block!.body.startsWith("Documented")).toBe(true);
+  });
+
+  it("handles an empty body (no preamble)", () => {
+    const text = `<skill name="empty" location="/x">\n\n</skill>`;
+    const block = parseSkillBlock(text);
+    expect(block).not.toBeNull();
+    expect(block!.body).toBe("");
+  });
+
+  it("condensed form has a single space between name and args", () => {
+    const text = `<skill name="x" location="/p">\nb\n</skill>\n\nfoo`;
+    expect(parseSkillBlock(text)!.condensed).toBe("/skill:x foo");
+  });
+
+  it("condensed form has no trailing space when args is absent", () => {
+    const text = `<skill name="x" location="/p">\nb\n</skill>`;
+    expect(parseSkillBlock(text)!.condensed).toBe("/skill:x");
+  });
+});
+
+describe("buildSkillBlock", () => {
+  it("emits pi's exact wrapper format with args", () => {
+    const out = buildSkillBlock({
+      name: "openspec-explore",
+      filePath: "/x/openspec-explore/SKILL.md",
+      baseDir: "/x/openspec-explore",
+      body: "Enter explore mode.",
+      userArgs: "continue with X",
+    });
+    expect(out).toBe(
+      `<skill name="openspec-explore" location="/x/openspec-explore/SKILL.md">\n` +
+        `References are relative to /x/openspec-explore.\n\n` +
+        `Enter explore mode.\n` +
+        `</skill>\n\n` +
+        `continue with X`,
+    );
+  });
+
+  it("emits wrapper without trailing args block when userArgs is absent", () => {
+    const out = buildSkillBlock({
+      name: "foo",
+      filePath: "/x/foo/SKILL.md",
+      baseDir: "/x/foo",
+      body: "body line",
+    });
+    expect(out.endsWith("</skill>")).toBe(true);
+    expect(out).not.toContain("</skill>\n\n");
+  });
+});
+
+describe("buildSkillBlock + parseSkillBlock round-trip", () => {
+  it("round-trips name / body / args (with args)", () => {
+    const built = buildSkillBlock({
+      name: "round",
+      filePath: "/p/SKILL.md",
+      baseDir: "/p",
+      body: "Some body\nwith multiple lines",
+      userArgs: "the args here",
+    });
+    const parsed = parseSkillBlock(built);
+    expect(parsed).not.toBeNull();
+    expect(parsed!.name).toBe("round");
+    expect(parsed!.location).toBe("/p/SKILL.md");
+    expect(parsed!.body).toBe("Some body\nwith multiple lines");
+    expect(parsed!.args).toBe("the args here");
+  });
+
+  it("round-trips with no args", () => {
+    const built = buildSkillBlock({
+      name: "noargs",
+      filePath: "/p/SKILL.md",
+      baseDir: "/p",
+      body: "Body only",
+    });
+    const parsed = parseSkillBlock(built);
+    expect(parsed!.args).toBeUndefined();
+    expect(parsed!.condensed).toBe("/skill:noargs");
+  });
+});

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",