@pi-harness/pi-harness 0.1.2 → 0.1.3

package/packages/core/test/git-time-capsule.test.ts

@@ -0,0 +1,115 @@
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { Context } from "@deepseek-ai/cordis";
+import { afterEach, describe, expect, test } from "vitest";
+import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+import { applyCapsule } from "../src/plugins/git-time-capsule.js";
+import gitTimeCapsulePlugin from "../src/plugins/git-time-capsule.js";
+
+const execFileAsync = promisify(execFile);
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
+});
+
+describe("git time capsule restore", () => {
+  test("checks and applies a capsule to a real git workspace", async () => {
+    const workspace = await mkdtemp(join(tmpdir(), "pi-harness-capsule-workspace-"));
+    const capsules = await mkdtemp(join(tmpdir(), "pi-harness-capsules-"));
+    temporaryDirectories.push(workspace, capsules);
+    await execFileAsync("git", ["init", "-q", "-b", "main"], { cwd: workspace });
+    await execFileAsync("git", ["config", "user.email", "test@example.invalid"], { cwd: workspace });
+    await execFileAsync("git", ["config", "user.name", "Pi Harness Test"], { cwd: workspace });
+    await writeFile(join(workspace, "note.txt"), "before\n", "utf8");
+    await execFileAsync("git", ["add", "note.txt"], { cwd: workspace });
+    await execFileAsync("git", ["commit", "-qm", "fixture"], { cwd: workspace });
+    await writeFile(join(workspace, "note.txt"), "after\n", "utf8");
+    const { stdout: patch } = await execFileAsync("git", ["diff", "--binary"], { cwd: workspace });
+    const capsule = join(capsules, "restore.patch");
+    await writeFile(capsule, patch, "utf8");
+
+    await applyCapsule(workspace, capsule);
+
+    await expect(readFile(join(workspace, "note.txt"), "utf8")).resolves.toBe("before\n");
+  });
+
+  test("rejects a capsule that does not apply cleanly", async () => {
+    const workspace = await mkdtemp(join(tmpdir(), "pi-harness-capsule-conflict-"));
+    const capsules = await mkdtemp(join(tmpdir(), "pi-harness-capsules-conflict-"));
+    temporaryDirectories.push(workspace, capsules);
+    await execFileAsync("git", ["init", "-q", "-b", "main"], { cwd: workspace });
+    await writeFile(join(workspace, "note.txt"), "current\n", "utf8");
+    const capsule = join(capsules, "conflict.patch");
+    await writeFile(capsule, "diff --git a/note.txt b/note.txt\n--- a/note.txt\n+++ b/note.txt\n@@ -1 +1 @@\n-old\n+restored\n", "utf8");
+
+    await expect(applyCapsule(workspace, capsule)).rejects.toThrow("does not apply cleanly");
+    await expect(readFile(join(workspace, "note.txt"), "utf8")).resolves.toBe("current\n");
+  });
+
+  test("requires explicit confirmation through the restore tool", async () => {
+    const workspace = await mkdtemp(join(tmpdir(), "pi-harness-capsule-tool-"));
+    const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-capsule-agent-"));
+    temporaryDirectories.push(workspace, agentDir);
+    const capsuleDirectory = join(agentDir, "capsules");
+    await mkdir(capsuleDirectory, { recursive: true });
+    await execFileAsync("git", ["init", "-q", "-b", "main"], { cwd: workspace });
+    await execFileAsync("git", ["config", "user.email", "test@example.invalid"], { cwd: workspace });
+    await execFileAsync("git", ["config", "user.name", "Pi Harness Test"], { cwd: workspace });
+    await writeFile(join(workspace, "note.txt"), "before\n", "utf8");
+    await execFileAsync("git", ["add", "note.txt"], { cwd: workspace });
+    await execFileAsync("git", ["commit", "-qm", "fixture"], { cwd: workspace });
+    await writeFile(join(workspace, "note.txt"), "after\n", "utf8");
+    const { stdout: patch } = await execFileAsync("git", ["diff", "--binary"], { cwd: workspace });
+    await writeFile(join(capsuleDirectory, "restore.patch"), patch, "utf8");
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    const panels = new PiPluginUiRegistry();
+    context.provide("piHarnessLaunch", { cwd: workspace, agentDir, args: [], requestExit() {} });
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", panels);
+    try {
+      await context.plugin(gitTimeCapsulePlugin);
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "git_restore");
+      expect(tool).toBeDefined();
+      await expect(tool!.execute("call-1", { name: "restore.patch", confirm: false }, undefined, undefined, {} as never)).rejects.toThrow("confirm=true");
+      await expect(tool!.execute("call-2", { name: "restore.patch", confirm: true }, undefined, undefined, {} as never)).resolves.toMatchObject({
+        details: { restored: true },
+      });
+      await expect(readFile(join(workspace, "note.txt"), "utf8")).resolves.toBe("before\n");
+    } finally {
+      await context.fiber.dispose();
+    }
+  });
+
+  test("creates distinct capsules and excludes untracked files from the recoverable count", async () => {
+    const workspace = await mkdtemp(join(tmpdir(), "pi-harness-capsule-distinct-workspace-"));
+    const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-capsule-distinct-agent-"));
+    temporaryDirectories.push(workspace, agentDir);
+    await execFileAsync("git", ["init", "-q", "-b", "main"], { cwd: workspace });
+    await execFileAsync("git", ["config", "user.email", "test@example.invalid"], { cwd: workspace });
+    await execFileAsync("git", ["config", "user.name", "Pi Harness Test"], { cwd: workspace });
+    await writeFile(join(workspace, "tracked.txt"), "before\n", "utf8");
+    await execFileAsync("git", ["add", "tracked.txt"], { cwd: workspace });
+    await execFileAsync("git", ["commit", "-qm", "fixture"], { cwd: workspace });
+    await writeFile(join(workspace, "tracked.txt"), "after\n", "utf8");
+    await writeFile(join(workspace, "untracked.txt"), "not in the patch\n", "utf8");
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    context.provide("piHarnessLaunch", { cwd: workspace, agentDir, args: [], requestExit() {} });
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", new PiPluginUiRegistry());
+    try {
+      await context.plugin(gitTimeCapsulePlugin);
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "git_snapshot");
+      await expect(tool!.execute("call-1", {}, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { files: 1 } });
+      await expect(tool!.execute("call-2", {}, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { files: 1 } });
+      await expect(readdir(join(agentDir, "capsules"))).resolves.toHaveLength(2);
+    } finally {
+      await context.fiber.dispose();
+    }
+  });
+});

