@pi-harness/pi-harness 0.1.13 → 0.1.15

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

@@ -1,69 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,137 +0,0 @@
-import { mkdtemp, readFile, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { afterEach, describe, expect, test } from "vitest";
-import { bootHarness, type BootedHarness } from "../src/boot.js";
-
-const booted: BootedHarness[] = [];
-
-afterEach(async () => {
-  await Promise.all(booted.splice(0).map(async (harness) => harness.dispose()));
-});
-
-async function createProfile(entries: unknown[]): Promise<{ directory: string; profilePath: string }> {
-  const directory = await mkdtemp(join(tmpdir(), "pi-harness-boot-"));
-  const profilePath = join(directory, "cordis.yml");
-  await writeFile(profilePath, JSON.stringify(entries), "utf8");
-  return { directory, profilePath };
-}
-
-async function createPlugin(directory: string, name: string, source: string): Promise<string> {
-  const path = join(directory, `${name}.mjs`);
-  await writeFile(path, source, "utf8");
-  return pathToFileURL(path).href;
-}
-
-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); }`,
-    );
-    await writeFile(profile.profilePath, JSON.stringify([{ name: plugin, config: { value: "active" } }]), "utf8");
-
-    const harness = await bootHarness({ configPath: profile.profilePath });
-    booted.push(harness);
-
-    expect(harness.context.get("fixtureValue")).toBe("active");
-  });
-
-  test("fails loudly when a plugin module cannot be resolved", async () => {
-    const profile = await createProfile([{ name: "./missing-plugin.mjs" }]);
-
-    await expect(bootHarness({ configPath: profile.profilePath })).rejects.toThrow(/missing-plugin\.mjs/);
-  });
-
-  test("reports plugins left pending by unresolved injections", async () => {
-    const profile = await createProfile([]);
-    const plugin = await createPlugin(profile.directory, "consumer", `export default { inject: ["serviceThatDoesNotExist"], apply() {} };`);
-    await writeFile(profile.profilePath, JSON.stringify([{ name: plugin }]), "utf8");
-
-    await expect(bootHarness({ configPath: profile.profilePath })).rejects.toThrow(/serviceThatDoesNotExist/);
-  });
-
-  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"); } };`,
-    );
-    await writeFile(profile.profilePath, JSON.stringify([{ name: owner, config: { markerPath } }, { name: failure }]), "utf8");
-
-    await expect(bootHarness({ configPath: profile.profilePath })).rejects.toThrow(/fixture activation failed/);
-    await expect(readFile(markerPath, "utf8")).resolves.toBe("started:disposed");
-  });
-
-  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 },
-        ],
-      },
-    ]);
-    await writeFile(profile.profilePath, source, "utf8");
-
-    await expect(bootHarness({ configPath: profile.profilePath })).rejects.toThrow(/nested activation failed/);
-
-    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;
-      },
-    });
-    booted.push(harness);
-
-    harness.context.loader.exit();
-
-    expect(reloads).toBe(1);
-  });
-});

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

@@ -1,74 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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: [] });
-  });
-});