@astrosheep/pi-context 0.25.1 → 0.26.0

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

@@ -0,0 +1,111 @@
+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("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 {};

package/dist/test/notes.integration.test.js

@@ -2,11 +2,10 @@ import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import test from "node:test";
-import { loadNotesSnapshot as loadNotesSnapshot } from "../src/notes/notes-snapshot.js";
+import { loadNotesSnapshot } from "../src/pi/notes/snapshot.js";
 import { renderBootBlock } from "../src/context/prompts.js";
 import { localIso } from "../src/notes/frontmatter.js";
-import { physicalPath, scopeDir } from "../src/notes/paths.js";
-import { listNotes } from "../src/notes/store.js";
+import { listNotes, physicalPath, scopeDir } from "./helpers/notes.js";
 import { TOOL_OUTPUT_MAX_BYTES } from "../src/tool-output.js";
 import { assertWithinBudget, call, context, explicitBoot, installExtensionTestEnvironment, makeExtension, manager, resultJson, resultRead, } from "./helpers/extension.js";
 const testEnvironment = installExtensionTestEnvironment("pi-context-integration");
@@ -20,7 +19,7 @@ test("notes_list is most-recently-updated first across merged scopes", async ()
     const put = (scope, path, updated) => {
         const file = physicalPath(scope, path, ctx);
         mkdirSync(dirname(file), { recursive: true });
-        writeFileSync(file, `---\nscope: ${scope}\norigin: self\nstatus: active\nstale: false\ncreated_at: ${localIso(updated - 1000)}\nupdated_at: ${localIso(updated)}\nlast_accessed: ${localIso(updated)}\naccess_count: 0\n---\n\nbody`);
+        writeFileSync(file, `---\nscope: ${scope}\norigin: self\nstatus: active\nstale: false\ncreatedAt: ${localIso(updated - 1000)}\nupdatedAt: ${localIso(updated)}\nlastAccessed: ${localIso(updated)}\naccessCount: 0\n---\n\nbody`);
     };
     const base = 1_700_000_000_000;
     put("session", "b.md", base + 10);
@@ -56,7 +55,6 @@ test("notes are real files that persist across sessions and round-trip Unicode",
     // A single-segment * never crosses `/`, so a nested-only store matches nothing at the root.
     const rootOnly = resultJson(await call(restoredCaptured, "notes_list", { pattern: "*", scope: "human" }, restoredCtx));
     assert.equal(rootOnly.files.length, 0, "glob * stays within one segment");
-    assert.equal(searched.files[0]?.created_at, listedFiles.files[0]?.created_at, "note tools agree on the timestamp format");
     assert.equal(searched.files[0]?.updated_at, listedFiles.files[0]?.updated_at);
     await assert.rejects(() => call(captured, "notes_write", { path: "../escape", content: "x" }, ctx), /unsupported component/);
 });
@@ -68,29 +66,29 @@ test("stale lifecycle: writes and metadata-only edits close and revive a note",
     // metadata-only: content unchanged, flag set, applied 0
     const markOnly = resultJson(await call(captured, "notes_edit", { path: "journal.md", stale: true }, ctx));
     assert.equal(markOnly.applied, 0);
-    assert.equal(listNotes(ctx, { scope: "session" })[0]?.meta.stale, true);
+    assert.equal((await listNotes(ctx, { scope: "session" }))[0]?.meta.stale, true);
     assert.equal(resultRead(await call(captured, "notes_read", { path: "journal.md" }, ctx)).content.endsWith("log line"), true, "mark-only leaves content unchanged");
     // explicit revive
     const revived = resultJson(await call(captured, "notes_edit", { path: "journal.md", stale: false }, ctx));
-    assert.equal(listNotes(ctx, { scope: "session" })[0]?.meta.stale, false, "stale:false revives");
+    assert.equal((await listNotes(ctx, { scope: "session" }))[0]?.meta.stale, false, "stale:false revives");
     // write+stale closure then plain write revival
     await call(captured, "notes_write", { path: "journal.md", content: "final", stale: true }, ctx);
-    assert.equal(listNotes(ctx, { scope: "session" })[0]?.meta.stale, true);
+    assert.equal((await listNotes(ctx, { scope: "session" }))[0]?.meta.stale, true);
     await call(captured, "notes_write", { path: "journal.md", content: "reopened" }, ctx);
-    assert.equal(listNotes(ctx, { scope: "session" })[0]?.meta.stale, false, "writing without stale revives");
+    assert.equal((await listNotes(ctx, { scope: "session" }))[0]?.meta.stale, false, "writing without stale revives");
     // metadata-only on a missing path is the typed not-found arm
     const missing = resultJson(await call(captured, "notes_edit", { path: "missing.md", stale: true }, ctx));
     assert.equal(missing.error, "note not found");
 });
