@pi-harness/pi-harness 0.1.2 → 0.1.3

package/packages/core/src/workspace-path.ts

@@ -0,0 +1,69 @@
+import { lstat, mkdir, realpath, stat } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+
+export interface WorkspacePath {
+  readonly root: string;
+  readonly target: string;
+  readonly relativePath: string;
+}
+
+export interface WorkspaceFilePath extends WorkspacePath {
+  readonly exists: boolean;
+}
+
+export function isPathInside(root: string, target: string): boolean {
+  const remainder = relative(root, target);
+  return remainder === "" || (remainder !== ".." && !remainder.startsWith(`..${sep}`) && !isAbsolute(remainder));
+}
+
+function assertInside(root: string, target: string, message: string): void {
+  if (!isPathInside(root, target)) throw new Error(message);
+}
+
+export async function resolveExistingWorkspacePath(root: string, requested: string, message: string): Promise<WorkspacePath> {
+  const canonicalRoot = await realpath(resolve(root));
+  const lexicalTarget = resolve(canonicalRoot, requested);
+  assertInside(canonicalRoot, lexicalTarget, message);
+  const target = await realpath(lexicalTarget);
+  assertInside(canonicalRoot, target, message);
+  return { root: canonicalRoot, target, relativePath: relative(canonicalRoot, target) || "." };
+}
+
+export async function prepareWorkspaceFile(root: string, requested: string, message: string): Promise<WorkspaceFilePath> {
+  const canonicalRoot = await realpath(resolve(root));
+  const lexicalTarget = resolve(canonicalRoot, requested);
+  assertInside(canonicalRoot, lexicalTarget, message);
+
+  let ancestor = dirname(lexicalTarget);
+  const missing: string[] = [];
+  let canonicalAncestor: string;
+  for (;;) {
+    try {
+      canonicalAncestor = await realpath(ancestor);
+      break;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+      const parent = dirname(ancestor);
+      if (parent === ancestor) throw error;
+      missing.unshift(basename(ancestor));
+      ancestor = parent;
+    }
+  }
+  assertInside(canonicalRoot, canonicalAncestor, message);
+  if (!(await stat(canonicalAncestor)).isDirectory()) throw new Error(message);
+
+  const parent = join(canonicalAncestor, ...missing);
+  await mkdir(parent, { recursive: true });
+  const canonicalParent = await realpath(parent);
+  assertInside(canonicalRoot, canonicalParent, message);
+  const target = join(canonicalParent, basename(lexicalTarget));
+  let exists = false;
+  try {
+    const metadata = await lstat(target);
+    if (metadata.isSymbolicLink() || !metadata.isFile()) throw new Error(message);
+    exists = true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+  }
+  return { root: canonicalRoot, target, relativePath: relative(canonicalRoot, target), exists };
+}

package/packages/core/test/agent-teams.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "vitest";
+import { dependencyCycle, readyTeamTasks } from "../src/plugins/agent-teams.js";
+
+describe("agent teams dependency graph", () => {
+  test("finds a cycle and returns its task ids", () => {
+    const tasks = [
+      { id: "plan", title: "Plan", assignee: "planner", status: "todo", dependsOn: ["review"] },
+      { id: "build", title: "Build", assignee: "builder", status: "todo", dependsOn: ["plan"] },
+      { id: "review", title: "Review", assignee: "reviewer", status: "todo", dependsOn: ["build"] },
+    ];
+
+    expect(dependencyCycle(tasks)).toEqual(["plan", "review", "build", "plan"]);
+  });
+
+  test("returns only tasks whose dependencies are complete", () => {
+    const tasks = [
+      { id: "plan", title: "Plan", assignee: "planner", status: "done", dependsOn: [] },
+      { id: "build", title: "Build", assignee: "builder", status: "todo", dependsOn: ["plan"] },
+      { id: "review", title: "Review", assignee: "reviewer", status: "blocked", dependsOn: ["build"] },
+    ];
+
+    expect(readyTeamTasks(tasks).map((task) => task.id)).toEqual(["build"]);
+  });
+});

