@astrosheep/pi-context 0.25.2 → 0.26.1

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

@@ -2,17 +2,14 @@ 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");
-test.beforeEach(() => testEnvironment.beforeEach());
-test.afterEach(() => testEnvironment.afterEach());
-test.after(() => testEnvironment.dispose());
+import { assertWithinBudget, call, context, explicitBoot, makeExtension, manager, resultJson, resultRead, } from "./helpers/extension.js";
+import { installExtensionTestHooks } from "./helpers/extension-test-environment.js";
+const testEnvironment = installExtensionTestHooks("pi-context-integration");
 test("notes_list is most-recently-updated first across merged scopes", async () => {
     const session = manager();
     const captured = makeExtension(session);
@@ -20,7 +17,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);
@@ -38,59 +35,58 @@ test("notes are real files that persist across sessions and round-trip Unicode",
     const original = manager();
     const captured = makeExtension(original);
     const ctx = context(original);
-    await call(captured, "notes_write", { path: "checkpoint/进度.md", content: "第一行\nneedle Café", scope: "human" }, ctx);
+    await call(captured, "notes_write", { address: "@human/checkpoint/进度.md", content: "第一行\nneedle Café" }, ctx);
     // A brand-new session over the same physical root sees the human note: nothing is replayed
     // from session entries, the file itself is the durable artifact.
     const restored = manager();
     const restoredCaptured = makeExtension(restored);
     const restoredCtx = context(restored);
-    const rawRead = await call(restoredCaptured, "notes_read", { path: "checkpoint/进度.md", scope: "human", offset_chars: -4 }, restoredCtx);
+    const rawRead = await call(restoredCaptured, "notes_read", { address: "@human/checkpoint/进度.md", offset_chars: -4 }, restoredCtx);
     const read = resultRead(rawRead);
     assert.equal(read.details.address, "@human/checkpoint/进度.md");
     assert.equal(read.content, "Café", "a negative offset reads the body tail in one call");
-    const searched = resultJson(await call(restoredCaptured, "notes_search", { query: "Café", scope: "human" }, restoredCtx));
+    const searched = resultJson(await call(restoredCaptured, "notes_search", { pattern: "@human/**", query: "Café" }, restoredCtx));
     assert.equal(searched.files[0]?.matches[0]?.line, 2);
-    const listedFiles = resultJson(await call(restoredCaptured, "notes_list", { pattern: "checkpoint/**", scope: "human" }, restoredCtx));
+    const listedFiles = resultJson(await call(restoredCaptured, "notes_list", { pattern: "@human/checkpoint/**" }, restoredCtx));
     assert.equal(listedFiles.files.length, 1, "glob ** crosses into the checkpoint directory");
-    assert.equal(listedFiles.files[0]?.path, "checkpoint/进度.md");
+    assert.equal(listedFiles.files[0]?.address, "@human/checkpoint/进度.md");
     // 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));
+    const rootOnly = resultJson(await call(restoredCaptured, "notes_list", { pattern: "@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/);
+    await assert.rejects(() => call(captured, "notes_write", { address: "../escape", content: "x" }, ctx), /unsupported component/);
 });
 test("stale lifecycle: writes and metadata-only edits close and revive a note", async () => {
     const sm = manager();
     const captured = makeExtension(sm);
     const ctx = context(sm);
-    await call(captured, "notes_write", { path: "journal.md", content: "log line" }, ctx);
+    await call(captured, "notes_write", { address: "journal.md", content: "log line" }, ctx);
     // metadata-only: content unchanged, flag set, applied 0
-    const markOnly = resultJson(await call(captured, "notes_edit", { path: "journal.md", stale: true }, ctx));
+    const markOnly = resultJson(await call(captured, "notes_edit", { address: "journal.md", stale: true }, ctx));
     assert.equal(markOnly.applied, 0);
-    assert.equal(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");
+    assert.equal((await listNotes(ctx, { scope: "session" }))[0]?.meta.stale, true);
+    assert.equal(resultRead(await call(captured, "notes_read", { address: "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");
+    const revived = resultJson(await call(captured, "notes_edit", { address: "journal.md", stale: false }, ctx));
+    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);
-    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");
+    await call(captured, "notes_write", { address: "journal.md", content: "final", stale: true }, ctx);
+    assert.equal((await listNotes(ctx, { scope: "session" }))[0]?.meta.stale, true);
+    await call(captured, "notes_write", { address: "journal.md", content: "reopened" }, ctx);
+    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));
+    const missing = resultJson(await call(captured, "notes_edit", { address: "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 +101,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 +115,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 +134,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 +149,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 +164,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>/);
 });
@@ -183,8 +179,8 @@ test("an over-budget note is delivered as a prefix and resumed by next_offset_ch
     const ctx = context(session);
     const huge = `H${"x".repeat(TOOL_OUTPUT_MAX_BYTES * 2)}`;
     const text = `${huge}\ntail line`;
-    await call(captured, "notes_write", { path: "huge.md", content: text }, ctx);
-    const rawFirst = await call(captured, "notes_read", { path: "huge.md" }, ctx);
+    await call(captured, "notes_write", { address: "huge.md", content: text }, ctx);
+    const rawFirst = await call(captured, "notes_read", { address: "huge.md" }, ctx);
     assertWithinBudget(rawFirst, "single oversized note");
     const first = resultRead(rawFirst);
     assert.ok(first.content.length > 0, "the page is not empty");
@@ -198,7 +194,7 @@ test("an over-budget note is delivered as a prefix and resumed by next_offset_ch
     const parts = [first.content];
     let offset = first.next_offset_chars;
     while (offset !== null) {
-        const rawChunk = await call(captured, "notes_read", { path: "huge.md", offset_chars: offset }, ctx);
+        const rawChunk = await call(captured, "notes_read", { address: "huge.md", offset_chars: offset }, ctx);
         assertWithinBudget(rawChunk, `huge note chunk at ${offset}`);
         const chunk = resultRead(rawChunk);
         assert.equal(chunk.offset_chars, offset, "the response echoes the resolved absolute offset");
@@ -207,7 +203,7 @@ test("an over-budget note is delivered as a prefix and resumed by next_offset_ch
     }
     assert.ok(parts.join("").endsWith(text), "the cursors reconstruct the body exactly");
     // A success carries structured details; an error stays a JSON envelope with no details.
-    const missingResult = await call(captured, "notes_read", { path: "no-such.md" }, ctx);
+    const missingResult = await call(captured, "notes_read", { address: "no-such.md" }, ctx);
     const missing = resultJson(missingResult);
     assert.deepEqual(Object.keys(missing).sort(), ["address", "error"], "the read error carries exactly error and address");
     assert.equal(missing.error, "note not found");
@@ -219,8 +215,8 @@ test("an over-budget note search match is a named prefix with an honest line add
     const ctx = context(session);
     // The query sits behind a prefix, so its address is a real body-absolute offset, not line 1.
     const hugeLine = `${'p'.repeat(500)}needle ${"y".repeat(TOOL_OUTPUT_MAX_BYTES * 2)}`;
-    await call(captured, "notes_write", { path: "a.md", content: "needle small" }, ctx);
-    await call(captured, "notes_write", { path: "search.md", content: hugeLine }, ctx);
+    await call(captured, "notes_write", { address: "a.md", content: "needle small" }, ctx);
+    await call(captured, "notes_write", { address: "search.md", content: hugeLine }, ctx);
     const pages = [];
     let cursor = 0;
     let next = 0;
@@ -232,7 +228,7 @@ test("an over-budget note search match is a named prefix with an honest line add
         if (next !== null)
             cursor = next;
     }
-    assert.deepEqual(pages.map((file) => file.path), ["a.md", "search.md"], "pagination reaches the oversized file instead of looping");
+    assert.deepEqual(pages.map((file) => file.address), ["a.md", "search.md"], "pagination reaches the oversized file instead of looping");
     const oversized = pages[1];
     assert.equal(oversized.matches_total, 1, "the file's full match count is named even though the line was cut");
     assert.equal(oversized.matches.length, 1);
@@ -241,13 +237,13 @@ test("an over-budget note search match is a named prefix with an honest line add
     assert.ok(hugeLine.startsWith(match.text), "the match text is a plain prefix of the line");
     assert.equal(match.text.includes("…"), false, "no marker is appended to the match text");
     assert.equal(match.line, 1, "the informational line number survives");
-    const atMatch = resultRead(await call(captured, "notes_read", { path: "search.md", offset_chars: match.offset_chars }, ctx));
+    const atMatch = resultRead(await call(captured, "notes_read", { address: "search.md", offset_chars: match.offset_chars }, ctx));
     assert.ok(atMatch.content.startsWith("needle"), "the search offset starts a read at the matched substring");
     // The body is reconstructible by following notes_read's cursor from the start of the file.
     const parts = [];
     let offset = 0;
     while (offset !== null) {
-        const rawChunk = await call(captured, "notes_read", { path: "search.md", offset_chars: offset }, ctx);
+        const rawChunk = await call(captured, "notes_read", { address: "search.md", offset_chars: offset }, ctx);
         assertWithinBudget(rawChunk, `search.md chunk at ${offset}`);
         const chunk = resultRead(rawChunk);
         assert.equal(chunk.offset_chars, offset, "the read echoes the resolved address");
@@ -260,10 +256,10 @@ test("notes_search scopes by glob pattern; a non-matching pattern is an empty pa
     const session = manager();
     const captured = makeExtension(session);
     const ctx = context(session);
-    await call(captured, "notes_write", { path: "deep/nested/a.md", content: "needle here" }, ctx);
-    await call(captured, "notes_write", { path: "top.md", content: "needle there" }, ctx);
+    await call(captured, "notes_write", { address: "deep/nested/a.md", content: "needle here" }, ctx);
+    await call(captured, "notes_write", { address: "top.md", content: "needle there" }, ctx);
     const scoped = resultJson(await call(captured, "notes_search", { query: "needle", pattern: "deep/**" }, ctx));
-    assert.deepEqual(scoped.files.map((file) => file.path), ["deep/nested/a.md"], "a glob scopes the search to the subtree");
+    assert.deepEqual(scoped.files.map((file) => file.address), ["deep/nested/a.md"], "a glob scopes the search to the subtree");
     const none = resultJson(await call(captured, "notes_search", { query: "needle", pattern: "absent/**" }, ctx));
     assert.equal(none.error, undefined, "a non-matching pattern is not an error");
     assert.deepEqual(none.files, [], "a non-matching pattern is an empty page");

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

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

package/dist/test/notes.test.js

@@ -7,22 +7,23 @@
  * 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";
-const testEnvironment = installExtensionTestEnvironment("pi-context-notes");
-test.beforeEach(() => testEnvironment.beforeEach());
-test.afterEach(() => testEnvironment.afterEach());
-test.after(() => testEnvironment.dispose());
+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, makeExtension, manager, resultJson, resultRead } from "./helpers/extension.js";
+import { installExtensionTestHooks } from "./helpers/extension-test-environment.js";
+const testEnvironment = installExtensionTestHooks("pi-context-notes");
 function freshRoot() {
     return testEnvironment.newNotesRoot();
 }
 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)) {
@@ -56,7 +57,7 @@ test("write lands a real markdown file with harness frontmatter and a pure body"
     const captured = makeExtension(session);
     const ctx = context(session);
     const sessionId = session.getSessionId();
-    const result = resultJson(await call(captured, "notes_write", { path: "a/b.md", content: "hello" }, ctx));
+    const result = resultJson(await call(captured, "notes_write", { address: "a/b.md", content: "hello" }, ctx));
     assert.deepEqual(Object.keys(result).sort(), ["address", "written"]);
     const file = physicalPath("session", "a/b.md", ctx);
     assert.equal(file, join(root, "pi", "session", sessionId, "a", "b.md"));
@@ -64,39 +65,144 @@ 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);
+    await call(captured, "notes_write", { address: "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", { address: "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", { address: "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", { address: "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", { address: "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", { address: "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", { address: "first.md" }, movedContext);
+    assert.equal(parseNote(readFileSync(firstFile, "utf8")).meta.project, projectA, "reading preserves existing project ownership");
+    await call(firstCaptured, "notes_write", { address: "new-from-project-b.md", content: "new note" }, 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", { address: "@project/project-note.md", content: "project home note" }, 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", { address: "legacy.md" }, ctx), /requires manual migration/);
+    await assert.rejects(() => call(captured, "notes_write", { address: "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", { address: "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();
     const captured = makeExtension(session);
     const ctx = context(session);
-    await call(captured, "notes_write", { path: "edit.md", content: "alpha\nbeta\nbeta\ngamma" }, ctx);
-    const ambiguous = resultJson(await call(captured, "notes_edit", { path: "edit.md", edits: [{ oldText: "beta", newText: "B" }] }, ctx));
+    await call(captured, "notes_write", { address: "edit.md", content: "alpha\nbeta\nbeta\ngamma" }, ctx);
+    const ambiguous = resultJson(await call(captured, "notes_edit", { address: "edit.md", edits: [{ oldText: "beta", newText: "B" }] }, ctx));
     assert.match(ambiguous.error, /occurs 2 times/);
     assert.deepEqual(ambiguous.line_numbers, [2, 3], "the multi-match error carries every match line number");
-    const missing = resultJson(await call(captured, "notes_edit", { path: "edit.md", edits: [{ oldText: "absent", newText: "x" }] }, ctx));
+    const missing = resultJson(await call(captured, "notes_edit", { address: "edit.md", edits: [{ oldText: "absent", newText: "x" }] }, ctx));
     assert.equal(missing.edit_index, 0, "a zero-match anchor names the failing edit index");
-    const all = resultJson(await call(captured, "notes_edit", { path: "edit.md", edits: [{ oldText: "beta", newText: "B" }], replace_all: true }, ctx));
+    const all = resultJson(await call(captured, "notes_edit", { address: "edit.md", edits: [{ oldText: "beta", newText: "B" }], replace_all: true }, ctx));
     assert.equal(all.applied, 1);
     assert.equal(all.address, "edit.md");
     assertNoPublicScope(all, "notes_edit");
-    assert.equal(resultRead(await call(captured, "notes_read", { path: "edit.md" }, ctx)).content.endsWith("alpha\nB\nB\ngamma"), true, "replace_all replaces every occurrence");
+    assert.equal(resultRead(await call(captured, "notes_read", { address: "edit.md" }, ctx)).content.endsWith("alpha\nB\nB\ngamma"), true, "replace_all replaces every occurrence");
     // An anchor that occurs only in frontmatter is not matched: edits are body-only.
-    const frontmatterOnly = resultJson(await call(captured, "notes_edit", { path: "edit.md", edits: [{ oldText: "scope", newText: "x" }] }, ctx));
+    const frontmatterOnly = resultJson(await call(captured, "notes_edit", { address: "edit.md", edits: [{ oldText: "scope", newText: "x" }] }, ctx));
     assert.equal(frontmatterOnly.edit_index, 0, "a frontmatter-only anchor is not a body match");
 });
 test("nothing-to-do, not-found, atomic batches, and replace_all zero-match are named", async () => {
@@ -104,25 +210,25 @@ test("nothing-to-do, not-found, atomic batches, and replace_all zero-match are n
     const session = manager();
     const captured = makeExtension(session);
     const ctx = context(session);
-    const nameOnly = resultJson(await call(captured, "notes_edit", { path: "edit.md" }, ctx));
+    const nameOnly = resultJson(await call(captured, "notes_edit", { address: "edit.md" }, ctx));
     assert.match(nameOnly.error, /nothing to do/, "neither edits nor setters is a named error");
-    await call(captured, "notes_write", { path: "edit.md", content: "alpha\nbeta" }, ctx);
-    const empty = resultJson(await call(captured, "notes_edit", { path: "edit.md", edits: [] }, ctx));
+    await call(captured, "notes_write", { address: "edit.md", content: "alpha\nbeta" }, ctx);
+    const empty = resultJson(await call(captured, "notes_edit", { address: "edit.md", edits: [] }, ctx));
     assert.match(empty.error, /nothing to do/, "an empty edits list with no setters is also nothing to do");
-    const editMissing = resultJson(await call(captured, "notes_edit", { path: "missing.md", stale: true }, ctx));
+    const editMissing = resultJson(await call(captured, "notes_edit", { address: "missing.md", stale: true }, ctx));
     assert.equal(editMissing.error, "note not found");
-    const readMissing = resultJson(await call(captured, "notes_read", { path: "missing.md" }, ctx));
+    const readMissing = resultJson(await call(captured, "notes_read", { address: "missing.md" }, ctx));
     assert.equal(readMissing.error, "note not found");
-    assert.equal(readMissing.path, "missing.md");
+    assert.equal(readMissing.address, "missing.md");
     const file = physicalPath("session", "edit.md", ctx);
     const before = readFileSync(file, "utf8");
-    const failed = resultJson(await call(captured, "notes_edit", { path: "edit.md", edits: [{ oldText: "alpha", newText: "A" }, { oldText: "absent", newText: "x" }] }, ctx));
+    const failed = resultJson(await call(captured, "notes_edit", { address: "edit.md", edits: [{ oldText: "alpha", newText: "A" }, { oldText: "absent", newText: "x" }] }, ctx));
     assert.equal(failed.edit_index, 1, "the failing edit is named");
     assert.equal(readFileSync(file, "utf8"), before, "a failing batch leaves the file byte-identical, frontmatter included");
-    const applied = resultJson(await call(captured, "notes_edit", { path: "edit.md", edits: [{ oldText: "alpha", newText: "A" }, { oldText: "beta", newText: "B" }] }, ctx));
+    const applied = resultJson(await call(captured, "notes_edit", { address: "edit.md", edits: [{ oldText: "alpha", newText: "A" }, { oldText: "beta", newText: "B" }] }, ctx));
     assert.equal(applied.applied, 2);
-    assert.equal(resultRead(await call(captured, "notes_read", { path: "edit.md" }, ctx)).content.endsWith("A\nB"), true);
-    const zero = resultJson(await call(captured, "notes_edit", { path: "edit.md", edits: [{ oldText: "zzz", newText: "y" }], replace_all: true }, ctx));
+    assert.equal(resultRead(await call(captured, "notes_read", { address: "edit.md" }, ctx)).content.endsWith("A\nB"), true);
+    const zero = resultJson(await call(captured, "notes_edit", { address: "edit.md", edits: [{ oldText: "zzz", newText: "y" }], replace_all: true }, ctx));
     assert.equal(zero.edit_index, 0, "replace_all with zero matches is the same zero-match error, not a silent no-op");
 });
 test("all notes tool results use address as the only home identity", async () => {
@@ -162,16 +268,16 @@ test("list and search merge scopes and carry addresses; the path jail rejects es
     const session = manager();
     const captured = makeExtension(session);
     const ctx = context(session);
-    await call(captured, "notes_write", { path: "one.md", content: "needle one", scope: "session" }, ctx);
-    await call(captured, "notes_write", { path: "two.md", content: "needle two", scope: "project" }, ctx);
-    await call(captured, "notes_write", { path: "three.md", content: "needle three", scope: "human" }, ctx);
+    await call(captured, "notes_write", { address: "one.md", content: "needle one" }, ctx);
+    await call(captured, "notes_write", { address: "@project/two.md", content: "needle two" }, ctx);
+    await call(captured, "notes_write", { address: "@human/three.md", content: "needle three" }, ctx);
     const listed = resultJson(await call(captured, "notes_list", {}, ctx));
     assert.deepEqual([...listed.files].map((file) => file.address).sort(), ["@human/three.md", "@project/two.md", "one.md"], "every merged row carries its full address");
     for (const row of listed.files) {
         assert.deepEqual(Object.keys(row).sort(), ["address", "stale", "updated_at"]);
         assert.equal(row.stale, false);
     }
-    const scoped = resultJson(await call(captured, "notes_list", { scope: "human" }, ctx));
+    const scoped = resultJson(await call(captured, "notes_list", { pattern: "@human/**" }, ctx));
     assert.deepEqual(scoped.files.map((file) => file.address), ["@human/three.md"], "an address-pattern filter narrows the set");
     const searched = resultJson(await call(captured, "notes_search", { query: "needle" }, ctx));
     assert.equal(searched.files.length, 3, "literal search finds matches in every scope");
@@ -187,7 +293,7 @@ test("list and search merge scopes and carry addresses; the path jail rejects es
     const escaped = ["../evil", "/abs", "a\\b"];
     for (const tool of ["notes_write", "notes_edit", "notes_read"]) {
         for (const path of escaped) {
-            await assert.rejects(() => call(captured, tool, { path, content: "x", edits: [{ oldText: "a", newText: "b" }] }, ctx), `${tool} rejects ${path}`);
+            await assert.rejects(() => call(captured, tool, { address: path, content: "x", edits: [{ oldText: "a", newText: "b" }] }, ctx), `${tool} rejects ${path}`);
         }
     }
     await assert.rejects(() => call(captured, "notes_list", { pattern: "bad\\glob" }, ctx), /backslash/);
@@ -209,7 +315,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 {};