package/packages/core/test/http.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "vitest";
+import { configureHttpProxy } from "../src/http.js";
+
+function globalDispatcherNames(): string[] {
+  return Object.getOwnPropertySymbols(globalThis)
+    .filter((symbol) => String(symbol).includes("undici.globalDispatcher"))
+    .map((symbol) => (globalThis as unknown as Record<symbol, { constructor?: { name?: string } }>)[symbol]?.constructor?.name ?? "unknown");
+}
+
+describe("configureHttpProxy", () => {
+  test("installs Pi's proxy-aware dispatcher so provider calls honour HTTP(S)_PROXY", async () => {
+    await expect(configureHttpProxy()).resolves.toBeUndefined();
+
+    expect(globalDispatcherNames()).toContain("EnvHttpProxyAgent");
+  });
+
+  test("applies the httpProxy setting to the environment Pi's dispatcher reads", async () => {
+    const previousHttp = process.env.HTTP_PROXY;
+    const previousHttps = process.env.HTTPS_PROXY;
+    delete process.env.HTTP_PROXY;
+    delete process.env.HTTPS_PROXY;
+    const services = { settingsManager: { getGlobalSettings: () => ({ httpProxy: "http://127.0.0.1:9999" }), getHttpIdleTimeoutMs: () => 30_000 } };
+
+    try {
+      await expect(configureHttpProxy(services as never)).resolves.toBeUndefined();
+
+      expect(process.env.HTTPS_PROXY).toBe("http://127.0.0.1:9999");
+      expect(process.env.HTTP_PROXY).toBe("http://127.0.0.1:9999");
+    } finally {
+      if (previousHttp === undefined) delete process.env.HTTP_PROXY; else process.env.HTTP_PROXY = previousHttp;
+      if (previousHttps === undefined) delete process.env.HTTPS_PROXY; else process.env.HTTPS_PROXY = previousHttps;
+    }
+  });
+});

package/packages/core/test/llm-verifier.test.ts

