@astrosheep/pi-context 0.26.1 → 0.26.2

package/README.md

@@ -109,9 +109,9 @@ const matches = await notes.search(["library"]);
 
 `list` and `search` share the `NotesQuery` type. A merged query uses `{ pattern? }`; a single-home query adds `scope`. Only `scope: "agent" | "model"` accepts `who`. TypeScript rejects combinations such as `{ scope: "project", who: "root" }`, and JavaScript callers receive a runtime refusal.
 
-The library returns full data, not tool envelopes or paginated/truncated output. `NoteError` exposes the existing named store refusals through `code`, with `lineNumbers` for ambiguous edits and `editIndex` for a failed edit. Runtime API fields and known persisted note metadata use camelCase; Pi tool wire fields such as `updated_at`, `offset_chars`, and `replace_all` retain their established names. A note carrying a known legacy snake_case metadata key is refused with an explicit manual-migration-required error; import and construction never migrate note data. Invalid addresses/identities and filesystem failures reject; only a missing `read` returns `undefined`. Notes remain markdown files with the existing size limits and same-directory atomic rename. Same-file read/modify/write work is serialized by absolute physical filename across all store instances in this process (including `.md` address aliases); symlink/case aliases and cross-process locking are not guaranteed. `list` and `search` asynchronously traverse homes and serialize each discovered file read against pending mutations, but are not global snapshots and may not discover a file created after traversal. Foreign named homes can be read (including the access-metadata update), but their bodies cannot be written or edited through the store. These are cooperative address rules, not an OS security sandbox.
+The library returns full data, not tool envelopes or paginated/truncated output. `NoteError` exposes the existing named store refusals through `code`, with `lineNumbers` for ambiguous edits and `editIndex` for a failed edit. Runtime API fields and known persisted note metadata use camelCase; Pi tool wire fields such as `updated_at`, `offset_chars`, and `replace_all` retain their established names. Unrecognized frontmatter keys, including old snake_case metadata, are preserved as ordinary extras; they are not interpreted as current camelCase fields or migrated automatically. Invalid addresses/identities and filesystem failures reject; only a missing `read` returns `undefined`. Notes remain markdown files with the existing size limits and same-directory atomic rename. Same-file read/modify/write work is serialized by absolute physical filename across all store instances in this process (including `.md` address aliases); symlink/case aliases and cross-process locking are not guaranteed. `list` and `search` asynchronously traverse homes and serialize each discovered file read against pending mutations, but are not global snapshots and may not discover a file created after traversal. Foreign named homes can be read (including the access-metadata update), but their bodies cannot be written or edited through the store. These are cooperative address rules, not an OS security sandbox.
 
-Addresses use bare paths, `@project/`, `@human/`, `@self/`, `@model/`, or explicit `@agents/<slug>/` and `@models/<slug>/`. Relative self/model addresses resolve to the supplied identity; listing renders their concrete names. The disk layout remains `pi/session/<sessionId>/`, `project/<projectKey>/`, `human/`, `agents/<agent>/`, and `models/<model>/`. No data migration happens on library import or construction. Notes already using camelCase metadata retain their metadata; known legacy snake_case keys require the root-coordinated manual migration before use. New session notes record the supplied project key.
+Addresses use bare paths, `@project/`, `@human/`, `@self/`, `@model/`, or explicit `@agents/<slug>/` and `@models/<slug>/`. Relative self/model addresses resolve to the supplied identity; listing renders their concrete names. The disk layout remains `pi/session/<sessionId>/`, `project/<projectKey>/`, `human/`, `agents/<agent>/`, and `models/<model>/`. No data migration happens on library import or construction. Notes already using camelCase metadata retain their metadata; old snake_case keys are preserved as unrecognized extras, not interpreted or migrated. New session notes record the supplied project key.
 
 ### Library and plugin boundary
 

