@astrosheep/pi-context 0.20.0 → 0.22.0

package/dist/test/integration.test.js

@@ -5,9 +5,10 @@ import { dirname, join } from "node:path";
 import test from "node:test";
 import { AgentSession, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import piContext, { historyFromSession, internal } from "../src/index.js";
-import { localIso } from "../src/notes.js";
-import { physicalPath } from "../src/memory/paths.js";
-import { listNotes } from "../src/memory/store.js";
+import { bootBlock } from "../src/prompts.js";
+import { localIso } from "../src/notes/model.js";
+import { physicalPath } from "../src/notes/paths.js";
+import { listNotes } from "../src/notes/store.js";
 import { middleTruncate, page, TOOL_OUTPUT_MAX_BYTES } from "../src/tool-output.js";
 // Settings fixtures live in temp directories. PI_CODING_AGENT_DIR is redirected for the
 // whole test process so the extension's SettingsManager.create(ctx.cwd, undefined, ...)
@@ -109,12 +110,41 @@ function noticesOf(ctx) {
 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 === "personal" ? `@personal/${path}` : path;
+        return tool.execute("call-1", { ...rest, address }, new AbortController().signal, () => { }, ctx);
+    }
+    if ((name === "notes_list" || name === "notes_search") && params.scope === "personal") {
+        const { scope: _scope, pattern, ...rest } = params;
+        return tool.execute("call-1", { ...rest, pattern: `@personal/${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");
-    return JSON.parse(text.text);
+    const value = JSON.parse(text.text);
+    const suffix = (address) => address.startsWith("@project/") ? address.slice("@project/".length) : address.startsWith("@personal/") ? address.slice("@personal/".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;
 }
 /** Assert the delivered wire text fits the tool-output budget, header included for raw reads. */
 export function assertWithinBudget(result, message) {
@@ -247,11 +277,13 @@ test("schemas cover the History/Notes actions plus reset controls", () => {
     // The write surface requires its body; the edit surface requires its anchors.
     const writeSchema = captured.tools.get("notes_write")?.parameters;
     assert.ok(writeSchema?.properties?.content, "notes_write exposes content");
-    assert.ok(writeSchema?.properties?.path, "notes_write exposes path");
-    assert.deepEqual([...(writeSchema?.required ?? [])].sort(), ["content", "path"], "notes_write requires path and content");
+    assert.ok(writeSchema?.properties?.address, "notes_write exposes address");
+    assert.equal(writeSchema?.properties?.scope, undefined, "notes_write has no scope parameter");
+    assert.deepEqual([...(writeSchema?.required ?? [])].sort(), ["address", "content"], "notes_write requires address and content");
     const editSchema = captured.tools.get("notes_edit")?.parameters;
     assert.ok(editSchema?.properties?.edits, "notes_edit exposes edits");
-    assert.deepEqual([...(editSchema?.required ?? [])].sort(), ["path"], "notes_edit requires only path; edits are optional for metadata-only updates");
+    assert.equal(editSchema?.properties?.scope, undefined, "notes_edit has no scope parameter");
+    assert.deepEqual([...(editSchema?.required ?? [])].sort(), ["address"], "notes_edit requires only address; edits are optional for metadata-only updates");
     // The history ordering switch is documented as newest-first by default.
     for (const name of ["history_windows", "history_list", "history_search"]) {
         const schema = captured.tools.get(name)?.parameters;
@@ -270,7 +302,12 @@ test("schemas cover the History/Notes actions plus reset controls", () => {
         assert.equal(schema?.properties?.limit_chars?.maximum, 50000, `${name} caps limit_chars at 50000`);
     }
     const noteReadSchema = captured.tools.get("notes_read")?.parameters;
-    assert.deepEqual(Object.keys(noteReadSchema?.properties ?? {}).sort(), ["limit_chars", "offset_chars", "path", "scope"], "notes_read exposes exactly the character-window params plus scope");
+    assert.deepEqual(Object.keys(noteReadSchema?.properties ?? {}).sort(), ["address", "limit_chars", "offset_chars"], "notes_read exposes exactly address and character-window params");
+    for (const name of ["notes_write", "notes_edit", "notes_read", "notes_list", "notes_search"]) {
+        const schema = captured.tools.get(name)?.parameters;
+        assert.equal(schema?.properties?.scope, undefined, `${name} has no scope property`);
+        assert.equal(schema?.additionalProperties, false, `${name} rejects scope as an additional property`);
+    }
     assert.equal(/start_|stop_line|total_lines/.test(captured.tools.get("notes_read")?.description ?? ""), false, "notes_read prose carries no line surface");
 });
 test("notes_list is most-recently-updated first across merged scopes", async () => {
@@ -286,36 +323,36 @@ test("notes_list is most-recently-updated first across merged scopes", async ()
     put("session", "b.md", base + 10);
     put("session", "a.md", base + 10);
     put("project", "c.md", base + 5);
-    put("global", "e.md", base + 20);
+    put("personal", "e.md", base + 20);
     const files = async (params) => resultJson(await call(captured, "notes_list", params, ctx)).files;
-    assert.deepEqual((await files({})).map((file) => file.path), ["e.md", "a.md", "b.md", "c.md"], "updated_at descending with path ascending as the tiebreak");
+    assert.deepEqual((await files({})).map((file) => file.address), ["@personal/e.md", "a.md", "b.md", "@project/c.md"], "updated_at descending with address ascending as the tiebreak");
     // A same-path pair in two scopes keeps both rows; equal timestamps tie-break by scope name.
-    put("global", "a.md", base + 10);
-    assert.deepEqual((await files({})).filter((file) => file.path === "a.md").map((file) => file.scope), ["global", "session"], "equal timestamps tie-break by scope name");
-    assert.deepEqual((await files({ scope: "session" })).map((file) => file.path), ["a.md", "b.md"], "a scope filter narrows the set");
+    put("personal", "a.md", base + 10);
+    assert.deepEqual((await files({})).filter((file) => file.address.endsWith("a.md")).map((file) => file.scope), ["personal", "session"], "equal timestamps tie-break by full address");
+    assert.deepEqual((await files({ pattern: "*.md" })).map((file) => file.address), ["a.md", "b.md"], "a bare pattern narrows to the session home");
 });
 test("notes are real files that persist across sessions and round-trip Unicode", async () => {
     const original = manager();
     const captured = makeExtension(original);
     const ctx = context(original);
-    await call(captured, "notes_write", { path: "checkpoint/进度.md", content: "第一行\nneedle Café", scope: "global" }, ctx);
-    // A brand-new session over the same physical root sees the global note: nothing is replayed
+    await call(captured, "notes_write", { path: "checkpoint/进度.md", content: "第一行\nneedle Café", scope: "personal" }, ctx);
+    // A brand-new session over the same physical root sees the personal 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: "global", offset_chars: -4 }, restoredCtx);
+    const rawRead = await call(restoredCaptured, "notes_read", { path: "checkpoint/进度.md", scope: "personal", offset_chars: -4 }, restoredCtx);
     const read = resultRead(rawRead);
-    assert.equal(read.details.path, "checkpoint/进度.md");
+    assert.equal(read.details.address, "@personal/checkpoint/进度.md");
     assert.equal(read.content, "Café", "a negative offset reads the body tail in one call");
-    assert.equal(read.details.scope, "global");
-    const searched = resultJson(await call(restoredCaptured, "notes_search", { query: "Café", scope: "global" }, restoredCtx));
+    assert.equal(read.details.scope, "personal");
+    const searched = resultJson(await call(restoredCaptured, "notes_search", { query: "Café", scope: "personal" }, restoredCtx));
     assert.equal(searched.files[0]?.matches[0]?.line, 2);
-    const listedFiles = resultJson(await call(restoredCaptured, "notes_list", { pattern: "checkpoint/**", scope: "global" }, restoredCtx));
+    const listedFiles = resultJson(await call(restoredCaptured, "notes_list", { pattern: "checkpoint/**", scope: "personal" }, restoredCtx));
     assert.equal(listedFiles.files.length, 1, "glob ** crosses into the checkpoint directory");
     assert.equal(listedFiles.files[0]?.path, "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: "global" }, restoredCtx));
+    const rootOnly = resultJson(await call(restoredCaptured, "notes_list", { pattern: "*", scope: "personal" }, 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);
@@ -343,6 +380,17 @@ test("stale lifecycle: writes and metadata-only edits close and revive a note",
     const missing = resultJson(await call(captured, "notes_edit", { path: "missing.md", stale: true }, ctx));
     assert.equal(missing.error, "note not found");
 });
+test("notes tools stay usable while a dream holds the lock", async () => {
+    // A live dream lock is not a general lock: the awake notes tools never consult it.
+    writeFileSync(join(process.env.PI_NOTES_HOME, ".dream.lock"), String(process.pid));
+    const sm = manager();
+    const captured = makeExtension(sm);
+    const ctx = context(sm);
+    const written = resultJson(await call(captured, "notes_write", { path: "during-dream.md", content: "awake" }, ctx));
+    assert.equal(written.address, "during-dream.md");
+    const edited = resultJson(await call(captured, "notes_edit", { path: "during-dream.md", edits: [{ oldText: "awake", newText: "still awake" }] }, ctx));
+    assert.equal(edited.applied, 1, "notes_edit still applies while a dream lock is held");
+});
 test("the boot notes index excludes stale notes while list, read, and search still see them", async () => {
     const sm = manager();
     const captured = makeExtension(sm);
@@ -354,7 +402,7 @@ test("the boot notes index excludes stale notes while list, read, and search sti
     const text = typeof boot?.message.content === "string" ? boot.message.content : "";
     assert.ok(text.includes("fresh.md"), "the fresh note is indexed");
     assert.equal(text.includes("old.md"), false, "the stale note leaves the boot index");
-    assert.equal(text.includes("stale content"), false, "the stale preview is not rendered");
+    assert.equal(text.includes("stale content"), false, "the stale note's body is absent from boot");
     const listed = resultJson(await call(captured, "notes_list", {}, ctx));
     assert.equal(listed.files.find((file) => file.path === "old.md")?.stale, true, "list carries the stale flag");
     assert.equal(listed.files.find((file) => file.path === "fresh.md")?.stale, false);
@@ -372,9 +420,30 @@ test("the boot notes index omits itself when every note is stale", async () => {
     runHandlers(captured, "session_start", {}, ctx);
     const text = typeof captured.sent[0]?.message.content === "string" ? captured.sent[0].message.content : "";
     assert.equal(text.includes("done.md"), false, "no stale note is indexed");
-    assert.equal(text.includes("finished"), false, "no stale preview is rendered");
+    assert.equal(text.includes("finished"), false, "the stale note's body is absent from boot");
     assert.ok(text.includes(internal.CONTEXT_WINDOW_PROTOCOL_OPEN_TAG), "the rest of the boot block still renders");
 });
+test("the boot block gives awake agents the notes-home file layout", () => {
+    const session = manager();
+    const rendered = bootBlock(context(session), "pcw:test:root", undefined, false);
+    assert.equal(rendered.includes(process.env.PI_NOTES_HOME ?? ""), false, "the absolute notes home is never exposed");
+    assert.match(rendered, /bare <vpath>.*@project\/<vpath>.*@personal\/<vpath>/);
+    assert.match(rendered, /there is no cross-home fallback/);
+    assert.match(rendered, /Any other note is a plain file — use the file tools/);
+});
+test("the boot block keeps fresh personal and project maps resident, never a session map", async () => {
+    const session = manager();
+    const captured = makeExtension(session);
+    const ctx = context(session);
+    await call(captured, "notes_write", { address: "MAP.md", content: "MAP: session" }, ctx);
+    await call(captured, "notes_write", { address: "@project/MAP.md", content: "MAP: project" }, ctx);
+    await call(captured, "notes_write", { address: "@personal/MAP.md", content: "MAP: personal" }, ctx);
+    const rendered = bootBlock(ctx, "pcw:test:root", undefined, false);
+    assert.ok(rendered.includes("MAP: personal"));
+    assert.ok(rendered.includes("MAP: project"));
+    assert.equal(rendered.includes("MAP: session"), false);
+    assert.ok(rendered.indexOf("MAP: personal") < rendered.indexOf("MAP: project"), "personal map precedes project map");
+});
 test("paged tool outputs stay bounded and cursors reconstruct history and notes", async () => {
     const session = manager();
     const captured = makeExtension(session);
@@ -636,8 +705,8 @@ test("an over-budget note is delivered as a prefix and resumed by next_offset_ch
     assert.ok(first.content.length > 0, "the page is not empty");
     assert.equal(first.content.includes("…"), false, "the payload is a plain prefix with no marker");
     assert.ok(first.content.startsWith("---\n"), "the frontmatter is delivered first");
-    assert.equal(first.header, `[huge.md · chars 0-${first.next_offset_chars} of ${first.total_chars} · continue at offset_chars=${first.next_offset_chars} · session · created ${String(first.details.created_at)} · updated ${String(first.details.updated_at)}]`, "the raw header names the file, the delivered range, the resume cursor, the scope and the timestamps");
-    assert.deepEqual(Object.keys(first.details).sort(), ["created_at", "limit_chars", "next_offset_chars", "offset_chars", "path", "scope", "total_chars", "updated_at"], "notes_read details carries exactly the slim window metadata plus scope");
+    assert.equal(first.header, `[huge.md · chars 0-${first.next_offset_chars} of ${first.total_chars} · continue at offset_chars=${first.next_offset_chars} · session · created ${String(first.details.created_at)} · updated ${String(first.details.updated_at)}]`, "the raw header names the address, delivered range, resume cursor, scope and timestamps");
+    assert.deepEqual(Object.keys(first.details).sort(), ["address", "created_at", "limit_chars", "next_offset_chars", "offset_chars", "scope", "total_chars", "updated_at"], "notes_read details carries exactly the slim window metadata plus scope");
     assert.equal("content" in first.details, false, "details never duplicates the payload");
     assert.equal(first.offset_chars, 0, "the default window starts at the resolved offset 0");
     // Following the cursor reconstructs frontmatter + body by plain concatenation.
@@ -655,7 +724,7 @@ test("an over-budget note is delivered as a prefix and resumed by next_offset_ch
     // 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 missing = resultJson(missingResult);
-    assert.deepEqual(Object.keys(missing).sort(), ["error", "path"], "the read error carries exactly error and path");
+    assert.deepEqual(Object.keys(missing).sort(), ["address", "error"], "the read error carries exactly error and address");
     assert.equal(missing.error, "note not found");
     assert.equal(missingResult.details, undefined, "a JSON error carries no details metadata");
 });
@@ -937,11 +1006,10 @@ test("custom reset boundary removes old provider context but history remains sea
     assert.equal(found.items[0]?.item_id, oldUserId);
     assert.ok(sessionManager.getEntry(compactionId));
 });
-test("the boot notes preview keeps short notes whole and long notes head-to-tail", async () => {
+test("the boot notes index shows one metadata line per note and never a body", async () => {
     const sessionManager = manager();
     const captured = makeExtension(sessionManager);
     const ctx = context(sessionManager);
-    // Unique Unicode code points so an overlap introduced by a naive head+tail concat is detectable.
     const longText = Array.from({ length: 400 }, (_, index) => String.fromCharCode(0x4e00 + index)).join("");
     const shortText = "short-first\nshort-second";
     await call(captured, "notes_write", { path: "long.md", content: longText }, ctx);
@@ -950,19 +1018,11 @@ test("the boot notes preview keeps short notes whole and long notes head-to-tail
     const boot = captured.sent[0];
     const text = typeof boot?.message.content === "string" ? boot.message.content : "";
     assert.ok(text.includes("long.md") && text.includes("short.md"), "both notes are indexed");
-    // Short note: complete, with its newline preserved and each line indented 2 spaces.
-    assert.ok(text.includes("  short-first\n  short-second"), "short note text is shown whole and indented");
-    // Long note preview: exactly first 80 + separator + last 240 Unicode characters.
-    const chars = Array.from(longText);
-    const head = chars.slice(0, 80).join("");
-    const tail = chars.slice(chars.length - 240).join("");
-    const previewLine = text.split("\n").find((line) => line.startsWith("  ") && line.includes("…"));
-    assert.ok(previewLine, "long note carries an ellipsis preview line");
-    const preview = Array.from(previewLine.slice(2));
-    assert.ok(previewLine.includes(head), "long preview keeps the head");
-    assert.ok(previewLine.includes(tail), "long preview keeps the tail");
-    assert.equal(preview.length, 321, "head 80 + one separator + tail 240, nothing duplicated");
-    assert.equal(previewLine.includes(longText), false, "long note is truncated, not shown whole");
+    // Each note is exactly one metadata line: address, line count, byte count, timestamp.
+    assert.match(text, /^- long\.md \(1 lines, \d+ UTF-8 bytes, updated [^)]+\)$/m, "the long note is a single metadata line");
+    assert.match(text, /^- short\.md \(2 lines, \d+ UTF-8 bytes, updated [^)]+\)$/m, "the short note is a single metadata line");
+    assert.equal(text.includes(longText), false, "the long note's body never reaches boot");
+    assert.equal(text.includes(shortText), false, "the short note's body never reaches boot");
 });
 test("the boot block is persisted at the root and baked into every reset summary", async () => {
     const sessionManager = manager();
@@ -986,8 +1046,7 @@ test("the boot block is persisted at the root and baked into every reset summary
     assert.ok(rootText.includes("decisions.md"));
     const decisionsMeta = listNotes(ctx, { scope: "session" }).find((row) => row.path === "decisions.md")?.meta;
     assert.ok(decisionsMeta);
-    const bootUpdated = assertIsoTimestamp(rootText, "note metadata carries an updated timestamp");
-    assert.equal(Date.parse(bootUpdated), decisionsMeta.updated_at, "boot note timestamp restores the persisted updatedAt");
+    assert.match(rootText, /updated \d+s ago\)/, "boot note metadata carries a relative update time");
     assert.ok(rootText.includes(internal.CONTEXT_WINDOW_PROTOCOL_OPEN_TAG));
     // Reset: the boot block IS the compaction summary; no separate boot/hint is persisted.
     await call(captured, "new_context", {}, ctx);
@@ -1001,8 +1060,8 @@ test("the boot block is persisted at the root and baked into every reset summary
     assert.equal(before.compaction.summary.startsWith(internal.CONTEXT_WINDOW_OPEN_TAG), false, "a reset line precedes the identity block");
     assert.match(before.compaction.summary, new RegExp(`Current context window id: ${details.windowId}`));
     assert.ok(before.compaction.summary.includes("decisions.md"));
-    const resetUpdated = assertIsoTimestamp(before.compaction.summary, "reset summary keeps the note updated timestamp");
-    assert.equal(Date.parse(resetUpdated), decisionsMeta.updated_at, "reset summary keeps the persisted updatedAt");
+    assert.match(before.compaction.summary, /updated \d+s ago\)/, "reset summary carries a relative update time");
+    assert.equal(listNotes(ctx, { scope: "session" }).find((row) => row.path === "decisions.md")?.meta.updated_at, decisionsMeta.updated_at, "rendering relative time preserves the stored timestamp");
     assert.ok(before.compaction.summary.includes(internal.CONTEXT_WINDOW_PROTOCOL_OPEN_TAG));
     const windows = historyFromSession(ctx);
     assert.ok(before.compaction.summary.includes(`Previous context window id: ${windows[windows.length - 1]?.windowId}`));
@@ -1584,7 +1643,8 @@ test("malformed frontmatter timestamps degrade to a finite fallback without pois
     assert.ok(Number.isFinite(rows[0].meta.updated_at), "a malformed timestamp degrades to a finite fallback");
     runHandlers(extension, "session_start", {}, ctx);
     const rendered = JSON.stringify(extension.sent);
-    assert.ok(rendered.includes("keep me"), "the valid body still renders");
+    assert.ok(rendered.includes("good.md"), "the valid note still renders as a metadata line");
+    assert.equal(rendered.includes("keep me"), false, "note bodies stay out of the boot block");
     assert.equal(rendered.includes("NaN"), false, "no malformed timestamp leaks into the boot block");
 });
 test("JSONL reload retains once-per-window boot and reminder without runtime memory", () => {
@@ -1663,7 +1723,7 @@ test("argument footguns die loudly and tool-run metadata surfaces (A1/A2/A3/B4/B
     assert.match(notePastEnd.error ?? "", /past the end/, "notes: past-end offset is a named error");
     assert.equal(notePastEnd.offset_chars, noteTotal + 1, "notes: the error echoes the offending offset");
     assert.equal(notePastEnd.total_chars, noteTotal, "notes: the error names the real length");
-    assert.equal(notePastEnd.path, "a.md", "notes: the error echoes the path");
+    assert.equal(notePastEnd.address, "a.md", "notes: the error echoes the address");
     const noteEnd = resultRead(await call(captured, "notes_read", { path: "a.md", offset_chars: noteTotal }, ctx));
     assert.equal(noteEnd.content, "", "notes: offset == total is the legal empty end-read");
     assert.equal(noteEnd.next_offset_chars, null, "notes: the end-read terminates");