@@ -0,0 +1,72 @@
+import { Context } from "@deepseek-ai/cordis";
+import { describe, expect, test } from "vitest";
+import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+import { parseVerifierResponse, summarizeVerifierHistory } from "../src/plugins/llm-verifier.js";
+import llmVerifierPlugin from "../src/plugins/llm-verifier.js";
+
+describe("llm verifier", () => {
+  test("summarizes verdict history for audit panels", () => {
+    expect(summarizeVerifierHistory([{ verdict: "pass" }, { verdict: "fail" }, { verdict: "unknown" }, { verdict: "pass" }] as never)).toEqual({
+      total: 4,
+      counts: { pass: 2, fail: 1, unknown: 1 },
+      recent: [{ verdict: "pass" }, { verdict: "fail" }, { verdict: "unknown" }, { verdict: "pass" }],
+    });
+  });
+
+  test("parses a bounded verdict and rationale from model output", () => {
+    expect(parseVerifierResponse("VERDICT: pass\nRATIONALE: The test output covers the claimed behavior.")).toEqual({
+      verdict: "pass",
+      rationale: "The test output covers the claimed behavior.",
+    });
+    expect(parseVerifierResponse("not a structured answer")).toEqual({
+      verdict: "unknown",
+      rationale: "Model did not return a structured verification verdict.",
+    });
+  });
+
+  test("verifies evidence through the configured model runtime", async () => {
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    const panels = new PiPluginUiRegistry();
+    const model = { provider: "everyapi", id: "verifier-model" };
+    context.provide("piModelRuntime", {
+      provider: "everyapi",
+      model: "verifier-model",
+      runtime: {
+        getModel: () => model,
+        complete: () => Promise.resolve({ content: [{ type: "text", text: "VERDICT: pass\nRATIONALE: Evidence matches the claim." }] }),
+      },
+    } as never);
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", panels);
+    try {
+      await context.plugin(llmVerifierPlugin, {});
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "llm_verify");
+      expect(tool).toBeDefined();
+      await expect(
+        tool!.execute("call-1", { claim: "The change is covered", evidence: "npx vitest run: 3 passed" }, undefined, undefined, {} as never),
+      ).resolves.toMatchObject({ details: { verdict: "pass", model: { provider: "everyapi", id: "verifier-model" } } });
+      const batchTool = tools.snapshot().customTools.find((candidate) => candidate.name === "llm_verify_batch");
+      expect(batchTool).toBeDefined();
+      await expect(
+        batchTool!.execute(
+          "call-2",
+          {
+            items: [
+              { claim: "The unit suite passes", evidence: "75 tests passed" },
+              { claim: "The build passes", evidence: "tsc exited 0" },
+            ],
+          },
+          undefined,
+          undefined,
+          {} as never,
+        ),
+      ).resolves.toMatchObject({ details: { results: [{ verdict: "pass" }, { verdict: "pass" }], summary: { total: 3, counts: { pass: 3 } } } });
+      await expect(panels.snapshot()).resolves.toMatchObject([
+        { id: "llm-verifier-panel", data: { latest: { verdict: "pass" }, history: { total: 3, counts: { pass: 3 } } } },
+      ]);
+    } finally {
+      await context.fiber.dispose();
+    }
+  });
+});

package/packages/core/test/mirage-bridge.test.ts

@@ -0,0 +1,54 @@
+import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { Context } from "@deepseek-ai/cordis";
+import { afterEach, describe, expect, test } from "vitest";
+import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+import mirageBridgePlugin from "../src/plugins/mirage-bridge.js";
+
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
+});
+
+describe("mirage bridge", () => {
+  test("checks the official CLI and executes inside the configured virtual workspace", async () => {
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-mirage-"));
+    temporaryDirectories.push(directory);
+    const executable = join(directory, "mirage-stub.mjs");
+    await writeFile(
+      executable,
+      `#!/usr/bin/env node
+if (process.argv[2] === "--version") console.log("mirage 0.9.0");
+else console.log(JSON.stringify(process.argv.slice(2)));
+`,
+      "utf8",
+    );
+    await chmod(executable, 0o755);
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    const panels = new PiPluginUiRegistry();
+    context.provide("piHarnessLaunch", { cwd: directory, agentDir: directory } as never);
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", panels);
+    try {
+      await context.plugin(mirageBridgePlugin, { executable, workspaceId: "review-sandbox" });
+      const doctor = tools.snapshot().customTools.find((tool) => tool.name === "mirage_doctor");
+      const execute = tools.snapshot().customTools.find((tool) => tool.name === "mirage_execute");
+      expect(doctor).toBeDefined();
+      expect(execute).toBeDefined();
+      await expect(doctor!.execute("doctor-1", {}, undefined, undefined, {} as never)).resolves.toMatchObject({
+        details: { available: true, version: "mirage 0.9.0", workspaceId: "review-sandbox" },
+      });
+      await expect(execute!.execute("run-1", { command: "grep -r TODO /workspace" }, undefined, undefined, {} as never)).resolves.toMatchObject({
+        details: { exitCode: 0, workspaceId: "review-sandbox", command: "grep -r TODO /workspace" },
+      });
+      await expect(panels.snapshot()).resolves.toMatchObject([
+        { id: "mirage-bridge-panel", data: { available: true, workspaceId: "review-sandbox", lastRun: { exitCode: 0 } } },
+      ]);
+    } finally {
+      await context.fiber.dispose();
+    }
+  });
+});