package/dist/build-info.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.26.1",
-  "sourceHash": "fb313022cd1aab93e422144e8f336eced42b67c4d35b89a1133be2254f066093"
+  "version": "0.26.2",
+  "sourceHash": "b35cc5826ee3ac651b5a18c57833aab912a9ee999af2c2dfc7f8672b74e31f81"
 }

package/dist/extension.js

@@ -1,5 +1,5 @@
 // <define:__PI_CONTEXT_BUILD__>
-var define_PI_CONTEXT_BUILD_default = { version: "0.26.1", sourceHash: "fb313022cd1aab93e422144e8f336eced42b67c4d35b89a1133be2254f066093" };
+var define_PI_CONTEXT_BUILD_default = { version: "0.26.2", sourceHash: "b35cc5826ee3ac651b5a18c57833aab912a9ee999af2c2dfc7f8672b74e31f81" };
 
 // src/index.ts
 import { VERSION as VERSION2 } from "@earendil-works/pi-coding-agent";
@@ -249,10 +249,10 @@ var WARNING_TYPE = "pi-context/warning";
 var RESET_MARKER_TYPE = "pi-context/reset-marker";
 var CONTINUATION_TYPE = "pi-context/continuation";
 var POCKET_SESSION_LIMIT = 5;
-var POCKET_PROJECT_LIMIT = 2;
-var POCKET_HUMAN_LIMIT = 2;
-var POCKET_AGENT_LIMIT = 1;
-var POCKET_MODEL_LIMIT = 1;
+var POCKET_PROJECT_LIMIT = 5;
+var POCKET_HUMAN_LIMIT = 5;
+var POCKET_AGENT_LIMIT = 5;
+var POCKET_MODEL_LIMIT = 3;
 var CONTEXT_WINDOW_OPEN_TAG = "<context_window>";
 var CONTEXT_WINDOW_CLOSE_TAG = "</context_window>";
 var CONTEXT_WINDOW_PROTOCOL_OPEN_TAG = "<context_window_protocol>";
@@ -594,7 +594,6 @@ var SCOPES = ["session", "project", "human", "agent", "model"];
 var ORIGINS = ["user", "self", "external"];
 var STATUSES = ["active", "superseded", "pending", "archived"];
 var TIMESTAMP_KEYS = ["createdAt", "updatedAt", "lastAccessed"];
