@astrosheep/pi-context 0.25.2 → 0.26.0

package/dist/test/notes.test.js

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

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

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

package/dist/test/reset-lifecycle.test.js

@@ -109,22 +109,25 @@ function appendDrafts(sessionManager, entries) {
 }
 function turnEndFacts(overrides = {}) {
     return {
+        windowId: "pcw:test:window",
         aborted: false,
         overflow: false,
         failed: false,
         enabled: true,
         queued: false,
         automaticResetEnabled: true,
-        thresholdDue: false,
+        hardReserveDue: false,
         ...overrides,
     };
 }
 function beforeSettleFacts(overrides = {}) {
     return {
+        windowId: "pcw:test:window",
         queued: false,
         enabled: true,
         automaticResetEnabled: true,
         aborted: false,
+        failed: false,
         ...overrides,
     };
 }
@@ -156,14 +159,15 @@ test("public reset boundary drafts one marker, one boot, and one continuation af
     assert.equal(markerDrafts.length, 1, "duplicate wipe requests in one turn dedupe");
     assert.equal(bootDrafts.length, 1);
     assert.equal(boundary.entries[0]?.type, "custom_message", "ordinary tool-batch entries precede the reset drafts");
-    assert.equal(boundary.entries[1]?.type, "custom");
-    assert.equal(boundary.entries[2]?.type, "custom_message");
+    assert.equal(boundary.entries[1]?.type, "compaction", "native retain-none checkpoint precedes the reset marker");
+    assert.equal(boundary.entries[2]?.type, "custom");
+    assert.equal(boundary.entries[3]?.type, "custom_message");
     const windowId = markerDrafts[0].data.windowId;
     assert.match(windowId, /^pcw:/);
     assert.equal(bootDrafts[0].details.windowId, windowId);
     const continuationDrafts = boundary.entries.filter((entry) => entry.type === "custom_message" && entry.customType === internal.CONTINUATION_TYPE);
     assert.equal(continuationDrafts.length, 1, "the boundary persists exactly one reset message");
-    assert.equal(boundary.entries[3]?.type, "custom_message", "the continuation closes the ordered reset shape");
+    assert.equal(boundary.entries[4]?.type, "custom_message", "the continuation closes the ordered reset shape");
     appendDrafts(h.sessionManager, boundary.entries);
     const branch = h.sessionManager.getBranch();
     assert.deepEqual(branch.filter((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE).map((entry) => entry.type === "custom" ? entry.data : undefined), [{ windowId }]);
@@ -189,12 +193,14 @@ test("off stops future automatic/manual reset requests while an existing marker
     assert.equal(afterOff.entries.length, 0, "off does not create another reset");
     await h.runCommand("pi-context", "on");
     await h.runCommand("wipe-memory");
-    assert.equal(h.sent.length, 2, "/wipe-memory writes one hidden boot and one continuation without a model turn");
-    assert.equal(h.sent[0]?.triggerTurn, false);
-    assert.equal(h.sent[0]?.customType, internal.BOOT_TYPE);
-    assert.equal(h.sent[1]?.customType, internal.CONTINUATION_TYPE);
+    assert.equal(h.sent.length, 1, "/wipe-memory sends one hidden close-out warning and starts a normal turn");
+    assert.equal(h.sent[0]?.triggerTurn, true);
+    assert.equal(h.sent[0]?.customType, internal.WARNING_TYPE);
+    const warning = h.sessionManager.getBranch().find((entry) => entry.type === "custom_message" && entry.customType === internal.WARNING_TYPE);
+    assert.ok(warning && warning.type === "custom_message");
+    assert.equal(warning.content, internal.WARNING_CONTENT);
     const markers = h.sessionManager.getBranch().filter((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE);
-    assert.equal(markers.length, 2, "off does not resurrect history; re-enabled wipe-memory creates the explicit new marker");
+    assert.equal(markers.length, 1, "manual command waits for an agent boundary; it does not persist an immediate reset");
 });
 test("reset construction failure preserves incoming and budget drafts without continuation", async () => {
     const sessionManager = Manager.inMemory("/private/tmp/pi-context-reset-failure-test");
@@ -220,13 +226,13 @@ test("reset construction failure preserves incoming and budget drafts without co
         isEnabled: () => true,
         budget: {
             automaticResetEnabled: () => true,
-            resetDue: () => false,
+            hardReserveDue: () => false,
             consumeTurnEnd: () => [budgetDraft],
             clear: () => { },
         },
         buildReset: () => { throw new Error("synthetic reset construction failure"); },
     });
-    lifecycle.request();
+    lifecycle.request(`pcw:${sessionManager.getSessionId().slice(0, 8)}:root`);
     const incoming = { type: "custom_message", customType: "foreign/boundary", content: "foreign draft", display: false };
     const results = [];
     for (const handler of handlers.get("turn_end") ?? [])
@@ -237,6 +243,52 @@ test("reset construction failure preserves incoming and budget drafts without co
     assert.equal(notices.at(-1)?.type, "warning");
     assert.match(notices.at(-1)?.message ?? "", /could not build reset/);
 });
+test("a stale async reset is discarded after a lifecycle switch without staging a notice", async () => {
+    const sessionManager = Manager.inMemory("/private/tmp/pi-context-stale-reset-test");
+    const handlers = new Map();
+    const api = {
+        on(name, handler) {
+            const list = handlers.get(name) ?? [];
+            list.push(handler);
+            handlers.set(name, list);
+            return () => { };
+        },
+    };
+    const ctx = {
+        sessionManager,
+        model: undefined,
+        signal: undefined,
+        hasPendingMessages: () => false,
+        ui: { notify() { } },
+    };
+    let resolveBuild;
+    const pendingBuild = new Promise((resolve) => { resolveBuild = resolve; });
+    let readyCount = 0;
+    const lifecycle = registerResetLifecycle(api, {
+        isEnabled: () => true,
+        budget: {
+            automaticResetEnabled: () => true,
+            hardReserveDue: () => false,
+            consumeTurnEnd: () => [],
+            clear: () => { },
+        },
+        buildReset: () => pendingBuild,
+        onResetReady: () => { readyCount++; },
+    });
+    const windowId = `pcw:${sessionManager.getSessionId().slice(0, 8)}:root`;
+    lifecycle.request(windowId);
+    const incoming = { type: "custom_message", customType: "foreign/boundary", content: "preserve me", display: false };
+    const turnEnd = handlers.get("turn_end")?.[0];
+    const sessionTree = handlers.get("session_tree")?.[0];
+    assert.ok(turnEnd && sessionTree);
+    const pending = turnEnd(fakeBoundaryEvent([incoming]), ctx);
+    await sessionTree({}, ctx);
+    resolveBuild([{ type: "custom_message", customType: internal.BOOT_TYPE, content: "stale", display: false }]);
+    const result = resultEntries([await pending]);
+    assert.deepEqual(result.entries, [incoming], "a switched lifecycle keeps incoming drafts but discards stale reset drafts");
+    assert.equal(result.continue, false);
+    assert.equal(readyCount, 0, "stale reset work cannot stage a success notice");
+});
 test("a queued success clears an overflow failure before settle recovery can reset", async () => {
     const sessionManager = Manager.inMemory("/private/tmp/pi-context-queued-overflow-test");
     const handlers = new Map();
@@ -260,7 +312,7 @@ test("a queued success clears an overflow failure before settle recovery can res
         isEnabled: () => true,
         budget: {
             automaticResetEnabled: () => true,
-            resetDue: () => false,
+            hardReserveDue: () => false,
             consumeTurnEnd: () => [],
             clear: () => { },
         },
@@ -288,55 +340,63 @@ test("a queued success clears an overflow failure before settle recovery can res
     assert.equal(await beforeSettle(settled, ctx), undefined, "the successful queued turn clears the stale recovery");
     assert.equal(resetCount, 0);
 });
-test("reset-control: an explicit request deduplicates and is consumed at the turn boundary", () => {
-    const idle = Object.freeze({ ...initialResetControl() });
-    const first = reduceResetControl(idle, { type: "request" });
-    assert.equal(first.effect, "requested");
-    assert.deepEqual(first.state, { request: "explicit", overflow: "idle" });
-    const again = reduceResetControl(first.state, { type: "request" });
-    assert.equal(again.effect, "already-requested");
-    assert.deepEqual(again.state, first.state, "a duplicate request does not change state");
-    const committed = reduceResetControl(again.state, { type: "turn_end", facts: turnEndFacts() });
-    assert.equal(committed.effect, "commit-boundary");
-    assert.deepEqual(committed.state, initialResetControl(), "the request is consumed whether or not it commits");
+test("reset-control: close-out phases deduplicate, span turns, and upgrade to a tool commit", () => {
+    const windowId = "pcw:test:window";
+    const first = reduceResetControl(initialResetControl(), { type: "close_out", windowId, source: "manual" });
+    assert.equal(first.effect, "close-out-armed");
+    assert.deepEqual(first.state.request, { phase: "close-out", windowId, source: "manual" });
+    const duplicate = reduceResetControl(first.state, { type: "close_out", windowId, source: "manual" });
+    assert.equal(duplicate.effect, "already-pending");
+    const noteTurn = reduceResetControl(first.state, { type: "turn_end", facts: turnEndFacts() });
+    assert.equal(noteTurn.effect, "none");
+    assert.deepEqual(noteTurn.state.request, first.state.request, "note/tool turns do not consume close-out");
+    const tool = reduceResetControl(noteTurn.state, { type: "tool_request", windowId });
+    assert.deepEqual(tool.state.request, { phase: "tool-requested", windowId });
+    const commit = reduceResetControl(tool.state, { type: "turn_end", facts: turnEndFacts() });
+    assert.equal(commit.effect, "commit-boundary");
+    assert.deepEqual(commit.state, initialResetControl());
 });
-test("reset-control: turn_end commits explicit and threshold resets, and skips disabled or failed turns", () => {
-    const explicit = reduceResetControl({ request: "explicit", overflow: "idle" }, { type: "turn_end", facts: turnEndFacts() });
-    assert.equal(explicit.effect, "commit-boundary");
-    const threshold = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts({ thresholdDue: true }) });
-    assert.equal(threshold.effect, "commit-boundary");
-    const neither = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts() });
-    assert.equal(neither.effect, "none");
-    const disabled = reduceResetControl({ request: "explicit", overflow: "idle" }, { type: "turn_end", facts: turnEndFacts({ enabled: false, thresholdDue: true }) });
-    assert.equal(disabled.effect, "none");
-    assert.deepEqual(disabled.state, initialResetControl(), "a disabled turn drops the explicit request without committing");
-    const failed = reduceResetControl({ request: "explicit", overflow: "idle" }, { type: "turn_end", facts: turnEndFacts({ failed: true, thresholdDue: true }) });
-    assert.equal(failed.effect, "none");
-    assert.deepEqual(failed.state, initialResetControl());
+test("reset-control: fallback is normal-stop only; hard reserve remains safety", () => {
+    const windowId = "pcw:test:window";
+    const manual = reduceResetControl(initialResetControl(), { type: "close_out", windowId, source: "manual" }).state;
+    const fallback = reduceResetControl(manual, { type: "before_settle", facts: beforeSettleFacts() });
+    assert.equal(fallback.effect, "commit-boundary", "manual close-out works even when automatic resets are disabled");
+    assert.deepEqual(fallback.state, initialResetControl());
+    const automatic = reduceResetControl(initialResetControl(), { type: "close_out", windowId, source: "automatic" }).state;
+    const disabledAuto = reduceResetControl(automatic, { type: "before_settle", facts: beforeSettleFacts({ automaticResetEnabled: false }) });
+    assert.equal(disabledAuto.effect, "none");
+    assert.deepEqual(disabledAuto.state, initialResetControl());
+    const safety = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts({ hardReserveDue: true }) });
+    assert.equal(safety.effect, "commit-boundary");
+    for (const outcome of [{ failed: true }, { aborted: true }]) {
+        const notNormalStop = reduceResetControl(manual, { type: "before_settle", facts: beforeSettleFacts(outcome) });
+        assert.equal(notNormalStop.effect, "none");
+        assert.deepEqual(notNormalStop.state, initialResetControl());
+    }
+    assert.deepEqual(reduceResetControl(manual, { type: "settled" }).state, initialResetControl());
 });
-test("reset-control: aborted turns clear the boundary, settlement keeps only an explicit request", () => {
-    const both = { request: "explicit", overflow: "pending" };
-    const aborted = reduceResetControl(both, { type: "turn_end", facts: turnEndFacts({ aborted: true }) });
+test("reset-control: abort and lifecycle transitions clear every pending phase", () => {
+    const windowId = "pcw:test:window";
+    const pending = reduceResetControl(initialResetControl(), { type: "close_out", windowId, source: "manual" }).state;
+    const aborted = reduceResetControl(pending, { type: "turn_end", facts: turnEndFacts({ aborted: true }) });
     assert.equal(aborted.effect, "none");
-    assert.deepEqual(aborted.state, initialResetControl(), "an abort manufactures no continuation");
-    const settled = reduceResetControl(both, { type: "settled" });
-    assert.deepEqual(settled.state, { request: "explicit", overflow: "idle" }, "settlement ends the failure chain only");
-    const cleared = reduceResetControl(both, { type: "clear" });
-    assert.deepEqual(cleared.state, initialResetControl());
+    assert.deepEqual(aborted.state, initialResetControl());
+    assert.deepEqual(reduceResetControl(pending, { type: "clear" }).state, initialResetControl());
+    assert.deepEqual(reduceResetControl(pending, { type: "settled" }).state, initialResetControl());
 });
 test("reset-control: overflow recovery is armed at turn_end and spent exactly once at settle", () => {
     const armed = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts({ overflow: true, failed: true }) });
-    assert.deepEqual(armed.state, { request: "none", overflow: "pending" });
+    assert.deepEqual(armed.state, { request: { phase: "none" }, overflow: "pending" });
     const recovered = reduceResetControl(armed.state, { type: "before_settle", facts: beforeSettleFacts() });
     assert.equal(recovered.effect, "recover-overflow", "the first settle commits the bounded recovery");
-    assert.deepEqual(recovered.state, { request: "none", overflow: "spent" });
+    assert.deepEqual(recovered.state, { request: { phase: "none" }, overflow: "spent" });
     const repeated = reduceResetControl(recovered.state, { type: "before_settle", facts: beforeSettleFacts() });
     assert.equal(repeated.effect, "none", "a spent recovery is never retried");
     const rearmed = reduceResetControl(recovered.state, { type: "turn_end", facts: turnEndFacts({ overflow: true, failed: true }) });
-    assert.deepEqual(rearmed.state, { request: "none", overflow: "pending-spent" });
+    assert.deepEqual(rearmed.state, { request: { phase: "none" }, overflow: "pending-spent" });
     const bounded = reduceResetControl(rearmed.state, { type: "before_settle", facts: beforeSettleFacts() });
     assert.equal(bounded.effect, "none", "a second failure chain stays bounded to the spent attempt");
-    assert.deepEqual(bounded.state, { request: "none", overflow: "spent" });
+    assert.deepEqual(bounded.state, { request: { phase: "none" }, overflow: "spent" });
 });
 test("reset-control: a queued turn defers recovery and its success supersedes the failure", () => {
     const armed = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts({ overflow: true, failed: true }) }).state;
@@ -350,52 +410,40 @@ test("reset-control: disabled mode and explicit aborts disarm overflow without a
     const armed = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts({ overflow: true, failed: true }) }).state;
     const disabled = reduceResetControl(armed, { type: "before_settle", facts: beforeSettleFacts({ enabled: false }) });
     assert.equal(disabled.effect, "none");
-    assert.deepEqual(disabled.state, { request: "none", overflow: "idle" });
+    assert.deepEqual(disabled.state, { request: { phase: "none" }, overflow: "idle" });
     const automaticOff = reduceResetControl(armed, { type: "before_settle", facts: beforeSettleFacts({ automaticResetEnabled: false }) });
     assert.equal(automaticOff.effect, "none");
-    assert.deepEqual(automaticOff.state, { request: "none", overflow: "idle" });
+    assert.deepEqual(automaticOff.state, { request: { phase: "none" }, overflow: "idle" });
     const aborted = reduceResetControl(armed, { type: "before_settle", facts: beforeSettleFacts({ aborted: true }) });
     assert.equal(aborted.effect, "none");
-    assert.deepEqual(aborted.state, { request: "none", overflow: "idle" });
+    assert.deepEqual(aborted.state, { request: { phase: "none" }, overflow: "idle" });
 });
