@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/core/test/resources.test.ts

@@ -0,0 +1,310 @@
+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 { ProjectTrustStore } from "@earendil-works/pi-coding-agent";
+import { afterEach, describe, expect, test } from "vitest";
+import modelsPlugin from "../src/plugins/models.js";
+import resourcesPlugin, { Config as ResourcesConfig } from "../src/plugins/resources.js";
+import { provideLaunchContext } from "../src/services.js";
+
+const contexts: Context[] = [];
+const isolatedResources = {
+  noExtensions: true,
+  noSkills: true,
+  noPromptTemplates: true,
+  noThemes: true,
+  noContextFiles: true,
+} as const;
+
+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-resources-cwd-"));
+  const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-resources-agent-"));
+  const context = new Context();
+  contexts.push(context);
+  provideLaunchContext(context, { cwd, agentDir, args: [], requestExit() {} });
+  await context.plugin(modelsPlugin, { provider: "deepseek", model: "deepseek-v4-flash", refreshOnCreate: false });
+  return { context, cwd, agentDir };
+}
+
+async function createProjectResources(cwd: string, marker: string): Promise<void> {
+  await Promise.all([
+    mkdir(join(cwd, ".pi", "extensions"), { recursive: true }),
+    mkdir(join(cwd, ".pi", "skills", "resource-probe"), { recursive: true }),
+    mkdir(join(cwd, ".pi", "prompts"), { recursive: true }),
+    mkdir(join(cwd, ".pi", "themes"), { recursive: true }),
+  ]);
+  await Promise.all([
+    writeFile(
+      join(cwd, ".pi", "extensions", "probe.js"),
+      `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(marker)}, "loaded"); export default function () {}`,
+      "utf8",
+    ),
+    writeFile(
+      join(cwd, ".pi", "skills", "resource-probe", "SKILL.md"),
+      "---\nname: resource-probe\ndescription: Verify resource loading\n---\n\n# Resource Probe\n",
+      "utf8",
+    ),
+    writeFile(join(cwd, ".pi", "prompts", "resource-probe.md"), "---\ndescription: Verify prompts\n---\nResource prompt\n", "utf8"),
+    writeFile(join(cwd, ".pi", "themes", "invalid.json"), "{ invalid-theme", "utf8"),
+    writeFile(join(cwd, "AGENTS.md"), "# Project instructions\n", "utf8"),
+  ]);
+}
+
+describe("resources plugin", () => {
+  test.each([42, "enabled", []])("rejects a non-object configuration: %j", async (config) => {
+    const { context } = await createContext();
+
+    await expect(context.plugin(resourcesPlugin, config as never)).rejects.toBeInstanceOf(Error);
+    expect(context.get("piResources")).toBeUndefined();
+  });
+
+  test.each([{ trustProject: "yes" }, { noExtensions: 1 }, { noPromptTemplates: [] }, { noThemes: {} }, { noContextFiles: "false" }])(
+    "rejects a non-boolean resource option: %j",
+    (config) => {
+      expect(() => ResourcesConfig(config as never)).toThrow();
+    },
+  );
+
+  test("rejects unknown configuration without publishing a partial service", async () => {
+    const { context } = await createContext();
+
+    await expect(context.plugin(resourcesPlugin, { noSkill: true } as never)).rejects.toThrow(/Unknown pi-resources config keys: noSkill/u);
+    expect(context.get("piResources")).toBeUndefined();
+  });
+
+  test("rejects a relative cwd when rebuilding cwd-bound resources", async () => {
+    const { context } = await createContext();
+    await context.plugin(resourcesPlugin, isolatedResources);
+    let creationError: unknown;
+    try {
+      await context.piResources.createForCwd("relative-session-cwd");
+    } catch (error) {
+      creationError = error;
+    }
+
+    expect(creationError).toBeInstanceOf(Error);
+    expect((creationError as Error).message).toMatch(/absolute/u);
+  });
+
+  test.each(["missing", "file"])("rejects an absolute cwd that is not an existing directory: %s", async (kind) => {
+    const { context, cwd } = await createContext();
+    await context.plugin(resourcesPlugin, isolatedResources);
+    const invalidCwd = join(cwd, kind);
+    if (kind === "file") await writeFile(invalidCwd, "not a directory", "utf8");
+    let creationError: unknown;
+    try {
+      await context.piResources.createForCwd(invalidCwd);
+    } catch (error) {
+      creationError = error;
+    }
+
+    expect(creationError).toBeInstanceOf(Error);
+    expect((creationError as Error).message).toMatch(/existing directory/u);
+  });
+
+  test("loads every enabled resource category from a trusted project", async () => {
+    const { context, cwd } = await createContext();
+    const marker = join(cwd, "extension-loaded.txt");
+    await createProjectResources(cwd, marker);
+
+    await context.plugin(resourcesPlugin, { trustProject: true });
+
+    await expect(access(marker)).resolves.toBeUndefined();
+    expect(context.piResources.resourceLoader.getSkills().skills.some((skill) => skill.name === "resource-probe")).toBe(true);
+    expect(context.piResources.resourceLoader.getPrompts().prompts.some((prompt) => prompt.name === "resource-probe")).toBe(true);
+    expect(context.piResources.resourceLoader.getThemes().diagnostics.some((diagnostic) => diagnostic.path?.endsWith("invalid.json"))).toBe(true);
+    expect(context.piResources.resourceLoader.getAgentsFiles().agentsFiles.some((file) => file.path === join(cwd, "AGENTS.md"))).toBe(true);
+  });
+
+  test("honors every resource-category disable flag", async () => {
+    const { context, cwd } = await createContext();
+    const marker = join(cwd, "extension-loaded.txt");
+    await createProjectResources(cwd, marker);
+
+    await context.plugin(resourcesPlugin, { trustProject: true, ...isolatedResources });
+
+    await expect(access(marker)).rejects.toMatchObject({ code: "ENOENT" });
+    expect(context.piResources.resourceLoader.getExtensions().extensions).toEqual([]);
+    expect(context.piResources.resourceLoader.getSkills()).toEqual({ skills: [], diagnostics: [] });
+    expect(context.piResources.resourceLoader.getPrompts()).toEqual({ prompts: [], diagnostics: [] });
+    expect(context.piResources.resourceLoader.getThemes()).toEqual({ themes: [], diagnostics: [] });
+    expect(context.piResources.resourceLoader.getAgentsFiles()).toEqual({ agentsFiles: [] });
+  });
+
+  test("loads user-owned agent extensions even when project resources are untrusted", async () => {
+    const { context, agentDir } = await createContext();
+    const marker = join(agentDir, "extension-loaded.txt");
+    await mkdir(join(agentDir, "extensions"), { recursive: true });
+    await writeFile(
+      join(agentDir, "extensions", "probe.js"),
+      `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(marker)}, "loaded"); export default function () {}`,
+      "utf8",
+    );
+
+    await context.plugin(resourcesPlugin, { trustProject: false, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true });
+
+    await expect(access(marker)).resolves.toBeUndefined();
+  });
+
+  test("explicit distrust overrides a saved trusted decision", async () => {
+    const { context, cwd, agentDir } = await createContext();
+    const marker = join(cwd, "extension-loaded.txt");
+    await createProjectResources(cwd, marker);
+    new ProjectTrustStore(agentDir).set(cwd, true);
+
+    await context.plugin(resourcesPlugin, { trustProject: false, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true });
+
+    await expect(access(marker)).rejects.toMatchObject({ code: "ENOENT" });
+    expect(context.piResources.settingsManager.isProjectTrusted()).toBe(false);
+  });
+
+  test("explicit trust overrides a saved untrusted decision", async () => {
+    const { context, cwd, agentDir } = await createContext();
+    const marker = join(cwd, "extension-loaded.txt");
+    await createProjectResources(cwd, marker);
+    new ProjectTrustStore(agentDir).set(cwd, false);
+
+    await context.plugin(resourcesPlugin, { trustProject: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true });
+
+    await expect(access(marker)).resolves.toBeUndefined();
+    expect(context.piResources.settingsManager.isProjectTrusted()).toBe(true);
+  });
+
+  test("uses the saved trust decision when the profile has no override", async () => {
+    const { context, cwd, agentDir } = await createContext();
+    const marker = join(cwd, "extension-loaded.txt");
+    await createProjectResources(cwd, marker);
+    new ProjectTrustStore(agentDir).set(cwd, true);
+
+    await context.plugin(resourcesPlugin, { noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true });
+
+    await expect(access(marker)).resolves.toBeUndefined();
+    expect(context.piResources.settingsManager.isProjectTrusted()).toBe(true);
+  });
+
+  test("fails activation on an extension load error without publishing partial resources", async () => {
+    const { context, agentDir } = await createContext();
+    await mkdir(join(agentDir, "extensions"), { recursive: true });
+    await writeFile(join(agentDir, "extensions", "broken.js"), `throw new Error("deliberate resource extension failure");`, "utf8");
+
+    let activationError: unknown;
+    try {
+      await context.plugin(resourcesPlugin, { noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true });
+    } catch (error) {
+      activationError = error;
+    }
+
+    expect(activationError).toBeInstanceOf(Error);
+    expect((activationError as Error).message).toMatch(/deliberate resource extension failure/u);
+    expect(context.get("piResources")).toBeUndefined();
+  });
+
+  test("sanitizes and bounds an extension failure before propagating it", async () => {
+    const { context, agentDir } = await createContext();
+    await mkdir(join(agentDir, "extensions"), { recursive: true });
+    await writeFile(join(agentDir, "extensions", "oversized-error.js"), `throw new Error("x".repeat(100_000) + "\\0\\nsecond line");`, "utf8");
+    let activationError: unknown;
+    try {
+      await context.plugin(resourcesPlugin, { noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true });
+    } catch (error) {
+      activationError = error;
+    }
+
+    expect(activationError).toBeInstanceOf(Error);
+    const message = (activationError as Error).message;
+    expect(message.length).toBeLessThanOrEqual(4_096);
+    expect(message).not.toContain("\0");
+    expect(message.split("\n")).toHaveLength(2);
+  });
+
+  test("publishes non-fatal loader diagnostics for the application surface", async () => {
+    const { context, cwd } = await createContext();
+    await mkdir(join(cwd, ".pi", "themes"), { recursive: true });
+    const themePath = join(cwd, ".pi", "themes", "invalid.json");
+    await writeFile(themePath, "{ invalid-theme", "utf8");
+
+    await context.plugin(resourcesPlugin, { trustProject: true, noExtensions: true, noSkills: true, noPromptTemplates: true, noContextFiles: true });
+
+    expect(context.piResources.diagnostics.some((diagnostic) => diagnostic.type === "warning" && diagnostic.message.includes(themePath))).toBe(true);
+  });
+
+  test("bounds the published resource diagnostic inventory with an omission summary", async () => {
+    const { context, cwd } = await createContext();
+    const themes = join(cwd, ".pi", "themes");
+    await mkdir(themes, { recursive: true });
+    await Promise.all(Array.from({ length: 110 }, async (_, index) => writeFile(join(themes, `invalid-${index}.json`), "{ invalid-theme", "utf8")));
+
+    await context.plugin(resourcesPlugin, { trustProject: true, noExtensions: true, noSkills: true, noPromptTemplates: true, noContextFiles: true });
+
+    expect(context.piResources.diagnostics).toHaveLength(100);
+    expect(context.piResources.diagnostics.at(-1)).toEqual({ type: "warning", message: "Resource diagnostics omitted: 11 additional warnings" });
+  });
+
+  test("fails activation when an extension registers an invalid provider", async () => {
+    const { context, agentDir } = await createContext();
+    await mkdir(join(agentDir, "extensions"), { recursive: true });
+    await writeFile(
+      join(agentDir, "extensions", "invalid-provider.js"),
+      `export default function (pi) { pi.registerProvider("invalid-provider", { streamSimple() {} }); }`,
+      "utf8",
+    );
+    let activationError: unknown;
+    try {
+      await context.plugin(resourcesPlugin, { noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true });
+    } catch (error) {
+      activationError = error;
+    }
+
+    expect(activationError).toBeInstanceOf(Error);
+    expect((activationError as Error).message).toMatch(/invalid-provider.*api.*required/isu);
+    expect(context.get("piResources")).toBeUndefined();
+    expect(context.piModelRuntime.runtime.getRegisteredProviderIds()).not.toContain("invalid-provider");
+  });
+
+  test("surfaces invalid trusted project settings as a warning while retaining global settings", async () => {
+    const { context, cwd, agentDir } = await createContext();
+    await mkdir(join(cwd, ".pi"), { recursive: true });
+    await writeFile(join(cwd, ".pi", "settings.json"), "{ invalid-project-settings", "utf8");
+    await writeFile(join(agentDir, "settings.json"), JSON.stringify({ httpIdleTimeoutMs: 12_345 }), "utf8");
+
+    await context.plugin(resourcesPlugin, { trustProject: true, ...isolatedResources });
+
+    expect(context.piResources.settingsManager.getHttpIdleTimeoutMs()).toBe(12_345);
+    expect(
+      context.piResources.diagnostics.some(
+        (diagnostic) => diagnostic.type === "warning" && /Invalid project settings file.*settings\.json/isu.test(diagnostic.message),
+      ),
+    ).toBe(true);
+  });
+
+  test("keeps cwd-bound resources and diagnostics isolated when rebuilding for another cwd", async () => {
+    const { context, cwd } = await createContext();
+    const otherCwd = await mkdtemp(join(tmpdir(), "pi-harness-resources-other-cwd-"));
+    await writeFile(join(cwd, "AGENTS.md"), "# Initial project\n", "utf8");
+    await writeFile(join(otherCwd, "AGENTS.md"), "# Other project\n", "utf8");
+    await context.plugin(resourcesPlugin, { ...isolatedResources, noContextFiles: false });
+
+    const other = await context.piResources.createForCwd(otherCwd);
+
+    expect(context.piResources.cwd).toBe(cwd);
+    expect(context.piResources.resourceLoader.getAgentsFiles().agentsFiles).toEqual([{ path: join(cwd, "AGENTS.md"), content: "# Initial project\n" }]);
+    expect(other.cwd).toBe(otherCwd);
+    expect(other.resourceLoader.getAgentsFiles().agentsFiles).toEqual([{ path: join(otherCwd, "AGENTS.md"), content: "# Other project\n" }]);
+    expect(other.diagnostics).not.toBe(context.piResources.diagnostics);
+  });
+
+  test("removes the resources service on plugin disposal", async () => {
+    const { context } = await createContext();
+    await context.plugin(resourcesPlugin, isolatedResources);
+    expect(context.get("piResources")).toBeDefined();
+
+    await context.fiber.dispose();
+
+    expect(context.get("piResources")).toBeUndefined();
+  });
+});

