@maxiaochao/pi-toolkit 0.9.3 → 0.9.6

package/packages/codex-edit/tests/legacy-parser-v0.1.7.mjs

@@ -0,0 +1,128 @@
+// Frozen semantic baseline from @maxiaochao/pi-codex-edit v0.1.7.
+// Source blob: codex-edit-v0.1.7:packages/codex-edit/src/parser.ts
+// Git blob ID: e2896b59d40b5f6f01b3a4a7918476f4acc28cd8
+// Keep this file unchanged; add cases to comparison-cases.mjs instead.
+
+export function parseLegacyPatch(patch) {
+  const lines = patch.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim().split("\n");
+  if (lines[0]?.trim() !== "*** Begin Patch") throw new Error("The first line of the patch must be '*** Begin Patch'");
+  if (lines.at(-1)?.trim() !== "*** End Patch") throw new Error("The last line of the patch must be '*** End Patch'");
+  const operations = [];
+  let index = 1;
+  while (index < lines.length - 1) {
+    const line = lines[index];
+    if (line.startsWith("*** Add File: ")) {
+      const path = line.slice("*** Add File: ".length);
+      index += 1;
+      const content = [];
+      while (index < lines.length - 1 && !lines[index].startsWith("*** ")) {
+        if (!lines[index].startsWith("+")) throw new Error(`Invalid add line ${index + 1}`);
+        content.push(lines[index].slice(1));
+        index += 1;
+      }
+      if (content.length === 0) throw new Error(`Add file hunk for path '${path}' is empty`);
+      operations.push({ action: "add", path, content: `${content.join("\n")}\n` });
+      continue;
+    }
+    if (line.startsWith("*** Delete File: ")) {
+      const path = line.slice("*** Delete File: ".length);
+      if (!path) throw new Error(`Delete file hunk on line ${index + 1} has an empty path`);
+      operations.push({ action: "delete", path });
+      index += 1;
+      continue;
+    }
+    if (line.startsWith("*** Update File: ")) {
+      const path = line.slice("*** Update File: ".length);
+      index += 1;
+      let moveTo;
+      if (lines[index]?.startsWith("*** Move to: ")) {
+        moveTo = lines[index].slice("*** Move to: ".length);
+        index += 1;
+      }
+      const chunks = [];
+      while (index < lines.length - 1 && !lines[index].startsWith("*** ")) {
+        let context;
+        if (lines[index] === "@@" || lines[index].startsWith("@@ ")) {
+          context = lines[index].slice(2).trim() || undefined;
+          index += 1;
+        }
+        const oldLines = [];
+        const newLines = [];
+        const contextLineIndices = [];
+        while (index < lines.length - 1 && !lines[index].startsWith("*** ") && !lines[index].startsWith("@@")) {
+          const change = lines[index];
+          const marker = change[0];
+          if (!["+", "-", " "].includes(marker)) throw new Error(`Invalid update line ${index + 1}`);
+          const text = change.slice(1);
+          if (marker === "+") newLines.push(text);
+          else if (marker === "-") oldLines.push(text);
+          else {
+            contextLineIndices.push([oldLines.length, newLines.length]);
+            oldLines.push(text);
+            newLines.push(text);
+          }
+          index += 1;
+        }
+        const endOfFile = lines[index] === "*** End of File";
+        if (endOfFile) index += 1;
+        if (oldLines.length === 0 && newLines.length === 0) throw new Error(`Empty update chunk on line ${index + 1}`);
+        chunks.push({ context, oldLines, newLines, contextLineIndices, endOfFile });
+      }
+      if (chunks.length === 0) throw new Error(`Update file hunk for path '${path}' is empty`);
+      operations.push({ action: "update", path, moveTo, chunks });
+      continue;
+    }
+    throw new Error(`Invalid hunk header on line ${index + 1}: ${line}`);
+  }
+  if (operations.length === 0) throw new Error("Patch contains no file operations");
+  const targets = operations.flatMap((operation) => [operation.path, operation.moveTo].filter(Boolean));
+  if (new Set(targets).size !== targets.length) throw new Error("Multiple operations target the same path");
+  return operations;
+}
+
+function findCandidates(lines, pattern, start, eof, compare) {
+  const candidates = [];
+  for (let index = start; index + pattern.length <= lines.length; index += 1) {
+    if (pattern.every((line, offset) => compare(lines[index + offset], line))) candidates.push(index);
+  }
+  candidates.sort((left, right) => eof ? right - left : left - right);
+  return candidates;
+}
+
+function locate(lines, pattern, start, eof, label) {
+  if (pattern.length === 0) return Math.min(start, lines.length);
+  const comparisons = [
+    (left, right) => left === right,
+    (left, right) => left.trimEnd() === right.trimEnd(),
+    (left, right) => left.trim() === right.trim(),
+  ];
+  for (const compare of comparisons) {
+    const candidates = findCandidates(lines, pattern, start, eof, compare);
+    if (candidates.length > 0) return candidates[0];
+  }
+  throw new Error(`Failed to find expected lines${label ? ` in ${label}` : ""}: ${pattern.join("\\n")}`);
+}
+
+export function applyLegacyUpdate(content, chunks, path) {
+  const bom = content.startsWith("\ufeff") ? "\ufeff" : "";
+  const withoutBom = bom ? content.slice(1) : content;
+  const ending = withoutBom.includes("\r\n") ? "\r\n" : "\n";
+  const normalized = withoutBom.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const hadFinalNewline = normalized.endsWith("\n");
+  const lines = normalized === "" ? [] : normalized.split("\n");
+  if (hadFinalNewline) lines.pop();
+  const replacements = [];
+  let cursor = 0;
+  for (const chunk of chunks) {
+    if (chunk.context !== undefined) cursor = locate(lines, [chunk.context], cursor, false, path) + 1;
+    const start = locate(lines, chunk.oldLines, cursor, chunk.endOfFile, path);
+    replacements.push({ start, length: chunk.oldLines.length, next: chunk.newLines });
+    cursor = start + chunk.oldLines.length;
+  }
+  const output = [...lines];
+  for (const replacement of [...replacements].reverse()) output.splice(replacement.start, replacement.length, ...replacement.next);
+  let next = output.join("\n");
+  if (hadFinalNewline || next.length > 0) next += "\n";
+  if (ending === "\r\n") next = next.replace(/\n/g, "\r\n");
+  return bom + next;
+}