package/packages/core/test/archify.test.ts

@@ -0,0 +1,33 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "vitest";
+import { buildArchitectureReport } from "../src/plugins/archify.js";
+
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
+});
+
+describe("archify", () => {
+  test("maps top-level workspace components and package dependencies", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-archify-"));
+    temporaryDirectories.push(root);
+    await mkdir(join(root, "src", "api"), { recursive: true });
+    await mkdir(join(root, "tests"), { recursive: true });
+    await writeFile(join(root, "src", "api", "server.ts"), "export {}", "utf8");
+    await writeFile(join(root, "tests", "server.test.ts"), "export {}", "utf8");
+    await writeFile(join(root, "package.json"), JSON.stringify({ dependencies: { zod: "^4.0.0" }, devDependencies: { vitest: "^4.0.0" } }), "utf8");
+
+    const report = await buildArchitectureReport(root);
+
+    expect(report.components).toEqual([
+      { id: "component_src", label: "src", path: "src", files: 1, directories: 1 },
+      { id: "component_tests", label: "tests", path: "tests", files: 1, directories: 0 },
+    ]);
+    expect(report.dependencies).toEqual(["vitest", "zod"]);
+    expect(report.mermaid).toContain("project --> component_src");
+    expect(report.mermaid).toContain('dependency_zod["zod"]');
+  });
+});

package/packages/core/test/better-sidebar.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "vitest";
+import { createSidebarInspector, summarizeSidebar } from "../src/plugins/better-sidebar.js";
+import type { WorkspaceGitStatus } from "../src/plugins/workspace-navigator.js";
+
+describe("better sidebar", () => {
+  test("summarizes workspace, Git, and session context without exposing full paths", () => {
+    const report = summarizeSidebar({
+      cwd: "/workspace/project",
+      gitAvailable: true,
+      branch: "feature/sidebar",
+      clean: false,
+      changedFiles: [
+        { path: "src/app.tsx", status: " M" },
+        { path: "README.md", status: "??" },
+      ],
+      directoryCount: 4,
+      fileCount: 18,
+      truncated: true,
+      sessionId: "session-1234567890",
+    });
+    expect(report).toEqual({
+      cwd: "/workspace/project",
+      gitAvailable: true,
+      branch: "feature/sidebar",
+      clean: false,
+      changedFiles: [
+        { path: "src/app.tsx", status: " M" },
+        { path: "README.md", status: "??" },
+      ],
+      directoryCount: 4,
+      fileCount: 18,
+      truncated: true,
+      sessionId: "session-1234567890",
+      changedCount: 2,
+      summary: "feature/sidebar · 2 个变更",
+    });
+  });
+
+  test("reports a clean non-Git workspace clearly", () => {
+    expect(
+      summarizeSidebar({
+        cwd: "/tmp/project",
+        gitAvailable: false,
+        branch: null,
+        clean: false,
+        changedFiles: [],
+        directoryCount: 0,
+        fileCount: 0,
+        truncated: false,
+        sessionId: "session",
+      }),
+    ).toMatchObject({
+      summary: "非 Git 工作区 · 无变更",
+      changedCount: 0,
+    });
+  });
+
+  test("distinguishes detached HEAD and counts changes before truncating details", () => {
+    const report = summarizeSidebar({
+      cwd: "/workspace/project",
+      gitAvailable: true,
+      branch: null,
+      clean: false,
+      changedFiles: Array.from({ length: 20 }, (_, index) => ({ path: `file-${index}.ts`, status: " M" })),
+      directoryCount: 1,
+      fileCount: 20,
+      truncated: false,
+      sessionId: "session",
+    });
+    expect(report.summary).toBe("detached HEAD · 20 个变更");
+    expect(report.changedCount).toBe(20);
+    expect(report.changedFiles).toHaveLength(12);
+  });
+
+  test("refreshes live Git state while reusing the bounded workspace tree", async () => {
+    let treeReads = 0;
+    let gitReads = 0;
+    const inspect = createSidebarInspector({
+      cwd: "/workspace/project",
+      getSessionId: () => "session",
+      listNodes() {
+        treeReads += 1;
+        return Promise.resolve({ nodes: [], directoryCount: 4, fileCount: 18, truncated: false });
+      },
+      readGitStatus() {
+        gitReads += 1;
+        return Promise.resolve(
+          gitReads === 1
+            ? { available: true, branch: "feature/old", clean: false, entries: [{ path: "src/app.ts", status: " M" }] }
+            : { available: true, branch: "main", clean: true, entries: [] },
+        );
+      },
+    });
+
+    await expect(inspect()).resolves.toMatchObject({ branch: "feature/old", changedCount: 1 });
+    await expect(inspect()).resolves.toMatchObject({ branch: "main", changedCount: 0, clean: true });
+    expect(treeReads).toBe(1);
+    expect(gitReads).toBe(2);
+  });
+
+  test("coalesces overlapping sidebar refreshes", async () => {
+    let resolveGit!: (status: WorkspaceGitStatus) => void;
+    let gitReads = 0;
+    const inspect = createSidebarInspector({
+      cwd: "/workspace/project",
+      getSessionId: () => "session",
+      listNodes() {
+        return Promise.resolve({ nodes: [], directoryCount: 0, fileCount: 0, truncated: false });
+      },
+      readGitStatus: () => {
+        gitReads += 1;
+        return new Promise((resolve) => {
+          resolveGit = resolve;
+        });
+      },
+    });
+
+    const first = inspect();
+    const second = inspect();
+    expect(second).toBe(first);
+    resolveGit({ available: true, branch: "main", clean: true, entries: [] });
+    await expect(first).resolves.toMatchObject({ branch: "main" });
+    expect(gitReads).toBe(1);
+  });
+});