-test("the filesystem notes loader treats an absent home as empty but surfaces a real directory read failure", () => {
+test("the filesystem notes loader treats an absent home as empty but surfaces a real directory read failure", async () => {
     const sm = manager();
     const ctx = context(sm);
-    assert.deepEqual(listNotes(ctx, { scope: "human" }), [], "a home that has not been created is empty");
+    assert.deepEqual(await listNotes(ctx, { scope: "human" }), [], "a home that has not been created is empty");
     const blockedHome = scopeDir("human", ctx);
     writeFileSync(blockedHome, "not a directory");
-    assert.throws(() => listNotes(ctx, { scope: "human" }), (error) => error.code === "ENOTDIR", "a non-ENOENT directory failure is not swallowed as an empty home");
+    await assert.rejects(() => listNotes(ctx, { scope: "human" }), (error) => error.code === "ENOTDIR", "a non-ENOENT directory failure is not swallowed as an empty home");
 });
-test("boot note acquisition is one closed snapshot and isolates one or all failed homes", () => {
+test("boot note acquisition is one closed snapshot and isolates one or all failed homes", async () => {
     const sm = manager();
     const ctx = context(sm);
     const updated = Date.now();
@@ -105,10 +103,10 @@ test("boot note acquisition is one closed snapshot and isolates one or all faile
             origin: "self",
             status: "active",
             stale: false,
-            created_at: updated,
-            updated_at: updated,
-            last_accessed: updated,
-            access_count: 0,
+            createdAt: updated,
+            updatedAt: updated,
+            lastAccessed: updated,
+            accessCount: 0,
         },
     });
     const rows = new Map([
@@ -119,7 +117,7 @@ test("boot note acquisition is one closed snapshot and isolates one or all faile
         ["model", [note("model", "model.md", "@models/default/model.md", "MODEL_POCKET_BODY")]],
     ]);
     const calls = new Map();
-    const snapshot = loadNotesSnapshot(ctx, (_ctx, scope) => {
+    const snapshot = await loadNotesSnapshot(ctx, (_ctx, scope) => {
         calls.set(scope, (calls.get(scope) ?? 0) + 1);
         return rows.get(scope) ?? [];
     });
@@ -138,7 +136,7 @@ test("boot note acquisition is one closed snapshot and isolates one or all faile
     assert.ok(rendered.includes("session.md") && rendered.includes("@human/human.md"), "pocket rows come from the same snapshot");
     assert.equal(rendered.includes("SESSION_POCKET_BODY"), false, "pocket bodies stay excluded");
     const readFailure = (code) => Object.assign(new Error("scripted read failure"), { code });
-    const oneFailed = loadNotesSnapshot(ctx, (_ctx, scope) => {
+    const oneFailed = await loadNotesSnapshot(ctx, (_ctx, scope) => {
         if (scope === "human")
             throw readFailure("EIO");
         return rows.get(scope) ?? [];
@@ -153,7 +151,7 @@ test("boot note acquisition is one closed snapshot and isolates one or all faile
     });
     assert.ok(oneFailedText.includes("PROJECT_MAP_BODY") && oneFailedText.includes("notes_list can retry after recovery"), "healthy homes and the recovery notice survive one failure");
     assert.equal(oneFailedText.includes("HUMAN_POCKET_BODY"), false, "the failed home's index is omitted");
-    const allFailed = loadNotesSnapshot(ctx, (_ctx, scope) => {
+    const allFailed = await loadNotesSnapshot(ctx, (_ctx, scope) => {
         throw readFailure(scope === "session" ? "EACCES" : "EIO");
     });
     assert.equal(allFailed.unavailable.length, 5);
@@ -168,12 +166,12 @@ test("boot note acquisition is one closed snapshot and isolates one or all faile
     assert.ok(allFailedText.includes("pcw:test:root") && allFailedText.includes("pcw:test:next"), "identity survives an all-home failure");
     assert.ok(allFailedText.includes("Your memory resets whenever the context window fills"), "protocol survives an all-home failure");
     assert.equal(allFailedText.includes("scripted read failure"), false, "the model-facing notice does not expose OS/error details");
-    assert.throws(() => loadNotesSnapshot(ctx, () => { throw new TypeError("programmer failure"); }), (error) => error instanceof TypeError, "unrelated TypeError construction failures remain visible");
-    assert.throws(() => loadNotesSnapshot(ctx, () => { throw Object.assign(new Error("invalid argument"), { code: "ERR_INVALID_ARG_TYPE" }); }), (error) => error.code === "ERR_INVALID_ARG_TYPE", "Node ERR_* failures are not treated as filesystem errno failures");
+    await assert.rejects(() => loadNotesSnapshot(ctx, () => { throw new TypeError("programmer failure"); }), (error) => error instanceof TypeError, "unrelated TypeError construction failures remain visible");
+    await assert.rejects(() => loadNotesSnapshot(ctx, () => { throw Object.assign(new Error("invalid argument"), { code: "ERR_INVALID_ARG_TYPE" }); }), (error) => error.code === "ERR_INVALID_ARG_TYPE", "Node ERR_* failures are not treated as filesystem errno failures");
 });
-test("the boot block gives awake agents the notes-home file layout", () => {
+test("the boot block gives awake agents the notes-home file layout", async () => {
     const session = manager();
-    const rendered = explicitBoot(context(session), "pcw:test:root", undefined);
+    const rendered = await explicitBoot(context(session), "pcw:test:root", undefined);
     assert.equal(rendered.includes(process.env.PI_NOTES_HOME ?? ""), false, "the absolute notes home is never exposed");
     assert.match(rendered, /bare <vpath>.*@project\/<vpath>.*@human\/<vpath>/);
 });

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

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

package/dist/test/notes.test.js

@@ -7,11 +7,14 @@
  * HERMETIC: every test points PI_NOTES_HOME at its own temp root; no real ~/.agents is touched.
  */
 import assert from "node:assert/strict";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
-import { physicalPath } from "../src/notes/paths.js";
-import { call, context, installExtensionTestEnvironment, makeExtension, manager, resultJson, resultRead } from "./helpers/extension.js";
+import { parseNote } from "../src/notes/frontmatter.js";
+import { projectKey } from "../src/notes/paths.js";
+import { listNotes, physicalPath, scopeDir } from "./helpers/notes.js";
+import { call, context, explicitBoot, installExtensionTestEnvironment, makeExtension, manager, resultJson, resultRead } from "./helpers/extension.js";
 const testEnvironment = installExtensionTestEnvironment("pi-context-notes");
 test.beforeEach(() => testEnvironment.beforeEach());
 test.afterEach(() => testEnvironment.afterEach());
@@ -22,7 +25,7 @@ function freshRoot() {
 function setUpdatedAt(scope, path, ctx, timestamp) {
     const file = physicalPath(scope, path, ctx);
     const raw = readFileSync(file, "utf8");
-    writeFileSync(file, raw.replace(/^updated_at: .*$/m, `updated_at: ${new Date(timestamp).toISOString()}`));
+    writeFileSync(file, raw.replace(/^updatedAt: .*$/m, `updatedAt: ${new Date(timestamp).toISOString()}`));
 }
 function assertNoPublicScope(value, label) {
     if (Array.isArray(value)) {
@@ -64,21 +67,126 @@ test("write lands a real markdown file with harness frontmatter and a pure body"
     const raw = readFileSync(file, "utf8");
     assert.match(raw, /^---\n/, "the file opens with frontmatter");
     assert.match(raw, /\n---\n\nhello$/, "frontmatter is followed by a blank line and the exact body");
-    for (const [key, value] of [["origin", "self"], ["status", "active"], ["stale", "false"], ["access_count", "0"]]) {
+    for (const [key, value] of [["origin", "self"], ["status", "active"], ["stale", "false"], ["accessCount", "0"]]) {
         assert.match(raw, new RegExp(`^${key}: ${value}$`, "m"), `frontmatter carries ${key}=${value}`);
     }
     assert.equal(/^scope:/m.test(raw), false, "scope is derived from the file home, never persisted");
-    for (const key of ["created_at", "updated_at", "last_accessed"]) {
+    for (const key of ["createdAt", "updatedAt", "lastAccessed"]) {
         assert.match(raw, new RegExp(`^${key}: \\d{4}-\\d{2}-\\d{2}T`, "m"), `frontmatter renders ${key} via localIso`);
     }
+    assert.equal(parseNote(raw).meta.project, projectKey(ctx.cwd), "a newly-created session note records its existing project key");
     assert.equal(result.address, "a/b.md");
     assert.equal(result.written, true);
+    assert.equal(existsSync(join(scopeDir("session", ctx), ".session.json")), false, "ownership is stored in note frontmatter, not a sidecar");
     // A leading YAML block in user content is stripped from the body.
     await call(captured, "notes_write", { path: "stripped.md", content: "---\nscope: human\nnonsense: true\n---\nreal body" }, ctx);
     const stripped = readFileSync(physicalPath("session", "stripped.md", ctx), "utf8");
     assert.match(stripped, /\n---\n\nreal body$/, "the injected block is not part of the body");
     assert.equal(stripped.includes("nonsense"), false, "the injected block never reaches the file");
 });
+test("session-note project ownership is per note, persistent across sessions, and not reassigned by cwd", async () => {
+    freshRoot();
+    const cwdA = join(testEnvironment.cwd, "project-a");
+    const cwdB = join(testEnvironment.cwd, "project-b");
+    mkdirSync(cwdA, { recursive: true });
+    mkdirSync(cwdB, { recursive: true });
+    const projectA = projectKey(cwdA);
+    const projectB = projectKey(cwdB);
+    assert.notEqual(projectA, projectB);
+    const firstSession = manager();
+    const firstCaptured = makeExtension(firstSession);
+    const firstCtx = context(firstSession, undefined, undefined, true, cwdA);
+    await call(firstCaptured, "notes_write", { path: "first.md", content: "first project session" }, firstCtx);
+    const firstFile = physicalPath("session", "first.md", firstCtx);
+    assert.equal(parseNote(readFileSync(firstFile, "utf8")).meta.project, projectA);
+    const secondSession = manager();
+    const secondCaptured = makeExtension(secondSession);
+    const secondCtx = context(secondSession, undefined, undefined, true, cwdA);
+    await call(secondCaptured, "notes_write", { path: "second.md", content: "same project, another session" }, secondCtx);
+    const secondFile = physicalPath("session", "second.md", secondCtx);
+    assert.equal(parseNote(readFileSync(secondFile, "utf8")).meta.project, projectA, "another session in the same project carries the matching key");
+    const thirdSession = manager();
+    const thirdCaptured = makeExtension(thirdSession);
+    const thirdCtx = context(thirdSession, undefined, undefined, true, cwdB);
+    await call(thirdCaptured, "notes_write", { path: "third.md", content: "different project" }, thirdCtx);
+    const thirdFile = physicalPath("session", "third.md", thirdCtx);
+    assert.equal(parseNote(readFileSync(thirdFile, "utf8")).meta.project, projectB);
+    const projectASessions = [firstFile, secondFile, thirdFile].filter((file) => parseNote(readFileSync(file, "utf8")).meta.project === projectA);
+    assert.deepEqual(projectASessions.sort(), [firstFile, secondFile].sort(), "exact frontmatter project matching recognizes only sessions from the same project");
+    const movedContext = context(firstSession, undefined, undefined, true, cwdB);
+    await call(firstCaptured, "notes_write", { path: "first.md", content: "overwritten from another cwd" }, movedContext);
+    assert.equal(parseNote(readFileSync(firstFile, "utf8")).meta.project, projectA, "overwriting an existing note does not silently reassign it");
+    await call(firstCaptured, "notes_edit", { path: "first.md", edits: [{ oldText: "overwritten", newText: "edited" }] }, movedContext);
+    assert.equal(parseNote(readFileSync(firstFile, "utf8")).meta.project, projectA, "editing an existing note preserves its original project key");
+    await call(firstCaptured, "notes_read", { path: "first.md" }, movedContext);
+    assert.equal(parseNote(readFileSync(firstFile, "utf8")).meta.project, projectA, "reading preserves existing project ownership");
+    await call(firstCaptured, "notes_write", { path: "new-from-project-b.md", content: "new note", scope: "session" }, movedContext);
+    assert.equal(parseNote(readFileSync(physicalPath("session", "new-from-project-b.md", movedContext), "utf8")).meta.project, projectB, "only a newly-created session note uses the current project key");
+    await call(firstCaptured, "notes_write", { path: "project-note.md", content: "project home note", scope: "project" }, movedContext);
+    assert.equal(parseNote(readFileSync(physicalPath("project", "project-note.md", movedContext), "utf8")).meta.project, undefined, "project-home notes do not receive session ownership metadata");
+    assert.equal((await listNotes(movedContext, { scope: "session" })).length, 2, "project ownership remains frontmatter, not a separate note");
+});
+test("linked git worktrees share the main checkout's project key", () => {
+    freshRoot();
+    // realpath keeps the fixture's gitdir pointer and the asserted paths on one spelling
+    // (macOS temp roots live under the /var -> /private/var symlink).
+    const root = realpathSync(testEnvironment.cwd);
+    const main = join(root, "repo");
+    mkdirSync(main, { recursive: true });
+    const git = (args) => {
+        execFileSync("git", ["-c", "user.email=test@test", "-c", "user.name=test", ...args], { cwd: main, stdio: "ignore" });
+    };
+    git(["init", "-q"]);
+    git(["commit", "-q", "--allow-empty", "-m", "init"]);
+    const worktree = join(root, "wt");
+    git(["worktree", "add", "-q", "--detach", worktree]);
+    assert.equal(projectKey(worktree), projectKey(main), "a linked worktree resolves to the main checkout's key");
+    assert.equal(projectKey(join(worktree, "gone", "deeper")), projectKey(main), "a nonexistent subdirectory still resolves through its worktree");
+    assert.equal(scopeDir("project", context(manager(), undefined, undefined, true, worktree)), scopeDir("project", context(manager(), undefined, undefined, true, main)), "@project uses the same physical home from both checkouts");
+});
+test("legacy metadata is refused for explicit manual migration; invalid project ownership stays unknown", async () => {
+    freshRoot();
+    const session = manager();
+    const captured = makeExtension(session);
+    const ctx = context(session);
+    const legacyFile = physicalPath("session", "legacy.md", ctx);
+    mkdirSync(scopeDir("session", ctx), { recursive: true });
+    writeFileSync(legacyFile, `---
+origin: self
+status: active
+stale: false
+created_at: 2026-01-01T00:00:00.000+00:00
+updated_at: 2026-01-01T00:00:00.000+00:00
+last_accessed: 2026-01-01T00:00:00.000+00:00
+access_count: 0
+---
+
+legacy body`);
+    assert.throws(() => parseNote(readFileSync(legacyFile, "utf8")), /legacy note metadata .*requires manual migration/);
+    const legacyBytes = readFileSync(legacyFile, "utf8");
+    await assert.rejects(() => listNotes(ctx, { scope: "session" }), /requires manual migration/);
+    await assert.rejects(() => call(captured, "notes_read", { path: "legacy.md" }, ctx), /requires manual migration/);
+    await assert.rejects(() => call(captured, "notes_write", { path: "legacy.md", content: "legacy overwritten" }, ctx), /requires manual migration/);
+    assert.equal(readFileSync(legacyFile, "utf8"), legacyBytes, "refusal preserves the unmigrated file byte-for-byte");
+    const invalidFile = physicalPath("session", "invalid.md", ctx);
+    writeFileSync(invalidFile, `---
+origin: self
+status: active
+stale: false
+createdAt: 2026-01-01T00:00:00.000+00:00
+updatedAt: 2026-01-01T00:00:00.000+00:00
+lastAccessed: 2026-01-01T00:00:00.000+00:00
+accessCount: 0
+project: 17
+---
+
+invalid owner`);
+    assert.equal(parseNote(readFileSync(invalidFile, "utf8")).meta.project, 17);
+    assert.notEqual(parseNote(readFileSync(invalidFile, "utf8")).meta.project, projectKey(ctx.cwd), "invalid ownership does not match the current project key");
+    await call(captured, "notes_write", { path: "invalid.md", content: "still invalid" }, ctx);
+    assert.equal(parseNote(readFileSync(invalidFile, "utf8")).meta.project, 17, "an invalid value remains unknown and is not replaced with cwd-derived ownership");
+    assert.equal(existsSync(join(scopeDir("session", ctx), ".session.json")), false, "new notes use no ownership sidecar");
+});
 test("edit is body-scoped with named failures and a replace_all escape hatch", async () => {
     freshRoot();
     const session = manager();
@@ -209,7 +317,29 @@ test("@ addresses select one home, reject illegal sigils, and never fall back",
     await assert.rejects(() => call(captured, "notes_write", { address: "bad@name.md", content: "no" }, ctx), /@project\/.*@human\/.*bare names are this session/);
     assert.equal(existsSync(join(root, "human", "bad@name.md")), false, "a bad sigil creates nothing anywhere");
 });
-const FRONTMATTER = (body) => `---\norigin: self\nstatus: active\nstale: false\ncreated_at: 2026-01-01T00:00:00.000+00:00\nupdated_at: 2026-01-01T00:00:00.000+00:00\nlast_accessed: 2026-01-01T00:00:00.000+00:00\naccess_count: 0\n---\n\n${body}`;
+test("Pi adapter resolves agent and switched model identity on each notes call and boot", async () => {
+    const root = freshRoot();
+    const session = manager();
+    const captured = makeExtension(session);
+    const ctx = context(session, undefined, undefined, true, testEnvironment.cwd, true, "provider/First.Model");
+    await withAgent("Test Agent", async () => {
+        await call(captured, "notes_write", { address: "@self/private.md", content: "agent note" }, ctx);
+        await call(captured, "notes_write", { address: "@model/private.md", content: "first model note" }, ctx);
+        ctx.model = context(session, undefined, undefined, true, testEnvironment.cwd, true, "other/Second.Model").model;
+        assert.equal(resultJson(await call(captured, "notes_read", { address: "@model/private.md" }, ctx)).error, "note not found", "switched model does not fall back to previous home");
+        await call(captured, "notes_write", { address: "@model/private.md", content: "second model note" }, ctx);
+        const listed = resultJson(await call(captured, "notes_list", {}, ctx));
+        assert.deepEqual(listed.files.map((row) => row.address).sort(), ["@agents/test-agent/private.md", "@models/second-model/private.md"]);
+        const boot = await explicitBoot(ctx, "test-window", undefined);
+        assert.ok(boot.includes("@models/second-model/private.md"));
+        assert.equal(boot.includes("@models/first-model/private.md"), false);
+        assert.match(resultRead(await call(captured, "notes_read", { address: "@models/first-model/private.md" }, ctx)).content, /first model note$/);
+        const refused = resultJson(await call(captured, "notes_edit", { address: "@models/first-model/private.md", stale: true }, ctx));
+        assert.match(refused.error, /not your home/);
+        assert.match(readFileSync(join(root, "models/first-model/private.md"), "utf8"), /first model note$/);
+    });
+});
+const FRONTMATTER = (body) => `---\norigin: self\nstatus: active\nstale: false\ncreatedAt: 2026-01-01T00:00:00.000+00:00\nupdatedAt: 2026-01-01T00:00:00.000+00:00\nlastAccessed: 2026-01-01T00:00:00.000+00:00\naccessCount: 0\n---\n\n${body}`;
 async function withAgent(name, run) {
     const previous = process.env.PI_NOTES_AGENT;
     if (name === undefined)

package/dist/test/reset-lifecycle.test.d.ts

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