package/packages/codex-edit/tests/native-vs-codex.ts

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { createEditToolDefinition } from "@earendil-works/pi-coding-agent";
+import registerCodexEdit from "../extensions/codex-edit.ts";
+import { comparisonCases } from "./comparison-cases.mjs";
+
+async function writeSnapshot(root, snapshot) {
+  for (const [path, content] of Object.entries(snapshot)) {
+    const absolute = join(root, path);
+    await mkdir(dirname(absolute), { recursive: true });
+    await writeFile(absolute, content, "utf8");
+  }
+}
+
+async function readSnapshot(root, relative = "") {
+  const snapshot = {};
+  for (const entry of await readdir(join(root, relative), { withFileTypes: true })) {
+    const path = relative ? `${relative}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) Object.assign(snapshot, await readSnapshot(root, path));
+    else snapshot[path] = await readFile(join(root, path), "utf8");
+  }
+  return snapshot;
+}
+
+async function runNativeCase(testCase) {
+  if (testCase.outcomes.native === "unsupported") {
+    assert.equal(testCase.nativeCalls, null, `${testCase.id}: unsupported native case must not invent edit calls`);
+    return "unsupported";
+  }
+  const workspace = await mkdtemp(join(tmpdir(), "codex-edit-native-"));
+  try {
+    await writeSnapshot(workspace, testCase.input);
+    const edit = createEditToolDefinition(workspace);
+    try {
+      for (const [index, call] of testCase.nativeCalls.entries()) {
+        await edit.execute(`native-${index}`, call, undefined, undefined, { cwd: workspace });
+      }
+      if (testCase.outcomes.native !== "pass") {
+        assert.fail(`${testCase.id}: native edit unexpectedly succeeded`);
+      }
+      assert.deepEqual(await readSnapshot(workspace), testCase.expected);
+      return "pass";
+    } catch (error) {
+      if (testCase.outcomes.native === "pass") throw error;
+      return "fail";
+    }
+  } finally {
+    await rm(workspace, { recursive: true, force: true });
+  }
+}
+
+async function getCodexTool() {
+  let tool;
+  await registerCodexEdit({
+    registerTool(definition) { tool = definition; },
+    on() {},
+    getActiveTools() { return []; },
+  });
+  assert.ok(tool, "Codex Edit extension did not register apply_patch");
+  return tool;
+}
+
+async function runCodexCase(tool, testCase) {
+  const workspace = await mkdtemp(join(tmpdir(), "codex-edit-local-"));
+  try {
+    await writeSnapshot(workspace, testCase.input);
+    try {
+      await tool.execute("codex-local", { patch: testCase.patch }, undefined, undefined, {
+        cwd: workspace,
+        hasUI: false,
+      });
+      if (testCase.outcomes.local !== "pass") {
+        assert.fail(`${testCase.id}: local Codex Edit unexpectedly succeeded`);
+      }
+      assert.deepEqual(await readSnapshot(workspace), testCase.expected);
+      return "pass";
+    } catch (error) {
+      if (testCase.outcomes.local === "pass") throw error;
+      assert.deepEqual(
+        await readSnapshot(workspace),
+        testCase.input,
+        `${testCase.id}: failed Codex patch must not partially mutate the workspace`,
+      );
+      return "fail";
+    }
+  } finally {
+    await rm(workspace, { recursive: true, force: true });
+  }
+}
+
+export default async function () {
+  const codexTool = await getCodexTool();
+  const results = [];
+  for (const testCase of comparisonCases) {
+    const native = await runNativeCase(testCase);
+    const codex = await runCodexCase(codexTool, testCase);
+    results.push({ id: testCase.id, native, codex });
+  }
+  assert.equal(results.length, comparisonCases.length);
+  assert.equal(results.filter(({ native }) => native === "pass").length, 5);
+  assert.equal(results.filter(({ native }) => native === "fail").length, 2);
+  assert.equal(results.filter(({ native }) => native === "unsupported").length, 5);
+  assert.equal(results.filter(({ codex }) => codex === "pass").length, 7);
+  assert.equal(results.filter(({ codex }) => codex === "fail").length, 5);
+  for (const result of results) console.log(`${result.id}: native=${result.native}, codex=${result.codex}`);
+  console.log(`Native edit vs local Codex Edit: ${results.length} comparison cases passed`);
+}

package/packages/codex-edit/tests/package.test.mjs

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { modelIsAllowed } from "../src/model-routing.ts";
+
+const packageDir = dirname(dirname(new URL(import.meta.url).pathname));
+
+test("package points Pi at the extension and config is reachable from it", async () => {
+  const manifest = JSON.parse(await readFile(join(packageDir, "package.json"), "utf8"));
+  assert.deepEqual(manifest.pi.extensions, ["./extensions/codex-edit.ts"]);
+  const source = await readFile(join(packageDir, "extensions/codex-edit.ts"), "utf8");
+  assert.match(source, /new URL\("\.\.\/config\.json", import\.meta\.url\)/);
+  assert.match(source, /model-routing\.ts/);
+  assert.match(source, /parameters: Type\.Object\(\{\s*patch: Type\.String/);
+  assert.match(source, /applyUpdateGroups\(before, operation\.chunkGroups, operation\.path\)/);
+  const config = JSON.parse(await readFile(join(packageDir, "config.json"), "utf8"));
+  assert.equal(config.enabled, true);
+  assert.deepEqual(config.models, ["gpt-5.6-*"]);
+});
+
+test("matches allowed model IDs with globs independently of provider and grammar support", () => {
+  const settings = { enabled: true, models: ["gpt-5.6-*", "my-codex-model"] };
+  const baseModel = {
+    id: "gpt-5.6-terra",
+    api: "openai-codex-responses",
+    compat: { supportsOpenAIGrammarTools: true },
+  };
+  assert.equal(modelIsAllowed({ ...baseModel, provider: "openai-codex" }, settings), true);
+  assert.equal(modelIsAllowed({ ...baseModel, provider: "another-provider" }, settings), true);
+  assert.equal(modelIsAllowed({ ...baseModel, compat: { supportsOpenAIGrammarTools: false } }, settings), true);
+  assert.equal(
+    modelIsAllowed(
+      { ...baseModel, api: "openai-responses", compat: { sessionAffinityFormat: "openai-nosession" } },
+      settings,
+    ),
+    true,
+  );
+  assert.equal(modelIsAllowed({ ...baseModel, api: "openai-completions" }, settings), false);
+  assert.equal(modelIsAllowed({ ...baseModel, id: "gpt-5.5" }, settings), false);
+  assert.equal(modelIsAllowed({ ...baseModel, id: "my-codex-model" }, settings), true);
+  assert.equal(modelIsAllowed({ ...baseModel, id: "my-codex-model-v2" }, settings), false);
+  assert.equal(modelIsAllowed({ ...baseModel, id: "GPT-5.6-terra" }, settings), false);
+  assert.equal(modelIsAllowed(baseModel, { enabled: false, models: ["gpt-5.6-*"] }), false);
+});
+
+test("execution keeps a resolved-path conflict guard after parser coalescing", async () => {
+  const source = await readFile(join(packageDir, "extensions/codex-edit.ts"), "utf8");
+  assert.match(source, /new Set\(targets\)\.size !== targets\.length/);
+  assert.match(source, /Multiple patch operations target the same resolved path/);
+});

package/packages/codex-edit/tests/parser.test.mjs

@@ -0,0 +1,308 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { applyUpdate, applyUpdateGroups, parsePatch, resolveWorkspacePath } from "../src/parser.ts";
+
+test("parses add, delete, update, and move operations", () => {
+  const operations = parsePatch(`*** Begin Patch
+*** Add File: added.txt
++hello
+*** Delete File: removed.txt
+*** Update File: old.txt
+*** Move to: new.txt
+@@
+-old
++new
+*** End Patch`);
+  assert.deepEqual(operations.map((operation) => operation.action), ["add", "delete", "update"]);
+  assert.equal(operations[0].content, "hello\n");
+  assert.equal(operations[2].moveTo, "new.txt");
+  assert.deepEqual(operations[2].chunks[0].oldLines, ["old"]);
+  assert.deepEqual(operations[2].chunks[0].newLines, ["new"]);
+});
+
+test("rejects malformed patches and duplicate targets", () => {
+  assert.throws(() => parsePatch("bad"), /first line/);
+  assert.throws(() => parsePatch(`*** Begin Patch
+*** Add File: same.txt
++x
+*** Add File: same.txt
++y
+*** End Patch`), /same path/);
+});
+
+test("applies multiple chunks using context and preserves BOM and CRLF", () => {
+  const before = "\ufefffunction run() {\r\n  const value = 1;\r\n  return value;\r\n}\r\n";
+  const operations = parsePatch(`*** Begin Patch
+*** Update File: src/run.js
+@@ function run() {
+-  const value = 1;
++  const value = 2;
+@@
+-  return value;
++  return value + 1;
+*** End Patch`);
+  const after = applyUpdate(before, operations[0].chunks, "src/run.js");
+  assert.equal(after, "\ufefffunction run() {\r\n  const value = 2;\r\n  return value + 1;\r\n}\r\n");
+});
+
+test("supports insertion chunks and EOF matching", () => {
+  const operations = parsePatch(`*** Begin Patch
+*** Update File: file.txt
+@@
++first
+*** End of File
+*** End Patch`);
+  assert.equal(applyUpdate("", operations[0].chunks, "file.txt"), "first\n");
+});
+
+test("uses the first matching region at or after the cursor", () => {
+  const operations = parsePatch(`*** Begin Patch
+*** Update File: file.txt
+@@
+-value
++changed
+*** End Patch`);
+  assert.equal(applyUpdate("value\nvalue\n", operations[0].chunks, "file.txt"), "changed\nvalue\n");
+});
+
+test("uses earlier hunks to advance the cursor through repeated HTML regions", () => {
+  const operations = parsePatch(`*** Begin Patch
+*** Update File: page.html
+@@
+-old
++new
+@@
+ </section>
++<section id="inserted"></section>
+ <section>
+*** End Patch`);
+  const before = `<header>
+old
+</header>
+<section>first</section>
+</section>
+<section>
+one
+</section>
+<section>
+two
+</section>
+`;
+  const after = `<header>
+new
+</header>
+<section>first</section>
+</section>
+<section id="inserted"></section>
+<section>
+one
+</section>
+<section>
+two
+</section>
+`;
+  assert.equal(applyUpdate(before, operations[0].chunks, "page.html"), after);
+});
+
+test("applies a hunk at the first repeated Markdown separator after its cursor", () => {
+  const operations = parsePatch(`*** Begin Patch
+*** Update File: SKILL.md
+@@
+-description: old
++description: new
+@@
+ ---
++Inserted after frontmatter.
+*** End Patch`);
+  const before = `---
+name: demo
+description: old
+---
+
+# Demo
+
+---
+Footer
+`;
+  const after = `---
+name: demo
+description: new
+---
+Inserted after frontmatter.
+
+# Demo
+
+---
+Footer
+`;
+  assert.equal(applyUpdate(before, operations[0].chunks, "SKILL.md"), after);
+});
+
+test("parses multiple file operations used by structural refactors", () => {
+  const operations = parsePatch(`*** Begin Patch
+*** Update File: extensions/tool.ts
+*** Move to: packages/tool/extensions/tool.ts
+@@
+-export const value = 1;
++export const value = 2;
+*** Add File: extensions/tool-wrapper.ts
++export { value } from "../packages/tool/extensions/tool.ts";
+*** Delete File: extensions/tool.test.ts
+*** End Patch`);
+  assert.deepEqual(
+    operations.map(({ action, path, moveTo }) => ({ action, path, moveTo })),
+    [
+      { action: "update", path: "extensions/tool.ts", moveTo: "packages/tool/extensions/tool.ts" },
+      { action: "add", path: "extensions/tool-wrapper.ts", moveTo: undefined },
+      { action: "delete", path: "extensions/tool.test.ts", moveTo: undefined },
+    ],
+  );
+});
+
+test("coalesces repeated updates to one path and preserves operation order", () => {
+  const operations = parsePatch(`*** Begin Patch
+*** Update File: src/tool.ts
+@@
+-const value = 1;
++const value = 2;
+*** Update File: src/tool.ts
+@@
+-const value = 2;
++const value = 3;
+*** End Patch`);
+  assert.equal(operations.length, 1);
+  assert.equal(operations[0].path, "src/tool.ts");
+  assert.equal(operations[0].chunkGroups.length, 2);
+  const after = applyUpdateGroups("const value = 1;\n", operations[0].chunkGroups, "src/tool.ts");
+  assert.equal(after, "const value = 3;\n");
+});
+
+test("still rejects conflicting repeated targets", () => {
+  assert.throws(() => parsePatch(`*** Begin Patch
+*** Update File: src/tool.ts
+@@
+-old
++new
+*** Delete File: src/tool.ts
+*** End Patch`), /same path/);
+  assert.throws(() => parsePatch(`*** Begin Patch
+*** Update File: src/old.ts
+*** Move to: src/new.ts
+@@
+-old
++new
+*** Add File: src/new.ts
++replacement
+*** End Patch`), /same path/);
+});
+
+test("rejects empty chunks and stale expected lines instead of guessing", () => {
+  assert.throws(() => parsePatch(`*** Begin Patch
+*** Update File: src/tool.ts
+@@
+*** End Patch`), /Empty update chunk/);
+  const [operation] = parsePatch(`*** Begin Patch
+*** Update File: src/tool.ts
+@@
+-missing line
++replacement
+*** End Patch`);
+  assert.throws(
+    () => applyUpdate("actual line\n", operation.chunks, operation.path),
+    /Failed to find expected lines in src\/tool\.ts/,
+  );
+});
+
+test("handles the reported project-scale repeated-file and Markdown shapes", () => {
+  const operations = parsePatch(`*** Begin Patch
+*** Update File: skills/pi-worktree/SKILL.md
+@@
+-description: old
++description: updated
+@@
+ ---
++Release notes follow.
+*** Update File: packages/tiny-subagent/src/tool.ts
+@@
+-const state = "old";
++const state = "middle";
+*** Update File: packages/tiny-subagent/src/tool.ts
+@@
+-const state = "middle";
++const state = "new";
+*** Update File: scripts/release-package.sh
+@@
+-ROOT_LEVEL=patch
++ROOT_LEVEL=minor
+*** Update File: scripts/release-package.sh
+@@
+-ROOT_LEVEL=minor
++ROOT_LEVEL=patch
+*** End Patch`);
+  assert.deepEqual(operations.map((operation) => operation.path), [
+    "skills/pi-worktree/SKILL.md",
+    "packages/tiny-subagent/src/tool.ts",
+    "scripts/release-package.sh",
+  ]);
+  assert.equal(operations[1].chunkGroups.length, 2);
+  assert.equal(operations[2].chunkGroups.length, 2);
+
+  const skill = `---
+name: pi-worktree
+description: old
+---
+
+# pi-worktree
+
+---
+Footer
+`;
+  assert.equal(
+    applyUpdateGroups(skill, operations[0].chunkGroups, operations[0].path),
+    `---
+name: pi-worktree
+description: updated
+---
+Release notes follow.
+
+# pi-worktree
+
+---
+Footer
+`,
+  );
+  assert.equal(
+    applyUpdateGroups('const state = "old";\n', operations[1].chunkGroups, operations[1].path),
+    'const state = "new";\n',
+  );
+  assert.equal(
+    applyUpdateGroups("ROOT_LEVEL=patch\n", operations[2].chunkGroups, operations[2].path),
+    "ROOT_LEVEL=patch\n",
+  );
+});
+
+test("rejects workspace escapes", () => {
+  assert.equal(resolveWorkspacePath("/tmp/project", "/tmp/project/src/a.js"), "/tmp/project/src/a.js");
+  assert.throws(() => resolveWorkspacePath("/tmp/project", "/tmp/other/a.js"), /escapes/);
+});
+
+test("round-trips a temporary file operation fixture", async () => {
+  const workspace = await mkdtemp(join(tmpdir(), "codex-edit-test-"));
+  try {
+    const path = join(workspace, "file.txt");
+    await writeFile(path, "before\n", "utf8");
+    const operations = parsePatch(`*** Begin Patch
+*** Update File: file.txt
+@@
+-before
++after
+*** End Patch`);
+    await writeFile(path, applyUpdate(await readFile(path, "utf8"), operations[0].chunks, "file.txt"), "utf8");
+    assert.equal(await readFile(path, "utf8"), "after\n");
+  } finally {
+    await rm(workspace, { recursive: true, force: true });
+  }
+});

package/packages/codex-edit/tests/released-vs-local.test.mjs

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { applyUpdate, parsePatch } from "../src/parser.ts";
+import { comparisonCases } from "./comparison-cases.mjs";
+import { runPatchCase } from "./comparison-harness.mjs";
+import { applyLegacyUpdate, parseLegacyPatch } from "./legacy-parser-v0.1.7.mjs";
+
+test("released v0.1.7 versus local parser over the growing comparison corpus", () => {
+  const results = [];
+  for (const testCase of comparisonCases) {
+    const released = runPatchCase(
+      testCase,
+      parseLegacyPatch,
+      applyLegacyUpdate,
+      testCase.outcomes.released,
+    );
+    const local = runPatchCase(testCase, parsePatch, applyUpdate, testCase.outcomes.local);
+    results.push({ id: testCase.id, released, local });
+  }
+
+  assert.equal(results.length, comparisonCases.length);
+  assert.deepEqual(
+    results.find(({ id }) => id === "repeated-update-same-path"),
+    { id: "repeated-update-same-path", released: "fail", local: "pass" },
+  );
+  assert.equal(results.filter(({ released }) => released === "pass").length, 6);
+  assert.equal(results.filter(({ released }) => released === "fail").length, 6);
+  assert.equal(results.filter(({ local }) => local === "pass").length, 7);
+  assert.equal(results.filter(({ local }) => local === "fail").length, 5);
+  for (const result of results) console.log(`${result.id}: released=${result.released}, local=${result.local}`);
+});

package/packages/tiny-subagent/CHANGELOG.md

@@ -0,0 +1,12 @@
+## 2026-09-30 - v0.1.1
+
+- Add standalone testing documentation and real production-runner screenshot/demo media.
+- Align the package manifest and root bundle with the shared workspace source.
+
+## 2026-09-01 - v0.1.0
+
+- Add the `tiny_subagents` Pi tool for one focused prompt in a fresh child Pi context.
+- Add package-local `worker.md` personas with model and built-in tool selection.
+- Return structured process, Pi protocol, stderr, stop-reason, exit, signal, and cancellation diagnostics.
+- Preserve oversized stdout, stderr, and final assistant output in private temporary artifacts.
+- Stream child event activity to the TUI and expose persona, prompt, and transcript details when expanded.