@astrosheep/pi-context 0.25.2 → 0.26.1

package/dist/test/helpers/extension.js

@@ -4,9 +4,9 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import piContext, { createPiContext } from "../../src/index.js";
-import { loadNotesSnapshot } from "../../src/notes/notes-snapshot.js";
+import { loadNotesSnapshot } from "../../src/pi/notes/snapshot.js";
 import { renderBootBlock } from "../../src/context/prompts.js";
-import { agentSlug, modelSlug } from "../../src/notes/paths.js";
+import { agentSlug, modelSlug } from "../../src/pi/notes/adapter.js";
 import { rootWindowId } from "../../src/context/context-window.js";
 import { TOOL_OUTPUT_MAX_BYTES } from "../../src/tool-output.js";
 let defaultCwd = "/private/tmp/pi-context-test-cwd";
@@ -130,14 +130,14 @@ export function makeExtension(sessionManager, settingsManager) {
     (settingsManager ? createPiContext({ settingsManager }) : piContext)(api);
     return captured;
 }
-export function explicitBoot(ctx, currentWindowId, previousWindowId) {
+export async function explicitBoot(ctx, currentWindowId, previousWindowId) {
     return renderBootBlock({
         agentName: agentSlug(ctx),
         modelName: modelSlug(ctx),
         firstWindowId: rootWindowId(ctx.sessionManager.getSessionId()),
         currentWindowId,
         previousWindowId,
-        notes: loadNotesSnapshot(ctx),
+        notes: await loadNotesSnapshot(ctx),
     });
 }
 export function context(sessionManager, compact, usage, idle = true, cwd = defaultCwd, projectTrusted = true, model) {
@@ -166,41 +166,12 @@ export function sentOf(captured, customType) {
 export async function call(captured, name, params, ctx) {
     const tool = captured.tools.get(name);
     assert.ok(tool, `registered ${name}`);
-    // Most pre-redesign coverage names session notes by their bare address. Keep these old
-    // fixture call sites readable while routing the direct tool invocation through its new
-    // address-shaped input; contract-specific tests below pass address themselves.
-    const noteCall = name === "notes_write" || name === "notes_edit" || name === "notes_read";
-    if (noteCall && "path" in params && !("address" in params)) {
-        const { path, scope, ...rest } = params;
-        assert.equal(typeof path, "string", "legacy note fixture path is a string");
-        const address = scope === "project" ? `@project/${path}` : scope === "human" ? `@human/${path}` : path;
-        return tool.execute("call-1", { ...rest, address }, new AbortController().signal, () => { }, ctx);
-    }
-    if ((name === "notes_list" || name === "notes_search") && params.scope === "human") {
-        const { scope: _scope, pattern, ...rest } = params;
-        return tool.execute("call-1", { ...rest, pattern: `@human/${typeof pattern === "string" ? pattern : "**"}` }, new AbortController().signal, () => { }, ctx);
-    }
-    if ((name === "notes_list" || name === "notes_search") && params.scope === "session") {
-        const { scope: _scope, pattern, ...rest } = params;
-        return tool.execute("call-1", { ...rest, pattern: typeof pattern === "string" ? pattern : "*.md" }, new AbortController().signal, () => { }, ctx);
-    }
     return tool.execute("call-1", params, new AbortController().signal, () => { }, ctx);
 }
 export function resultJson(result) {
     const text = result.content[0];
     assert.ok(text && text.type === "text", "tool result carries text");
-    const value = JSON.parse(text.text);
-    const suffix = (address) => address.startsWith("@project/") ? address.slice("@project/".length) : address.startsWith("@human/") ? address.slice("@human/".length) : address;
-    const legacyPath = (row) => {
-        if (typeof row.address === "string" && row.path === undefined)
-            Object.defineProperty(row, "path", { value: suffix(row.address), enumerable: false });
-    };
-    legacyPath(value);
-    if (Array.isArray(value.files))
-        for (const file of value.files)
-            if (file && typeof file === "object")
-                legacyPath(file);
-    return value;
+    return JSON.parse(text.text);
 }
 /** Assert the delivered wire text fits the tool-output budget, header included for raw reads. */
 export function assertWithinBudget(result, message) {
@@ -223,32 +194,6 @@ export function resultRead(result) {
     assert.equal(Array.from(content).length, end - offset_chars, "READ WINDOW range matches the delivered payload");
     return { header, content, offset_chars, total_chars, next_offset_chars, details: (result.details ?? {}) };
 }
-/**
- * Assert a value is a local-time ISO 8601 string with an explicit numeric offset (never "Z")
- * and that Date.parse restores the stored epoch milliseconds. No time zone is assumed.
- */
-export function assertLocalIso(value, epochMs, message) {
-    assert.equal(typeof value, "string", message);
-    assert.match(value, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[+-]\d{2}:\d{2}$/, message);
-    assert.equal(Date.parse(value), epochMs, `${message}: Date.parse restores the stored epoch ms`);
-}
-/** Assert the text contains a well-formed local ISO timestamp and return it, without pinning surrounding wording. */
-export function assertIsoTimestamp(text, message) {
-    const match = text.match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[+-]\d{2}:\d{2}/);
-    assert.ok(match, message);
-    assert.equal(Number.isNaN(Date.parse(match[0])), false, `${message}: timestamp parses`);
-    return match[0];
-}
-/** Assert `actual` is a middle-truncation of `original`: same head, same tail, strictly fewer characters. */
-export function assertTruncationOf(original, actual) {
-    const match = actual.match(/^([\s\S]*)…\[truncated \d+ chars\]…([\s\S]*)$/);
-    assert.ok(match, "truncated value carries the middle-truncation marker");
-    const head = match[1];
-    const tail = match[2];
-    assert.ok(original.startsWith(head), "truncation keeps the original head");
-    assert.ok(original.endsWith(tail), "truncation keeps the original tail");
-    assert.ok(head.length + tail.length < original.length, "truncation actually removes characters");
-}
 export async function runManualCompact(captured, ctx) {
     const handler = captured.handlers.get("session_before_compact")?.[0];
     assert.ok(handler, "session_before_compact handler registered");
@@ -270,32 +215,13 @@ export async function runManualCompact(captured, ctx) {
     };
     return (await handler(event, ctx));
 }
-export function runHandlers(captured, name, event, ctx) {
+export async function runHandlers(captured, name, event, ctx) {
     const isIdle = ctx.isIdle;
     if (name === "agent_settled")
         ctx.isIdle = () => true;
     try {
         for (const handler of captured.handlers.get(name) ?? [])
-            handler(event, ctx);
-    }
-    finally {
-        ctx.isIdle = isIdle;
-    }
-}
-export async function runHandlersAsync(captured, name, event, ctx) {
-    const results = [];
-    for (const handler of captured.handlers.get(name) ?? [])
-        results.push(await handler(event, ctx));
-    return results;
-}
-export function completeRequestedCompaction(ctx) {
-    const requests = ctx.compactionRequests;
-    const options = requests.shift();
-    assert.ok(options?.onComplete, "a reset request has a completion callback");
-    const isIdle = ctx.isIdle;
-    ctx.isIdle = () => true;
-    try {
-        options.onComplete({});
+            await handler(event, ctx);
     }
     finally {
         ctx.isIdle = isIdle;

package/dist/test/helpers/notes.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type NoteRow, type NotesQuery, type Scope } from "../../src/notes/index.js";
+/** Test-only conveniences for fixtures that still model notes through a live Pi context. */
+export declare function physicalPath(scope: Scope, path: string, ctx: ExtensionContext, who?: string): string;
+export declare function scopeDir(scope: Scope, ctx: ExtensionContext, who?: string): string;
+export declare function listNotes(ctx: ExtensionContext, query?: NotesQuery): Promise<NoteRow[]>;

package/dist/test/helpers/notes.js

@@ -0,0 +1,13 @@
+import { createNotesStore } from "../../src/notes/index.js";
+import { notesContextFromPi } from "../../src/pi/notes/adapter.js";
+import { physicalPath as corePhysicalPath, scopeDir as coreScopeDir } from "../../src/notes/paths.js";
+/** Test-only conveniences for fixtures that still model notes through a live Pi context. */
+export function physicalPath(scope, path, ctx, who) {
+    return corePhysicalPath(scope, path, notesContextFromPi(ctx), who);
+}
+export function scopeDir(scope, ctx, who) {
+    return coreScopeDir(scope, notesContextFromPi(ctx), who);
+}
+export function listNotes(ctx, query = {}) {
+    return createNotesStore(notesContextFromPi(ctx)).list(query);
+}

package/dist/test/history.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/history.integration.test.js

@@ -2,11 +2,9 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { historyFromSession } from "../src/index.js";
 import { TOOL_OUTPUT_MAX_BYTES } from "../src/tool-output.js";
-import { appendText, assertWithinBudget, call, context, installExtensionTestEnvironment, makeExtension, manager, objectSchema, resultJson, resultRead, } from "./helpers/extension.js";
-const testEnvironment = installExtensionTestEnvironment("pi-context-integration");
-test.beforeEach(() => testEnvironment.beforeEach());
-test.afterEach(() => testEnvironment.afterEach());
-test.after(() => testEnvironment.dispose());
+import { appendText, assertWithinBudget, call, context, makeExtension, manager, objectSchema, resultJson, resultRead, } from "./helpers/extension.js";
+import { installExtensionTestHooks } from "./helpers/extension-test-environment.js";
+const testEnvironment = installExtensionTestHooks("pi-context-integration");
 test("schemas cover the History/Notes actions plus reset controls", () => {
     const captured = makeExtension(manager());
     for (const name of [
@@ -94,7 +92,7 @@ test("paged tool outputs stay bounded and cursors reconstruct history and notes"
     }
     assert.equal(readParts.join(""), historyText);
     for (let index = 0; index < 100; index++) {
-        await call(captured, "notes_write", { path: `page-${"x".repeat(120)}-${index}.md`, content: Array.from({ length: 1000 }, (_, line) => `needle ${line} ${"z".repeat(30)}`).join("\n") }, ctx);
+        await call(captured, "notes_write", { address: `page-${"x".repeat(120)}-${index}.md`, content: Array.from({ length: 1000 }, (_, line) => `needle ${line} ${"z".repeat(30)}`).join("\n") }, ctx);
     }
     const listPages = [];
     let listOffset = 0;
@@ -102,7 +100,7 @@ test("paged tool outputs stay bounded and cursors reconstruct history and notes"
     while (listNext !== null) {
         const result = resultJson(await call(captured, "notes_list", { max_results: 300, cursor: listOffset }, ctx));
         assert.ok(Buffer.byteLength(JSON.stringify(result), "utf8") <= TOOL_OUTPUT_MAX_BYTES);
-        listPages.push(...result.files.map((file) => file.path));
+        listPages.push(...result.files.map((file) => file.address));
         listNext = result.next_cursor;
         if (listNext !== null)
             listOffset = listNext;
@@ -127,7 +125,7 @@ test("paged tool outputs stay bounded and cursors reconstruct history and notes"
     let noteOffset = 0;
     let noteNext = 0;
     while (noteNext !== null) {
-        const raw = await call(captured, "notes_read", { path: `page-${"x".repeat(120)}-0.md`, offset_chars: noteOffset }, ctx);
+        const raw = await call(captured, "notes_read", { address: `page-${"x".repeat(120)}-0.md`, offset_chars: noteOffset }, ctx);
         assertWithinBudget(raw, `notes_read page at ${noteOffset}`);
         const result = resultRead(raw);
         // The window is a plain prefix of the file, so the pages join by plain concatenation.
@@ -172,7 +170,7 @@ test("a page cap limits the page, not the enumerable set: cursors stay truthful
     assert.equal(searchTail.next_cursor, null);
     // notes_search: max_files caps the page, not the matched files.
     for (let index = 0; index < 7; index++)
-        await call(captured, "notes_write", { path: `needle-${index}.md`, content: "needle" }, ctx);
+        await call(captured, "notes_write", { address: `needle-${index}.md`, content: "needle" }, ctx);
     const notes = async (params) => resultJson(await call(captured, "notes_search", params, ctx));
     const notesFirst = await notes({ query: "needle", max_files: 3 });
     assert.equal(notesFirst.files.length, 3);
@@ -200,18 +198,18 @@ test("multi-query search: OR semantics, dedupe, and bare-string backward compati
     assert.deepEqual(await historyIds({ query: ["alpha"] }), [bothId, alphaId], "history: a one-element array searches that literal");
     assert.deepEqual(await historyIds({ query: "alpha" }), orIds.filter((id) => id !== betaId), "history: a bare string still behaves exactly as before");
     assert.deepEqual(await historyIds({ query: "alpha" }), await historyIds({ query: ["alpha"] }), "history: bare string equals the single-element list");
-    await call(captured, "notes_write", { path: "both.md", content: "alpha beta\nunrelated" }, ctx);
-    await call(captured, "notes_write", { path: "alpha.md", content: "alpha only" }, ctx);
-    await call(captured, "notes_write", { path: "beta.md", content: "beta only" }, ctx);
-    await call(captured, "notes_write", { path: "gamma.md", content: "gamma only" }, ctx);
+    await call(captured, "notes_write", { address: "both.md", content: "alpha beta\nunrelated" }, ctx);
+    await call(captured, "notes_write", { address: "alpha.md", content: "alpha only" }, ctx);
+    await call(captured, "notes_write", { address: "beta.md", content: "beta only" }, ctx);
+    await call(captured, "notes_write", { address: "gamma.md", content: "gamma only" }, ctx);
     const notesSearch = async (params) => resultJson(await call(captured, "notes_search", params, ctx)).files;
     const orFiles = await notesSearch({ query: ["alpha", "beta"] });
-    assert.deepEqual(orFiles.map((file) => file.path), ["alpha.md", "beta.md", "both.md"], "notes: a file matching any query is returned once, path-ordered");
-    assert.equal(orFiles.find((file) => file.path === "both.md")?.matches.length, 1, "notes: one line containing both queries is reported once");
-    assert.deepEqual((await notesSearch({ query: ["alpha"] })).map((file) => file.path), ["alpha.md", "both.md"], "notes: a one-element array searches that literal");
-    assert.deepEqual((await notesSearch({ query: "alpha" })).map((file) => file.path), ["alpha.md", "both.md"], "notes: a bare string still behaves exactly as before");
-    assert.deepEqual((await notesSearch({ query: "alpha" })).map((file) => file.path), (await notesSearch({ query: ["alpha"] })).map((file) => file.path), "notes: bare string equals the single-element list");
-    assert.deepEqual((await notesSearch({ query: ["gamma"] })).map((file) => file.path), ["gamma.md"]);
+    assert.deepEqual(orFiles.map((file) => file.address), ["alpha.md", "beta.md", "both.md"], "notes: a file matching any query is returned once, address-ordered");
+    assert.equal(orFiles.find((file) => file.address === "both.md")?.matches.length, 1, "notes: one line containing both queries is reported once");
+    assert.deepEqual((await notesSearch({ query: ["alpha"] })).map((file) => file.address), ["alpha.md", "both.md"], "notes: a one-element array searches that literal");
+    assert.deepEqual((await notesSearch({ query: "alpha" })).map((file) => file.address), ["alpha.md", "both.md"], "notes: a bare string still behaves exactly as before");
+    assert.deepEqual((await notesSearch({ query: "alpha" })).map((file) => file.address), (await notesSearch({ query: ["alpha"] })).map((file) => file.address), "notes: bare string equals the single-element list");
+    assert.deepEqual((await notesSearch({ query: ["gamma"] })).map((file) => file.address), ["gamma.md"]);
     // An empty array is an argument error, not a silently empty result set.
     await assert.rejects(() => call(captured, "history_search", { query: [] }, ctx), /non-empty array of strings/, "history: empty query array is refused");
     await assert.rejects(() => call(captured, "notes_search", { query: [] }, ctx), /non-empty array of strings/, "notes: empty query array is refused");

package/dist/test/notes-library.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/notes-library.test.js

@@ -0,0 +1,128 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { createNotesStore, NoteError } from "../src/notes/index.js";
+function fixture(t) {
+    const home = mkdtempSync(join(tmpdir(), "notes-library-"));
+    t.after(() => rmSync(home, { recursive: true, force: true }));
+    const context = { home, sessionId: "session-a", projectKey: "project-12345678", agent: "root", model: "test-model" };
+    return { home, context, notes: createNotesStore(context) };
+}
+test("standalone notes API persists camelCase metadata, edits, lists and searches full results", async (t) => {
+    const { home, notes } = fixture(t);
+    const first = await notes.write("checkpoint", "alpha\nneedle 😀", { origin: "user" });
+    assert.equal(first.meta.project, "project-12345678");
+    const read = (await notes.read("checkpoint.md"));
+    assert.equal(read.body, "alpha\nneedle 😀");
+    assert.equal(read.meta.origin, "user");
+    assert.equal(read.meta.accessCount, 1);
+    assert.equal(await notes.read("missing.md"), undefined);
+    const edited = await notes.edit("checkpoint", [{ oldText: "alpha", newText: "beta" }]);
+    assert.deepEqual(edited.change, { kind: "body", before: "alpha\nneedle 😀", after: "beta\nneedle 😀" });
+    assert.equal(edited.resolvedScope, read.resolvedScope);
+    assert.equal(edited.applied, 1);
+    const metadataEdit = await notes.edit("checkpoint", undefined, { stale: true });
+    assert.equal(metadataEdit.change.kind, "metadata");
+    assert.match(metadataEdit.change.before, /\nstale: false\n/);
+    assert.match(metadataEdit.change.after, /\nstale: true\n/);
+    assert.equal(metadataEdit.change.after.includes("needle"), false, "metadata-only diff excludes body");
+    assert.equal((await notes.list())[0]?.meta.stale, true);
+    const matches = await notes.search(["needle"]);
+    assert.equal(matches[0]?.matches[0]?.line, 2);
+    const text = (await notes.read("checkpoint")).text;
+    assert.equal(Array.from(text).slice(matches[0].matches[0].offsetChars).join(""), "needle 😀");
+    // An existing hand-written extra field and original ownership survive a new caller.
+    const path = join(home, "pi/session/session-a/checkpoint.md");
+    writeFileSync(path, readFileSync(path, "utf8").replace("\n---\n\n", "\nsourceWindow: pcw:test\nrecurrenceCount: 2\nrecurrenceWindows:\n  - pcw:one\n  - pcw:two\n__proto__: {\"sentinel\":true}\ncustom: preserved\n---\n\n"));
+    const moved = createNotesStore({ home, sessionId: "session-a", projectKey: "other-12345678", agent: "root", model: "test-model" });
+    const rewritten = await moved.write("checkpoint", "new body");
+    assert.equal(rewritten.meta.createdAt, first.meta.createdAt);
+    assert.equal(rewritten.meta.project, "project-12345678");
+    assert.equal(rewritten.meta.custom, "preserved");
+    assert.deepEqual(rewritten.meta["__proto__"], { sentinel: true });
+    assert.deepEqual((await moved.read("checkpoint"))?.meta["__proto__"], { sentinel: true }, "unknown __proto__ metadata survives persistence and reread");
+    assert.equal(rewritten.meta.sourceWindow, "pcw:test");
+    assert.equal(rewritten.meta.recurrenceCount, 2);
+    assert.deepEqual(rewritten.meta.recurrenceWindows, ["pcw:one", "pcw:two"]);
+    assert.equal(rewritten.meta.stale, false);
+    const combined = await moved.edit("checkpoint", [{ oldText: "new", newText: "final" }], { stale: true });
+    assert.equal(combined.change.kind, "file");
+    assert.match(combined.change.after, /\nstale: true\n/);
+    assert.match(combined.change.after, /final body$/);
+    assert.deepEqual((await moved.edit("checkpoint", undefined, { stale: true })).change, { kind: "none", before: "", after: "" });
+});
+test("same-file read/modify/write operations serialize across stores and markdown aliases", async (t) => {
+    const { home, context, notes } = fixture(t);
+    const other = createNotesStore(context);
+    await notes.write("shared", "alpha\nbeta");
+    const firstEdit = notes.edit("shared", [{ oldText: "alpha", newText: "A" }]);
+    const secondEdit = other.edit("shared.md", [{ oldText: "beta", newText: "B" }]);
+    await Promise.all([firstEdit, secondEdit]);
+    assert.equal((await notes.read("shared"))?.body, "A\nB", "edits through address aliases retain both changes");
+    const before = (await notes.read("shared")).meta.accessCount;
+    const [readA, readB] = await Promise.all([notes.read("shared.md"), other.read("shared")]);
+    assert.ok(readA && readB);
+    assert.equal((await notes.list({ scope: "session" }))[0]?.meta.accessCount, before + 2, "parallel reads do not lose access-counter updates");
+    const file = join(home, "pi/session/session-a/shared.md");
+    const stableEdits = [{ oldText: "A", newText: "first" }];
+    const operation = notes.edit("shared", stableEdits);
+    stableEdits[0].newText = "mutated after call";
+    await operation;
+    assert.equal((await notes.read("shared"))?.body, "first\nB", "edit arguments are snapshotted at method entry");
+    assert.equal(readFileSync(file, "utf8").includes("mutated after call"), false);
+});
+test("stores snapshot explicit identity and do not leak homes across instances", async (t) => {
+    const { home, context } = fixture(t);
+    const mutable = { ...context };
+    const notes = createNotesStore(mutable);
+    const other = createNotesStore({ ...context, home: join(home, "other"), agent: "other-agent", model: "other-model" });
+    assert.equal(existsSync(join(home, "other")), false, "construction does not create the supplied home");
+    mutable.agent = "changed-after-construction";
+    await notes.write("@self/private", "first");
+    await other.write("@self/private", "second");
+    assert.equal((await notes.read("@self/private"))?.body, "first");
+    assert.equal((await other.read("@self/private"))?.body, "second");
+    assert.equal((await notes.list())[0]?.address, "@agents/root/private.md");
+    assert.equal((await other.list())[0]?.address, "@agents/other-agent/private.md");
+    mkdirSync(join(home, "agents/visitor"), { recursive: true });
+    writeFileSync(join(home, "agents/visitor/hello.md"), "visiting");
+    assert.equal((await notes.read("@agents/visitor/hello"))?.body, "visiting");
+    await assert.rejects(() => notes.write("@agents/visitor/hello", "overwrite"), (error) => error instanceof NoteError && error.code === "invalid_scope");
+});
+test("list and search share scoped pattern scans and search offsets count Unicode code points", async (t) => {
+    const { notes } = fixture(t);
+    await notes.write("shared.md", "😀 needle in session");
+    await notes.write("@project/shared.md", "needle in project");
+    await notes.write("@human/shared.md", "needle in human");
+    await notes.write("@project/elsewhere.md", "unrelated");
+    const pattern = "**/shared.md";
+    const listed = await notes.list({ pattern });
+    const searched = await notes.search(["needle"], { pattern });
+    const listedAddresses = listed.map((row) => row.address).sort();
+    const searchedAddresses = searched.map((row) => row.address).sort();
+    assert.deepEqual(searchedAddresses, ["@human/shared.md", "@project/shared.md", "shared.md"]);
+    assert.deepEqual(searchedAddresses, listedAddresses, "list and search traverse the same filtered homes and files");
+    const sessionMatch = searched.find((row) => row.address === "shared.md").matches[0];
+    const serialized = (await notes.read("shared.md")).text;
+    assert.ok(Array.from(serialized).slice(sessionMatch.offsetChars).join("").startsWith("needle"), "the absolute offset counts the emoji as one code point");
+});
+test("invalid addressing and failed edits leave stored bytes untouched without poisoning the queue", async (t) => {
+    const { home, context, notes } = fixture(t);
+    assert.throws(() => createNotesStore({ ...context, sessionId: "../escape" }));
+    await assert.rejects(() => notes.write("@project/../escape", "bad"));
+    await assert.rejects(() => notes.list({ scope: "agent", who: "../escape" }));
+    // The typed API disallows this; JavaScript callers must still receive a refusal.
+    // @ts-expect-error who cannot accompany project scope
+    await assert.rejects(() => notes.list({ scope: "project", who: "root" }), (error) => error instanceof NoteError && error.code === "invalid_scope");
+    await notes.write("edit", "alpha\nbeta\nbeta");
+    const path = join(home, "pi/session/session-a/edit.md");
+    const before = readFileSync(path, "utf8");
+    await assert.rejects(() => notes.edit("edit", [{ oldText: "beta", newText: "B" }]), (error) => error instanceof NoteError && error.code === "ambiguous_edit" && error.lineNumbers?.join(",") === "2,3");
+    await assert.rejects(() => notes.edit("edit", [{ oldText: "alpha", newText: "A" }, { oldText: "absent", newText: "X" }]), (error) => error instanceof NoteError && error.code === "no_match" && error.editIndex === 1);
+    assert.equal(readFileSync(path, "utf8"), before);
+    await assert.rejects(() => notes.edit("absent", undefined, { stale: true }), (error) => error instanceof NoteError && error.code === "not_found");
+    await notes.edit("edit", [{ oldText: "alpha", newText: "A" }]);
+    assert.equal((await notes.read("edit"))?.body, "A\nbeta\nbeta", "failed operations do not poison later queue work");
+});

package/dist/test/notes.integration.test.d.ts

@@ -0,0 +1 @@
+export {};