@astrosheep/pi-context 0.25.2 → 0.26.0

package/dist/test/agent-loop.test.js

@@ -6,7 +6,7 @@ import test from "node:test";
 import { createAssistantMessageEventStream, getCurrentSystemMessage } from "@earendil-works/pi-ai";
 import { createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import piContext, { createPiContext } from "../src/index.js";
-import { BOOT_TYPE, CONTEXT_WINDOW_OPEN_TAG, CONTINUATION, CONTINUATION_TYPE, GUIDANCE_OPEN_TAG, GUIDANCE_TYPE, RESET_MARKER_TYPE, WARNING_TYPE } from "../src/protocol.js";
+import { BOOT_TYPE, CONTEXT_WINDOW_OPEN_TAG, CONTINUATION, CONTINUATION_TYPE, GUIDANCE_OPEN_TAG, GUIDANCE_TYPE, RESET_MARKER_TYPE, WARNING_CONTENT, WARNING_PROMPT, WARNING_TYPE } from "../src/protocol.js";
 async function openFixture(options) {
     const dir = options.cwd ?? mkdtempSync(join(tmpdir(), "pi-context-agent-loop-"));
     const ownsDir = options.cwd === undefined;
@@ -76,7 +76,7 @@ async function openFixture(options) {
             }],
     });
     await loader.reload();
