@astrosheep/pi-context 0.24.0 → 0.25.1

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

@@ -1,196 +1,461 @@
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import test from "node:test";
-import { registerResetLifecycle } from "../src/reset-lifecycle.js";
+import { SessionManager as Manager } from "@earendil-works/pi-coding-agent";
+import piContext, { internal } from "../src/index.js";
+import { initialResetControl, reduceResetControl, registerResetLifecycle, } from "../src/context/reset-lifecycle.js";
+const previousNotesHome = process.env.PI_NOTES_HOME;
+const testNotesHome = mkdtempSync(join(tmpdir(), "pi-context-lifecycle-notes-"));
+process.env.PI_NOTES_HOME = testNotesHome;
+test.after(() => {
+    if (previousNotesHome === undefined)
+        delete process.env.PI_NOTES_HOME;
+    else
+        process.env.PI_NOTES_HOME = previousNotesHome;
+    rmSync(testNotesHome, { recursive: true, force: true });
+});
 function harness() {
+    const sessionManager = Manager.inMemory("/private/tmp/pi-context-lifecycle-test");
     const handlers = new Map();
-    const messages = [];
+    const tools = new Map();
+    const commands = new Map();
+    const sent = [];
     const notices = [];
-    const requests = [];
-    let sessionId = "first", currentReset = "", enabled = true, idle = true, pending = false;
-    let signal;
-    let throwOnCompact = false;
-    const ctx = {
-        sessionManager: { getSessionId: () => sessionId },
-        isIdle: () => idle,
-        hasPendingMessages: () => pending,
-        get signal() { return signal; },
-        compact: (options) => {
-            if (throwOnCompact)
-                throw new Error("synchronous failure");
-            requests.push(options);
+    const api = {
+        on(name, handler) {
+            const list = handlers.get(name) ?? [];
+            list.push(handler);
+            handlers.set(name, list);
+            return () => { };
         },
-        ui: { notify: (message) => notices.push(message) },
-    };
-    const lifecycle = registerResetLifecycle({
-        on: (name, fn) => handlers.set(name, fn),
-        sendMessage: (message) => messages.push(message.customType),
-    }, {
-        isEnabled: () => enabled,
-        continuation: { customType: "continue", content: "resume", display: false },
-        buildReset: () => ({ compaction: { summary: "reset", firstKeptEntryId: "marker", tokensBefore: 100, details: {} } }),
-        isCurrentReset: (id) => id === currentReset,
-        onReset: () => { },
-    });
-    const emit = (name, event = {}) => handlers.get(name)?.(event, ctx);
-    return {
-        ctx, lifecycle, emit, messages, notices, requests,
-        setIdle: (value) => { idle = value; },
-        setPending: (value) => { pending = value; },
-        setSignal: (value) => { signal = value; },
-        setSession: (value) => { sessionId = value; },
-        setThrow: () => { throwOnCompact = true; },
-        disable: () => { enabled = false; lifecycle.clear(); },
-        enable: () => { enabled = true; },
-        before: (reason = "threshold") => emit("session_before_compact", { reason, signal: new AbortController().signal }),
-        // Do not await this result until after the manually driven compact callbacks:
-        // real Pi awaits the originating handler while the continuation can emit its
-        // own nested agent_settled event.
-        settle: () => { emit("agent_end"); idle = true; return emit("agent_settled"); },
-        success: (id = "reset", willRetry = false) => {
-            currentReset = id;
-            emit("session_compact", { compactionEntry: { id }, willRetry });
+        registerTool(tool) { tools.set(tool.name, tool); },
+        registerCommand(name, command) { commands.set(name, command); },
+        registerFlag() { },
+        appendEntry(customType, data) { sessionManager.appendCustomEntry(customType, data); },
+        sendMessage(message, options) {
+            sent.push({ customType: message.customType, details: message.details, triggerTurn: options?.triggerTurn });
+            sessionManager.appendCustomMessageEntry(message.customType, message.content, message.display, message.details);
         },
-        complete: (index = 0) => requests[index].onComplete({}),
     };
+    piContext(api);
+    const ctx = {
+        sessionManager,
+        cwd: "/private/tmp",
+        model: undefined,
+        isIdle: () => true,
+        hasPendingMessages: () => false,
+        signal: undefined,
+        getContextUsage: () => undefined,
+        compact: () => assert.fail("the reset path must not call ctx.compact()"),
+        abort: () => { },
+        isProjectTrusted: () => true,
+        ui: { notify: (message, type) => notices.push({ message, type }) },
+    };
+    const emit = async (name, event) => {
+        const results = [];
+        for (const handler of handlers.get(name) ?? [])
+            results.push(await handler(event, ctx));
+        return results;
+    };
+    const runCommand = async (name, args = "") => {
+        const command = commands.get(name);
+        assert.ok(command, `${name} command is registered`);
+        const commandCtx = Object.assign({}, ctx, {
+            waitForIdle: async () => { },
+            ui: { notify: (message, type) => notices.push({ message, type }) },
+        });
+        await command.handler(args, commandCtx);
+    };
+    const callTool = async (name) => {
+        const tool = tools.get(name);
+        assert.ok(tool, `${name} is registered`);
+        return tool.execute("call", {}, new AbortController().signal, () => { }, ctx);
+    };
+    return { sessionManager, handlers, sent, notices, emit, runCommand, callTool };
+}
+function resultEntries(results) {
+    let entries = [];
+    let shouldContinue = false;
+    for (const result of results) {
+        if (!result || typeof result !== "object")
+            continue;
+        const value = result;
+        if (value.entries)
+            entries = value.entries;
+        if (value.continue !== undefined)
+            shouldContinue = value.continue;
+    }
+    return { entries, continue: shouldContinue };
+}
+function appendDrafts(sessionManager, entries) {
+    for (const entry of entries) {
+        switch (entry.type) {
+            case "custom":
+                sessionManager.appendCustomEntry(entry.customType, entry.data);
+                break;
+            case "custom_message":
+                sessionManager.appendCustomMessageEntry(entry.customType, entry.content, entry.display, entry.details);
+                break;
+            case "context_edit":
+                sessionManager.appendContextEdit(entry.targetId, entry.replacement);
+                break;
+            case "compaction":
+                sessionManager.appendCompaction(entry.summary, entry.firstKeptEntryId, 0, entry.details, true, entry.usage);
+                break;
+        }
+    }
 }
-test("the originating settled handler waits for its continuation's nested settlement", async () => {
+function turnEndFacts(overrides = {}) {
+    return {
+        aborted: false,
+        overflow: false,
+        failed: false,
+        enabled: true,
+        queued: false,
+        automaticResetEnabled: true,
+        thresholdDue: false,
+        ...overrides,
+    };
+}
+function beforeSettleFacts(overrides = {}) {
+    return {
+        queued: false,
+        enabled: true,
+        automaticResetEnabled: true,
+        aborted: false,
+        ...overrides,
+    };
+}
+function fakeBoundaryEvent(entries = []) {
+    return {
+        type: "turn_end",
+        entries,
+        continue: false,
+        context: { contextEntries: [], contextMessages: [], llmMessages: [], pendingMessages: [], canContinue: true },
+        outcome: "completed",
+        turnIndex: 0,
+        message: { role: "assistant", content: [], timestamp: Date.now() },
+        toolResults: [],
+        messageEntryId: "assistant-entry",
+        toolResultEntryIds: [],
+    };
+}
+test("public reset boundary drafts one marker, one boot, and one continuation after a tool batch", async () => {
     const h = harness();
-    assert.equal(h.lifecycle.request(), "rollover_requested");
-    assert.equal(h.lifecycle.request(), "rollover_already_pending");
-    const outer = h.settle();
-    assert.equal(h.requests.length, 1);
-    h.success();
-    h.success();
-    h.complete();
-    h.complete();
-    assert.deepEqual(h.messages, ["continue"], "one continuation starts after compaction completion");
-    let released = false;
-    void Promise.resolve(outer).then(() => { released = true; });
-    await Promise.resolve();
-    assert.equal(released, false, "sending the continuation does not release the original handler");
-    await h.settle();
-    await outer;
-    assert.equal(released, true, "only the continuation's settled event releases its owner");
-    assert.equal(h.requests.length, 1, "duplicate compact and settled callbacks do not restart reset work");
+    h.sessionManager.appendMessage({ role: "user", content: [{ type: "text", text: "before reset" }], timestamp: Date.now() });
+    const first = await h.callTool("wipe_memory");
+    const second = await h.callTool("wipe_memory");
+    assert.ok(first.content.length > 0 && second.content.length > 0, "both tool calls return normally");
+    const toolBatch = [{ type: "custom_message", customType: "foreign/tool-batch", content: "tool finished", display: false }];
+    const boundary = resultEntries(await h.emit("turn_end", fakeBoundaryEvent(toolBatch)));
+    assert.equal(boundary.continue, true, "the whole tool batch continues only after the boundary is committed");
+    const markerDrafts = boundary.entries.filter((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE);
+    const bootDrafts = boundary.entries.filter((entry) => entry.type === "custom_message" && entry.customType === internal.BOOT_TYPE);
+    assert.equal(markerDrafts.length, 1, "duplicate wipe requests in one turn dedupe");
+    assert.equal(bootDrafts.length, 1);
+    assert.equal(boundary.entries[0]?.type, "custom_message", "ordinary tool-batch entries precede the reset drafts");
+    assert.equal(boundary.entries[1]?.type, "custom");
+    assert.equal(boundary.entries[2]?.type, "custom_message");
+    const windowId = markerDrafts[0].data.windowId;
+    assert.match(windowId, /^pcw:/);
+    assert.equal(bootDrafts[0].details.windowId, windowId);
+    const continuationDrafts = boundary.entries.filter((entry) => entry.type === "custom_message" && entry.customType === internal.CONTINUATION_TYPE);
+    assert.equal(continuationDrafts.length, 1, "the boundary persists exactly one reset message");
+    assert.equal(boundary.entries[3]?.type, "custom_message", "the continuation closes the ordered reset shape");
+    appendDrafts(h.sessionManager, boundary.entries);
+    const branch = h.sessionManager.getBranch();
+    assert.deepEqual(branch.filter((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE).map((entry) => entry.type === "custom" ? entry.data : undefined), [{ windowId }]);
+    assert.equal(branch.filter((entry) => entry.type === "custom_message" && entry.customType === internal.BOOT_TYPE).length, 1);
 });
-test("a reset requested by a continuation completes before its predecessor releases", async () => {
+test("off stops future automatic/manual reset requests while an existing marker remains authoritative", async () => {
     const h = harness();
-    h.lifecycle.request();
-    const first = h.settle();
-    h.success("first");
-    h.complete();
-    assert.deepEqual(h.messages, ["continue"]);
-    // This models wipe_memory being called during the first continuation run.
-    assert.equal(h.lifecycle.request(), "rollover_requested");
-    const second = h.settle();
-    assert.equal(h.requests.length, 2, "the continuation's settled handler starts its requested reset");
-    h.success("second");
-    h.complete(1);
-    assert.deepEqual(h.messages, ["continue", "continue"]);
-    let firstReleased = false;
-    void Promise.resolve(first).then(() => { firstReleased = true; });
-    await Promise.resolve();
-    assert.equal(firstReleased, false, "the predecessor remains owned while the second continuation runs");
-    await h.settle();
-    await second;
-    await first;
-    assert.equal(firstReleased, true);
-    assert.equal(h.lifecycle.request(), "rollover_requested", "a later window can request another reset");
+    await h.callTool("wipe_memory");
+    const first = resultEntries(await h.emit("turn_end", fakeBoundaryEvent()));
+    assert.ok(first.entries.some((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE));
+    appendDrafts(h.sessionManager, first.entries);
+    await h.runCommand("pi-context", "off");
+    const before = await h.emit("session_before_compact", {
+        type: "session_before_compact",
+        reason: "manual",
+        willRetry: false,
+        branchEntries: h.sessionManager.getBranch(),
+        preparation: { tokensBefore: 100, firstKeptEntryId: null, keptMessages: [], droppedMessages: [] },
+        signal: new AbortController().signal,
+    });
+    assert.deepEqual(before.at(-1), { cancel: true }, "/compact is canceled when an existing marker would expose old canonical history");
+    const afterOff = resultEntries(await h.emit("turn_end", fakeBoundaryEvent()));
+    assert.equal(afterOff.entries.length, 0, "off does not create another reset");
+    await h.runCommand("pi-context", "on");
+    await h.runCommand("wipe-memory");
+    assert.equal(h.sent.length, 2, "/wipe-memory writes one hidden boot and one continuation without a model turn");
+    assert.equal(h.sent[0]?.triggerTurn, false);
+    assert.equal(h.sent[0]?.customType, internal.BOOT_TYPE);
+    assert.equal(h.sent[1]?.customType, internal.CONTINUATION_TYPE);
+    const markers = h.sessionManager.getBranch().filter((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE);
+    assert.equal(markers.length, 2, "off does not resurrect history; re-enabled wipe-memory creates the explicit new marker");
 });
-test("automatic compactions reset on the spot, with no continuation", () => {
-    const h = harness();
-    assert.ok(h.before().compaction, "the native attempt becomes our reset immediately");
-    assert.deepEqual(h.messages, []);
+test("reset construction failure preserves incoming and budget drafts without continuation", async () => {
+    const sessionManager = Manager.inMemory("/private/tmp/pi-context-reset-failure-test");
+    const handlers = new Map();
+    const notices = [];
+    const api = {
+        on(name, handler) {
+            const list = handlers.get(name) ?? [];
+            list.push(handler);
+            handlers.set(name, list);
+            return () => { };
+        },
+    };
+    const ctx = {
+        sessionManager,
+        model: undefined,
+        signal: undefined,
+        hasPendingMessages: () => false,
+        ui: { notify: (message, type) => notices.push({ message, type }) },
+    };
+    const budgetDraft = { type: "custom_message", customType: internal.GUIDANCE_TYPE, content: "budget draft", display: false };
+    const lifecycle = registerResetLifecycle(api, {
+        isEnabled: () => true,
+        budget: {
+            automaticResetEnabled: () => true,
+            resetDue: () => false,
+            consumeTurnEnd: () => [budgetDraft],
+            clear: () => { },
+        },
+        buildReset: () => { throw new Error("synthetic reset construction failure"); },
+    });
+    lifecycle.request();
+    const incoming = { type: "custom_message", customType: "foreign/boundary", content: "foreign draft", display: false };
+    const results = [];
+    for (const handler of handlers.get("turn_end") ?? [])
+        results.push(await handler(fakeBoundaryEvent([incoming]), ctx));
+    const result = resultEntries(results);
+    assert.deepEqual(result.entries, [incoming, budgetDraft], "already-built drafts survive reset construction failure");
+    assert.equal(result.continue, false, "a failed reset does not request continuation");
+    assert.equal(notices.at(-1)?.type, "warning");
+    assert.match(notices.at(-1)?.message ?? "", /could not build reset/);
 });
-test("failure, synchronous scheduling errors, and cancellation release their owners without retry", async () => {
-    const failed = harness();
-    failed.lifecycle.request();
-    const outer = failed.settle();
-    failed.requests[0].onError(new Error("Nothing to compact"));
-    failed.requests[0].onError(new Error("duplicate callback"));
-    failed.complete();
-    await outer;
-    assert.equal(failed.notices.length, 1);
-    assert.deepEqual(failed.messages, []);
-    assert.equal(failed.lifecycle.request(), "rollover_requested", "a later explicit request is possible");
-    const synchronous = harness();
-    synchronous.setThrow();
-    synchronous.lifecycle.request();
-    await synchronous.settle();
-    assert.equal(synchronous.notices.length, 1);
-    assert.equal(synchronous.lifecycle.request(), "rollover_requested");
-    const aborted = harness();
-    aborted.lifecycle.request();
-    aborted.setSignal(AbortSignal.abort());
-    await aborted.settle();
-    assert.equal(aborted.requests.length, 0);
-    assert.deepEqual(aborted.messages, []);
+test("a queued success clears an overflow failure before settle recovery can reset", async () => {
+    const sessionManager = Manager.inMemory("/private/tmp/pi-context-queued-overflow-test");
+    const handlers = new Map();
+    const api = {
+        on(name, handler) {
+            const list = handlers.get(name) ?? [];
+            list.push(handler);
+            handlers.set(name, list);
+            return () => { };
+        },
+    };
+    const ctx = {
+        sessionManager,
+        model: { contextWindow: 100_000, maxTokens: 4_096 },
+        signal: undefined,
+        hasPendingMessages: () => false,
+        ui: { notify() { } },
+    };
+    let resetCount = 0;
+    const lifecycle = registerResetLifecycle(api, {
+        isEnabled: () => true,
+        budget: {
+            automaticResetEnabled: () => true,
+            resetDue: () => false,
+            consumeTurnEnd: () => [],
+            clear: () => { },
+        },
+        buildReset: () => {
+            resetCount += 1;
+            return [];
+        },
+    });
+    const failed = fakeBoundaryEvent();
+    failed.message = { ...failed.message, stopReason: "error", errorMessage: "Prompt too long: context exceeds maximum context length" };
+    const turnEnd = handlers.get("turn_end")?.[0];
+    const beforeSettle = handlers.get("agent_before_settle")?.[0];
+    assert.ok(turnEnd && beforeSettle);
+    await turnEnd(failed, ctx);
+    const queued = {
+        ...failed,
+        type: "agent_before_settle",
+        outcome: "error",
+        context: { ...failed.context, pendingMessages: [{ role: "user", content: [{ type: "text", text: "queued success" }], timestamp: Date.now() }] },
+    };
+    assert.equal(await beforeSettle(queued, ctx), undefined, "a queued message defers overflow recovery");
+    const success = fakeBoundaryEvent();
+    await turnEnd(success, ctx);
+    const settled = { ...queued, context: { ...queued.context, pendingMessages: [] }, outcome: "completed" };
+    assert.equal(await beforeSettle(settled, ctx), undefined, "the successful queued turn clears the stale recovery");
+    assert.equal(resetCount, 0);
 });
-test("shutdown, tree invalidation, toggling off, and stale sessions release waiters safely", async () => {
-    for (const boundary of ["session_shutdown", "session_start", "session_tree", "off", "session-change"]) {
-        const h = harness();
-        h.lifecycle.request();
-        const outer = h.settle();
-        h.success();
-        h.complete();
-        if (boundary === "off") {
-            h.disable();
-            h.enable();
-        }
-        else if (boundary === "session-change") {
-            h.setSession("second");
-            h.complete();
-            h.emit("session_tree");
-        }
-        else
-            h.emit(boundary);
-        h.complete();
-        h.requests[0].onError(new Error("late error"));
-        await outer;
-        assert.deepEqual(h.notices, [], boundary);
-        assert.deepEqual(h.messages, ["continue"], boundary);
-        if (boundary === "session_shutdown")
-            h.emit("session_start");
-        if (boundary === "session-change")
-            h.emit("session_tree");
-        assert.equal(h.lifecycle.request(), "rollover_requested", `${boundary}: a fresh request still works`);
-    }
+test("reset-control: an explicit request deduplicates and is consumed at the turn boundary", () => {
+    const idle = Object.freeze({ ...initialResetControl() });
+    const first = reduceResetControl(idle, { type: "request" });
+    assert.equal(first.effect, "requested");
+    assert.deepEqual(first.state, { request: "explicit", overflow: "idle" });
+    const again = reduceResetControl(first.state, { type: "request" });
+    assert.equal(again.effect, "already-requested");
+    assert.deepEqual(again.state, first.state, "a duplicate request does not change state");
+    const committed = reduceResetControl(again.state, { type: "turn_end", facts: turnEndFacts() });
+    assert.equal(committed.effect, "commit-boundary");
+    assert.deepEqual(committed.state, initialResetControl(), "the request is consumed whether or not it commits");
 });
-test("queued or competing work is not duplicated and releases an unneeded continuation owner", async () => {
-    const competing = harness();
-    competing.lifecycle.request();
-    competing.setIdle(false);
-    assert.equal(competing.emit("agent_settled"), undefined, "another run owns the first settled event");
-    competing.setIdle(true);
-    const outer = competing.settle();
-    competing.success();
-    competing.setIdle(false);
-    competing.complete();
-    await outer;
-    assert.deepEqual(competing.messages, [], "an active prompt owns continuation");
-    const queued = harness();
-    queued.lifecycle.request();
-    const queuedOuter = queued.settle();
-    queued.success();
-    queued.setPending(true);
-    queued.complete();
-    await queuedOuter;
-    assert.deepEqual(queued.messages, [], "queued user work is never duplicated");
+test("reset-control: turn_end commits explicit and threshold resets, and skips disabled or failed turns", () => {
+    const explicit = reduceResetControl({ request: "explicit", overflow: "idle" }, { type: "turn_end", facts: turnEndFacts() });
+    assert.equal(explicit.effect, "commit-boundary");
+    const threshold = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts({ thresholdDue: true }) });
+    assert.equal(threshold.effect, "commit-boundary");
+    const neither = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts() });
+    assert.equal(neither.effect, "none");
+    const disabled = reduceResetControl({ request: "explicit", overflow: "idle" }, { type: "turn_end", facts: turnEndFacts({ enabled: false, thresholdDue: true }) });
+    assert.equal(disabled.effect, "none");
+    assert.deepEqual(disabled.state, initialResetControl(), "a disabled turn drops the explicit request without committing");
+    const failed = reduceResetControl({ request: "explicit", overflow: "idle" }, { type: "turn_end", facts: turnEndFacts({ failed: true, thresholdDue: true }) });
+    assert.equal(failed.effect, "none");
+    assert.deepEqual(failed.state, initialResetControl());
 });
-test("foreign boundaries and native compactions do not manufacture a continuation", async () => {
-    const h = harness();
-    h.lifecycle.request();
-    const outer = h.settle();
-    h.emit("session_compact", { compactionEntry: { id: "foreign" }, willRetry: false });
-    h.emit("session_compact", { compactionEntry: { id: "foreign" }, willRetry: false });
-    assert.equal(h.lifecycle.request(), "rollover_already_pending");
-    h.complete();
-    await outer;
-    assert.deepEqual(h.messages, []);
-    const native = harness();
-    native.lifecycle.request();
-    native.success("native", false);
-    await native.settle();
-    assert.equal(native.requests.length, 0);
-    assert.deepEqual(native.messages, []);
+test("reset-control: aborted turns clear the boundary, settlement keeps only an explicit request", () => {
+    const both = { request: "explicit", overflow: "pending" };
+    const aborted = reduceResetControl(both, { type: "turn_end", facts: turnEndFacts({ aborted: true }) });
+    assert.equal(aborted.effect, "none");
+    assert.deepEqual(aborted.state, initialResetControl(), "an abort manufactures no continuation");
+    const settled = reduceResetControl(both, { type: "settled" });
+    assert.deepEqual(settled.state, { request: "explicit", overflow: "idle" }, "settlement ends the failure chain only");
+    const cleared = reduceResetControl(both, { type: "clear" });
+    assert.deepEqual(cleared.state, initialResetControl());
+});
+test("reset-control: overflow recovery is armed at turn_end and spent exactly once at settle", () => {
+    const armed = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts({ overflow: true, failed: true }) });
+    assert.deepEqual(armed.state, { request: "none", overflow: "pending" });
+    const recovered = reduceResetControl(armed.state, { type: "before_settle", facts: beforeSettleFacts() });
+    assert.equal(recovered.effect, "recover-overflow", "the first settle commits the bounded recovery");
+    assert.deepEqual(recovered.state, { request: "none", overflow: "spent" });
+    const repeated = reduceResetControl(recovered.state, { type: "before_settle", facts: beforeSettleFacts() });
+    assert.equal(repeated.effect, "none", "a spent recovery is never retried");
+    const rearmed = reduceResetControl(recovered.state, { type: "turn_end", facts: turnEndFacts({ overflow: true, failed: true }) });
+    assert.deepEqual(rearmed.state, { request: "none", overflow: "pending-spent" });
+    const bounded = reduceResetControl(rearmed.state, { type: "before_settle", facts: beforeSettleFacts() });
+    assert.equal(bounded.effect, "none", "a second failure chain stays bounded to the spent attempt");
+    assert.deepEqual(bounded.state, { request: "none", overflow: "spent" });
+});
+test("reset-control: a queued turn defers recovery and its success supersedes the failure", () => {
+    const armed = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts({ overflow: true, failed: true }) }).state;
+    const deferred = reduceResetControl(armed, { type: "before_settle", facts: beforeSettleFacts({ queued: true }) });
+    assert.equal(deferred.effect, "none");
+    assert.deepEqual(deferred.state, armed, "a queued message leaves the overflow chain armed");
+    const success = reduceResetControl(armed, { type: "turn_end", facts: turnEndFacts() });
+    assert.deepEqual(success.state, initialResetControl(), "a successful queued turn clears the stale failure");
+});
+test("reset-control: disabled mode and explicit aborts disarm overflow without a recovery", () => {
+    const armed = reduceResetControl(initialResetControl(), { type: "turn_end", facts: turnEndFacts({ overflow: true, failed: true }) }).state;
+    const disabled = reduceResetControl(armed, { type: "before_settle", facts: beforeSettleFacts({ enabled: false }) });
+    assert.equal(disabled.effect, "none");
+    assert.deepEqual(disabled.state, { request: "none", overflow: "idle" });
+    const automaticOff = reduceResetControl(armed, { type: "before_settle", facts: beforeSettleFacts({ automaticResetEnabled: false }) });
+    assert.equal(automaticOff.effect, "none");
+    assert.deepEqual(automaticOff.state, { request: "none", overflow: "idle" });
+    const aborted = reduceResetControl(armed, { type: "before_settle", facts: beforeSettleFacts({ aborted: true }) });
+    assert.equal(aborted.effect, "none");
+    assert.deepEqual(aborted.state, { request: "none", overflow: "idle" });
+});
+test("reset-control: policy guards are consulted only in the branches that need them", () => {
+    const tracked = (overrides) => {
+        const calls = { queued: 0, automatic: 0, threshold: 0 };
+        const facts = {
+            aborted: overrides.aborted ?? false,
+            overflow: overrides.overflow ?? false,
+            failed: overrides.failed ?? false,
+            enabled: overrides.enabled ?? true,
+            get queued() { calls.queued += 1; return overrides.queuedResult ?? false; },
+            get automaticResetEnabled() { calls.automatic += 1; return overrides.automaticResult ?? true; },
+            get thresholdDue() { calls.threshold += 1; return overrides.thresholdResult ?? true; },
+        };
+        return { facts, calls };
+    };
+    const aborted = tracked({ aborted: true });
+    reduceResetControl(initialResetControl(), { type: "turn_end", facts: aborted.facts });
+    assert.deepEqual(aborted.calls, { queued: 0, automatic: 0, threshold: 0 }, "an abort consults no policy guard");
+    const failed = tracked({ failed: true });
+    reduceResetControl(initialResetControl(), { type: "turn_end", facts: failed.facts });
+    assert.deepEqual(failed.calls, { queued: 0, automatic: 0, threshold: 0 }, "a failed turn consults no threshold guard");
+    const disabled = tracked({ enabled: false });
+    reduceResetControl(initialResetControl(), { type: "turn_end", facts: disabled.facts });
+    assert.deepEqual(disabled.calls, { queued: 0, automatic: 0, threshold: 0 }, "a disabled turn consults no threshold guard");
+    const overflow = tracked({ overflow: true, queuedResult: false });
+    reduceResetControl(initialResetControl(), { type: "turn_end", facts: overflow.facts });
+    assert.deepEqual(overflow.calls, { queued: 1, automatic: 1, threshold: 0 }, "an overflow turn consults only the overflow guards");
+    const complete = tracked({ thresholdResult: false });
+    reduceResetControl(initialResetControl(), { type: "turn_end", facts: complete.facts });
+    assert.deepEqual(complete.calls, { queued: 0, automatic: 0, threshold: 1 }, "a completed turn consults only the threshold guard");
+    const settleCalls = { queued: 0, enabled: 0, automatic: 0 };
+    const settleFacts = {
+        get queued() { settleCalls.queued += 1; return true; },
+        get enabled() { settleCalls.enabled += 1; return true; },
+        get automaticResetEnabled() { settleCalls.automatic += 1; return true; },
+        aborted: false,
+    };
+    reduceResetControl({ request: "none", overflow: "pending" }, { type: "before_settle", facts: settleFacts });
+    assert.deepEqual(settleCalls, { queued: 1, enabled: 0, automatic: 0 }, "a queued settle consults only the pending-message guard");
+});
+test("a committed reset places incoming and budget drafts before marker -> boot -> continuation", async () => {
+    const sessionManager = Manager.inMemory("/private/tmp/pi-context-reset-ordering-test");
+    const handlers = new Map();
+    const api = {
+        on(name, handler) {
+            const list = handlers.get(name) ?? [];
+            list.push(handler);
+            handlers.set(name, list);
+            return () => { };
+        },
+    };
+    const ctx = {
+        sessionManager,
+        model: undefined,
+        signal: undefined,
+        hasPendingMessages: () => false,
+        ui: { notify() { } },
+    };
+    const windowId = "pcw:ordering:test";
+    const budgetDraft = { type: "custom_message", customType: internal.GUIDANCE_TYPE, content: "budget draft", display: false };
+    const lifecycle = registerResetLifecycle(api, {
+        isEnabled: () => true,
+        budget: {
+            automaticResetEnabled: () => true,
+            resetDue: () => false,
+            consumeTurnEnd: () => [budgetDraft],
+            clear: () => { },
+        },
+        buildReset: () => [
+            { type: "custom", customType: internal.RESET_MARKER_TYPE, data: { windowId } },
+            { type: "custom_message", customType: internal.BOOT_TYPE, content: "boot", display: false, details: { windowId } },
+            { type: "custom_message", customType: internal.CONTINUATION_TYPE, content: "continuation", display: false },
+        ],
+    });
+    lifecycle.request();
+    const incoming = { type: "custom_message", customType: "foreign/boundary", content: "incoming", display: false };
+    const results = [];
+    for (const handler of handlers.get("turn_end") ?? [])
+        results.push(await handler(fakeBoundaryEvent([incoming]), ctx));
+    const result = resultEntries(results);
+    assert.equal(result.continue, true);
+    const customTypes = (entries) => entries.map((entry) => {
+        assert.ok(entry.type === "custom" || entry.type === "custom_message", "the boundary only carries named reset drafts here");
+        return entry.customType;
+    });
+    assert.deepEqual(customTypes(result.entries), [
+        "foreign/boundary",
+        internal.GUIDANCE_TYPE,
+        internal.RESET_MARKER_TYPE,
+        internal.BOOT_TYPE,
+        internal.CONTINUATION_TYPE,
+    ], "ordinary and budget drafts precede the closed reset shape");
+    appendDrafts(sessionManager, result.entries);
+    const branch = sessionManager.getBranch();
+    const markerIndex = branch.findIndex((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE);
+    assert.ok(markerIndex >= 0);
+    assert.deepEqual(customTypes(branch.slice(markerIndex)), [
+        internal.RESET_MARKER_TYPE,
+        internal.BOOT_TYPE,
+        internal.CONTINUATION_TYPE,
+    ], "the persisted reset shape remains marker -> boot -> continuation");
 });