package/packages/core/test/boot.test.ts

@@ -27,7 +27,11 @@ async function createPlugin(directory: string, name: string, source: string): Pr
 describe("bootHarness", () => {
   test("loads a profile and activates its plugin", async () => {
     const profile = await createProfile([]);
-    const plugin = await createPlugin(profile.directory, "provider", `export default function provider(ctx, config) { ctx.provide("fixtureValue", config.value); }`);
+    const plugin = await createPlugin(
+      profile.directory,
+      "provider",
+      `export default function provider(ctx, config) { ctx.provide("fixtureValue", config.value); }`,
+    );
     await writeFile(profile.profilePath, JSON.stringify([{ name: plugin, config: { value: "active" } }]), "utf8");
 
     const harness = await bootHarness({ configPath: profile.profilePath });
@@ -53,8 +57,16 @@ describe("bootHarness", () => {
   test("disposes already-active plugins when a later activation fails", async () => {
     const profile = await createProfile([]);
     const markerPath = join(profile.directory, "lifecycle.txt");
-    const owner = await createPlugin(profile.directory, "owner", `import { appendFileSync, writeFileSync } from "node:fs"; export default function owner(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.provide("fixtureOwnerReady", true); ctx.effect(() => () => appendFileSync(config.markerPath, ":disposed")); }`);
-    const failure = await createPlugin(profile.directory, "failure", `export default { inject: ["fixtureOwnerReady"], apply() { throw new Error("fixture activation failed"); } };`);
+    const owner = await createPlugin(
+      profile.directory,
+      "owner",
+      `import { appendFileSync, writeFileSync } from "node:fs"; export default function owner(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.provide("fixtureOwnerReady", true); ctx.effect(() => () => appendFileSync(config.markerPath, ":disposed")); }`,
+    );
+    const failure = await createPlugin(
+      profile.directory,
+      "failure",
+      `export default { inject: ["fixtureOwnerReady"], apply() { throw new Error("fixture activation failed"); } };`,
+    );
     await writeFile(profile.profilePath, JSON.stringify([{ name: owner, config: { markerPath } }, { name: failure }]), "utf8");
 
     await expect(bootHarness({ configPath: profile.profilePath })).rejects.toThrow(/fixture activation failed/);
@@ -64,8 +76,22 @@ describe("bootHarness", () => {
   test("does not rewrite a profile when a nested group rolls back", async () => {
     const profile = await createProfile([]);
     const active = await createPlugin(profile.directory, "active", `export default function active(ctx) { ctx.provide("fixtureNestedReady", true); }`);
-    const failure = await createPlugin(profile.directory, "nested-failure", `export default { inject: ["fixtureNestedReady"], apply() { throw new Error("nested activation failed"); } };`);
-    const source = JSON.stringify([{ id: "fixture-group", name: "cordis:group", group: true, config: [{ id: "active", name: active }, { id: "nested-failure", name: failure }] }]);
+    const failure = await createPlugin(
+      profile.directory,
+      "nested-failure",
+      `export default { inject: ["fixtureNestedReady"], apply() { throw new Error("nested activation failed"); } };`,
+    );
+    const source = JSON.stringify([
+      {
+        id: "fixture-group",
+        name: "cordis:group",
+        group: true,
+        config: [
+          { id: "active", name: active },
+          { id: "nested-failure", name: failure },
+        ],
+      },
+    ]);
     await writeFile(profile.profilePath, source, "utf8");
 
     await expect(bootHarness({ configPath: profile.profilePath })).rejects.toThrow(/nested activation failed/);
@@ -73,10 +99,27 @@ describe("bootHarness", () => {
     await expect(readFile(profile.profilePath, "utf8")).resolves.toBe(source);
   });
 
+  test("rejects a duplicate entry id reused across sibling groups", async () => {
+    const profile = await createProfile([]);
+    const first = await createPlugin(profile.directory, "first", `export default function first(ctx, config) { ctx.provide("fixtureDuplicate", config?.tag ?? "no-config"); }`);
+    const second = await createPlugin(profile.directory, "second", `export default function second(ctx) { ctx.provide("fixtureDuplicateSecond", true); }`);
+    await writeFile(profile.profilePath, JSON.stringify([
+      { id: "one", name: "cordis:group", group: true, config: [{ id: "shared", name: first, config: { tag: "kept" } }] },
+      { id: "two", name: "cordis:group", group: true, config: [{ id: "shared", name: second }] },
+    ]), "utf8");
+
+    await expect(bootHarness({ configPath: profile.profilePath })).rejects.toThrow(/Duplicate loader entry id "shared"/);
+  });
+
   test("forwards Cordis full-reload requests to the host", async () => {
     const profile = await createProfile([]);
     let reloads = 0;
-    const harness = await bootHarness({ configPath: profile.profilePath, onFullReload() { reloads += 1; } });
+    const harness = await bootHarness({
+      configPath: profile.profilePath,
+      onFullReload() {
+        reloads += 1;
+      },
+    });
     booted.push(harness);
 
     harness.context.loader.exit();

package/packages/core/test/colleague-skill.test.ts

@@ -0,0 +1,74 @@
+import { Context } from "@deepseek-ai/cordis";
+import { describe, expect, test } from "vitest";
+import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+import { createColleagueHandoff } from "../src/plugins/colleague-skill.js";
+import colleagueSkillPlugin from "../src/plugins/colleague-skill.js";
+
+describe("colleague skill", () => {
+  test("normalizes a bounded handoff packet for another role", () => {
+    expect(
+      createColleagueHandoff(
+        {
+          toRole: "reviewer",
+          objective: "检查 API 错误处理",
+          context: "最近增加了 SSE 重连逻辑。",
+          constraints: ["不改公开接口"],
+          files: ["packages/api-gateway/src/index.ts"],
+          acceptance: ["补充回归测试", "说明失败原因"],
+        },
+        "handoff-1",
+        "2026-09-03T00:00:00.000Z",
+      ),
+    ).toEqual({
+      id: "handoff-1",
+      toRole: "reviewer",
+      objective: "检查 API 错误处理",
+      context: "最近增加了 SSE 重连逻辑。",
+      constraints: ["不改公开接口"],
+      files: ["packages/api-gateway/src/index.ts"],
+      acceptance: ["补充回归测试", "说明失败原因"],
+      createdAt: "2026-09-03T00:00:00.000Z",
+    });
+  });
+
+  test("rejects empty objectives and oversized packets", () => {
+    expect(() => createColleagueHandoff({ toRole: "reviewer", objective: " " }, "handoff-1", "2026-09-03T00:00:00.000Z")).toThrow("objective");
+    expect(() =>
+      createColleagueHandoff(
+        { toRole: "reviewer", objective: "x", files: Array.from({ length: 21 }, (_, index) => `file-${index}`) },
+        "handoff-1",
+        "2026-09-03T00:00:00.000Z",
+      ),
+    ).toThrow("files must contain 20 items");
+  });
+
+  test("persists a handoff through the registered Pi 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/colleague-handoff", data }),
+      },
+    } as never);
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", panels);
+    try {
+      await context.plugin(colleagueSkillPlugin);
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "colleague_handoff");
+      expect(tool).toBeDefined();
+      await expect(
+        tool!.execute("call-1", { toRole: "reviewer", objective: "检查变更", files: ["src/index.ts"] }, undefined, undefined, {} as never),
+      ).resolves.toMatchObject({
+        details: { toRole: "reviewer", objective: "检查变更", files: ["src/index.ts"] },
+      });
+      await expect(panels.snapshot()).resolves.toMatchObject([
+        { id: "colleague-skill-panel", data: { latest: { toRole: "reviewer", objective: "检查变更" } } },
+      ]);
+    } finally {
+      await context.fiber.dispose();
+    }
+  });
+});

package/packages/core/test/config.test.ts

@@ -0,0 +1,121 @@
+import { access, mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import { afterEach, describe, expect, test } from "vitest";
+import { provideLaunchContext } from "../src/services.js";
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import resourcesPlugin from "../src/plugins/resources.js";
+import sessionPlugin from "../src/plugins/session.js";
+import toolsPlugin from "../src/plugins/tools.js";
+import { Config as ModelsConfig } from "../src/plugins/models.js";
+
+const contexts: Context[] = [];
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map(async (context) => context.fiber.dispose()));
+});
+
+async function createContext(): Promise<{ context: Context; cwd: string; agentDir: string }> {
+  const cwd = await mkdtemp(join(tmpdir(), "pi-harness-config-cwd-"));
+  const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-config-agent-"));
+  const context = new Context();
+  contexts.push(context);
+  provideLaunchContext(context, { cwd, agentDir, args: [], requestExit() {} });
+  return { context, cwd, agentDir };
+}
+
+describe("plugin configuration validation", () => {
+  test("rejects an unknown key instead of silently restoring the default toolset", async () => {
+    const { context } = await createContext();
+
+    await expect(context.plugin(toolsPlugin, { name: ["read"] } as never)).rejects.toThrow(/Unknown pi-tools config keys: name/);
+    expect(context.get("piTools")).toBeUndefined();
+  });
+
+  test("rejects an unknown key in the session plugin", async () => {
+    const { context } = await createContext();
+
+    await expect(context.plugin(sessionPlugin, { storage: "memory", directroy: "/tmp/x" } as never)).rejects.toThrow(/Unknown pi-session config keys: directroy/);
+  });
+
+  test("rejects an empty session directory instead of writing transcripts to the launch cwd", async () => {
+    const { context } = await createContext();
+
+    await expect(context.plugin(sessionPlugin, { storage: "jsonl", directory: "" })).rejects.toThrow(/directory/);
+  });
+
+  test("falls back to the agent directory when the session directory is null", async () => {
+    const { context, agentDir } = await createContext();
+
+    await context.plugin(sessionPlugin, { storage: "jsonl", directory: null } as never);
+
+    expect(context.piSession.manager.getSessionDir()).toBe(join(agentDir, "sessions"));
+  });
+
+  test("rejects blank provider and model identifiers at validation time", () => {
+    expect(() => ModelsConfig({ provider: "", model: "deepseek-v4-flash" })).toThrow(/provider/);
+    expect(() => ModelsConfig({ provider: "deepseek", model: "" })).toThrow(/model/);
+  });
+
+  test("rejects a blank core tool name", async () => {
+    const { context } = await createContext();
+
+    await expect(context.plugin(toolsPlugin, { names: [""] })).rejects.toThrow(/names/);
+  });
+});
+
+describe("project trust", () => {
+  test("does not load project-local extensions from an untrusted working directory", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-untrusted-"));
+    const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-untrusted-agent-"));
+    const marker = join(cwd, "executed.txt");
+    await mkdir(join(cwd, ".pi", "extensions"), { recursive: true });
+    await writeFile(join(cwd, ".pi", "extensions", "evil.js"), `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(marker)}, "executed"); export default function (pi) {};`, "utf8");
+    const context = new Context();
+    contexts.push(context);
+    provideLaunchContext(context, { cwd, agentDir, args: [], requestExit() {} });
+    context.provide("piModelRuntime", { runtime: await ModelRuntime.create({ refreshOnCreate: false, modelsPath: null, authPath: join(agentDir, "auth.json") }), provider: "none", model: "none" });
+
+    await context.plugin(resourcesPlugin, { noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true });
+
+    await expect(access(marker)).rejects.toThrow();
+    expect(context.piResources.diagnostics.some((diagnostic) => diagnostic.message.includes("not trusted"))).toBe(true);
+  }, 30_000);
+
+  test("loads project-local extensions when the profile opts in", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-trusted-"));
+    const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-trusted-agent-"));
+    const marker = join(cwd, "executed.txt");
+    await mkdir(join(cwd, ".pi", "extensions"), { recursive: true });
+    await writeFile(join(cwd, ".pi", "extensions", "probe.js"), `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(marker)}, "executed"); export default function (pi) {};`, "utf8");
+    const context = new Context();
+    contexts.push(context);
+    provideLaunchContext(context, { cwd, agentDir, args: [], requestExit() {} });
+    context.provide("piModelRuntime", { runtime: await ModelRuntime.create({ refreshOnCreate: false, modelsPath: null, authPath: join(agentDir, "auth.json") }), provider: "none", model: "none" });
+
+    await context.plugin(resourcesPlugin, { trustProject: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true });
+
+    await expect(access(marker)).resolves.toBeUndefined();
+  }, 30_000);
+});
+
+describe("launch context", () => {
+  test("rejects a relative agent directory so credentials cannot land in the working directory", () => {
+    const context = new Context();
+    contexts.push(context);
+
+    expect(() => provideLaunchContext(context, { cwd: "/tmp", agentDir: "", args: [], requestExit() {} })).toThrow(/agent directory must be an absolute path/);
+    expect(() => provideLaunchContext(context, { cwd: "relative", agentDir: "/tmp", args: [], requestExit() {} })).toThrow(/cwd must be an absolute path/);
+  });
+
+  test("exposes the launch directory as a URL that survives percent, hash and question marks", () => {
+    const context = new Context();
+    contexts.push(context);
+    provideLaunchContext(context, { cwd: "/tmp/a%20b#c?d", agentDir: "/tmp", args: [], requestExit() {} });
+
+    const cwdUrl = context.piHarnessLaunch.cwdUrl;
+    expect(cwdUrl).toBeDefined();
+    expect(new URL(cwdUrl ?? "").pathname).toBe("/tmp/a%2520b%23c%3Fd");
+  });
+});

package/packages/core/test/context-doctor.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "vitest";
+import { inspectMessages } from "../src/plugins/context-doctor.js";
+
+describe("context doctor", () => {
+  test("reports pressure, oversized messages, and tool errors", () => {
+    const report = inspectMessages(
+      [
+        { role: "user", content: "ok" },
+        { role: "user", content: "x".repeat(200) },
+        { role: "toolResult", isError: true },
+      ],
+      { percent: 82, tokens: 820, contextWindow: 1000 },
+      75,
+      100,
+    );
+    expect(report).toMatchObject({
+      status: "warning",
+      usagePercent: 82,
+      tokens: 820,
+      contextWindow: 1000,
+      messageCount: 3,
+      oversizedMessages: 1,
+      toolErrors: 1,
+    });
+    expect(report.recommendations).toHaveLength(3);
+  });
+
+  test("stays healthy when usage and messages are within limits", () => {
+    const report = inspectMessages([{ role: "user", content: "short" }], { percent: 20, tokens: 20, contextWindow: 1000 }, 75, 1024);
+    expect(report).toMatchObject({ status: "ok", usagePercent: 20, messageCount: 1, oversizedMessages: 0, toolErrors: 0, recommendations: [] });
+  });
+});

package/packages/core/test/dependency-checker.test.ts

@@ -0,0 +1,60 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "vitest";
+import { inspectManifest, parseRequirements } from "../src/plugins/dependency-checker.js";
+
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
+});
+
+describe("dependency checker", () => {
+  test("parses Python requirements, detects conflicts, and checks a local virtualenv", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-dependency-checker-"));
+    temporaryDirectories.push(root);
+    await writeFile(join(root, "requirements.txt"), "requests==2.31.0\nrequests>=2.32\nflask>=3.0\n# comment\n-r base.txt\n");
+    await mkdir(join(root, ".venv/lib/python3.12/site-packages/requests"), { recursive: true });
+
+    expect(parseRequirements("requests==2.31.0\nrequests>=2.32\n")).toEqual({
+      names: ["requests"],
+      constraints: [{ name: "requests", constraints: ["==2.31.0", ">=2.32"] }],
+    });
+    await expect(inspectManifest(root, "requirements.txt")).resolves.toMatchObject({
+      ecosystem: "python",
+      declared: 2,
+      installed: 1,
+      missing: ["flask"],
+      invalid: [],
+      conflicts: [{ name: "requests", constraints: ["==2.31.0", ">=2.32"] }],
+    });
+  });
+
+  test("reports conflicting npm declarations while preserving installed checks", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-dependency-checker-"));
+    temporaryDirectories.push(root);
+    await writeFile(join(root, "package.json"), JSON.stringify({ dependencies: { react: "18.3.1" }, devDependencies: { react: "19.0.0", vite: "6.0.0" } }));
+    await mkdir(join(root, "node_modules/react"), { recursive: true });
+    await mkdir(join(root, "node_modules/vite"), { recursive: true });
+    await expect(inspectManifest(root)).resolves.toMatchObject({
+      ecosystem: "npm",
+      declared: 2,
+      installed: 2,
+      missing: [],
+      conflicts: [{ name: "react", constraints: ["18.3.1", "19.0.0"] }],
+    });
+
+    await writeFile(join(root, "package.json"), JSON.stringify({ dependencies: { react: "^18.0.0" }, devDependencies: { react: ">=18" } }));
+    await expect(inspectManifest(root)).resolves.toMatchObject({ conflicts: [] });
+  });
+
+  test("checks dependencies relative to a nested package manifest", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-dependency-checker-nested-"));
+    temporaryDirectories.push(root);
+    await mkdir(join(root, "apps/example/node_modules/local-only"), { recursive: true });
+    await writeFile(join(root, "apps/example/package.json"), JSON.stringify({ dependencies: { "local-only": "1.0.0" } }));
+
+    await expect(inspectManifest(root, "apps/example/package.json")).resolves.toMatchObject({ installed: 1, missing: [] });
+  });
+});