package/packages/core/test/reviewer-bot.test.ts

@@ -0,0 +1,55 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, 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 reviewerBotPlugin from "../src/plugins/reviewer-bot.js";
+import { provideLaunchContext, PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+
+const execFileAsync = promisify(execFile);
+const contexts: Context[] = [];
+
+async function fixture() {
+  const root = await mkdtemp(join(tmpdir(), "pi-harness-reviewer-"));
+  await execFileAsync("git", ["init", "-q"], { cwd: root });
+  await execFileAsync("git", ["config", "user.email", "test@example.invalid"], { cwd: root });
+  await execFileAsync("git", ["config", "user.name", "Pi Harness Test"], { cwd: root });
+  await writeFile(join(root, "file.txt"), "base\n");
+  await execFileAsync("git", ["add", "."], { cwd: root });
+  await execFileAsync("git", ["commit", "-qm", "base"], { cwd: root });
+  const context = new Context();
+  const tools = new PiToolRegistry();
+  const panels = new PiPluginUiRegistry();
+  provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
+  context.provide("piTools", tools);
+  context.provide("piPluginUi", panels);
+  await context.plugin(reviewerBotPlugin, { maxDiffBytes: 64 * 1024, timeoutMs: 5_000 });
+  contexts.push(context);
+  const tool = tools.snapshot().customTools.find((item) => item.name === "review_changes");
+  if (tool === undefined) throw new Error("review_changes was not registered");
+  return { root, context, tools, panels, tool };
+}
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
+});
+
+describe("reviewer bot", () => {
+  test("reviews a clean diff and reports changed files", async () => {
+    const { root, tool, panels } = await fixture();
+    await writeFile(join(root, "file.txt"), "changed\n");
+    expect(tool.executionMode).toBe("sequential");
+    expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
+    await expect(tool.execute("review", {}, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { status: "pass", changedFiles: 1 } });
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { latest: { status: "pass" } } }]);
+  });
+
+  test("cleans up registrations on disposal", async () => {
+    const { context, tools, panels } = await fixture();
+    await context.fiber.dispose();
+    expect(tools.snapshot().customTools).toHaveLength(0);
+    await expect(panels.snapshot()).resolves.toHaveLength(0);
+  });
+});