package/packages/core/test/module-search.test.ts

@@ -0,0 +1,78 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { Context } from "@deepseek-ai/cordis";
+import { describe, expect, test } from "vitest";
+import { PiPluginUiRegistry, PiToolRegistry, provideLaunchContext } from "../src/services.js";
+import { extractModuleMatches } from "../src/plugins/module-search.js";
+import moduleSearchPlugin from "../src/plugins/module-search.js";
+
+describe("module search", () => {
+  test("extracts matching imports and exports with line numbers", () => {
+    expect(
+      extractModuleMatches(
+        'import { readFile } from "node:fs/promises";\nexport function readConfig() { return readFile; }\nconst ignored = 1;',
+        "config.ts",
+        "read",
+        "all",
+      ),
+    ).toEqual([
+      { kind: "import", name: "readFile", path: "config.ts", line: 1, text: 'import { readFile } from "node:fs/promises";' },
+      { kind: "export", name: "readConfig", path: "config.ts", line: 2, text: "export function readConfig() { return readFile; }" },
+    ]);
+    expect(extractModuleMatches('import { readFile, writeFile } from "node:fs/promises";', "config.ts", "readFile", "import")).toEqual([
+      { kind: "import", name: "readFile", path: "config.ts", line: 1, text: 'import { readFile, writeFile } from "node:fs/promises";' },
+    ]);
+  });
+
+  test("searches source files without traversing dependency directories", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-module-search-"));
+    await writeFile(join(cwd, "module.ts"), 'import { readFile } from "node:fs";\nexport const readConfig = readFile;\n', "utf8");
+    await writeFile(join(cwd, "ignored.js"), "export const readIgnored = true;\n", "utf8");
+    await mkdir(join(cwd, "node_modules", "dependency"), { recursive: true });
+    await writeFile(join(cwd, "node_modules", "dependency", "index.ts"), "export const readDependency = true;\n", "utf8");
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    const panels = new PiPluginUiRegistry();
+    provideLaunchContext(context, { cwd, agentDir: cwd, args: [], requestExit() {} });
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", panels);
+    try {
+      await context.plugin(moduleSearchPlugin);
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "module_search");
+      expect(tool).toBeDefined();
+      await expect(tool!.execute("call-1", { query: "read", kind: "export" }, undefined, undefined, {} as never)).resolves.toMatchObject({
+        details: {
+          matches: [
+            { name: "readIgnored", path: "ignored.js" },
+            { name: "readConfig", path: "module.ts" },
+          ],
+          scannedFiles: 2,
+        },
+      });
+    } finally {
+      await context.fiber.dispose();
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  test("reports truncation when one file contains more matches than the limit", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-module-search-limit-"));
+    await writeFile(join(cwd, "module.ts"), "export const readOne = 1; export const readTwo = 2;\n", "utf8");
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    provideLaunchContext(context, { cwd, agentDir: cwd, args: [], requestExit() {} });
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", new PiPluginUiRegistry());
+    try {
+      await context.plugin(moduleSearchPlugin);
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "module_search");
+      await expect(tool!.execute("call-1", { query: "read", kind: "export", maxResults: 1 }, undefined, undefined, {} as never)).resolves.toMatchObject({
+        details: { matches: [{ name: "readOne" }], truncated: true },
+      });
+    } finally {
+      await context.fiber.dispose();
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+});

package/packages/core/test/plugin-check.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "vitest";
+import { isPluginRepositoryName } from "../src/plugins/plugin-check.js";
+
+describe("plugin repository discovery", () => {
+  test("accepts Pi Harness and legacy DSH plugin directory names", () => {
+    expect(isPluginRepositoryName("pi-colleague-skill")).toBe(true);
+    expect(isPluginRepositoryName("dsh-vision-toolkit")).toBe(true);
+    expect(isPluginRepositoryName("example-plugin")).toBe(true);
+  });
+
+  test("does not scan dependency or hidden directories", () => {
+    expect(isPluginRepositoryName("node_modules")).toBe(false);
+    expect(isPluginRepositoryName(".git")).toBe(false);
+    expect(isPluginRepositoryName("workspace")).toBe(false);
+  });
+});

package/packages/core/test/plugin-stars.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "vitest";
+import { Context } from "@deepseek-ai/cordis";
+import { provideLaunchContext } from "../src/services.js";
+import { parsePluginStarsPayload, searchPluginStars } from "../src/plugins/plugin-stars.js";
+import pluginStars from "../src/plugins/plugin-stars.js";
+import toolsPlugin from "../src/plugins/tools.js";
+
+describe("plugin stars", () => {
+  test("normalizes curated ranking data and filters by query", () => {
+    const report = parsePluginStarsPayload({
+      generatedAt: "2026-09-02T12:00:00Z",
+      source: "dsh-plugin-stars",
+      plugins: [
+        {
+          id: "1",
+          name: "ModLens",
+          fullName: "liustack/modlens",
+          description: "Vision bridge",
+          htmlUrl: "https://github.com/liustack/modlens",
+          stars: 3835,
+          topics: ["dsh-plugin", "vision"],
+        },
+        {
+          id: "2",
+          name: "Other",
+          fullName: "owner/other",
+          description: "Task board",
+          htmlUrl: "https://github.com/owner/other",
+          stars: 281,
+          topics: ["taskboard"],
+        },
+      ],
+    });
+
+    expect(searchPluginStars(report, "vision")).toEqual([
+      expect.objectContaining({ name: "ModLens", fullName: "liustack/modlens", stars: 3835, topics: ["dsh-plugin", "vision"] }),
+    ]);
+    expect(report).toMatchObject({ generatedAt: "2026-09-02T12:00:00Z", source: "dsh-plugin-stars" });
+  });
+
+  test("drops malformed or non-GitHub entries", () => {
+    const report = parsePluginStarsPayload({ plugins: [{ name: "bad", fullName: "bad", htmlUrl: "https://example.com", stars: -1 }, null] });
+    expect(report.plugins).toEqual([]);
+  });
+
+  test("registers a read-only search tool and panel", async () => {
+    const context = new Context();
+    provideLaunchContext(context, { cwd: "/tmp", agentDir: "/tmp", args: [], requestExit() {} });
+    await context.plugin(toolsPlugin, { names: [] });
+    await context.plugin(pluginStars, { sourceUrl: "https://raw.githubusercontent.com/ywsldxk/dsh-plugin-stars/main/data/plugins.json" });
+    expect(context.piTools.snapshot().customTools.map((tool) => tool.name)).toContain("plugin_stars_search");
+    await expect(context.piPluginUi.snapshot()).resolves.toEqual([expect.objectContaining({ id: "plugin-stars-panel", title: "Plugin Stars" })]);
+    await context.fiber.dispose();
+  });
+});

package/packages/core/test/profiles.integration.test.ts

@@ -21,7 +21,13 @@ async function bootProfile(profile: string): Promise<{ harness: BootedHarness; c
     configPath,
     prepare(context) {
       provideLaunchContext(context, { cwd, agentDir, args: [], requestExit() {} });
-      provideStdioContext(context, { readPrompt() { return Promise.resolve(""); }, writeOutput() {}, writeError() {} });
+      provideStdioContext(context, {
+        readPrompt() {
+          return Promise.resolve("");
+        },
+        writeOutput() {},
+        writeError() {},
+      });
     },
   });
   booted.push(harness);
@@ -37,7 +43,14 @@ describe("packaged profiles", () => {
     expect(harness.context.get("piApplication")).toBeDefined();
     expect(harness.context.get("hmr")).toBeUndefined();
     expect(names).not.toContain("@deepseek-ai/cordis-plugin-hmr");
-  });
+    expect(names).toContain("@pi-harness/core/plugins/vision-toolkit");
+    expect(names).toContain("@pi-harness/core/plugins/plugin-stars");
+    expect(names).toContain("@pi-harness/core/plugins/session-bridge");
+    expect(names).toContain("@pi-harness/core/plugins/skill-guard");
+    expect(names).toContain("@pi-harness/core/plugins/recall-unread");
+    expect(names).toContain("@pi-harness/core/plugins/turn-rewind");
+    expect(names).toContain("@pi-harness/core/plugins/context-doctor");
+  }, 15_000);
 
   test("boots the development profile with logger, timer, and HMR plugins", async () => {
     const { harness, cwd } = await bootProfile("development");
@@ -48,7 +61,9 @@ describe("packaged profiles", () => {
 
     expect(timer?.fiber?.ctx.get("timer")).toBeDefined();
     expect(hmr?.fiber?.ctx.get("hmr")).toMatchObject({ baseDir: cwd });
-    expect(names).toEqual(expect.arrayContaining(["@deepseek-ai/cordis-plugin-logger-console", "@deepseek-ai/cordis-plugin-timer", "@deepseek-ai/cordis-plugin-hmr"]));
+    expect(names).toEqual(
+      expect.arrayContaining(["@deepseek-ai/cordis-plugin-logger-console", "@deepseek-ai/cordis-plugin-timer", "@deepseek-ai/cordis-plugin-hmr"]),
+    );
   });
 
   test("activates an external tool plugin before the runtime through Cordis injection", async () => {
@@ -65,26 +80,45 @@ describe("packaged profiles", () => {
       runtime: import.meta.resolve("@pi-harness/core/plugins/runtime"),
       stdio: import.meta.resolve("@pi-harness/core/plugins/stdio"),
     };
-    await writeFile(configPath, JSON.stringify([
-      { id: "models", name: plugins.models, config: { provider: "deepseek", model: "deepseek-v4-flash", refreshOnCreate: false } },
-      { id: "resources", name: plugins.resources, config: { noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true } },
-      { id: "model", name: plugins.model, config: {} },
-      { id: "session", name: plugins.session, config: { storage: "memory" } },
-      { id: "tools", name: plugins.tools, config: { names: [] } },
-      { id: "hello", name: plugins.hello, config: {} },
-      { id: "runtime", name: plugins.runtime, inject: ["piHelloTool"], config: { thinkingLevel: "medium" } },
-      { id: "stdio", name: plugins.stdio, config: {} },
-    ]), "utf8");
+    await writeFile(
+      configPath,
+      JSON.stringify([
+        { id: "models", name: plugins.models, config: { provider: "deepseek", model: "deepseek-v4-flash", refreshOnCreate: false } },
+        {
+          id: "resources",
+          name: plugins.resources,
+          config: { noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true },
+        },
+        { id: "model", name: plugins.model, config: {} },
+        { id: "session", name: plugins.session, config: { storage: "memory" } },
+        { id: "tools", name: plugins.tools, config: { names: [] } },
+        { id: "hello", name: plugins.hello, config: {} },
+        { id: "runtime", name: plugins.runtime, inject: ["piHelloTool"], config: { thinkingLevel: "medium" } },
+        { id: "stdio", name: plugins.stdio, config: {} },
+      ]),
+      "utf8",
+    );
     const harness = await bootHarness({
       configPath,
       prepare(context) {
         provideLaunchContext(context, { cwd, agentDir, args: [], requestExit() {} });
-        provideStdioContext(context, { readPrompt() { return Promise.resolve(""); }, writeOutput() {}, writeError() {} });
+        provideStdioContext(context, {
+          readPrompt() {
+            return Promise.resolve("");
+          },
+          writeOutput() {},
+          writeError() {},
+        });
       },
     });
     booted.push(harness);
 
-    expect(harness.context.get("piTools")?.snapshot().customTools.map((tool) => tool.name)).toEqual(["hello"]);
+    expect(
+      harness.context
+        .get("piTools")
+        ?.snapshot()
+        .customTools.map((tool) => tool.name),
+    ).toEqual(["hello"]);
     const sessionTools = harness.context.get("piRuntime")?.session.getAllTools();
     expect(sessionTools).toHaveLength(1);
     expect(sessionTools?.[0]?.name).toBe("hello");

package/packages/core/test/prompt-library.test.ts

@@ -0,0 +1,56 @@
+import { Context } from "@deepseek-ai/cordis";
+import { describe, expect, test } from "vitest";
+import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+import { createPromptTemplate } from "../src/plugins/prompt-library.js";
+import promptLibraryPlugin from "../src/plugins/prompt-library.js";
+
+describe("prompt library", () => {
+  test("normalizes a bounded prompt template", () => {
+    expect(
+      createPromptTemplate({ title: "  Review API  ", prompt: "  Check error handling.  ", tags: ["api", "review"] }, "prompt-1", "2026-09-03T00:00:00.000Z"),
+    ).toEqual({
+      id: "prompt-1",
+      title: "Review API",
+      prompt: "Check error handling.",
+      tags: ["api", "review"],
+      createdAt: "2026-09-03T00:00:00.000Z",
+      updatedAt: "2026-09-03T00:00:00.000Z",
+    });
+  });
+
+  test("rejects empty or oversized templates", () => {
+    expect(() => createPromptTemplate({ title: " ", prompt: "x" }, "prompt-1", "2026-09-03T00:00:00.000Z")).toThrow("title");
+    expect(() => createPromptTemplate({ title: "x", prompt: "x".repeat(8_001) }, "prompt-1", "2026-09-03T00:00:00.000Z")).toThrow("8,000");
+  });
+
+  test("persists templates through the registered tool and panel", async () => {
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    const panels = new PiPluginUiRegistry();
+    const entries: unknown[] = [];
+    context.provide("piSession", {
+      manager: {
+        getEntries: () => entries,
+        appendCustomEntry: (_type: string, data: unknown) => entries.push({ type: "custom", customType: "pi-harness/prompt-library", data }),
+      },
+    } as never);
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", panels);
+    try {
+      await context.plugin(promptLibraryPlugin);
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "prompt_library");
+      expect(tool).toBeDefined();
+      await expect(
+        tool!.execute("call-1", { action: "save", title: "Review", prompt: "Review this diff", tags: ["code"] }, undefined, undefined, {} as never),
+      ).resolves.toMatchObject({
+        details: { templates: [{ title: "Review", prompt: "Review this diff" }] },
+      });
+      await expect(tool!.execute("call-2", { action: "list", query: "review" }, undefined, undefined, {} as never)).resolves.toMatchObject({
+        details: { templates: [{ title: "Review" }] },
+      });
+      await expect(panels.snapshot()).resolves.toMatchObject([{ id: "prompt-library-panel", data: { total: 1 } }]);
+    } finally {
+      await context.fiber.dispose();
+    }
+  });
+});

package/packages/core/test/readme-gen.test.ts

@@ -0,0 +1,45 @@
+import { mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { renderReadme, writeReadmeFile } from "../src/plugins/readme-gen.js";
+
+describe("readme generator", () => {
+  test("renders scripts and active plugins as markdown", () => {
+    expect(
+      renderReadme({
+        name: "demo",
+        version: "1.2.3",
+        description: "A demo project",
+        scripts: ["build", "test"],
+        plugins: ["@pi-harness/core/plugins/archify"],
+      }),
+    ).toBe(
+      "# demo\n\nA demo project\n\nVersion: 1.2.3\n\n## Scripts\n\n- `npm run build`\n- `npm run test`\n\n## Runtime plugins\n\n- `@pi-harness/core/plugins/archify`\n",
+    );
+  });
+
+  test("requires confirmation and writes inside the workspace", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-readme-"));
+    try {
+      await expect(writeReadmeFile(root, "# Demo\n", "README.generated.md", false)).rejects.toThrow(/confirm=true/);
+      await expect(writeReadmeFile(root, "# Demo\n", "../outside.md", true)).rejects.toThrow(/inside the workspace/);
+      await expect(writeReadmeFile(root, "# Demo\n", "docs/README.generated.md", true)).resolves.toMatchObject({
+        path: "docs/README.generated.md",
+        bytes: 7,
+        overwritten: false,
+      });
+      await expect(readFile(join(root, "docs/README.generated.md"), "utf8")).resolves.toBe("# Demo\n");
+      const outside = await mkdtemp(join(tmpdir(), "pi-harness-readme-outside-"));
+      try {
+        await writeFile(join(outside, "README.md"), "outside\n", "utf8");
+        await symlink(join(outside, "README.md"), join(root, "README.link.md"));
+        await expect(writeReadmeFile(root, "# Demo\n", "README.link.md", true)).rejects.toThrow(/symbolic link/);
+      } finally {
+        await rm(outside, { recursive: true, force: true });
+      }
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});