-var LEGACY_KNOWN_KEYS = ["created_at", "updated_at", "last_accessed", "access_count", "source_window", "recurrence_count", "recurrence_windows"];
 var KNOWN_KEYS = ["origin", "status", "stale", "createdAt", "updatedAt", "lastAccessed", "accessCount", "sourceWindow", "supersedes", "recurrenceCount", "recurrenceWindows"];
 var pad2 = (value) => String(value).padStart(2, "0");
 function localIso(epochMs) {
@@ -668,8 +667,6 @@ function parseFrontmatter(raw) {
 }
 function parseNote(raw, now = Date.now()) {
   const { fields, body } = parseFrontmatter(raw);
-  const legacyKeys = LEGACY_KNOWN_KEYS.filter((key) => Object.hasOwn(fields, key));
-  if (legacyKeys.length > 0) throw new Error(`legacy note metadata ${legacyKeys.join(", ")} requires manual migration to camelCase before this note can be used`);
   const meta = { ...fields };
   meta.scope = isScope(meta.scope) ? meta.scope : "session";
   meta.origin = isOrigin(meta.origin) ? meta.origin : "self";
@@ -1483,7 +1480,7 @@ function notesIndex(snapshot) {
   if (recentNotes.length > 0) {
     const lines = [`You find ${recentNotes.length} crumpled note${recentNotes.length === 1 ? "" : "s"} in your pocket (by prefix, most recent first within each: up to ${POCKET_SESSION_LIMIT} from this session, ${POCKET_PROJECT_LIMIT} from @project, ${POCKET_HUMAN_LIMIT} from @human, ${POCKET_AGENT_LIMIT} from @self, ${POCKET_MODEL_LIMIT} from @model). A note's content never appears here, so its name has to say what the note is about:`];
     for (const row of recentNotes) {
-      lines.push(`- ${row.address} (${row.body.split("\n").length} lines, ${row.sizeBytes} UTF-8 bytes, updated ${relativeTime(row.meta.updatedAt, snapshot.openedAt)})`);
+      lines.push(`- ${row.address}  \xB7  ${Array.from(row.body).length} chars  \xB7  ${relativeTime(row.meta.updatedAt, snapshot.openedAt)}`);
     }
     sections.push(lines.join("\n"));
   }

package/dist/src/context/prompts.js

@@ -32,8 +32,8 @@ function notesUnavailableNotice(snapshot) {
  * per home, and the session home is never peeked — a session MAP.md is an ordinary note. The
  * pocket then lists recent fresh notes under per-home quotas (POCKET_SESSION_LIMIT /
  * POCKET_PROJECT_LIMIT / POCKET_HUMAN_LIMIT / POCKET_AGENT_LIMIT / POCKET_MODEL_LIMIT),
- * most-recently-updated first within each home, one metadata line each: address, line count,
- * UTF-8 byte count, relative update time at window open. Bodies never render
+ * most-recently-updated first within each home, one metadata line each: address, body character
+ * count, relative update time at window open. Bodies never render
  * in the pocket; stale notes are excluded; MAP.md itself never takes a pocket seat.
  */
 function notesIndex(snapshot) {
@@ -59,7 +59,7 @@ function notesIndex(snapshot) {
     if (recentNotes.length > 0) {
         const lines = [`You find ${recentNotes.length} crumpled note${recentNotes.length === 1 ? "" : "s"} in your pocket (by prefix, most recent first within each: up to ${POCKET_SESSION_LIMIT} from this session, ${POCKET_PROJECT_LIMIT} from @project, ${POCKET_HUMAN_LIMIT} from @human, ${POCKET_AGENT_LIMIT} from @self, ${POCKET_MODEL_LIMIT} from @model). A note's content never appears here, so its name has to say what the note is about:`];
         for (const row of recentNotes) {
-            lines.push(`- ${row.address} (${row.body.split("\n").length} lines, ${row.sizeBytes} UTF-8 bytes, updated ${relativeTime(row.meta.updatedAt, snapshot.openedAt)})`);
+            lines.push(`- ${row.address}  ·  ${Array.from(row.body).length} chars  ·  ${relativeTime(row.meta.updatedAt, snapshot.openedAt)}`);
         }
         sections.push(lines.join("\n"));
     }

package/dist/src/dream/doctor.js

@@ -41,10 +41,6 @@ export function doctor(home) {
             if (!valid.test(fields.get(key) ?? ""))
                 report(path, `missing/invalid ${key}; repair frontmatter`);
         }
-        for (const [legacy, current] of [["created_at", "createdAt"], ["updated_at", "updatedAt"], ["last_accessed", "lastAccessed"], ["access_count", "accessCount"], ["source_window", "sourceWindow"], ["recurrence_count", "recurrenceCount"], ["recurrence_windows", "recurrenceWindows"]]) {
-            if (fields.has(legacy))
-                report(path, `legacy metadata key ${legacy}; manually migrate to ${current}`);
-        }
         for (const key of ["createdAt", "updatedAt", "lastAccessed"]) {
             const value = fields.get(key);
             if (!value || !Number.isFinite(Date.parse(value)))

package/dist/src/notes/frontmatter.d.ts

@@ -33,8 +33,7 @@ export declare function isScope(value: unknown): value is Scope;
 export declare function isOrigin(value: unknown): value is Origin;
 /**
  * Parse a note file. Missing known keys take the Design defaults (status active, stale false,
- * accessCount 0, timestamps now); unknown keys are carried through untouched. Known
- * snake_case metadata is refused because it requires the explicit manual migration.
+ * accessCount 0, timestamps now); unknown keys are carried through untouched.
  */
 export declare function parseNote(raw: string, now?: number): {
     meta: NoteMeta;

package/dist/src/notes/frontmatter.js

@@ -2,7 +2,6 @@ const SCOPES = ["session", "project", "human", "agent", "model"];
 const ORIGINS = ["user", "self", "external"];
 const STATUSES = ["active", "superseded", "pending", "archived"];
 const TIMESTAMP_KEYS = ["createdAt", "updatedAt", "lastAccessed"];
-const LEGACY_KNOWN_KEYS = ["created_at", "updated_at", "last_accessed", "access_count", "source_window", "recurrence_count", "recurrence_windows"];
 /** Emission order, exactly the Design's key list. */
 const KNOWN_KEYS = ["origin", "status", "stale", "createdAt", "updatedAt", "lastAccessed", "accessCount", "sourceWindow", "supersedes", "recurrenceCount", "recurrenceWindows"];
 const pad2 = (value) => String(value).padStart(2, "0");
@@ -98,14 +97,10 @@ function parseFrontmatter(raw) {
 }
 /**
  * Parse a note file. Missing known keys take the Design defaults (status active, stale false,
- * accessCount 0, timestamps now); unknown keys are carried through untouched. Known
- * snake_case metadata is refused because it requires the explicit manual migration.
+ * accessCount 0, timestamps now); unknown keys are carried through untouched.
  */
 export function parseNote(raw, now = Date.now()) {
     const { fields, body } = parseFrontmatter(raw);
-    const legacyKeys = LEGACY_KNOWN_KEYS.filter((key) => Object.hasOwn(fields, key));
-    if (legacyKeys.length > 0)
-        throw new Error(`legacy note metadata ${legacyKeys.join(", ")} requires manual migration to camelCase before this note can be used`);
     const meta = { ...fields };
     // scope is a legacy on-disk field: store callers derive it from the file's home and
     // overwrite it after parsing, so an absent or outdated value just falls back.

package/dist/src/protocol.d.ts

@@ -6,10 +6,10 @@ export declare const RESET_MARKER_TYPE = "pi-context/reset-marker";
 export declare const CONTINUATION_TYPE = "pi-context/continuation";
 export { MAX_NOTE_BYTES, MAX_NOTE_PATH_BYTES } from "./notes/constants.js";
 export declare const POCKET_SESSION_LIMIT = 5;
-export declare const POCKET_PROJECT_LIMIT = 2;
-export declare const POCKET_HUMAN_LIMIT = 2;
-export declare const POCKET_AGENT_LIMIT = 1;
-export declare const POCKET_MODEL_LIMIT = 1;
+export declare const POCKET_PROJECT_LIMIT = 5;
+export declare const POCKET_HUMAN_LIMIT = 5;
+export declare const POCKET_AGENT_LIMIT = 5;
+export declare const POCKET_MODEL_LIMIT = 3;
 export declare const CONTEXT_WINDOW_OPEN_TAG = "<context_window>";
 export declare const CONTEXT_WINDOW_CLOSE_TAG = "</context_window>";
 export declare const CONTEXT_WINDOW_PROTOCOL_OPEN_TAG = "<context_window_protocol>";

package/dist/src/protocol.js

@@ -6,10 +6,10 @@ export const RESET_MARKER_TYPE = "pi-context/reset-marker";
 export const CONTINUATION_TYPE = "pi-context/continuation";
 export { MAX_NOTE_BYTES, MAX_NOTE_PATH_BYTES } from "./notes/constants.js";
 export const POCKET_SESSION_LIMIT = 5;
-export const POCKET_PROJECT_LIMIT = 2;
-export const POCKET_HUMAN_LIMIT = 2;
-export const POCKET_AGENT_LIMIT = 1;
-export const POCKET_MODEL_LIMIT = 1;
+export const POCKET_PROJECT_LIMIT = 5;
+export const POCKET_HUMAN_LIMIT = 5;
+export const POCKET_AGENT_LIMIT = 5;
+export const POCKET_MODEL_LIMIT = 3;
 export const CONTEXT_WINDOW_OPEN_TAG = "<context_window>";
 export const CONTEXT_WINDOW_CLOSE_TAG = "</context_window>";
 export const CONTEXT_WINDOW_PROTOCOL_OPEN_TAG = "<context_window_protocol>";

package/dist/test/boot.integration.test.js

@@ -69,7 +69,7 @@ test("the root boot and reset boot carry durable window identity", async () => {
     assert.ok(rootText.includes("decisions.md"));
     const decisionsMeta = (await listNotes(ctx, { scope: "session" })).find((row) => row.path === "decisions.md")?.meta;
     assert.ok(decisionsMeta);
-    assert.match(rootText, /updated \d+s ago\)/, "boot note metadata carries a relative update time");
+    assert.match(rootText, /·  \d+s ago/, "boot note metadata carries a relative update time");
     assert.ok(rootText.includes(internal.CONTEXT_WINDOW_PROTOCOL_OPEN_TAG));
     // Reset: the marker and boot are committed together at the turn boundary.
     await call(captured, "wipe_memory", {}, ctx);

package/dist/test/doctor.test.js

@@ -6,13 +6,12 @@ import test from "node:test";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 const note = "---\norigin: self\nstatus: active\nstale: false\ncreatedAt: 2026-01-01T00:00:00Z\nupdatedAt: 2026-01-01T00:00:00Z\nlastAccessed: 2026-01-01T00:00:00Z\naccessCount: 0\n---\n\n";
-test("doctor identifies legacy metadata as requiring manual migration", (t) => {
-    const root = mkdtempSync(join(tmpdir(), "dream-doctor-legacy-"));
+test("doctor ignores unknown frontmatter keys while validating canonical metadata", (t) => {
+    const root = mkdtempSync(join(tmpdir(), "dream-doctor-extra-"));
     t.after(() => rmSync(root, { recursive: true, force: true }));
     mkdirSync(join(root, "human"));
-    writeFileSync(join(root, "human/legacy.md"), note.replace("createdAt", "created_at"));
-    const issues = doctor(root);
-    assert.ok(issues.some((issue) => issue.includes("legacy metadata key created_at; manually migrate to createdAt")));
+    writeFileSync(join(root, "human/extra.md"), note.replace("accessCount: 0", "accessCount: 0\ncreated_at: 2025-01-01\nupdated_at: 2025-01-01\nlast_accessed: 2025-01-01\naccess_count: 7\nsource_window: old\nrecurrence_count: 2\nrecurrence_windows: old"));
+    assert.deepEqual(doctor(root), [], "unknown fields have no special diagnostics");
 });
 test("doctor validates without repairing files or running the dreamer", async () => {
     const root = mkdtempSync(join(tmpdir(), "dream-doctor-test-"));

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

@@ -133,6 +133,24 @@ test("boot note acquisition is one closed snapshot and isolates one or all faile
     assert.ok(rendered.includes("PROJECT_MAP_BODY") && rendered.includes("AGENT_MAP_BODY"), "MAP residency comes from the snapshot");
     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");
+    assert.match(rendered, /- session\.md  ·  19 chars  ·  \d+s ago/);
+    assert.equal(rendered.includes("UTF-8 bytes"), false, "pocket rows omit implementation-oriented byte counts");
+    const expanded = await loadNotesSnapshot(ctx, (_ctx, scope) => {
+        if (scope === "project" || scope === "human" || scope === "agent" || scope === "model") {
+            return Array.from({ length: 6 }, (_, i) => note(scope, `note-${i}.md`, `@${scope === "agent" ? "agents/root" : scope === "model" ? "models/default" : scope}/note-${i}.md`, `body ${i}`));
+        }
+        return rows.get(scope) ?? [];
+    });
+    const expandedText = renderBootBlock({ ...renderData, notes: expanded });
+    for (const prefix of ["@project", "@human", "@agents/root"]) {
+        for (let i = 0; i < 5; i++)
+            assert.ok(expandedText.includes(`- ${prefix}/note-${i}.md  ·  `), `${prefix} includes note ${i}`);
+        assert.equal(expandedText.includes(`- ${prefix}/note-5.md  ·  `), false, `${prefix} is capped at five`);
+    }
+    for (let i = 0; i < 3; i++)
+        assert.ok(expandedText.includes(`- @models/default/note-${i}.md  ·  `), `@model includes note ${i}`);
+    assert.equal(expandedText.includes("- @models/default/note-3.md  ·  "), false, "@model is capped at three");
+    assert.match(expandedText, /5 from @project, 5 from @human, 5 from @self, 3 from @model/);
     const readFailure = (code) => Object.assign(new Error("scripted read failure"), { code });
     const oneFailed = await loadNotesSnapshot(ctx, (_ctx, scope) => {
         if (scope === "human")

package/dist/test/notes.test.js

@@ -142,7 +142,7 @@ test("linked git worktrees share the main checkout's project 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 () => {
+test("unrecognized metadata remains ordinary frontmatter; invalid project ownership stays unknown", async () => {
     freshRoot();
     const session = manager();
     const captured = makeExtension(session);
@@ -157,15 +157,24 @@ 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
+source_window: old-window
+recurrence_count: 2
+recurrence_windows: old-window
 ---
 
 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 parsed = parseNote(readFileSync(legacyFile, "utf8"), Date.parse("2026-02-01T00:00:00Z"));
+    assert.equal(parsed.meta.createdAt, Date.parse("2026-02-01T00:00:00Z"), "missing canonical timestamp takes the normal default");
+    assert.equal(parsed.meta.created_at, "2026-01-01T00:00:00.000+00:00", "unrecognized fields remain ordinary extras");
+    assert.equal((await listNotes(ctx, { scope: "session" }))[0]?.address, "legacy.md");
+    assert.match(resultRead(await call(captured, "notes_read", { address: "legacy.md" }, ctx)).content, /legacy body$/);
+    await call(captured, "notes_edit", { address: "legacy.md", edits: [{ oldText: "legacy body", newText: "edited body" }] }, ctx);
+    await call(captured, "notes_write", { address: "legacy.md", content: "overwritten body" }, ctx);
+    const rewritten = parseNote(readFileSync(legacyFile, "utf8"));
+    assert.equal(rewritten.body, "overwritten body");
+    for (const key of ["created_at", "updated_at", "last_accessed", "access_count", "source_window", "recurrence_count", "recurrence_windows"]) {
+        assert.deepEqual(rewritten.meta[key], parsed.meta[key], `${key} is preserved as unrecognized frontmatter, not migrated`);
+    }
     const invalidFile = physicalPath("session", "invalid.md", ctx);
     writeFileSync(invalidFile, `---
 origin: self

package/docs/architecture.md

@@ -43,7 +43,7 @@ Boot is a fixed snapshot for its window, stored as an extension custom message a
 
 History reads reconstruct the selected session branch on demand without a cache, so branch navigation cannot expose history from a sibling.
 
-The boot notes index in `pi/notes/snapshot.ts` is a closed snapshot: the current session, project, human, agent, and model homes are each loaded at most once while constructing a boot. `context/prompts.ts` then renders that explicit snapshot without reading the filesystem or consulting the clock. MAP bodies and pocket metadata are derived from the same snapshot, so a boot cannot mix two filesystem reads. Note storage and home traversal use `node:fs/promises`; same-file operations queue by absolute physical filename across store instances in this process, without promising symlink/case-alias or cross-process locking. Known persisted metadata is camelCase, and a known legacy snake_case key refuses use until the root-coordinated manual migration; startup does not migrate notes. A missing home (`ENOENT`) is normal. A real read failure omits only that home's index, preserves healthy homes, adds a model-facing `notes_list` recovery notice, and notifies the human once for that window. Boot/reset construction captures session, agent, and model identity before awaiting the snapshot, then checks lifecycle generation, active window, enabled state, and abort status before sending or returning artifacts; stale completions cannot commit into a switched or shut-down session. Note reads never mutate files or create fallback state.
+The boot notes index in `pi/notes/snapshot.ts` is a closed snapshot: the current session, project, human, agent, and model homes are each loaded at most once while constructing a boot. `context/prompts.ts` then renders that explicit snapshot without reading the filesystem or consulting the clock. MAP bodies and pocket metadata are derived from the same snapshot, so a boot cannot mix two filesystem reads. Note storage and home traversal use `node:fs/promises`; same-file operations queue by absolute physical filename across store instances in this process, without promising symlink/case-alias or cross-process locking. Known persisted metadata is camelCase. Old snake_case keys are unrecognized extras, not interpreted or migrated; startup does not migrate notes. A missing home (`ENOENT`) is normal. A real read failure omits only that home's index, preserves healthy homes, adds a model-facing `notes_list` recovery notice, and notifies the human once for that window. Boot/reset construction captures session, agent, and model identity before awaiting the snapshot, then checks lifecycle generation, active window, enabled state, and abort status before sending or returning artifacts; stale completions cannot commit into a switched or shut-down session. Note reads never mutate files or create fallback state.
 
 `notes/session-replay.ts` accepts only supported operations, safe virtual paths, representable timestamps and results within the UTF-8 size limit. Invalid operations are ignored; they cannot replace a valid note. Notes remain in their filesystem-backed homes, unchanged by session branch navigation.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/pi-context",
-  "version": "0.26.1",
+  "version": "0.26.2",
   "type": "module",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",

package/src/context/prompts.ts

@@ -36,8 +36,8 @@ function notesUnavailableNotice(snapshot: NotesSnapshot): string | undefined {
  * per home, and the session home is never peeked — a session MAP.md is an ordinary note. The
  * pocket then lists recent fresh notes under per-home quotas (POCKET_SESSION_LIMIT /
  * POCKET_PROJECT_LIMIT / POCKET_HUMAN_LIMIT / POCKET_AGENT_LIMIT / POCKET_MODEL_LIMIT),
- * most-recently-updated first within each home, one metadata line each: address, line count,
- * UTF-8 byte count, relative update time at window open. Bodies never render
+ * most-recently-updated first within each home, one metadata line each: address, body character
+ * count, relative update time at window open. Bodies never render
  * in the pocket; stale notes are excluded; MAP.md itself never takes a pocket seat.
  */
 function notesIndex(snapshot: NotesSnapshot): string {
@@ -62,7 +62,7 @@ function notesIndex(snapshot: NotesSnapshot): string {
 	if (recentNotes.length > 0) {
 		const lines = [`You find ${recentNotes.length} crumpled note${recentNotes.length === 1 ? "" : "s"} in your pocket (by prefix, most recent first within each: up to ${POCKET_SESSION_LIMIT} from this session, ${POCKET_PROJECT_LIMIT} from @project, ${POCKET_HUMAN_LIMIT} from @human, ${POCKET_AGENT_LIMIT} from @self, ${POCKET_MODEL_LIMIT} from @model). A note's content never appears here, so its name has to say what the note is about:`];
 		for (const row of recentNotes) {
-			lines.push(`- ${row.address} (${row.body.split("\n").length} lines, ${row.sizeBytes} UTF-8 bytes, updated ${relativeTime(row.meta.updatedAt, snapshot.openedAt)})`);
+			lines.push(`- ${row.address}  ·  ${Array.from(row.body).length} chars  ·  ${relativeTime(row.meta.updatedAt, snapshot.openedAt)}`);
 		}
 		sections.push(lines.join("\n"));
 	}

package/src/dream/doctor.ts

@@ -30,9 +30,6 @@ export function doctor(home: string): string[] {
 		for (const [key, valid] of Object.entries({ origin: /^(user|self|external)$/, status: /^(active|superseded|pending|archived)$/, stale: /^(true|false)$/, accessCount: /^\d+$/ })) {
 			if (!valid.test(fields.get(key) ?? "")) report(path, `missing/invalid ${key}; repair frontmatter`);
 		}
-		for (const [legacy, current] of [["created_at", "createdAt"], ["updated_at", "updatedAt"], ["last_accessed", "lastAccessed"], ["access_count", "accessCount"], ["source_window", "sourceWindow"], ["recurrence_count", "recurrenceCount"], ["recurrence_windows", "recurrenceWindows"]]) {
-			if (fields.has(legacy)) report(path, `legacy metadata key ${legacy}; manually migrate to ${current}`);
-		}
 		for (const key of ["createdAt", "updatedAt", "lastAccessed"]) {
 			const value = fields.get(key);
 			if (!value || !Number.isFinite(Date.parse(value))) report(path, `missing/invalid ${key}; use an ISO timestamp`);

package/src/notes/frontmatter.ts

@@ -30,7 +30,6 @@ const SCOPES: readonly Scope[] = ["session", "project", "human", "agent", "model
 const ORIGINS: readonly Origin[] = ["user", "self", "external"];
 const STATUSES: readonly NoteStatus[] = ["active", "superseded", "pending", "archived"];
 const TIMESTAMP_KEYS = ["createdAt", "updatedAt", "lastAccessed"] as const;
-const LEGACY_KNOWN_KEYS = ["created_at", "updated_at", "last_accessed", "access_count", "source_window", "recurrence_count", "recurrence_windows"] as const;
 /** Emission order, exactly the Design's key list. */
 const KNOWN_KEYS = ["origin", "status", "stale", "createdAt", "updatedAt", "lastAccessed", "accessCount", "sourceWindow", "supersedes", "recurrenceCount", "recurrenceWindows"] as const;
 
@@ -125,13 +124,10 @@ function parseFrontmatter(raw: string): { fields: Record<string, unknown>; body:
 
 /**
  * Parse a note file. Missing known keys take the Design defaults (status active, stale false,
- * accessCount 0, timestamps now); unknown keys are carried through untouched. Known
- * snake_case metadata is refused because it requires the explicit manual migration.
+ * accessCount 0, timestamps now); unknown keys are carried through untouched.
  */
 export function parseNote(raw: string, now = Date.now()): { meta: NoteMeta; body: string } {
 	const { fields, body } = parseFrontmatter(raw);
-	const legacyKeys = LEGACY_KNOWN_KEYS.filter((key) => Object.hasOwn(fields, key));
-	if (legacyKeys.length > 0) throw new Error(`legacy note metadata ${legacyKeys.join(", ")} requires manual migration to camelCase before this note can be used`);
 	const meta = { ...fields } as Record<string, unknown>;
 	// scope is a legacy on-disk field: store callers derive it from the file's home and
 	// overwrite it after parsing, so an absent or outdated value just falls back.

package/src/protocol.ts

@@ -6,10 +6,10 @@ export const RESET_MARKER_TYPE = "pi-context/reset-marker";
 export const CONTINUATION_TYPE = "pi-context/continuation";
 export { MAX_NOTE_BYTES, MAX_NOTE_PATH_BYTES } from "./notes/constants.js";
 export const POCKET_SESSION_LIMIT = 5;
-export const POCKET_PROJECT_LIMIT = 2;
-export const POCKET_HUMAN_LIMIT = 2;
-export const POCKET_AGENT_LIMIT = 1;
-export const POCKET_MODEL_LIMIT = 1;
+export const POCKET_PROJECT_LIMIT = 5;
+export const POCKET_HUMAN_LIMIT = 5;
+export const POCKET_AGENT_LIMIT = 5;
+export const POCKET_MODEL_LIMIT = 3;
 export const CONTEXT_WINDOW_OPEN_TAG = "<context_window>";
 export const CONTEXT_WINDOW_CLOSE_TAG = "</context_window>";
 export const CONTEXT_WINDOW_PROTOCOL_OPEN_TAG = "<context_window_protocol>";