-    const sessionManager = SessionManager.inMemory(dir);
+    const sessionManager = options.sessionManager ?? (options.sessionDir ? SessionManager.create(dir, options.sessionDir) : SessionManager.inMemory(dir));
     options.seed?.(sessionManager);
     const created = await createAgentSession({
         cwd: dir,
@@ -90,7 +90,7 @@ async function openFixture(options) {
     });
     session = created.session;
     session.subscribe((event) => events.push(event));
-    session.agent.streamFunction = (_model, context, streamOptions) => {
+    session.agent.streamFunction = async (_model, context, streamOptions) => {
         const aborted = streamOptions?.signal?.aborted === true;
         streamContexts.push(context);
         streamSignals.push(aborted);
@@ -113,7 +113,7 @@ async function openFixture(options) {
         }
         requests.push(context);
         const request = requests.length;
-        const message = options.script(request, context);
+        const message = await options.script(request, context);
         const stream = createAssistantMessageEventStream();
         stream.push({ type: "done", reason: (message.stopReason === "error" || message.stopReason === "aborted" ? "stop" : message.stopReason), message });
         stream.end();
@@ -268,13 +268,181 @@ test("real AgentSession: explicit tiny-session wipe ignores keepRecentTokens and
         const boot = fixture.sessionManager.getBranch().find((entry) => entry.type === "custom_message" && entry.customType === BOOT_TYPE && entry.details && typeof entry.details === "object" && entry.details.windowId === windowId);
         assert.ok(boot && boot.type === "custom_message", "the reset boot is persisted after the marker");
         assert.equal(boot.details.windowId, windowId);
-        assert.equal(fixture.sessionManager.getBranch().filter((entry) => entry.type === "compaction").length, 0, "the explicit path does not manufacture a native compaction");
+        const checkpoint = fixture.sessionManager.getBranch().find((entry) => entry.type === "compaction");
+        assert.ok(checkpoint && checkpoint.type === "compaction", "explicit wipe commits a native checkpoint without a summary model call");
+        assert.equal(checkpoint.summary, "");
+        assert.equal(checkpoint.firstKeptEntryId, checkpoint.id, "the checkpoint retains none of the preceding context");
         assert.ok(JSON.stringify(fixture.sessionManager.getBranch()).includes("OLD_CONTEXT_SENTINEL"), "raw history remains readable");
     }
     finally {
         fixture.close();
     }
 });
+test("real AgentSession: manual close-out spans note turns and commits its checkpoint after notes", { timeout: 20000 }, async () => {
+    let fixture;
+    fixture = await openFixture({
+        compactionEnabled: false,
+        script: (request, context) => {
+            if (request === 1)
+                return assistant(fixture, [{ type: "text", text: "before manual close-out" }]);
+            if (request === 2) {
+                assert.ok(text(context).includes(WARNING_PROMPT), "manual /wipe-memory sends the shared close-out warning");
+                return assistant(fixture, [{ type: "toolCall", id: "manual-note-a", name: "notes_write", arguments: { address: "manual-a.md", content: "MANUAL_NOTE_ALPHA" } }], "toolUse");
+            }
+            if (request === 3)
+                return assistant(fixture, [{ type: "toolCall", id: "manual-note-b", name: "notes_write", arguments: { address: "manual-b.md", content: "MANUAL_NOTE_BETA" } }], "toolUse");
+            if (request === 4)
+                return assistant(fixture, [{ type: "toolCall", id: "manual-wipe", name: "wipe_memory", arguments: {} }], "toolUse");
+            assertFreshRequest(fixture, request - 1, "MANUAL_CLOSEOUT_OLD_SENTINEL");
+            return assistant(fixture, [{ type: "text", text: "new window resumed" }]);
+        },
+    });
+    try {
+        await fixture.session.prompt("MANUAL_CLOSEOUT_OLD_SENTINEL");
+        await fixture.session.waitForIdle();
+        await fixture.session.prompt("/wipe-memory");
+        await fixture.session.waitForIdle();
+        assert.equal(fixture.requests.length, 5, "two note turns, explicit wipe, and one fresh continuation run");
+        assert.equal(resetMarkers(fixture).length, 1);
+        const branch = fixture.sessionManager.getBranch();
+        const warningIndex = branch.findIndex((entry) => entry.type === "custom_message" && entry.customType === WARNING_TYPE);
+        const checkpointIndex = branch.findIndex((entry) => entry.type === "compaction");
+        const markerIndex = branch.findIndex((entry) => entry.type === "custom" && entry.customType === RESET_MARKER_TYPE);
+        assert.ok(warningIndex >= 0 && warningIndex < checkpointIndex, "the warning is durable before the checkpoint");
+        const warning = branch[warningIndex];
+        assert.ok(warning?.type === "custom_message");
+        assert.equal(warning.content, WARNING_CONTENT, "manual and budget close-out persist the same hidden warning");
+        assert.equal(branch[markerIndex - 1]?.id, branch[checkpointIndex]?.id, "native retain-none checkpoint immediately precedes the marker");
+        assert.ok(branch.slice(0, checkpointIndex).filter((entry) => entry.type === "message" && entry.message.role === "toolResult" && entry.message.toolName === "notes_write").length >= 2, "both note writes finish before the checkpoint");
+        const marker = resetMarkers(fixture)[0];
+        assert.equal(marker.type, "custom");
+        const windowId = marker.data.windowId;
+        const boot = branch.find((entry) => entry.type === "custom_message" && entry.customType === BOOT_TYPE && entry.details?.windowId === windowId);
+        assert.ok(boot && boot.type === "custom_message");
+        assert.ok(typeof boot.content === "string" && boot.content.includes("manual-a.md") && boot.content.includes("manual-b.md"), "the fresh boot indexes both completed notes");
+        assert.equal(boot.display, false);
+        const canonical = fixture.sessionManager.buildSessionProjection().messages;
+        assert.equal(JSON.stringify(canonical).includes("MANUAL_CLOSEOUT_OLD_SENTINEL"), false, "canonical context excludes the prior window");
+        assert.ok(canonical.some((message) => message.role === "compactionSummary"), "the empty native summary wrapper remains canonical");
+        assert.ok(JSON.stringify(branch).includes("MANUAL_CLOSEOUT_OLD_SENTINEL"), "raw history remains intact");
+    }
+    finally {
+        fixture.close();
+    }
+});
+test("real AgentSession: repeated manual commands share one pending window and normal-stop fallback", { timeout: 20000 }, async () => {
+    let fixture;
+    let announceStarted;
+    let releaseResponse;
+    const started = new Promise((resolve) => { announceStarted = resolve; });
+    const gate = new Promise((resolve) => { releaseResponse = resolve; });
+    fixture = await openFixture({
+        compactionEnabled: false,
+        script: async (request) => {
+            if (request === 1) {
+                announceStarted();
+                await gate;
+            }
+            return assistant(fixture, [{ type: "text", text: "close-out complete" }]);
+        },
+    });
+    try {
+        const first = fixture.session.prompt("/wipe-memory");
+        await started;
+        const second = fixture.session.prompt("/wipe-memory");
+        releaseResponse();
+        await Promise.all([first, second]);
+        await fixture.session.waitForIdle();
+        assert.equal(fixture.requests.length, 2, "duplicate command waits do not schedule a second fresh-window request");
+        assert.equal(fixture.sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === WARNING_TYPE).length, 1, "the same pending-window warning is deduplicated");
+        assert.equal(resetMarkers(fixture).length, 1, "normal stop commits exactly one reset");
+        assert.equal(fixture.sessionManager.getBranch().filter((entry) => entry.type === "compaction").length, 1);
+    }
+    finally {
+        releaseResponse();
+        fixture.close();
+    }
+});
+test("real AgentSession: user abort, synthetic aborted response, and generic error never fall back", { timeout: 25000 }, async () => {
+    for (const mode of ["ctx-abort", "synthetic-abort", "generic-error"]) {
+        let fixture;
+        let didAbort = false;
+        fixture = await openFixture({
+            compactionEnabled: false,
+            hook: mode === "ctx-abort" ? (pi) => pi.on("context", (_event, ctx) => {
+                if (!didAbort) {
+                    didAbort = true;
+                    ctx.abort();
+                }
+            }) : undefined,
+            script: (request) => {
+                if (request === 1 && mode === "synthetic-abort")
+                    return assistant(fixture, [{ type: "text", text: "synthetic aborted" }], "aborted");
+                if (request === 1 && mode === "generic-error")
+                    return assistant(fixture, [{ type: "text", text: "request failed" }], "error", { errorMessage: "synthetic generic provider failure" });
+                return assistant(fixture, [{ type: "text", text: "later user turn" }]);
+            },
+        });
+        try {
+            await fixture.session.prompt("/wipe-memory");
+            await fixture.session.waitForIdle();
+            assert.equal(resetMarkers(fixture).length, 0, `${mode} does not force a reset`);
+            assert.equal(fixture.sessionManager.getBranch().filter((entry) => entry.type === "compaction").length, 0);
+            assert.equal(fixture.notices.some((notice) => notice.includes("memory cleared")), false);
+            if (mode === "ctx-abort")
+                assert.equal(fixture.streamSignals.at(-1), true, "this case aborts the real Pi operation signal");
+            else
+                assert.equal(fixture.streamSignals.at(-1), false, "synthetic abort/error is not a user abort signal");
+            await fixture.session.prompt("AFTER_UNSUCCESSFUL_CLOSEOUT");
+            await fixture.session.waitForIdle();
+            assert.equal(resetMarkers(fixture).length, 0, "no pending close-out leaks into a later prompt");
+        }
+        finally {
+            fixture.close();
+        }
+    }
+});
+test("real AgentSession: steering and follow-up queued during fallback reach the old window once", { timeout: 25000 }, async () => {
+    for (const delivery of ["steer", "followUp"]) {
+        let fixture;
+        let announceStarted;
+        let releaseResponse;
+        const started = new Promise((resolve) => { announceStarted = resolve; });
+        const gate = new Promise((resolve) => { releaseResponse = resolve; });
+        fixture = await openFixture({
+            compactionEnabled: false,
+            script: async (request, context) => {
+                if (request === 1) {
+                    assert.ok(text(context).includes(WARNING_PROMPT));
+                    announceStarted();
+                    await gate;
+                }
+                if (request === 2)
+                    assert.equal(text(context).split("QUEUED_DURING_FALLBACK").length - 1, 1, `${delivery} is delivered once before fallback`);
+                return assistant(fixture, [{ type: "text", text: `response ${request}` }]);
+            },
+        });
+        try {
+            const command = fixture.session.prompt("/wipe-memory");
+            await started;
+            if (delivery === "steer")
+                fixture.session.steer("QUEUED_DURING_FALLBACK");
+            else
+                fixture.session.followUp("QUEUED_DURING_FALLBACK");
+            releaseResponse();
+            await command;
+            await fixture.session.waitForIdle();
+            assert.equal(fixture.requests.length, 3, `${delivery} runs once before one fresh continuation`);
+            assert.equal(resetMarkers(fixture).length, 1, `${delivery} does not duplicate the fallback reset`);
+            assert.equal(fixture.sessionManager.getBranch().filter((entry) => entry.type === "message" && JSON.stringify(entry.message).includes("QUEUED_DURING_FALLBACK")).length, 1);
+            assertFreshRequest(fixture, 2, "QUEUED_DURING_FALLBACK");
+        }
+        finally {
+            releaseResponse();
+            fixture.close();
+        }
+    }
+});
 test("real AgentSession: a reset survives all notes-home read failures with an incomplete boot", { timeout: 15000 }, async () => {
     let fixture;
     fixture = await openFixture({
@@ -390,6 +558,66 @@ test("real AgentSession: successive resets and a mixed tool batch cut only after
         }
     }
 });
+test("real AgentSession: two retain-none checkpoints survive session-file reopen", { timeout: 20000 }, async () => {
+    const sessionDir = mkdtempSync(join(tmpdir(), "pi-context-persisted-session-"));
+    let fixture;
+    let sessionFile = "";
+    let sessionId = "";
+    fixture = await openFixture({
+        compactionEnabled: false,
+        sessionDir,
+        script: (request) => request < 3
+            ? assistant(fixture, [{ type: "toolCall", id: `persisted-wipe-${request}`, name: "wipe_memory", arguments: {} }], "toolUse")
+            : assistant(fixture, [{ type: "text", text: "second reset window complete" }]),
+    });
+    try {
+        await fixture.session.prompt("PERSISTED_OLD_WINDOW_SENTINEL");
+        await fixture.session.waitForIdle();
+        assert.equal(fixture.requests.length, 3, "two explicit requests and one final continuation, with no summary-model request");
+        assert.equal(resetMarkers(fixture).length, 2);
+        assertFreshRequest(fixture, 2, "PERSISTED_OLD_WINDOW_SENTINEL");
+        const branch = fixture.sessionManager.getBranch();
+        const checkpoints = branch.filter((entry) => entry.type === "compaction");
+        assert.equal(checkpoints.length, 2);
+        const markers = resetMarkers(fixture);
+        assert.equal(markers[0]?.parentId, checkpoints[0]?.id);
+        assert.equal(markers[1]?.parentId, checkpoints[1]?.id);
+        assert.equal(checkpoints[0]?.type === "compaction" ? checkpoints[0].firstKeptEntryId : undefined, checkpoints[0]?.id);
+        assert.equal(checkpoints[1]?.type === "compaction" ? checkpoints[1].firstKeptEntryId : undefined, checkpoints[1]?.id);
+        sessionFile = fixture.sessionManager.getSessionFile() ?? "";
+        sessionId = fixture.sessionManager.getSessionId();
+        assert.ok(sessionFile && existsSync(sessionFile), "the SDK persisted the real session file");
+    }
+    finally {
+        fixture.close();
+    }
+    try {
+        const reopened = SessionManager.open(sessionFile, sessionDir);
+        assert.equal(reopened.getSessionId(), sessionId);
+        const branch = reopened.getBranch();
+        assert.equal(branch.filter((entry) => entry.type === "compaction").length, 2);
+        assert.equal(branch.filter((entry) => entry.type === "custom" && entry.customType === RESET_MARKER_TYPE).length, 2);
+        assert.ok(JSON.stringify(branch).includes("PERSISTED_OLD_WINDOW_SENTINEL"), "raw history survives disk reopen");
+        const canonical = reopened.buildSessionProjection().messages;
+        assert.equal(JSON.stringify(canonical).includes("PERSISTED_OLD_WINDOW_SENTINEL"), false, "disk-loaded canonical context agrees with the fresh request");
+        assert.ok(canonical.some((message) => message.role === "compactionSummary"), "the accepted empty-summary wrapper survives reload");
+        const system = getCurrentSystemMessage(canonical);
+        assert.ok(JSON.stringify(system).includes("Use the tools as requested."), "the complete system prompt survives the checkpoint");
+        assert.ok(system?.toolsAdded?.some((tool) => tool.name === "wipe_memory"), "the active tool loadout survives reopen");
+        const reopenedMarkers = branch.filter((entry) => entry.type === "custom" && entry.customType === RESET_MARKER_TYPE);
+        const latestMarker = reopenedMarkers.at(-1);
+        const previousMarker = reopenedMarkers[0];
+        assert.ok(latestMarker?.type === "custom" && previousMarker?.type === "custom");
+        const latestWindowId = latestMarker.data.windowId;
+        const previousWindowId = previousMarker.data.windowId;
+        const latestBoot = branch.find((entry) => entry.type === "custom_message" && entry.customType === BOOT_TYPE && entry.details?.windowId === latestWindowId);
+        assert.ok(latestBoot && latestBoot.type === "custom_message" && typeof latestBoot.content === "string");
+        assert.ok(latestBoot.content.includes(`Previous context window id: ${previousWindowId}`));
+    }
+    finally {
+        rmSync(sessionDir, { recursive: true, force: true });
+    }
+});
 test("real AgentSession: steering and follow-up are delivered exactly once in the fresh window", async () => {
     for (const deliverAs of ["steer", "followUp"]) {
         let fixture;
@@ -531,6 +759,7 @@ test("real AgentSession: overflow and recoverable length reset and retry once; r
             await fixture.session.prompt(`RECOVER_${failure}_SENTINEL`);
             await fixture.session.waitForIdle();
             assert.equal(resetMarkers(fixture).length, 1, `${failure} performs one reset`);
+            assert.equal(fixture.sessionManager.getBranch().filter((entry) => entry.type === "compaction").length, 1, `${failure} commits one native reset checkpoint`);
             assert.equal(fixture.requests.length, 2, `${failure} resumes once`);
             assertFreshRequest(fixture, 1, `RECOVER_${failure}_SENTINEL`);
         }
@@ -546,8 +775,8 @@ test("real AgentSession: overflow and recoverable length reset and retry once; r
         await repeated.session.prompt("REPEATED_OVERFLOW_SENTINEL");
         await repeated.session.waitForIdle();
         assert.equal(resetMarkers(repeated).length, 1, "repeated overflow does not create repeated windows");
+        assert.equal(repeated.sessionManager.getBranch().filter((entry) => entry.type === "compaction").length, 1, "bounded overflow recovery commits one retain-none checkpoint");
         assert.equal(repeated.requests.length, 2, "repeated overflow stops after one recovery request");
-        assert.ok(repeated.events.some((event) => event.type === "compaction_end" && typeof event.errorMessage === "string"));
     }
     finally {
         repeated.close();
@@ -709,7 +938,7 @@ test("real AgentSession: injected settings managers own live policy and ignore c
         await first.session.waitForIdle();
         assert.equal(resetMarkers(first).length, 1, "live enablement and a lower reserve apply on the next turn");
         firstHighUsage.next = true;
-        firstManager.applyOverrides({ compaction: { reserveTokens: 90_000 } });
+        firstManager.applyOverrides({ compaction: { reserveTokens: 80_000 } });
         await first.session.prompt("INJECTED_LIVE_HIGH_RESERVE");
         await first.session.waitForIdle();
         assert.equal(resetMarkers(first).length, 2, "a live reserve increase drives the next reset decision");
@@ -781,14 +1010,83 @@ test("real AgentSession: injected model overrides select the active model's rese
         rmSync(notesRoot, { recursive: true, force: true });
     }
 });
+test("real AgentSession: persisted budget warning re-arms after a later abort/error", { timeout: 30000 }, async () => {
+    for (const mode of ["ctx-abort", "generic-error"]) {
+        let fixture;
+        let warningTurnStarted;
+        let releaseWarningTurn;
+        let didAbort = false;
+        const warningStarted = new Promise((resolve) => { warningTurnStarted = resolve; });
+        const warningGate = new Promise((resolve) => { releaseWarningTurn = resolve; });
+        fixture = await openFixture({
+            compactionEnabled: true,
+            hook: mode === "ctx-abort" ? (pi, _getSession, requests) => pi.on("context", (_event, ctx) => {
+                if (!didAbort && requests.length === 3) {
+                    didAbort = true;
+                    ctx.abort();
+                }
+            }) : undefined,
+            script: async (request, context) => {
+                if (request === 1)
+                    return assistant(fixture, [{ type: "toolCall", id: "rearm-probe-1", name: "get_context_remaining", arguments: {} }], "toolUse", { usage: usage(50_000) });
+                if (request === 2)
+                    return assistant(fixture, [{ type: "toolCall", id: "rearm-probe-2", name: "get_context_remaining", arguments: {} }], "toolUse", { usage: usage(60_000) });
+                if (request === 3) {
+                    assert.ok(text(context).includes(WARNING_PROMPT), "the low-budget request carries the close-out warning");
+                    warningTurnStarted();
+                    await warningGate;
+                    return assistant(fixture, [{ type: "toolCall", id: "rearm-note", name: "notes_write", arguments: { address: "warning-rearm.md", content: "DURABLE_WARNING_CHECKPOINT" } }], "toolUse", { usage: usage(60_000) });
+                }
+                if (request === 4 && mode === "generic-error") {
+                    assert.equal(text(context).split(WARNING_PROMPT).length - 1, 1, "the durable warning is not injected a second time");
+                    assert.ok(text(context).includes("REARM_QUEUED_FOLLOWUP"));
+                    return assistant(fixture, [{ type: "text", text: "ordinary provider failure" }], "error", { errorMessage: "synthetic non-overflow failure", usage: usage(60_000) });
+                }
+                return assistant(fixture, [{ type: "text", text: `normal response ${request}` }], "stop", { usage: usage(60_000) });
+            },
+        });
+        try {
+            const initialTurn = fixture.session.prompt(`REARM_${mode}_INITIAL`);
+            await warningStarted;
+            fixture.session.steer("REARM_QUEUED_FOLLOWUP");
+            releaseWarningTurn();
+            await initialTurn;
+            await fixture.session.waitForIdle();
+            const afterFailure = fixture.sessionManager.getBranch();
+            assert.equal(afterFailure.filter((entry) => entry.type === "custom_message" && entry.customType === WARNING_TYPE).length, 1, "the warning was persisted exactly once before the failed follow-up");
+            assert.ok(existsSync(join(fixture.notesRoot, "pi", "session", fixture.sessionManager.getSessionId(), "warning-rearm.md")), "the preceding note/tool turn completed");
+            assert.equal(resetMarkers(fixture).length, 0, `${mode} itself must not reset`);
+            assert.equal(afterFailure.filter((entry) => entry.type === "compaction").length, 0);
+            const failedContext = fixture.streamContexts[3];
+            assert.ok(failedContext);
+            assert.equal(text(failedContext).split(WARNING_PROMPT).length - 1, 1, "the persisted warning appears once, without duplicate injection");
+            assert.equal(text(failedContext).split("REARM_QUEUED_FOLLOWUP").length - 1, 1, "queued follow-up reaches the failed request once");
+            assert.equal(fixture.streamSignals.at(-1), mode === "ctx-abort", "the abort case cancels Pi's real signal; the error case does not");
+            await fixture.session.prompt("REARM_AFTER_FAILED_TURN");
+            await fixture.session.waitForIdle();
+            assert.equal(resetMarkers(fixture).length, 1, "the next low-budget normal stop re-arms and commits one reset");
+            assert.equal(fixture.sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === WARNING_TYPE).length, 1, "re-arming does not duplicate the durable warning");
+            const checkpoint = fixture.sessionManager.getBranch().find((entry) => entry.type === "compaction");
+            assert.ok(checkpoint?.type === "compaction");
+            assert.equal(checkpoint.firstKeptEntryId, checkpoint.id, "the retry closes with one retain-none checkpoint");
+            assertFreshRequest(fixture, fixture.requests.length - 1, "REARM_AFTER_FAILED_TURN");
+        }
+        finally {
+            releaseWarningTurn();
+            fixture.close();
+        }
+    }
+});
 test("real AgentSession: warning precedes a durable checkpoint, including failed writes and an ignored warning", { timeout: 20000 }, async () => {
     for (const scenario of ["checkpoint", "write-error", "ignored-warning"]) {
         let fixture;
         fixture = await openFixture({
             compactionEnabled: true,
             script: (request, context) => {
-                if (request === 3)
-                    assert.ok(text(context).includes(GUIDANCE_OPEN_TAG), "the critical warning reaches the provider before checkpoint choice");
+                if (request === 3) {
+                    assert.ok(text(context).includes(GUIDANCE_OPEN_TAG), "the warning remains in its hidden guidance wrapper");
+                    assert.ok(text(context).includes(WARNING_PROMPT), "the shared close-out warning reaches the provider before checkpoint choice");
+                }
                 if (request === 1)
                     return assistant(fixture, [{ type: "toolCall", id: "budget-probe-1", name: "get_context_remaining", arguments: {} }], "toolUse", { usage: usage(50_000) });
                 if (request === 2)
@@ -821,8 +1119,9 @@ test("real AgentSession: warning precedes a durable checkpoint, including failed
                 assert.ok(branch.some((entry) => entry.type === "message" && entry.message.role === "toolResult" && entry.message.toolName === "notes_write" && entry.message.isError), "the failed write is a durable tool error");
             }
             else {
-                assert.equal(resetMarkers(fixture).length, 0, "ignoring the warning does not reset automatically");
+                assert.equal(resetMarkers(fixture).length, 1, "normal stop falls back to the same reset even when the warning was ignored");
                 assert.equal(existsSync(noteFile), false);
+                assertFreshRequest(fixture, fixture.requests.length - 1, `WARNING_${scenario.toUpperCase()}_SENTINEL`);
             }
         }
         finally {

package/dist/test/boot.integration.test.d.ts

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

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

@@ -1,8 +1,9 @@
 import assert from "node:assert/strict";
+import { rmSync, writeFileSync } from "node:fs";
 import test from "node:test";
 import { historyFromSession, internal } from "../src/index.js";
-import { listNotes } from "../src/notes/store.js";
-import { CONTINUATION_TYPE } from "../src/protocol.js";
+import { listNotes } from "./helpers/notes.js";
+import { CONTINUATION_TYPE, WARNING_TYPE } from "../src/protocol.js";
 import { appendText, call, commitTurnEndBoundary, context, installExtensionTestEnvironment, makeExtension, manager, noticesOf, resultJson, resultRead, runContextHook, runContextWithSystemHook, runHandlers, runManualCompact, runCommand, sentOf, } from "./helpers/extension.js";
 const testEnvironment = installExtensionTestEnvironment("pi-context-integration");
 test.beforeEach(() => testEnvironment.beforeEach());
@@ -21,7 +22,12 @@ test("custom reset marker removes old provider context while history remains sea
     const branch = sessionManager.getBranch();
     const marker = branch.find((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE);
     assert.ok(marker && marker.type === "custom");
-    assert.equal(marker.parentId, toolResultId, "marker follows the completed tool result");
+    const checkpoint = branch.find((entry) => entry.type === "compaction");
+    assert.ok(checkpoint && checkpoint.type === "compaction", "reset persists a native retain-none checkpoint");
+    assert.equal(checkpoint.parentId, toolResultId, "checkpoint follows the completed tool result");
+    assert.equal(checkpoint.summary, "");
+    assert.equal(checkpoint.firstKeptEntryId, checkpoint.id);
+    assert.equal(marker.parentId, checkpoint.id, "marker follows the native checkpoint");
     assert.deepEqual(Object.keys(marker.data), ["windowId"]);
     const projected = await runContextWithSystemHook(captured, ctx, sessionManager.buildSessionContext().messages);
     const providerText = JSON.stringify(projected?.messages ?? []);
@@ -46,14 +52,14 @@ test("the root boot and reset boot carry durable window identity", async () => {
     appendText(sessionManager, "assistant", "working");
     await call(captured, "notes_write", { path: "decisions.md", content: "use terra" }, ctx);
     // Root window: session_start persists the boot block without triggering a turn.
-    runHandlers(captured, "session_start", { reason: "startup" }, ctx);
+    await runHandlers(captured, "session_start", { reason: "startup" }, ctx);
     assert.equal(captured.sent.length, 1);
     const rootBoot = captured.sent[0];
     assert.equal(rootBoot?.message.customType, internal.BOOT_TYPE);
     assert.equal(rootBoot?.message.display, false, "boot block stays out of the TUI");
     assert.equal(rootBoot?.options?.triggerTurn, false);
     assert.equal(noticesOf(ctx).length, 0, "initial boot is silent");
-    runHandlers(captured, "session_start", { reason: "reload" }, ctx);
+    await runHandlers(captured, "session_start", { reason: "reload" }, ctx);
     assert.equal(noticesOf(ctx).length, 0, "reload is silent");
     assert.deepEqual(rootBoot?.message.details, { windowId: `pcw:${sessionManager.getSessionId().slice(0, 8)}:root` });
     const rootText = typeof rootBoot?.message.content === "string" ? rootBoot.message.content : "";
@@ -63,7 +69,7 @@ test("the root boot and reset boot carry durable window identity", async () => {
     assert.match(rootText, new RegExp(`First context window id: pcw:${sessionManager.getSessionId().slice(0, 8)}:root`));
     assert.match(rootText, new RegExp(`Current context window id: pcw:${sessionManager.getSessionId().slice(0, 8)}:root`));
     assert.ok(rootText.includes("decisions.md"));
-    const decisionsMeta = listNotes(ctx, { scope: "session" }).find((row) => row.path === "decisions.md")?.meta;
+    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.ok(rootText.includes(internal.CONTEXT_WINDOW_PROTOCOL_OPEN_TAG));
@@ -72,8 +78,8 @@ test("the root boot and reset boot carry durable window identity", async () => {
     assert.equal(noticesOf(ctx).length, 0, "requesting a reset does not announce success");
     const boundary = await commitTurnEndBoundary(captured, sessionManager, ctx);
     assert.equal(boundary.continue, true);
-    runHandlers(captured, "turn_start", {}, ctx);
-    runHandlers(captured, "agent_settled", {}, ctx);
+    await runHandlers(captured, "turn_start", {}, ctx);
+    await runHandlers(captured, "agent_settled", {}, ctx);
     assert.equal(noticesOf(ctx).filter((notice) => notice.message.includes("memory cleared")).length, 1, "the committed reset is announced once");
     const entries = sessionManager.getBranch();
     const marker = entries.find((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE);
@@ -85,7 +91,28 @@ test("the root boot and reset boot carry durable window identity", async () => {
     const continuation = entries.find((entry) => entry.type === "custom_message" && entry.customType === CONTINUATION_TYPE);
     assert.ok(continuation && continuation.type === "custom_message" && continuation.display === false, "the resumed run is represented by one hidden continuation");
 });
-test("a marker tail with only metadata repairs its missing boot and continuation without moving the boundary", () => {
+test("an aborted async boot repair emits no boot, continuation, or incomplete-notes notice", async () => {
+    const notesHome = process.env.PI_NOTES_HOME;
+    assert.ok(notesHome);
+    rmSync(notesHome, { recursive: true, force: true });
+    writeFileSync(notesHome, "not a directory");
+    const sessionManager = manager();
+    const windowId = "pcw:aborted-boot-repair";
+    sessionManager.appendCustomEntry(internal.RESET_MARKER_TYPE, { windowId });
+    const captured = makeExtension(sessionManager);
+    const ctx = context(sessionManager);
+    const controller = new AbortController();
+    ctx.signal = controller.signal;
+    const sessionStart = captured.handlers.get("session_start")?.[0];
+    assert.ok(sessionStart);
+    const pending = sessionStart({ reason: "startup" }, ctx);
+    controller.abort();
+    await pending;
+    assert.equal(captured.sent.length, 0, "aborted snapshot work cannot append the reset boot or continuation");
+    assert.equal(noticesOf(ctx).some((notice) => notice.message.includes("notes index incomplete")), false, "aborted snapshot work cannot notify about missing homes");
+    assert.equal(sessionManager.getBranch().some((entry) => entry.type === "custom_message" && [internal.BOOT_TYPE, CONTINUATION_TYPE].includes(entry.customType)), false);
+});
+test("a marker tail with only metadata repairs its missing boot and continuation without moving the boundary", async () => {
     const sessionManager = manager(true);
     const windowId = "pcw:metadata-tail";
     const markerId = sessionManager.appendCustomEntry(internal.RESET_MARKER_TYPE, { windowId });
@@ -93,7 +120,7 @@ test("a marker tail with only metadata repairs its missing boot and continuation
     sessionManager.appendThinkingLevelChange("low");
     const captured = makeExtension(sessionManager);
     const ctx = context(sessionManager);
-    runHandlers(captured, "session_start", { reason: "startup" }, ctx);
+    await runHandlers(captured, "session_start", { reason: "startup" }, ctx);
     const branch = sessionManager.getBranch();
     const markerIndex = branch.findIndex((entry) => entry.id === markerId);
     const bootEntries = branch.filter((entry) => entry.type === "custom_message" && entry.customType === internal.BOOT_TYPE && entry.details && typeof entry.details === "object" && entry.details.windowId === windowId);
@@ -108,13 +135,13 @@ test("a marker tail with only metadata repairs its missing boot and continuation
     assert.equal(captured.sent[1]?.message.customType, CONTINUATION_TYPE);
     assert.equal(noticesOf(ctx).length, 0, "repairing a reset tail is not a new reset");
 });
-test("a bare marker tail repairs the full ordered reset shape", () => {
+test("a bare marker tail repairs the full ordered reset shape", async () => {
     const sessionManager = manager(true);
     const windowId = "pcw:bare-marker";
     const markerId = sessionManager.appendCustomEntry(internal.RESET_MARKER_TYPE, { windowId });
     const captured = makeExtension(sessionManager);
     const ctx = context(sessionManager);
-    runHandlers(captured, "session_start", { reason: "startup" }, ctx);
+    await runHandlers(captured, "session_start", { reason: "startup" }, ctx);
     assert.equal(captured.sent.length, 2, "a bare marker emits a boot and a continuation");
     const branch = sessionManager.getBranch();
     const markerIndex = branch.findIndex((entry) => entry.id === markerId);
@@ -123,7 +150,7 @@ test("a bare marker tail repairs the full ordered reset shape", () => {
     assert.ok(bootIndex > markerIndex, "the repaired boot follows its marker");
     assert.ok(continuationIndex > bootIndex, "the repaired continuation follows its boot");
 });
-test("a marker tail that already carries a boot repairs only its missing continuation, once", () => {
+test("a marker tail that already carries a boot repairs only its missing continuation, once", async () => {
     const sessionManager = manager(true);
     const windowId = "pcw:missing-continuation";
     const markerId = sessionManager.appendCustomEntry(internal.RESET_MARKER_TYPE, { windowId });
@@ -131,23 +158,23 @@ test("a marker tail that already carries a boot repairs only its missing continu
     sessionManager.appendCustomMessageEntry(internal.BOOT_TYPE, "already-persisted boot", false, { windowId });
     const captured = makeExtension(sessionManager);
     const ctx = context(sessionManager);
-    runHandlers(captured, "session_start", { reason: "startup" }, ctx);
+    await runHandlers(captured, "session_start", { reason: "startup" }, ctx);
     assert.equal(captured.sent.length, 1, "only the missing continuation is emitted");
     assert.equal(captured.sent[0]?.message.customType, CONTINUATION_TYPE);
     assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === internal.BOOT_TYPE).length, 1, "the existing boot is never duplicated");
     assert.ok(sessionManager.getBranch().findIndex((entry) => entry.id === markerId) >= 0);
-    runHandlers(captured, "session_start", { reason: "reload" }, ctx);
+    await runHandlers(captured, "session_start", { reason: "reload" }, ctx);
     assert.equal(captured.sent.length, 1, "a complete reset tail is idempotent");
     assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === CONTINUATION_TYPE).length, 1);
 });
-test("a marker tail followed by real conversation is never repaired", () => {
+test("a marker tail followed by real conversation is never repaired", async () => {
     const sessionManager = manager(true);
     const windowId = "pcw:unsafe-tail";
     sessionManager.appendCustomEntry(internal.RESET_MARKER_TYPE, { windowId });
     appendText(sessionManager, "user", "post-marker work that must not be pushed behind a late boot");
     const captured = makeExtension(sessionManager);
     const ctx = context(sessionManager);
-    runHandlers(captured, "session_start", { reason: "startup" }, ctx);
+    await runHandlers(captured, "session_start", { reason: "startup" }, ctx);
     assert.equal(captured.sent.length, 0, "an unsafe marker tail emits nothing");
     assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === internal.BOOT_TYPE).length, 0, "no boot is appended after real work");
     assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === CONTINUATION_TYPE).length, 0, "no continuation is appended after real work");
@@ -180,37 +207,36 @@ test("wipe_memory uses one turn boundary and never calls ctx.compact", async ()
     assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE).length, 1);
     assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === internal.BOOT_TYPE && entry.details && typeof entry.details === "object" && "windowId" in entry.details).length, 1);
 });
-test("pi-context command toggles future work, /wipe-memory is the manual path, and active markers cancel /compact", async () => {
+test("pi-context command toggles future work, /wipe-memory starts close-out, and /compact remains disabled", async () => {
     const sessionManager = manager();
     appendText(sessionManager, "user", "hello");
     const captured = makeExtension(sessionManager);
     const low = context(sessionManager, undefined, { tokens: 170_000, contextWindow: 200_000, percent: 85 });
     // On by default: session_start persists the root boot block.
-    runHandlers(captured, "session_start", { reason: "startup" }, low);
+    await runHandlers(captured, "session_start", { reason: "startup" }, low);
     assert.equal(captured.sent.length, 1);
     assert.equal(captured.sent[0]?.message.customType, internal.BOOT_TYPE);
     let notices = await runCommand(captured, "pi-context", "off", low);
     assert.match(notices[0]?.message ?? "", /off/);
     assert.equal(await runContextHook(captured, low), undefined, "no guidance while off");
     assert.equal(sentOf(captured, internal.GUIDANCE_TYPE).length, 0, "no guidance persisted while off");
-    runHandlers(captured, "session_start", { reason: "startup" }, low);
+    await runHandlers(captured, "session_start", { reason: "startup" }, low);
     assert.equal(captured.sent.length, 1, "no new boot block is persisted while off");
     const offResult = resultJson(await call(captured, "wipe_memory", {}, low));
     assert.match(offResult.error ?? "", /off/, "wipe_memory refuses while off");
     notices = await runCommand(captured, "pi-context", "on", low);
     assert.match(notices[0]?.message ?? "", /on/);
     notices = await runCommand(captured, "wipe-memory", "", low);
-    assert.equal(notices.length, 1, "manual clear emits exactly one notification");
-    assert.match(notices[0]?.message ?? "", /memory cleared/);
-    assert.equal(captured.sent.length, 3, "/wipe-memory writes one hidden boot and one continuation without triggering a model turn");
-    assert.equal(captured.sent[1]?.options?.triggerTurn, false);
-    assert.equal(captured.sent[1]?.message.customType, internal.BOOT_TYPE);
-    assert.equal(captured.sent[2]?.message.customType, CONTINUATION_TYPE);
-    assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE).length, 1);
+    assert.equal(notices.length, 0, "the command begins a model close-out rather than announcing a reset request");
+    assert.equal(captured.sent.length, 2, "the command persists one hidden warning after the startup boot");
+    assert.equal(captured.sent[1]?.options?.triggerTurn, true, "the shared warning starts an ordinary agent turn");
+    assert.equal(captured.sent[1]?.message.customType, WARNING_TYPE);
+    assert.equal(captured.sent[1]?.message.display, false);
+    assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE).length, 0, "no reset is claimed until close-out completes");
     const markerContext = await runManualCompact(captured, low);
-    assert.deepEqual(markerContext, { cancel: true }, "/compact is canceled while a marker is active");
+    assert.deepEqual(markerContext, { cancel: true }, "/compact is canceled while context windows are enabled");
     const projected = await runContextWithSystemHook(captured, low, sessionManager.buildSessionContext().messages);
-    assert.equal(JSON.stringify(projected?.messages ?? []).includes("hello"), false, "off keeps the existing wipe in force");
+    assert.equal(JSON.stringify(projected?.messages ?? []).includes("hello"), true, "the old window remains active until the close-out commits");
     notices = await runCommand(captured, "pi-context", "maybe", low);
     assert.equal(notices[0]?.type, "error", "unknown argument rejected");
     // Bare command reports current state without changing it.

package/dist/test/budget-settings.integration.test.d.ts

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