@astrosheep/pi-context 0.24.0 → 0.25.0

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

@@ -1,238 +1,830 @@
 import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
-import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
-import { createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
-import piContext from "../src/index.js";
-import { GUIDANCE_OPEN_TAG, WARNING_TYPE, GUIDANCE_TYPE } from "../src/protocol.js";
-for (const mode of ["golden", "write-error", "ignored-warning", "explicit", "uncompactable", "followup", "steering", "repeat", "nested", "immediate-dispose", "abort"]) {
-    test(`real Pi loop: ${mode} reset preserves history and handles completion`, { timeout: 15000 }, async () => {
-        const dir = mkdtempSync(join(tmpdir(), "pi-context-loop-"));
-        const previousDir = process.env.PI_CODING_AGENT_DIR;
-        const previousNotesRoot = process.env.PI_NOTES_HOME;
-        process.env.PI_CODING_AGENT_DIR = dir;
-        const notesRoot = mkdtempSync(join(tmpdir(), "pi-context-loop-notes-"));
+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, GUIDANCE_OPEN_TAG, GUIDANCE_TYPE, RESET_MARKER_TYPE, 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;
+    const notesRoot = options.notesRoot ?? mkdtempSync(join(tmpdir(), "pi-context-agent-loop-notes-"));
+    const ownsNotesRoot = options.notesRoot === undefined;
+    const agentDir = options.agentDir ?? dir;
+    const managesEnvironment = options.manageEnvironment ?? true;
+    const previousDir = managesEnvironment ? process.env.PI_CODING_AGENT_DIR : undefined;
+    const previousNotesRoot = managesEnvironment ? process.env.PI_NOTES_HOME : undefined;
+    if (managesEnvironment) {
+        process.env.PI_CODING_AGENT_DIR = agentDir;
         process.env.PI_NOTES_HOME = notesRoot;
-        let session;
-        let disposed = false;
-        try {
-            const runtime = await ModelRuntime.create({ authPath: join(dir, "auth.json"), modelsPath: null, modelsStorePath: join(dir, "models"), refreshOnCreate: false });
-            await runtime.setRuntimeApiKey("openai", "scripted-test-key");
-            const base = runtime.getModels("openai")[0];
-            assert.ok(base);
-            const model = { ...base, contextWindow: 100000, maxTokens: 4096 };
-            const usageMode = mode === "golden" || mode === "write-error" || mode === "ignored-warning";
-            const expectedResets = mode === "abort" || mode === "uncompactable" ? 0 : mode === "nested" ? 2 : 1;
-            // 0.86 split-turn cut can still summarize a turn prefix, so keepRecentTokens: 1 no longer
-            // makes a reset uncompactable; a keep larger than the whole session keeps everything and does.
-            const settings = { compaction: { enabled: usageMode, reserveTokens: 32768, keepRecentTokens: mode === "uncompactable" ? 1_000_000 : 200 }, retry: { enabled: false } };
-            writeFileSync(join(dir, "settings.json"), JSON.stringify(settings));
-            const settingsManager = SettingsManager.create(dir, dir);
-            let resets = 0;
-            let settled = 0;
-            let targetResets = expectedResets;
-            let activeSentinel = "OLD_CONTEXT_SENTINEL";
-            let finish;
-            let failFinish;
-            const finished = new Promise((resolve, reject) => { finish = resolve; failFinish = reject; });
-            const finishTimeout = setTimeout(() => failFinish(new Error(`timed out waiting for ${mode} agent settlement (resets=${resets}, settled=${settled}, requests=${requests.length})`)), 5000);
-            const loader = new DefaultResourceLoader({ cwd: dir, agentDir: dir, settingsManager,
-                noExtensions: true, noSkills: true, noThemes: true, noPromptTemplates: true,
-                systemPromptOverride: () => "Use the tools as requested.", agentsFilesOverride: () => ({ agentsFiles: [] }),
-                extensionFactories: [piContext, (pi) => {
-                        pi.on("session_compact", () => { resets++; });
-                        pi.on("agent_settled", () => {
-                            settled++;
-                            if (mode === "abort") {
-                                if (settled === 1)
-                                    finish();
-                                return;
-                            }
-                            if (resets >= targetResets && requests.length > 0 && !requests.at(-1).includes(activeSentinel))
-                                finish();
-                        });
-                        pi.on("tool_result", () => {
-                            if (mode === "abort")
-                                void session.abort();
-                        });
-                        pi.on("tool_call", async () => {
-                            if (mode === "followup")
-                                await session.followUp("QUEUED_INPUT_SENTINEL");
-                            if (mode === "steering")
-                                await session.steer("QUEUED_INPUT_SENTINEL");
-                        });
-                    }],
-            });
-            await loader.reload();
-            const sm = SessionManager.inMemory(dir);
-            sm.appendMessage({ role: "user", content: "Earlier work to retain in durable history.", timestamp: Date.now() });
-            sm.appendMessage({ role: "assistant", api: model.api, provider: model.provider, model: model.id,
-                content: [{ type: "text", text: "Earlier result. ".repeat(100) }], stopReason: "stop", timestamp: Date.now(),
-                usage: { input: 100, output: 100, cacheRead: 0, cacheWrite: 0, totalTokens: 200, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } } });
-            ({ session } = await createAgentSession({ cwd: dir, agentDir: dir, modelRuntime: runtime, model, settingsManager, sessionManager: sm, resourceLoader: loader, tools: ["wipe_memory", "notes_write", "get_context_remaining"] }));
-            const requests = [];
-            let checkpointed = false;
-            let freshTurns = 0;
-            session.agent.streamFunction = (_model, context) => {
-                requests.push(JSON.stringify(context.messages));
-                const n = requests.length;
-                const request = requests[n - 1];
-                const fresh = !request.includes("OLD_CONTEXT_SENTINEL");
-                if (fresh)
-                    freshTurns++;
-                // The early reminder and the final warning steer share one structural envelope:
-                // <context_window_guidance>. The reminder is the first in the window, the
-                // warning the second, so the envelope count identifies which arrived.
-                // The early reminder and the final warning steer share one structural envelope,
-                // <context_window_guidance>. The reminder is deferred to the end of the turn while
-                // streaming, so in this scripted tool-calling loop only the warning reaches the
-                // provider context: the envelope's presence marks the warning.
-                const budgetMarkers = request.split(GUIDANCE_OPEN_TAG).length - 1;
-                const sawWarning = budgetMarkers >= 1;
-                const sawGuidance = budgetMarkers >= 1;
-                const explicitReset = (n === 1 && !usageMode && mode !== "uncompactable") || (mode === "repeat" && (n === 1 || n === 3)) || (mode === "nested" && n === 3);
-                const nestedCheckpoint = mode === "nested" && n === 2;
-                const checkpoint = usageMode && sawWarning && !checkpointed && mode !== "ignored-warning";
-                if (checkpoint)
-                    checkpointed = true;
-                // The warning is chosen from the previous turn's usage, so a scripted run has to
-                // keep taking turns until it sees the warning (first window) or the next
-                // window's reminder. "ignored-warning" keeps working instead of checkpointing.
-                const probe = usageMode && !checkpoint && ((!fresh && !sawWarning) || (mode === "ignored-warning" && sawWarning) || (fresh && freshTurns === 2 && !sawGuidance));
-                const tokens = usageMode ? (fresh ? (freshTurns === 1 ? 100 : 50000) : sawWarning ? 70000 : n === 1 ? 50000 : 60000) : 100;
-                const tool = explicitReset || nestedCheckpoint || (mode === "uncompactable" && n === 1);
-                const call = probe ? "get_context_remaining" : checkpoint || nestedCheckpoint ? "notes_write" : tool ? "wipe_memory" : undefined;
-                const message = { role: "assistant", api: model.api, provider: model.provider, model: model.id,
-                    content: probe ? [{ type: "toolCall", id: "probe-call", name: "get_context_remaining", arguments: {} }]
-                        : checkpoint || nestedCheckpoint ? [{ type: "toolCall", id: "checkpoint-call", name: "notes_write", arguments: { address: mode === "write-error" ? "../invalid.md" : "checkpoint.md", content: nestedCheckpoint ? "NESTED_RESET_PADDING ".repeat(300) : "CHECKPOINT_SENTINEL" } }]
-                            : tool ? [{ type: "toolCall", id: "reset-call", name: "wipe_memory", arguments: {} }]
-                                : [{ type: "text", text: fresh ? "Resumed." : "Working." }],
-                    stopReason: call ? "toolUse" : "stop", timestamp: Date.now(),
-                    usage: { input: tokens, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: tokens + 1, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
-                };
-                const stream = createAssistantMessageEventStream();
-                stream.push({ type: "done", reason: message.stopReason, message });
-                stream.end();
-                return stream;
+    }
+    if (options.notesRootFile) {
+        rmSync(notesRoot, { recursive: true, force: true });
+        writeFileSync(notesRoot, "blocked notes root");
+    }
+    const runtime = await ModelRuntime.create({
+        authPath: join(dir, "auth.json"),
+        modelsPath: null,
+        modelsStorePath: join(dir, "models"),
+        refreshOnCreate: false,
+    });
+    await runtime.setRuntimeApiKey("openai", "scripted-test-key");
+    const base = runtime.getModels("openai")[0];
+    assert.ok(base, "the installed SDK exposes a scripted model");
+    const model = { ...base, contextWindow: options.contextWindow ?? 100_000, maxTokens: 4096 };
+    runtime.stream = (() => { throw new Error("unexpected native model request"); });
+    runtime.complete = (() => { throw new Error("unexpected native model request"); });
+    runtime.streamSimple = (() => { throw new Error("unexpected native model request"); });
+    runtime.completeSimple = (() => { throw new Error("unexpected native model request"); });
+    if (options.writeSettings !== false)
+        writeFileSync(join(agentDir, "settings.json"), JSON.stringify({
+            compaction: {
+                enabled: options.defaultCompactionEnabled ?? options.compactionEnabled ?? true,
+                reserveTokens: options.defaultReserveTokens ?? 32_768,
+                keepRecentTokens: options.keepRecentTokens ?? 200,
+            },
+            retry: { enabled: false },
+        }));
+    if (options.projectSettings !== undefined) {
+        mkdirSync(join(dir, ".pi"), { recursive: true });
+        writeFileSync(join(dir, ".pi", "settings.json"), JSON.stringify(options.projectSettings));
+    }
+    const settingsManager = typeof options.settingsManager === "function"
+        ? options.settingsManager(model)
+        : options.settingsManager ?? SettingsManager.create(dir, agentDir, { projectTrusted: options.projectTrusted ?? true });
+    const requests = [];
+    const streamContexts = [];
+    const streamSignals = [];
+    const events = [];
+    const notices = [];
+    let session;
+    const loader = new DefaultResourceLoader({
+        cwd: dir,
+        agentDir,
+        settingsManager,
+        noExtensions: true,
+        noSkills: true,
+        noThemes: true,
+        noPromptTemplates: true,
+        systemPromptOverride: () => options.systemPrompt ?? "Use the tools as requested.",
+        agentsFilesOverride: () => ({ agentsFiles: [] }),
+        extensionFactories: [options.settingsManager ? createPiContext({ settingsManager }) : piContext, (pi) => {
+                options.hook?.(pi, () => session, requests);
+            }],
+    });
+    await loader.reload();
+    const sessionManager = SessionManager.inMemory(dir);
+    options.seed?.(sessionManager);
+    const created = await createAgentSession({
+        cwd: dir,
+        agentDir,
+        modelRuntime: runtime,
+        model,
+        settingsManager,
+        sessionManager,
+        resourceLoader: loader,
+        tools: options.tools ?? ["wipe_memory", "notes_write", "get_context_remaining"],
+    });
+    session = created.session;
+    session.subscribe((event) => events.push(event));
+    session.agent.streamFunction = (_model, context, streamOptions) => {
+        const aborted = streamOptions?.signal?.aborted === true;
+        streamContexts.push(context);
+        streamSignals.push(aborted);
+        if (aborted) {
+            const message = {
+                role: "assistant",
+                api: model.api,
+                provider: model.provider,
+                model: model.id,
+                content: [],
+                stopReason: "aborted",
+                errorMessage: "scripted request aborted",
+                timestamp: Date.now(),
+                usage: usage(0, 0),
             };
-            await session.bindExtensions({});
-            let failure;
-            session.subscribe((event) => {
-                if (mode === "uncompactable" && event.type === "compaction_end" && event.errorMessage) {
-                    failure = event.errorMessage;
-                    finish();
+            const stream = createAssistantMessageEventStream();
+            stream.push({ type: "error", reason: "aborted", error: message });
+            stream.end();
+            return stream;
+        }
+        requests.push(context);
+        const request = requests.length;
+        const message = options.script(request, context);
+        const stream = createAssistantMessageEventStream();
+        stream.push({ type: "done", reason: (message.stopReason === "error" || message.stopReason === "aborted" ? "stop" : message.stopReason), message });
+        stream.end();
+        return stream;
+    };
+    await session.bindExtensions({
+        uiContext: {
+            notify(message) {
+                if (message.startsWith("pi-context: memory cleared · ")) {
+                    const windowId = message.split(" · ")[1];
+                    assert.ok(sessionManager.getBranch().some((entry) => entry.type === "custom" && entry.customType === RESET_MARKER_TYPE && entry.data?.windowId === windowId), "notification follows the reset marker commit");
+                    assert.ok(sessionManager.getBranch().some((entry) => entry.type === "custom_message" && entry.customType === BOOT_TYPE && entry.details?.windowId === windowId), "notification follows the reset boot commit");
                 }
-            });
-            await session.prompt("OLD_CONTEXT_SENTINEL: save progress and continue the task.");
-            if (mode === "immediate-dispose") {
-                // prompt() must not resolve after compaction merely because sendMessage is
-                // detached: by this point the continuation has settled and answered.
-                session.dispose();
-                disposed = true;
-                assert.ok(settled >= 2, "the continuation settles before the originating prompt resolves");
-                assert.ok(requests.length >= 2 && !requests.at(-1).includes("OLD_CONTEXT_SENTINEL"), "the resumed answer exists before immediate disposal");
-            }
-            await finished;
-            clearTimeout(finishTimeout);
-            if (!disposed)
-                await session.waitForIdle();
-            if (mode === "abort") {
-                assert.equal(resets, 0, "user cancellation clears pending rollover");
-                assert.equal(requests.length, 1, "no continuation resurrects the cancelled run");
-                await session.prompt("Resume explicitly after cancellation.");
-                assert.equal(requests.length, 2);
-                assert.ok(requests[1].includes("Resume explicitly after cancellation."));
-                assert.ok(requests[1].includes("OLD_CONTEXT_SENTINEL"), "no reset happened: history is intact");
-                return;
+                if (message.includes("context budget low") || message.includes("context budget critical")) {
+                    const customType = message.includes("context budget critical") ? WARNING_TYPE : GUIDANCE_TYPE;
+                    assert.ok(sessionManager.getBranch().some((entry) => entry.type === "custom_message" && entry.customType === customType), "budget notifications follow the reminder commit");
+                }
+                notices.push(message);
+            },
+        },
+    });
+    return {
+        dir,
+        notesRoot,
+        sessionManager,
+        session,
+        model,
+        requests,
+        streamContexts,
+        streamSignals,
+        events,
+        notices,
+        close: () => {
+            session.dispose();
+            if (managesEnvironment) {
+                if (previousDir === undefined)
+                    delete process.env.PI_CODING_AGENT_DIR;
+                else
+                    process.env.PI_CODING_AGENT_DIR = previousDir;
+                if (previousNotesRoot === undefined)
+                    delete process.env.PI_NOTES_HOME;
+                else
+                    process.env.PI_NOTES_HOME = previousNotesRoot;
             }
-            if (mode === "uncompactable") {
-                assert.match(failure ?? "", /Nothing to compact/);
-                assert.equal(resets, 0);
-                assert.equal(requests.length, 1, "failed reset does not loop or resume automatically");
-                await session.prompt("Continue after the failed reset.");
-                assert.equal(requests.length, 2);
-                assert.ok(requests[1].includes("OLD_CONTEXT_SENTINEL"));
-                return;
+            if (ownsDir)
+                rmSync(dir, { recursive: true, force: true });
+            if (ownsNotesRoot)
+                rmSync(notesRoot, { recursive: true, force: true });
+        },
+    };
+}
+function usage(input, output = 1) {
+    return {
+        input,
+        output,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: input + output,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+function assistant(fixture, content, stopReason = "stop", extra = {}) {
+    return {
+        role: "assistant",
+        api: fixture.model.api,
+        provider: fixture.model.provider,
+        model: fixture.model.id,
+        content,
+        stopReason,
+        timestamp: Date.now(),
+        usage: usage(100),
+        ...extra,
+    };
+}
+function text(message) {
+    return JSON.stringify(message?.messages ?? []);
+}
+function resetMarkers(fixture) {
+    return fixture.sessionManager.getBranch().filter((entry) => entry.type === "custom" && entry.customType === RESET_MARKER_TYPE);
+}
+function contextRemainingResults(fixture) {
+    const results = [];
+    for (const entry of fixture.sessionManager.getBranch()) {
+        if (entry.type !== "message" || entry.message.role !== "toolResult" || entry.message.toolName !== "get_context_remaining")
+            continue;
+        const content = entry.message.content.find((part) => part.type === "text")?.text;
+        if (content === undefined)
+            continue;
+        const value = JSON.parse(content);
+        if (typeof value.remaining_tokens === "number" || value.remaining_tokens === null)
+            results.push(value.remaining_tokens);
+    }
+    return results;
+}
+function assertFreshRequest(fixture, requestIndex, oldSentinel) {
+    const body = text(fixture.requests[requestIndex]);
+    assert.equal(body.includes(oldSentinel), false, "the new provider request excludes the old window transcript");
+    assert.ok(body.includes(CONTEXT_WINDOW_OPEN_TAG), "the new provider request includes the fresh context-window boot");
+}
+test("real AgentSession: aborted low-budget requests notify only after a retry commits the reminder", async () => {
+    let fixture;
+    fixture = await openFixture({
+        compactionEnabled: false,
+        script: (request) => assistant(fixture, [{ type: "text", text: `response ${request}` }], request === 2 ? "aborted" : "stop", { usage: usage(50_000) }),
+    });
+    try {
+        const reminders = () => fixture.sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === GUIDANCE_TYPE);
+        const notices = () => fixture.notices.filter((message) => message.includes("context budget low"));
+        await fixture.session.prompt("Establish usage below the reminder line.");
+        await fixture.session.waitForIdle();
+        assert.equal(reminders().length, 0);
+        await fixture.session.prompt("Abort this low-budget request.");
+        await fixture.session.waitForIdle();
+        assert.equal(reminders().length, 0, "an aborted turn does not commit its reminder");
+        assert.equal(notices().length, 0, "an uncommitted reminder never notifies");
+        await fixture.session.prompt("Retry successfully.");
+        await fixture.session.waitForIdle();
+        assert.equal(reminders().length, 1);
+        assert.equal(notices().length, 1, "the committed retry notifies once");
+        await fixture.session.prompt("Continue in the same window.");
+        await fixture.session.waitForIdle();
+        assert.equal(reminders().length, 1);
+        assert.equal(notices().length, 1, "later turns cannot repeat the notice");
+    }
+    finally {
+        fixture.close();
+    }
+});
+test("real AgentSession: explicit tiny-session wipe ignores keepRecentTokens and preserves raw history", async () => {
+    let fixture;
+    fixture = await openFixture({
+        compactionEnabled: false,
+        keepRecentTokens: 1_000_000,
+        script: (request, context) => request === 1
+            ? assistant(fixture, [{ type: "toolCall", id: "wipe-1", name: "wipe_memory", arguments: {} }], "toolUse")
+            : assistant(fixture, [{ type: "text", text: "resumed in a new window" }]),
+    });
+    try {
+        assert.equal(fixture.requests.length, 0, "startup boot does not trigger a model request");
+        assert.equal(fixture.notices.length, 0, "startup boot is silent");
+        await fixture.session.prompt("OLD_CONTEXT_SENTINEL: retain this only in durable history.");
+        await fixture.session.waitForIdle();
+        assert.equal(fixture.notices.filter((message) => message.includes("memory cleared")).length, 1, "the reset notifies once");
+        assert.equal(fixture.requests.length, 2, "the tool starts exactly one continuation");
+        assert.ok(text(fixture.requests[0]).includes("OLD_CONTEXT_SENTINEL"));
+        assertFreshRequest(fixture, 1, "OLD_CONTEXT_SENTINEL");
+        assert.equal(resetMarkers(fixture).length, 1, "explicit wipe does not depend on Pi's compaction keep window");
+        const marker = resetMarkers(fixture)[0];
+        assert.equal(marker.type, "custom");
+        assert.deepEqual(Object.keys(marker.data), ["windowId"]);
+        const windowId = marker.data.windowId;
+        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");
+        assert.ok(JSON.stringify(fixture.sessionManager.getBranch()).includes("OLD_CONTEXT_SENTINEL"), "raw history remains readable");
+    }
+    finally {
+        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({
+        compactionEnabled: false,
+        notesRootFile: true,
+        script: (request) => request === 1
+            ? assistant(fixture, [{ type: "toolCall", id: "wipe-notes-failure", name: "wipe_memory", arguments: {} }], "toolUse")
+            : assistant(fixture, [{ type: "text", text: "resumed despite notes failure" }]),
+    });
+    try {
+        await fixture.session.prompt("NOTES_FAILURE_RESET_SENTINEL");
+        await fixture.session.waitForIdle();
+        assert.equal(fixture.requests.length, 2, "the failed notes index does not cancel the continuation");
+        assertFreshRequest(fixture, 1, "NOTES_FAILURE_RESET_SENTINEL");
+        assert.equal(resetMarkers(fixture).length, 1, "one reset marker is committed");
+        const marker = resetMarkers(fixture)[0];
+        assert.equal(marker.type, "custom");
+        const windowId = marker.data.windowId;
+        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");
+        const bootText = typeof boot.content === "string" ? boot.content : JSON.stringify(boot.content);
+        assert.ok(bootText.includes("Notes index incomplete"));
+        assert.ok(bootText.includes("notes_list can retry after recovery"));
+        assert.ok(bootText.includes("<context_window_protocol>"));
+    }
+    finally {
+        fixture.close();
+    }
+});
+test("real AgentSession: reset projection drops legacy message shapes but keeps raw history and equal/backwards new timestamps", { timeout: 15000 }, async () => {
+    let fixture;
+    const legacyTimestamp = Date.now();
+    const legacyTexts = [
+        "OLD_BASH_EXECUTION",
+        "OLD_TOOL_RESULT",
+        "OLD_COMPACTION_SUMMARY_WRAPPER",
+        "OLD_BRANCH_SUMMARY",
+    ];
+    fixture = await openFixture({
+        compactionEnabled: false,
+        seed: (sessionManager) => {
+            sessionManager.appendMessage({ role: "user", content: [{ type: "text", text: "OLD_USER_BEFORE_LEGACY_ENTRIES" }], timestamp: legacyTimestamp });
+            sessionManager.appendMessage({ role: "bashExecution", command: legacyTexts[0], output: legacyTexts[0], exitCode: 0, cancelled: false, truncated: false, timestamp: legacyTimestamp });
+            sessionManager.appendMessage({ role: "toolResult", content: [{ type: "text", text: legacyTexts[1] }], toolCallId: "legacy-tool", toolName: "bash", isError: false, timestamp: legacyTimestamp });
+            const compactionParent = sessionManager.getLeafId();
+            sessionManager.appendCompaction(legacyTexts[2], compactionParent, 123, { legacy: true }, true);
+            sessionManager.branchWithSummary(sessionManager.getLeafId(), legacyTexts[3], { legacy: true }, true);
+        },
+        script: (request, context) => {
+            if (request === 1)
+                return assistant(fixture, [{ type: "toolCall", id: "wipe-legacy", name: "wipe_memory", arguments: {} }], "toolUse");
+            if (request === 2) {
+                const body = text(context);
+                for (const legacy of legacyTexts)
+                    assert.equal(body.includes(legacy), false, `${legacy} is cut from the reset projection`);
+                return assistant(fixture, [{ type: "toolCall", id: "new-timestamp", name: "notes_write", arguments: { address: "equal-timestamp.md", content: "NEW_EQUAL_BACKWARDS_MESSAGE" } }], "toolUse", { timestamp: legacyTimestamp - 1 });
             }
-            assert.equal(resets, expectedResets);
-            if (mode === "golden" || mode === "write-error" || mode === "ignored-warning") {
-                const branch = sm.getBranch();
-                const guidanceIndices = branch.flatMap((entry, i) => entry.type === "custom_message" && entry.customType === GUIDANCE_TYPE ? [i] : []);
-                const warningIndices = branch.flatMap((entry, i) => entry.type === "custom_message" && entry.customType === WARNING_TYPE ? [i] : []);
-                const noteFile = join(notesRoot, "pi", "session", sm.getSessionId(), "checkpoint.md");
-                const resetIndex = branch.findIndex((entry) => entry.type === "compaction");
-                assert.equal(guidanceIndices.length, 1, "one early reminder");
-                assert.equal(warningIndices.length, 1, "one final warning steer");
-                assert.ok(warningIndices[0] > guidanceIndices[0], "the reminder precedes the warning");
-                if (mode === "ignored-warning") {
-                    assert.equal(existsSync(noteFile), false, "an ignored warning leaves no checkpoint");
-                }
-                else if (mode === "write-error") {
-                    assert.equal(existsSync(noteFile), false, "failed write creates no checkpoint");
-                    assert.ok(branch.some((entry) => entry.type === "message" && entry.message.role === "toolResult" && entry.message.toolName === "notes_write" && entry.message.isError));
-                    assert.ok(!requests.at(-1).includes("checkpoint.md"), "fresh context must not invent a saved note");
-                }
-                else {
-                    assert.ok(existsSync(noteFile), "the checkpoint is a real file on disk");
-                    assert.ok(resetIndex > warningIndices[0], "the warning precedes the wipe");
-                    assert.ok(requests.at(-1).includes("checkpoint.md"), "fresh boot carries the saved checkpoint as a metadata line");
-                }
-                assert.ok(!requests.at(-1).includes(GUIDANCE_OPEN_TAG), "new window excludes old guidance");
+            const body = text(context);
+            for (const legacy of legacyTexts)
+                assert.equal(body.includes(legacy), false, `${legacy} stays absent after another fresh-window turn`);
+            assert.ok(body.includes("NEW_EQUAL_BACKWARDS_MESSAGE"), "a new message with an equal/backwards timestamp survives the projection");
+            const newAssistant = context.messages.find((message) => message.role === "assistant" && JSON.stringify(message).includes("NEW_EQUAL_BACKWARDS_MESSAGE"));
+            assert.equal(newAssistant?.timestamp, legacyTimestamp - 1, "projection preserves the new message timestamp");
+            return assistant(fixture, [{ type: "text", text: "legacy projection clean" }]);
+        },
+    });
+    try {
+        await fixture.session.prompt("NEW_WINDOW_PROJECTION_SENTINEL");
+        await fixture.session.waitForIdle();
+        assert.equal(fixture.requests.length, 3, "the fresh window accepts one additional new-window tool turn");
+        assert.equal(resetMarkers(fixture).length, 1);
+        const raw = JSON.stringify(fixture.sessionManager.getBranch());
+        for (const legacy of legacyTexts)
+            assert.ok(raw.includes(legacy), `${legacy} remains in durable raw history`);
+    }
+    finally {
+        fixture.close();
+    }
+});
+test("real AgentSession: successive resets and a mixed tool batch cut only after every tool result", async () => {
+    for (const scenario of ["successive", "mixed"]) {
+        let fixture;
+        fixture = await openFixture({
+            compactionEnabled: false,
+            script: (request) => {
+                if (scenario === "successive" && request < 3)
+                    return assistant(fixture, [{ type: "toolCall", id: `wipe-${request}`, name: "wipe_memory", arguments: {} }], "toolUse");
+                if (scenario === "mixed" && request === 1)
+                    return assistant(fixture, [
+                        { type: "toolCall", id: "wipe-1", name: "wipe_memory", arguments: {} },
+                        { type: "toolCall", id: "note-1", name: "notes_write", arguments: { address: "batch.md", content: "MIXED_BATCH_NOTE" } },
+                    ], "toolUse");
+                return assistant(fixture, [{ type: "text", text: "fresh completion" }]);
+            },
+        });
+        try {
+            await fixture.session.prompt(`OLD_${scenario.toUpperCase()}_SENTINEL`);
+            await fixture.session.waitForIdle();
+            const expected = scenario === "successive" ? 2 : 1;
+            assert.equal(resetMarkers(fixture).length, expected);
+            assert.equal(fixture.requests.length, expected + 1);
+            assertFreshRequest(fixture, fixture.requests.length - 1, `OLD_${scenario.toUpperCase()}_SENTINEL`);
+            if (scenario === "mixed") {
+                const branch = fixture.sessionManager.getBranch();
+                const markerIndex = branch.findIndex((entry) => entry.type === "custom" && entry.customType === RESET_MARKER_TYPE);
+                assert.ok(markerIndex > 0, "the marker follows the completed tool batch");
+                assert.ok(branch.slice(0, markerIndex).some((entry) => entry.type === "message" && entry.message.role === "toolResult" && entry.message.toolName === "notes_write"), "notes_write completes before the cut");
+                assert.ok(existsSync(join(fixture.notesRoot, "pi", "session", fixture.sessionManager.getSessionId(), "batch.md")));
             }
-            if (mode === "followup" || mode === "steering") {
-                assert.ok(requests[1].includes("QUEUED_INPUT_SENTINEL"), "queued user work is delivered before rollover");
-                assert.ok(requests[1].includes("OLD_CONTEXT_SENTINEL"), "queue drains in the existing window");
-                assert.ok(!requests[2].includes("QUEUED_INPUT_SENTINEL"), "queue is not replayed after rollover");
-                const queuedEntries = sm.getBranch().filter((entry) => entry.type === "message" && JSON.stringify(entry.message).includes("QUEUED_INPUT_SENTINEL"));
-                assert.equal(queuedEntries.length, 1, "one durable user input");
+        }
+        finally {
+            fixture.close();
+        }
+    }
+});
+test("real AgentSession: steering and follow-up are delivered exactly once in the fresh window", async () => {
+    for (const deliverAs of ["steer", "followUp"]) {
+        let fixture;
+        fixture = await openFixture({
+            compactionEnabled: false,
+            hook: (pi, getSession) => {
+                pi.on("tool_call", async (event) => {
+                    if (event.toolName !== "wipe_memory")
+                        return;
+                    if (deliverAs === "steer")
+                        await getSession().steer("QUEUED_ONCE");
+                    else
+                        await getSession().followUp("QUEUED_ONCE");
+                });
+            },
+            script: (request) => request === 1
+                ? assistant(fixture, [{ type: "toolCall", id: "wipe-queue", name: "wipe_memory", arguments: {} }], "toolUse")
+                : assistant(fixture, [{ type: "text", text: "queued message handled" }]),
+        });
+        try {
+            await fixture.session.prompt(`OLD_${deliverAs}_SENTINEL`);
+            await fixture.session.waitForIdle();
+            assert.equal(fixture.requests.length, 2, `${deliverAs} does not duplicate the resumed request`);
+            assertFreshRequest(fixture, 1, `OLD_${deliverAs}_SENTINEL`);
+            assert.equal(text(fixture.requests[1]).split("QUEUED_ONCE").length - 1, 1, `${deliverAs} arrives once in the new window`);
+            const queued = fixture.sessionManager.getBranch().filter((entry) => entry.type === "message" && JSON.stringify(entry.message).includes("QUEUED_ONCE"));
+            assert.equal(queued.length, 1, `${deliverAs} has one durable user message`);
+        }
+        finally {
+            fixture.close();
+        }
+    }
+});
+test("real AgentSession: hidden or missing reset boots refuse to move the boundary", { timeout: 15000 }, async () => {
+    let fixture;
+    fixture = await openFixture({
+        compactionEnabled: false,
+        script: () => assistant(fixture, [{ type: "text", text: "scripted acknowledgement" }]),
+    });
+    try {
+        await fixture.session.prompt("ROOT_BEFORE_HIDDEN_BOOT");
+        await fixture.session.waitForIdle();
+        await fixture.session.prompt("/wipe-memory");
+        await fixture.session.waitForIdle();
+        await fixture.session.prompt("VALID_POST_MARKER_WORK");
+        await fixture.session.waitForIdle();
+        const marker = resetMarkers(fixture)[0];
+        assert.ok(marker && marker.type === "custom");
+        const windowId = marker.data.windowId;
+        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");
+        fixture.sessionManager.appendContextEdit(boot.id, null);
+        const bootCount = () => fixture.sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === BOOT_TYPE && entry.details && typeof entry.details === "object" && entry.details.windowId === windowId).length;
+        assert.equal(bootCount(), 1);
+        await fixture.session.reload();
+        assert.equal(bootCount(), 1, "a raw boot hidden by context_edit is not replaced at the tail");
+        const requestsBeforeRefusal = fixture.requests.length;
+        await fixture.session.prompt("MISSING_PROJECTED_BOOT_SENTINEL");
+        await fixture.session.waitForIdle();
+        assert.equal(bootCount(), 1, "a refused active window never receives a replacement boot");
+        assert.ok(fixture.requests.length <= requestsBeforeRefusal, "the normal provider request is not generated from a shortened window");
+        const safeContext = fixture.streamContexts.at(-1);
+        assert.ok(safeContext, "the SDK may still invoke the stream function with an aborted signal");
+        assert.ok(safeContext.messages.every((message) => message.role === "system"), "a refused request receives system-only safe context");
+        assert.equal(fixture.streamSignals.at(-1), true, "the refused request is aborted before provider work");
+        assert.ok(JSON.stringify(fixture.sessionManager.getBranch()).includes("VALID_POST_MARKER_WORK"), "raw post-marker work remains durable");
+    }
+    finally {
+        fixture.close();
+    }
+    let missingRaw;
+    missingRaw = await openFixture({
+        compactionEnabled: false,
+        seed: (sessionManager) => {
+            sessionManager.appendCustomEntry(RESET_MARKER_TYPE, { windowId: "pcw:missing:boot" });
+            sessionManager.appendMessage({ role: "user", content: [{ type: "text", text: "RAW_POST_MARKER_WORK" }], timestamp: Date.now() });
+        },
+        script: () => assistant(missingRaw, [{ type: "text", text: "must not be called normally" }]),
+    });
+    try {
+        assert.equal(missingRaw.sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === BOOT_TYPE).length, 0, "post-marker conversation blocks startup repair");
+        await missingRaw.session.prompt("MISSING_RAW_BOOT_SENTINEL");
+        await missingRaw.session.waitForIdle();
+        assert.equal(missingRaw.sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === BOOT_TYPE).length, 0, "later conversation without a boot is refused, not repaired");
+        assert.equal(missingRaw.streamSignals.at(-1), true);
+        assert.ok(missingRaw.streamContexts.at(-1)?.messages.every((message) => message.role === "system"));
+    }
+    finally {
+        missingRaw.close();
+    }
+});
+test("real AgentSession: the complete system message and a changed tool loadout survive the reset projection", async () => {
+    let fixture;
+    fixture = await openFixture({
+        compactionEnabled: false,
+        systemPrompt: ["SYSTEM_SECTION_ALPHA", "SYSTEM_SECTION_BETA", "SYSTEM_TOOLS_SECTION", "SYSTEM_LOADOUT_SECTION"].join("\n"),
+        tools: ["wipe_memory"],
+        script: (request, context) => {
+            const systemText = JSON.stringify(context.messages.filter((message) => message.role === "system"));
+            const currentSystem = getCurrentSystemMessage(context.messages);
+            const effectiveToolNames = (currentSystem?.toolsAdded ?? []).map((tool) => tool.name).sort();
+            assert.ok(systemText.includes("SYSTEM_SECTION_ALPHA"));
+            assert.ok(systemText.includes("SYSTEM_SECTION_BETA"));
+            assert.ok(systemText.includes("SYSTEM_TOOLS_SECTION"));
+            assert.ok(systemText.includes("SYSTEM_LOADOUT_SECTION"));
+            if (request === 1) {
+                assert.deepEqual(effectiveToolNames, ["wipe_memory"]);
+                fixture.session.setActiveToolsByName(["wipe_memory", "get_context_remaining"]);
+                return assistant(fixture, [{ type: "toolCall", id: "wipe-system", name: "wipe_memory", arguments: {} }], "toolUse");
             }
-            if (mode === "nested") {
-                assert.equal(resets, 2, "a continuation-requested reset forms a second completed handoff");
-                assert.equal(new Set(sm.getBranch().filter((entry) => entry.type === "compaction").map((entry) => JSON.stringify(entry.details))).size, 2);
+            assert.deepEqual(effectiveToolNames, ["get_context_remaining", "wipe_memory"]);
+            assert.ok(JSON.stringify(context.messages).includes(CONTEXT_WINDOW_OPEN_TAG));
+            return assistant(fixture, [{ type: "text", text: "all system sections survived" }]);
+        },
+    });
+    try {
+        await fixture.session.prompt("SYSTEM_LOADOUT_SENTINEL");
+        await fixture.session.waitForIdle();
+        assert.equal(fixture.requests.length, 2);
+        assertFreshRequest(fixture, 1, "SYSTEM_LOADOUT_SENTINEL");
+    }
+    finally {
+        fixture.close();
+    }
+});
+test("real AgentSession: overflow and recoverable length reset and retry once; repeated failure is bounded", { timeout: 15000 }, async () => {
+    for (const failure of ["overflow", "length"]) {
+        let fixture;
+        fixture = await openFixture({
+            script: (request) => {
+                if (request === 1 && failure === "overflow")
+                    return assistant(fixture, [{ type: "text", text: "overflow response" }], "error", { errorMessage: "Prompt too long: context exceeds maximum context length" });
+                if (request === 1)
+                    return assistant(fixture, [{ type: "text", text: "truncated" }], "length", { usage: usage(99_000, 1) });
+                return assistant(fixture, [{ type: "text", text: "recovered" }]);
+            },
+        });
+        try {
+            await fixture.session.prompt(`RECOVER_${failure}_SENTINEL`);
+            await fixture.session.waitForIdle();
+            assert.equal(resetMarkers(fixture).length, 1, `${failure} performs one reset`);
+            assert.equal(fixture.requests.length, 2, `${failure} resumes once`);
+            assertFreshRequest(fixture, 1, `RECOVER_${failure}_SENTINEL`);
+        }
+        finally {
+            fixture.close();
+        }
+    }
+    let repeated;
+    repeated = await openFixture({
+        script: (request) => assistant(repeated, [{ type: "text", text: `overflow-${request}` }], "error", { errorMessage: "Prompt too long: context exceeds maximum context length" }),
+    });
+    try {
+        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.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();
+    }
+});
+test("real AgentSession: concurrent trusted projects keep reserve and automatic policy isolated", { timeout: 20000 }, async () => {
+    const agentDir = mkdtempSync(join(tmpdir(), "pi-context-shared-agent-"));
+    const notesRoot = mkdtempSync(join(tmpdir(), "pi-context-shared-notes-"));
+    const cwdAutomatic = mkdtempSync(join(tmpdir(), "pi-context-project-automatic-"));
+    const cwdModel = mkdtempSync(join(tmpdir(), "pi-context-project-model-"));
+    const cwdSession = mkdtempSync(join(tmpdir(), "pi-context-project-session-"));
+    writeFileSync(join(agentDir, "settings.json"), JSON.stringify({
+        compaction: { enabled: true, reserveTokens: 70_000, keepRecentTokens: 200 },
+        retry: { enabled: false },
+    }));
+    let automatic;
+    let modelInvalidated;
+    let sessionInvalidated;
+    const script = (fixture, highUsage) => () => {
+        const response = assistant(fixture(), [{ type: "text", text: "policy isolation response" }], "stop", { usage: usage(highUsage.next ? 85_000 : 100) });
+        highUsage.next = false;
+        return response;
+    };
+    const automaticUsage = { next: true };
+    const modelUsage = { next: true };
+    const sessionUsage = { next: true };
+    try {
+        // All three sessions share one stable global settings root. Only their trusted
+        // project settings differ, so this cannot pass by rotating PI_CODING_AGENT_DIR.
+        automatic = await openFixture({
+            contextWindow: 100_000,
+            cwd: cwdAutomatic,
+            agentDir,
+            notesRoot,
+            writeSettings: false,
+            projectSettings: { compaction: { enabled: true, reserveTokens: 20_000 } },
+            script: script(() => automatic, automaticUsage),
+        });
+        modelInvalidated = await openFixture({
+            contextWindow: 100_000,
+            cwd: cwdModel,
+            agentDir,
+            notesRoot,
+            writeSettings: false,
+            projectSettings: { compaction: { enabled: false, reserveTokens: 80_000 } },
+            script: script(() => modelInvalidated, modelUsage),
+        });
+        sessionInvalidated = await openFixture({
+            contextWindow: 100_000,
+            cwd: cwdSession,
+            agentDir,
+            notesRoot,
+            writeSettings: false,
+            projectSettings: { compaction: { enabled: false, reserveTokens: 80_000 } },
+            script: script(() => sessionInvalidated, sessionUsage),
+        });
+        await Promise.all([
+            automatic.session.prompt("AUTOMATIC_POLICY_PROJECT"),
+            modelInvalidated.session.prompt("MODEL_POLICY_PROJECT"),
+            sessionInvalidated.session.prompt("SESSION_POLICY_PROJECT"),
+        ]);
+        await Promise.all([automatic.session.waitForIdle(), modelInvalidated.session.waitForIdle(), sessionInvalidated.session.waitForIdle()]);
+        assert.equal(resetMarkers(automatic).length, 1, "the low reserve and enabled project resets automatically");
+        assert.equal(resetMarkers(modelInvalidated).length, 0, "the high reserve and disabled project does not reset");
+        assert.equal(resetMarkers(sessionInvalidated).length, 0, "the second high reserve and disabled session does not reset");
+        writeFileSync(join(cwdModel, ".pi", "settings.json"), JSON.stringify({ compaction: { enabled: true, reserveTokens: 20_000 } }));
+        modelUsage.next = true;
+        const changedModel = { ...modelInvalidated.model, id: `${modelInvalidated.model.id}-changed` };
+        modelInvalidated.model = changedModel;
+        await modelInvalidated.session.setModel(changedModel, { persist: false });
+        await modelInvalidated.session.prompt("MODEL_POLICY_AFTER_INVALIDATION");
+        await modelInvalidated.session.waitForIdle();
+        assert.equal(resetMarkers(modelInvalidated).length, 1, "model_select invalidates the instance policy cache");
+        writeFileSync(join(cwdSession, ".pi", "settings.json"), JSON.stringify({ compaction: { enabled: true, reserveTokens: 20_000 } }));
+        sessionUsage.next = true;
+        await sessionInvalidated.session.reload();
+        await sessionInvalidated.session.prompt("SESSION_POLICY_AFTER_INVALIDATION");
+        await sessionInvalidated.session.waitForIdle();
+        assert.equal(resetMarkers(sessionInvalidated).length, 1, "session reload invalidates the instance policy cache");
+    }
+    finally {
+        sessionInvalidated?.close();
+        modelInvalidated?.close();
+        automatic?.close();
+        rmSync(agentDir, { recursive: true, force: true });
+        rmSync(notesRoot, { recursive: true, force: true });
+        rmSync(cwdAutomatic, { recursive: true, force: true });
+        rmSync(cwdModel, { recursive: true, force: true });
+        rmSync(cwdSession, { recursive: true, force: true });
+    }
+});
+test("real AgentSession: injected settings managers own live policy and ignore conflicting default files", { timeout: 20000 }, async () => {
+    const firstManager = SettingsManager.inMemory({ compaction: { enabled: true, reserveTokens: 80_000 } });
+    const secondManager = SettingsManager.inMemory({ compaction: { enabled: false, reserveTokens: 20_000 } });
+    const defaultAgentDir = mkdtempSync(join(tmpdir(), "pi-context-injected-default-agent-"));
+    const notesRoot = mkdtempSync(join(tmpdir(), "pi-context-injected-notes-"));
+    const previousAgentDir = process.env.PI_CODING_AGENT_DIR;
+    const previousNotesRoot = process.env.PI_NOTES_HOME;
+    writeFileSync(join(defaultAgentDir, "settings.json"), JSON.stringify({ compaction: { enabled: false, reserveTokens: 1_000 } }));
+    process.env.PI_CODING_AGENT_DIR = defaultAgentDir;
+    process.env.PI_NOTES_HOME = notesRoot;
+    let first;
+    let second;
+    const firstHighUsage = { next: false };
+    const secondHighUsage = { next: false };
+    const script = (getFixture, highUsage) => (request) => {
+        const fixture = getFixture();
+        if (request === 1) {
+            highUsage.next = false;
+            return assistant(fixture, [{ type: "toolCall", id: "remaining", name: "get_context_remaining", arguments: {} }], "toolUse", { usage: usage(20_000) });
+        }
+        const input = highUsage.next ? 85_000 : 100;
+        highUsage.next = false;
+        return assistant(fixture, [{ type: "text", text: "scripted policy response" }], "stop", { usage: usage(input) });
+    };
+    try {
+        first = await openFixture({
+            contextWindow: 100_000,
+            agentDir: defaultAgentDir,
+            notesRoot,
+            writeSettings: false,
+            defaultCompactionEnabled: false,
+            defaultReserveTokens: 1_000,
+            settingsManager: firstManager,
+            manageEnvironment: false,
+            tools: ["get_context_remaining"],
+            script: script(() => first, firstHighUsage),
+        });
+        second = await openFixture({
+            contextWindow: 100_000,
+            agentDir: defaultAgentDir,
+            notesRoot,
+            writeSettings: false,
+            defaultCompactionEnabled: true,
+            defaultReserveTokens: 95_000,
+            settingsManager: secondManager,
+            manageEnvironment: false,
+            tools: ["get_context_remaining"],
+            script: script(() => second, secondHighUsage),
+        });
+        await Promise.all([first.session.prompt("INJECTED_FIRST"), second.session.prompt("INJECTED_SECOND")]);
+        await Promise.all([first.session.waitForIdle(), second.session.waitForIdle()]);
+        assert.deepEqual(contextRemainingResults(first), [0], "the injected high reserve reaches the warning line in the real tool result");
+        assert.ok((contextRemainingResults(second)[0] ?? 0) > 0, "the second injected reserve produces a distinct real tool result");
+        assert.equal(resetMarkers(first).length, 1, "enabled injected policy resets at the first session's reserve");
+        assert.equal(resetMarkers(second).length, 0, "disabled injected policy does not inherit the first session's reset decision");
+        firstHighUsage.next = true;
+        firstManager.setCompactionEnabled(false);
+        firstManager.applyOverrides({ compaction: { reserveTokens: 90_000 } });
+        await first.session.prompt("INJECTED_LIVE_DISABLE");
+        await first.session.waitForIdle();
+        assert.equal(resetMarkers(first).length, 1, "a public setter disables the next turn without reload");
+        assert.equal(resetMarkers(second).length, 0, "the second live manager remains unchanged");
+        firstHighUsage.next = true;
+        firstManager.setCompactionEnabled(true);
+        firstManager.applyOverrides({ compaction: { reserveTokens: 1_000 } });
+        await first.session.prompt("INJECTED_LIVE_ENABLE_LOW_RESERVE");
+        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 } });
+        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");
+    }
+    finally {
+        second?.close();
+        first?.close();
+        if (previousAgentDir === undefined)
+            delete process.env.PI_CODING_AGENT_DIR;
+        else
+            process.env.PI_CODING_AGENT_DIR = previousAgentDir;
+        if (previousNotesRoot === undefined)
+            delete process.env.PI_NOTES_HOME;
+        else
+            process.env.PI_NOTES_HOME = previousNotesRoot;
+        rmSync(defaultAgentDir, { recursive: true, force: true });
+        rmSync(notesRoot, { recursive: true, force: true });
+    }
+});
+test("real AgentSession: injected model overrides select the active model's reserve", { timeout: 20000 }, async () => {
+    let settingsManager;
+    let modelBId = "";
+    const notesRoot = mkdtempSync(join(tmpdir(), "pi-context-model-override-notes-"));
+    const previousNotesRoot = process.env.PI_NOTES_HOME;
+    process.env.PI_NOTES_HOME = notesRoot;
+    let fixture;
+    fixture = await openFixture({
+        contextWindow: 100_000,
+        notesRoot,
+        settingsManager: (model) => {
+            modelBId = `${model.id}-changed`;
+            settingsManager = SettingsManager.inMemory({
+                compaction: {
+                    enabled: false,
+                    reserveTokens: 10_000,
+                    modelOverrides: {
+                        [`${model.provider}/${model.id}`]: { reserveTokens: 70_000 },
+                        [`${model.provider}/${modelBId}`]: { reserveTokens: 1_000 },
+                    },
+                },
+            });
+            return settingsManager;
+        },
+        manageEnvironment: false,
+        tools: ["get_context_remaining"],
+        script: (request) => request === 1 || request === 3
+            ? assistant(fixture, [{ type: "toolCall", id: `remaining-${request}`, name: "get_context_remaining", arguments: {} }], "toolUse", { usage: usage(30_000) })
+            : assistant(fixture, [{ type: "text", text: "scripted model override response" }], "stop", { usage: usage(1_000) }),
+    });
+    try {
+        await fixture.session.prompt("MODEL_OVERRIDE_A");
+        await fixture.session.waitForIdle();
+        assert.deepEqual(contextRemainingResults(fixture), [0], "model-a's high reserve reaches zero in the real tool result");
+        const changedModel = { ...fixture.model, id: modelBId };
+        fixture.model = changedModel;
+        await fixture.session.setModel(changedModel, { persist: false });
+        await fixture.session.prompt("MODEL_OVERRIDE_B");
+        await fixture.session.waitForIdle();
+        const results = contextRemainingResults(fixture);
+        assert.equal(results.length, 2);
+        assert.ok((results[1] ?? 0) > 0, "model-b's lower reserve is selected for the next real tool result");
+    }
+    finally {
+        fixture.close();
+        if (previousNotesRoot === undefined)
+            delete process.env.PI_NOTES_HOME;
+        else
+            process.env.PI_NOTES_HOME = previousNotesRoot;
+        rmSync(notesRoot, { recursive: true, force: true });
+    }
+});
+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 === 1)
+                    return assistant(fixture, [{ type: "toolCall", id: "budget-probe-1", name: "get_context_remaining", arguments: {} }], "toolUse", { usage: usage(50_000) });
+                if (request === 2)
+                    return assistant(fixture, [{ type: "toolCall", id: "budget-probe-2", name: "get_context_remaining", arguments: {} }], "toolUse", { usage: usage(60_000) });
+                if (request === 3 && scenario !== "ignored-warning")
+                    return assistant(fixture, [{ type: "toolCall", id: "checkpoint", name: "notes_write", arguments: {
+                                address: scenario === "write-error" ? "../invalid.md" : "checkpoint.md",
+                                content: "CHECKPOINT_SENTINEL",
+                            } }], "toolUse", { usage: usage(60_000) });
+                if (request === 4 && scenario !== "ignored-warning")
+                    return assistant(fixture, [{ type: "toolCall", id: "wipe-after-checkpoint", name: "wipe_memory", arguments: {} }], "toolUse", { usage: usage(60_000) });
+                return assistant(fixture, [{ type: "text", text: scenario === "ignored-warning" ? "warning intentionally ignored" : "checkpoint and wipe complete" }], "stop", { usage: usage(60_000) });
+            },
+        });
+        try {
+            await fixture.session.prompt(`WARNING_${scenario.toUpperCase()}_SENTINEL`);
+            await fixture.session.waitForIdle();
+            const branch = fixture.sessionManager.getBranch();
+            assert.equal(branch.filter((entry) => entry.type === "custom_message" && entry.customType === GUIDANCE_TYPE).length, 1, "one early reminder is durable");
+            assert.equal(branch.filter((entry) => entry.type === "custom_message" && entry.customType === WARNING_TYPE).length, 1, "one critical warning is durable");
+            const noteFile = join(fixture.notesRoot, "pi", "session", fixture.sessionManager.getSessionId(), "checkpoint.md");
+            if (scenario === "checkpoint") {
+                assert.equal(resetMarkers(fixture).length, 1);
+                assert.equal(existsSync(noteFile), true, "a successful checkpoint reaches the notes store before reset");
+                assert.ok(text(fixture.requests.at(-1)).includes("checkpoint.md"), "the fresh boot indexes the successful checkpoint");
             }
-            if (mode === "repeat") {
-                const nextFinished = new Promise((resolve) => { finish = resolve; });
-                targetResets = 2;
-                activeSentinel = "SECOND_WINDOW_SENTINEL";
-                await session.prompt("SECOND_WINDOW_SENTINEL: " + "Additional work. ".repeat(100));
-                await nextFinished;
-                await session.waitForIdle();
-                assert.equal(resets, 2);
-                assert.ok(!requests.at(-1).includes("SECOND_WINDOW_SENTINEL"));
-                const boundaries = sm.getBranch().filter((entry) => entry.type === "compaction");
-                assert.equal(new Set(boundaries.map((entry) => JSON.stringify(entry.details))).size, 2);
+            else if (scenario === "write-error") {
+                assert.equal(resetMarkers(fixture).length, 1);
+                assert.equal(existsSync(noteFile), false, "a failed checkpoint does not create a note");
+                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");
             }
-            assert.ok(requests[0].includes("OLD_CONTEXT_SENTINEL"));
-            assert.ok(!requests.at(-1).includes("OLD_CONTEXT_SENTINEL"));
-            assert.ok(requests.at(-1).includes("context_window"));
-            assert.ok(JSON.stringify(session.sessionManager.getBranch()).includes("OLD_CONTEXT_SENTINEL"));
-            if (mode === "golden") {
-                await session.prompt("Keep working in the new window until its reminder threshold.");
-                assert.equal(resets, 1);
-                const branch = sm.getBranch();
-                const boundary = branch.findIndex((entry) => entry.type === "compaction");
-                const reminders = branch.flatMap((entry, i) => entry.type === "custom_message" && entry.customType === GUIDANCE_TYPE ? [i] : []);
-                assert.equal(reminders.length, 2, "the next window gets its own reminder");
-                assert.ok(reminders[1] > boundary, "old messages cannot suppress a new window's reminder");
-                const warnings = branch.flatMap((entry, i) => entry.type === "custom_message" && entry.customType === WARNING_TYPE ? [i] : []);
-                assert.equal(warnings.length, 1, "the next window has no warning yet");
+            else {
+                assert.equal(resetMarkers(fixture).length, 0, "ignoring the warning does not reset automatically");
+                assert.equal(existsSync(noteFile), false);
             }
         }
         finally {
-            if (!disposed)
-                session?.dispose();
-            if (previousDir === undefined)
-                delete process.env.PI_CODING_AGENT_DIR;
-            else
-                process.env.PI_CODING_AGENT_DIR = previousDir;
-            if (previousNotesRoot === undefined)
-                delete process.env.PI_NOTES_HOME;
-            else
-                process.env.PI_NOTES_HOME = previousNotesRoot;
-            rmSync(dir, { recursive: true, force: true });
-            rmSync(notesRoot, { recursive: true, force: true });
+            fixture.close();
         }
-    });
-}
+    }
+});