package/packages/core/test/runtime-fixture.ts

@@ -10,7 +10,7 @@ import runtimePlugin from "../src/plugins/runtime.js";
 import sessionPlugin from "../src/plugins/session.js";
 import toolsPlugin from "../src/plugins/tools.js";
 
-export async function createTestRuntimeContext(
+export async function createTestRuntimeServices(
   responses: FauxResponseStep[],
   toolNames: string[] = [],
   resourceOptions: { noExtensions: boolean; agentDir?: string } = { noExtensions: true },
@@ -41,6 +41,15 @@ export async function createTestRuntimeContext(
   context.provide("piModels", { runtime: modelRuntime, model });
   await context.plugin(sessionPlugin, { storage: "memory" });
   await context.plugin(toolsPlugin, { names: toolNames });
+  return { context, faux };
+}
+
+export async function createTestRuntimeContext(
+  responses: FauxResponseStep[],
+  toolNames: string[] = [],
+  resourceOptions: { noExtensions: boolean; agentDir?: string } = { noExtensions: true },
+): Promise<{ context: Context; faux: FauxProviderHandle }> {
+  const { context, faux } = await createTestRuntimeServices(responses, toolNames, resourceOptions);
   await context.plugin(runtimePlugin, { thinkingLevel: "off" });
   return { context, faux };
 }

package/packages/core/test/runtime.test.ts

@@ -2,10 +2,12 @@ import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fauxAssistantMessage } from "@earendil-works/pi-ai/providers/faux";
-import { afterEach, describe, expect, test } from "vitest";
+import { afterEach, describe, expect, test, vi } from "vitest";
 import { Context } from "@deepseek-ai/cordis";
 import runtimePlugin from "../src/plugins/runtime.js";
-import { createTestRuntimeContext } from "./runtime-fixture.js";
+import { PiRuntime } from "../src/runtime.js";
+import { PiToolRegistry } from "../src/services.js";
+import { createTestRuntimeContext, createTestRuntimeServices } from "./runtime-fixture.js";
 
 const contexts: Context[] = [];
 
@@ -122,6 +124,73 @@ describe("Pi runtime plugin", () => {
     expect(order).toEqual(["teardown:start", "teardown:end", "second-session:created"]);
   }, 20_000);
 
+  test("releases the SessionManager gate when initial runtime creation fails", async () => {
+    const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-gate-recovery-"));
+    const { context } = await createTestRuntimeServices([], [], { noExtensions: false, agentDir });
+    contexts.push(context);
+    context.piResources.resourceLoader.getExtensions().errors.push({ path: "reload-broken.js", error: "gate creation failure" });
+
+    await expect(context.plugin(runtimePlugin, { thinkingLevel: "off" })).rejects.toThrow(/gate creation failure/iu);
+    const unregisterProbe = context.piTools.register({ name: "gate-recovery-probe" } as never);
+    unregisterProbe();
+    let outcome: "pending" | "resolved" | "rejected" = "pending";
+    let recoveryError: unknown;
+    const activation = context.plugin(runtimePlugin, { thinkingLevel: "off" }).then(
+      () => {
+        outcome = "resolved";
+      },
+      (error: unknown) => {
+        outcome = "rejected";
+        recoveryError = error;
+      },
+    );
+
+    await vi.waitFor(() => expect(outcome).not.toBe("pending"), { timeout: 1_000, interval: 10 });
+    expect(recoveryError).toBeInstanceOf(Error);
+    expect((recoveryError as Error).message).toMatch(/gate creation failure/iu);
+    expect(outcome).toBe("rejected");
+    await activation;
+  });
+
+  test("releases the SessionManager gate when runtime binding fails", async () => {
+    const { context } = await createRuntimeContext();
+    const shared = {
+      piHarnessLaunch: context.get("piHarnessLaunch"),
+      piModelRuntime: context.get("piModelRuntime"),
+      piModels: context.get("piModels"),
+      piResources: context.get("piResources"),
+      piSession: context.get("piSession"),
+    };
+    await context.fiber.dispose();
+
+    const failing = new Context();
+    contexts.push(failing);
+    for (const [service, value] of Object.entries(shared)) failing.provide(service as keyof typeof shared, value as never);
+    failing.provide("piTools", new PiToolRegistry(["not-a-pi-tool"]));
+    await expect(failing.plugin(runtimePlugin, { thinkingLevel: "off" })).rejects.toThrow(/not-a-pi-tool/iu);
+
+    const recovery = new Context();
+    contexts.push(recovery);
+    for (const [service, value] of Object.entries(shared)) recovery.provide(service as keyof typeof shared, value as never);
+    recovery.provide("piTools", new PiToolRegistry());
+    let outcome: "pending" | "resolved" | "rejected" = "pending";
+    let recoveryError: unknown;
+    const activation = recovery.plugin(runtimePlugin, { thinkingLevel: "off" }).then(
+      () => {
+        outcome = "resolved";
+      },
+      (error: unknown) => {
+        outcome = "rejected";
+        recoveryError = error;
+      },
+    );
+
+    await vi.waitFor(() => expect(outcome).not.toBe("pending"), { timeout: 1_000, interval: 10 });
+    expect(recoveryError).toBeUndefined();
+    expect(outcome).toBe("resolved");
+    await activation;
+  });
+
   test("disposes the Pi session even when the in-flight abort rejects", async () => {
     const { context } = await createRuntimeContext();
     const runtime = context.piRuntime;
@@ -141,6 +210,37 @@ describe("Pi runtime plugin", () => {
     await expect(runtime.prompt("too late")).rejects.toThrow(/disposed/);
   });
 
+  test("makes concurrent disposal callers wait for the same teardown", async () => {
+    let resolveAbort: (() => void) | undefined;
+    let runtimeDisposals = 0;
+    const runtime = new PiRuntime({
+      session: {
+        isIdle: false,
+        abort: () =>
+          new Promise<void>((resolve) => {
+            resolveAbort = resolve;
+          }),
+      },
+      dispose: () => {
+        runtimeDisposals += 1;
+        return Promise.resolve();
+      },
+    } as never);
+
+    const first = runtime.dispose();
+    await vi.waitFor(() => expect(resolveAbort).toBeDefined());
+    let secondSettled = false;
+    const second = runtime.dispose().then(() => {
+      secondSettled = true;
+    });
+    await Promise.resolve();
+    expect(secondSettled).toBe(false);
+
+    resolveAbort?.();
+    await Promise.all([first, second]);
+    expect(runtimeDisposals).toBe(1);
+  });
+
   test("keeps the agent run alive when a pi/session-event listener throws", async () => {
     const { context, responseText, callCount } = await createRuntimeContext();
     const extensionErrors: string[] = [];
@@ -157,4 +257,57 @@ describe("Pi runtime plugin", () => {
     expect(callCount()).toBe(1);
     expect(extensionErrors).toContain("listener boom");
   });
+
+  test("bounds listener failures without executing hostile error accessors", async () => {
+    const { context, responseText, callCount } = await createRuntimeContext();
+    const extensionErrors: string[] = [];
+    let accessed = false;
+    let events = 0;
+    const hostile = new Error();
+    Object.defineProperty(hostile, "message", {
+      get() {
+        accessed = true;
+        throw new Error("hostile error getter executed");
+      },
+    });
+    context.on("pi/extension-error", (error) => {
+      extensionErrors.push(error.error);
+    });
+    context.on("pi/session-event", () => {
+      events += 1;
+      throw events === 1 ? new Error("x".repeat(3_000)) : hostile;
+    });
+
+    await context.piRuntime.prompt("respond once");
+
+    expect(responseText.join("")).toBe("deterministic response");
+    expect(callCount()).toBe(1);
+    expect(events).toBeGreaterThan(1);
+    expect(extensionErrors[0]).toHaveLength(2_000);
+    expect(extensionErrors).toContain("Unknown pi/session-event listener error");
+    expect(accessed).toBe(false);
+  });
+
+  test("keeps extension-error observers from interrupting the agent run", async () => {
+    const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-extension-error-observer-"));
+    await mkdir(join(agentDir, "extensions"), { recursive: true });
+    await writeFile(
+      join(agentDir, "extensions", "probe.js"),
+      `export default function (pi) { pi.on("turn_start", () => { throw new Error("extension turn failure"); }); }`,
+      "utf8",
+    );
+    const { context, faux } = await createTestRuntimeContext([fauxAssistantMessage("response survived")], [], { noExtensions: false, agentDir });
+    contexts.push(context);
+    let observed = 0;
+    context.on("pi/extension-error", () => {
+      observed += 1;
+      throw new Error("extension error observer failed");
+    });
+
+    await context.piRuntime.prompt("respond once");
+
+    expect(observed).toBeGreaterThan(0);
+    expect(faux.state.callCount).toBe(1);
+    expect(context.piRuntime.session.messages.some((message) => message.role === "assistant")).toBe(true);
+  });
 });

package/packages/core/test/secure-audit.test.ts

@@ -1,5 +1,8 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 import { describe, expect, test } from "vitest";
-import { auditText, summarizeAudit } from "../src/plugins/secure-audit.js";
+import { auditText, auditWorkspace, summarizeAudit } from "../src/plugins/secure-audit.js";
 
 describe("secure audit", () => {
   test("detects secrets without returning their values", () => {
@@ -13,4 +16,14 @@ describe("secure audit", () => {
     expect(findings.map((finding) => finding.kind)).toEqual(["shell-pipeline", "destructive-command"]);
     expect(summarizeAudit(findings)).toMatchObject({ total: 2, critical: 0, high: 2, changed: true });
   });
+
+  test("skips invalid UTF-8 files instead of scanning replacement characters", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-secure-audit-"));
+    await writeFile(join(root, "invalid.txt"), Buffer.from([0xc3, 0x28, 0x41, 0x50, 0x49, 0x5f, 0x4b, 0x45, 0x59, 0x3d, 0x73, 0x6b]));
+    try {
+      await expect(auditWorkspace(root)).resolves.toMatchObject({ total: 0, scanned: 1, skipped: 1 });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
 });