-test("reset-control: policy guards are consulted only in the branches that need them", () => {
-    const tracked = (overrides) => {
-        const calls = { queued: 0, automatic: 0, threshold: 0 };
-        const facts = {
-            aborted: overrides.aborted ?? false,
-            overflow: overrides.overflow ?? false,
-            failed: overrides.failed ?? false,
-            enabled: overrides.enabled ?? true,
-            get queued() { calls.queued += 1; return overrides.queuedResult ?? false; },
-            get automaticResetEnabled() { calls.automatic += 1; return overrides.automaticResult ?? true; },
-            get thresholdDue() { calls.threshold += 1; return overrides.thresholdResult ?? true; },
-        };
-        return { facts, calls };
+test("reset-control: lazy guards preserve overflow policy ordering", () => {
+    const calls = { queued: 0, automatic: 0, hardReserve: 0 };
+    const facts = {
+        windowId: "pcw:test:window",
+        aborted: false,
+        overflow: true,
+        failed: true,
+        enabled: true,
+        get queued() { calls.queued += 1; return false; },
+        get automaticResetEnabled() { calls.automatic += 1; return true; },
+        get hardReserveDue() { calls.hardReserve += 1; return true; },
     };
-    const aborted = tracked({ aborted: true });
-    reduceResetControl(initialResetControl(), { type: "turn_end", facts: aborted.facts });
-    assert.deepEqual(aborted.calls, { queued: 0, automatic: 0, threshold: 0 }, "an abort consults no policy guard");
-    const failed = tracked({ failed: true });
-    reduceResetControl(initialResetControl(), { type: "turn_end", facts: failed.facts });
-    assert.deepEqual(failed.calls, { queued: 0, automatic: 0, threshold: 0 }, "a failed turn consults no threshold guard");
-    const disabled = tracked({ enabled: false });
-    reduceResetControl(initialResetControl(), { type: "turn_end", facts: disabled.facts });
-    assert.deepEqual(disabled.calls, { queued: 0, automatic: 0, threshold: 0 }, "a disabled turn consults no threshold guard");
-    const overflow = tracked({ overflow: true, queuedResult: false });
-    reduceResetControl(initialResetControl(), { type: "turn_end", facts: overflow.facts });
-    assert.deepEqual(overflow.calls, { queued: 1, automatic: 1, threshold: 0 }, "an overflow turn consults only the overflow guards");
-    const complete = tracked({ thresholdResult: false });
-    reduceResetControl(initialResetControl(), { type: "turn_end", facts: complete.facts });
-    assert.deepEqual(complete.calls, { queued: 0, automatic: 0, threshold: 1 }, "a completed turn consults only the threshold guard");
+    reduceResetControl(initialResetControl(), { type: "turn_end", facts });
+    assert.deepEqual(calls, { queued: 1, automatic: 1, hardReserve: 0 }, "overflow checks never consult hard-reserve policy");
     const settleCalls = { queued: 0, enabled: 0, automatic: 0 };
     const settleFacts = {
+        windowId: "pcw:test:window",
         get queued() { settleCalls.queued += 1; return true; },
         get enabled() { settleCalls.enabled += 1; return true; },
         get automaticResetEnabled() { settleCalls.automatic += 1; return true; },
         aborted: false,
+        failed: false,
     };
-    reduceResetControl({ request: "none", overflow: "pending" }, { type: "before_settle", facts: settleFacts });
-    assert.deepEqual(settleCalls, { queued: 1, enabled: 0, automatic: 0 }, "a queued settle consults only the pending-message guard");
+    const pendingOverflow = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts({ overflow: true, failed: true }) }).state;
+    reduceResetControl(pendingOverflow, { type: "before_settle", facts: settleFacts });
+    assert.deepEqual(settleCalls, { queued: 1, enabled: 0, automatic: 0 }, "queued settle checks no further overflow policy");
 });
 test("a committed reset places incoming and budget drafts before marker -> boot -> continuation", async () => {
     const sessionManager = Manager.inMemory("/private/tmp/pi-context-reset-ordering-test");
@@ -421,17 +469,18 @@ test("a committed reset places incoming and budget drafts before marker -> boot
         isEnabled: () => true,
         budget: {
             automaticResetEnabled: () => true,
-            resetDue: () => false,
+            hardReserveDue: () => false,
             consumeTurnEnd: () => [budgetDraft],
             clear: () => { },
         },
         buildReset: () => [
+            { type: "compaction", summary: "", firstKeptEntryId: null },
             { type: "custom", customType: internal.RESET_MARKER_TYPE, data: { windowId } },
             { type: "custom_message", customType: internal.BOOT_TYPE, content: "boot", display: false, details: { windowId } },
             { type: "custom_message", customType: internal.CONTINUATION_TYPE, content: "continuation", display: false },
         ],
     });
-    lifecycle.request();
+    lifecycle.request(`pcw:${sessionManager.getSessionId().slice(0, 8)}:root`);
     const incoming = { type: "custom_message", customType: "foreign/boundary", content: "incoming", display: false };
     const results = [];
     for (const handler of handlers.get("turn_end") ?? [])
@@ -439,12 +488,15 @@ test("a committed reset places incoming and budget drafts before marker -> boot
     const result = resultEntries(results);
     assert.equal(result.continue, true);
     const customTypes = (entries) => entries.map((entry) => {
-        assert.ok(entry.type === "custom" || entry.type === "custom_message", "the boundary only carries named reset drafts here");
+        if (entry.type === "compaction")
+            return "native-compaction";
+        assert.ok(entry.type === "custom" || entry.type === "custom_message", "the boundary only carries expected reset drafts here");
         return entry.customType;
     });
     assert.deepEqual(customTypes(result.entries), [
         "foreign/boundary",
         internal.GUIDANCE_TYPE,
+        "native-compaction",
         internal.RESET_MARKER_TYPE,
         internal.BOOT_TYPE,
         internal.CONTINUATION_TYPE,
@@ -452,7 +504,12 @@ test("a committed reset places incoming and budget drafts before marker -> boot
     appendDrafts(sessionManager, result.entries);
     const branch = sessionManager.getBranch();
     const markerIndex = branch.findIndex((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE);
-    assert.ok(markerIndex >= 0);
+    assert.ok(markerIndex > 0);
+    assert.equal(branch[markerIndex - 1]?.type, "compaction", "the checkpoint is directly before the marker");
+    const checkpoint = branch[markerIndex - 1];
+    assert.ok(checkpoint?.type === "compaction");
+    assert.equal(checkpoint.summary, "");
+    assert.equal(checkpoint.firstKeptEntryId, checkpoint.id, "Pi materializes null as retain-none");
     assert.deepEqual(customTypes(branch.slice(markerIndex)), [
         internal.RESET_MARKER_TYPE,
         internal.BOOT_TYPE,