@astrosheep/pi-context 0.24.0 → 0.25.1

package/dist/src/context/boot.js

@@ -0,0 +1,46 @@
+import { loadNotesSnapshot } from "../notes/notes-snapshot.js";
+import { agentSlug, modelSlug } from "../notes/paths.js";
+import { BOOT_TYPE } from "../protocol.js";
+import { renderBootBlock } from "./prompts.js";
+import { currentReset, isWindowBoot, rootWindowId } from "./context-window.js";
+import { repairResetTail } from "./reset-artifacts.js";
+/** Render the boot block from the live context; acquisition stays with loadNotesSnapshot. */
+function bootContent(ctx, currentId, previousId, notes) {
+    return renderBootBlock({
+        agentName: agentSlug(ctx),
+        modelName: modelSlug(ctx),
+        firstWindowId: rootWindowId(ctx.sessionManager.getSessionId()),
+        currentWindowId: currentId,
+        previousWindowId: previousId,
+        notes,
+    });
+}
+/**
+ * Acquire one notes snapshot and build the boot custom message for a window. The caller
+ * supplies `previousId` only when a reset boundary needs the prior window identity.
+ */
+export function buildBootMessage(ctx, windowId, previousId, notifyIncompleteNotes) {
+    const notes = loadNotesSnapshot(ctx);
+    notifyIncompleteNotes?.(ctx, windowId, notes);
+    return { customType: BOOT_TYPE, content: bootContent(ctx, windowId, previousId, notes), display: false, details: { windowId } };
+}
+/** Persist one hidden boot message without triggering a model turn. */
+export function sendBoot(pi, boot) {
+    pi.sendMessage({ customType: boot.customType, content: boot.content, display: boot.display, details: boot.details }, { triggerTurn: false });
+}
+/**
+ * Boot entry point for `session_start` / `session_tree`. Ordinary startup ensures one root
+ * boot; a reset marker instead asks reset-artifact repair to complete its persisted tail.
+ * Boot idempotence lives here: an already-projected root boot or a complete reset tail emits nothing.
+ */
+export function ensureBoot(pi, ctx, notifyIncompleteNotes) {
+    const reset = currentReset(ctx);
+    if (reset) {
+        repairResetTail(pi, ctx, reset, notifyIncompleteNotes);
+        return;
+    }
+    const windowId = rootWindowId(ctx.sessionManager.getSessionId());
+    if (ctx.sessionManager.buildSessionProjection().messages.some((message) => isWindowBoot(message, windowId)))
+        return;
+    sendBoot(pi, buildBootMessage(ctx, windowId, undefined, notifyIncompleteNotes));
+}

package/dist/src/context/budget.js

@@ -0,0 +1,150 @@
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { GUIDANCE_CLOSE_TAG, GUIDANCE_OPEN_TAG, GUIDANCE_TYPE, WARNING_PROMPT, WARNING_TYPE } from "../protocol.js";
+import { readThresholdSettings } from "./thresholds.js";
+import { currentWindowId, hasWindowMessage, windowUsage } from "./context-window.js";
+import { tokenBudgetGuidance } from "./prompts.js";
+import { output } from "../tool-output.js";
+/** Remaining tokens in the provider's active window, or null without a usable estimate. */
+export function remainingTokens(ctx) {
+    const usage = windowUsage(ctx);
+    return !usage || usage.tokens === null ? null : Math.max(0, usage.contextWindow - usage.tokens);
+}
+export function registerBudget(pi, isEnabled, settingsManager) {
+    let cachedPolicy;
+    const notifiedWarnings = new Set();
+    const resolvePolicy = (ctx) => {
+        if (!settingsManager && cachedPolicy)
+            return { ...cachedPolicy, warnings: [] };
+        const resolution = readThresholdSettings(ctx, settingsManager);
+        for (const warning of resolution.warnings) {
+            if (notifiedWarnings.has(warning))
+                continue;
+            notifiedWarnings.add(warning);
+            ctx.ui.notify(warning, "warning");
+        }
+        if (!settingsManager)
+            cachedPolicy = { thresholds: resolution.thresholds, automatic: resolution.automatic };
+        return resolution;
+    };
+    const thresholdsFor = (ctx) => {
+        return resolvePolicy(ctx).thresholds;
+    };
+    const automaticResetEnabled = (ctx) => {
+        return resolvePolicy(ctx).automatic;
+    };
+    const resetDue = (ctx) => {
+        if (!automaticResetEnabled(ctx))
+            return false;
+        const usage = windowUsage(ctx);
+        return usage !== undefined && usage.tokens !== null && usage.contextWindow - usage.tokens <= thresholdsFor(ctx).reserve;
+    };
+    const invalidateThresholds = () => { cachedPolicy = undefined; };
+    let pendingGuidance;
+    let pendingWarning;
+    let pendingNotices = [];
+    const notifyCommittedReminders = (ctx) => {
+        const windowId = currentWindowId(ctx);
+        for (const notice of pendingNotices) {
+            if (notice.windowId !== windowId || !hasWindowMessage(ctx, notice.customType))
+                continue;
+            ctx.ui.notify(notice.customType === WARNING_TYPE
+                ? "pi-context: context budget critical — final checkpoint warning recorded for the model."
+                : "pi-context: context budget low — checkpoint reminder recorded for the model, kept out of the chat view.", "warning");
+        }
+        pendingNotices = [];
+    };
+    const clearStaged = () => {
+        pendingGuidance = undefined;
+        pendingWarning = undefined;
+    };
+    const resetForTransition = () => {
+        clearStaged();
+        pendingNotices = [];
+        invalidateThresholds();
+        notifiedWarnings.clear();
+    };
+    const consumeTurnEnd = (ctx) => {
+        const staged = [
+            pendingGuidance ? { ...pendingGuidance, customType: GUIDANCE_TYPE } : undefined,
+            pendingWarning ? { ...pendingWarning, customType: WARNING_TYPE } : undefined,
+        ];
+        clearStaged();
+        const windowId = currentWindowId(ctx);
+        const drafts = staged.filter((draft) => draft !== undefined && draft.windowId === windowId);
+        pendingNotices = drafts.map(({ windowId, customType }) => ({ windowId, customType }));
+        return drafts.map((draft) => ({
+            type: "custom_message",
+            customType: draft.customType,
+            content: draft.content,
+            display: false,
+        }));
+    };
+    pi.on("session_start", (_event, ctx) => { resetForTransition(); thresholdsFor(ctx); });
+    pi.on("session_tree", resetForTransition);
+    pi.on("model_select", resetForTransition);
+    pi.on("session_shutdown", resetForTransition);
+    // A request can fail before Pi emits turn_end. agent_settled is the public
+    // lifecycle point that must discard an uncommitted draft before the next prompt.
+    // UI notices follow committed reminders. Aborted requests can retry their drafts
+    // without showing the same low-budget notification twice.
+    pi.on("turn_start", (_event, ctx) => notifyCommittedReminders(ctx));
+    pi.on("agent_settled", (_event, ctx) => {
+        notifyCommittedReminders(ctx);
+        clearStaged();
+    });
+    pi.on("context", (_event, ctx) => {
+        if (!isEnabled())
+            return undefined;
+        // The early reminder persists once per window the first time remaining crosses
+        // reserve+margin. It never edits the outgoing request.
+        const remaining = remainingTokens(ctx);
+        if (remaining === null)
+            return undefined;
+        const windowId = currentWindowId(ctx);
+        const { reminder, warning } = thresholdsFor(ctx);
+        if (hasWindowMessage(ctx, WARNING_TYPE) || pendingWarning?.windowId === windowId)
+            return undefined;
+        if (remaining <= warning) {
+            // A not-yet-committed shallow reminder is superseded by the final warning.
+            pendingGuidance = undefined;
+            const content = `${GUIDANCE_OPEN_TAG}\n${WARNING_PROMPT}\n${GUIDANCE_CLOSE_TAG}`;
+            pendingWarning = { windowId, content };
+            const warningMessage = {
+                role: "custom",
+                customType: WARNING_TYPE,
+                content,
+                display: false,
+                timestamp: Date.now(),
+            };
+            return { messages: [..._event.messages, warningMessage] };
+        }
+        if (hasWindowMessage(ctx, GUIDANCE_TYPE) || pendingGuidance?.windowId === windowId)
+            return undefined;
+        if (remaining <= reminder) {
+            // Persist at turn_end, before any reset drafts. A queued sendMessage could
+            // otherwise cross the marker and leak the old window's reminder forward.
+            const left = Math.max(0, remaining - warning);
+            pendingGuidance = { windowId, content: tokenBudgetGuidance(left) };
+        }
+        return undefined;
+    });
+    pi.registerTool(defineTool({
+        name: "get_context_remaining",
+        label: "Get context remaining",
+        description: "Return estimated context tokens left before your memory is wiped; null when Pi cannot estimate usage.",
+        parameters: Type.Object({}, { additionalProperties: false }),
+        async execute(_id, _params, _signal, _update, ctx) {
+            // The countdown the model sees ends at the warning line (reserve + runway);
+            // the runway below it is overdraft the model never sees. See protocol.ts.
+            const remaining = remainingTokens(ctx);
+            return output({ remaining_tokens: remaining === null ? null : Math.max(0, remaining - thresholdsFor(ctx).warning) });
+        },
+    }));
+    return {
+        automaticResetEnabled,
+        resetDue,
+        consumeTurnEnd,
+        clear: () => { clearStaged(); pendingNotices = []; },
+    };
+}

package/dist/src/context/context-window.js

@@ -0,0 +1,112 @@
+import { getCurrentSystemMessage } from "@earendil-works/pi-ai";
+import { estimateContextTokens } from "@earendil-works/pi-ai/utils/estimate";
+import { convertToLlm } from "@earendil-works/pi-coding-agent";
+import { BOOT_TYPE, RESET_MARKER_TYPE } from "../protocol.js";
+export function isWindowMarker(entry) {
+    return entry.type === "custom" && entry.customType === RESET_MARKER_TYPE &&
+        typeof entry.data === "object" && entry.data !== null &&
+        typeof entry.data.windowId === "string" &&
+        entry.data.windowId.length > 0;
+}
+/** Only the active branch can supply a window boundary. */
+export function currentReset(ctx) {
+    const branch = ctx.sessionManager.getBranch();
+    for (let i = branch.length - 1; i >= 0; i--) {
+        const entry = branch[i];
+        if (entry && isWindowMarker(entry))
+            return entry;
+    }
+    return undefined;
+}
+/** Mint the durable identity of a session's root history window. */
+export function rootWindowId(sessionId) {
+    return `pcw:${sessionId.slice(0, 8)}:root`;
+}
+/** Persisted messages in the active window, excluding earlier windows on this branch. */
+export function hasWindowMessage(ctx, customType) {
+    const branch = ctx.sessionManager.getBranch();
+    for (let i = branch.length - 1; i >= 0; i--) {
+        const entry = branch[i];
+        if (isWindowMarker(entry))
+            break;
+        if (entry.type === "custom_message" && entry.customType === customType)
+            return true;
+    }
+    return false;
+}
+/** The root or latest durable marker on the active branch. */
+export function currentWindowId(ctx) {
+    return currentReset(ctx)?.data.windowId ?? rootWindowId(ctx.sessionManager.getSessionId());
+}
+/** The durable window active just before the marker: the last earlier marker, else the root window. */
+export function previousWindowId(ctx, markerId) {
+    let previousId = rootWindowId(ctx.sessionManager.getSessionId());
+    for (const entry of ctx.sessionManager.getBranch()) {
+        if (entry.id === markerId)
+            break;
+        if (isWindowMarker(entry))
+            previousId = entry.data.windowId;
+    }
+    return previousId;
+}
+function hasWindowId(details, windowId) {
+    return typeof details === "object" && details !== null &&
+        typeof details.windowId === "string" &&
+        details.windowId === windowId;
+}
+/** Match a provider-facing boot message, optionally by window identity. */
+export function isWindowBoot(message, windowId) {
+    return message.role === "custom" && message.customType === BOOT_TYPE && (windowId === undefined || hasWindowId(message.details, windowId));
+}
+/** Match a persisted boot entry by raw identity, even when a later edit hides it from projection. */
+export function isWindowBootEntry(entry, windowId) {
+    return entry.type === "custom_message" && entry.customType === BOOT_TYPE && hasWindowId(entry.details, windowId);
+}
+/**
+ * The durable marker selects a boot message by identity, never by wall-clock time.
+ * The boot is the first conversation message of the window. Folding only its prefix
+ * preserves later prompt/tool patches in place, including their cacheable ordering.
+ */
+export function projectWindow(messages, windowId) {
+    const cut = messages.findIndex((message) => isWindowBoot(message, windowId));
+    if (cut < 0)
+        throw new Error(`Missing boot for context window ${windowId}`);
+    const head = getCurrentSystemMessage(messages.slice(0, cut));
+    const suffix = messages.slice(cut);
+    return head ? [head, ...suffix] : suffix;
+}
+/**
+ * Root windows are not reset boundaries. A forked session can copy a root boot whose
+ * details name the source session; refresh that boot in-place in the provider projection
+ * while retaining every user/assistant/tool message from the copied root transcript.
+ */
+export function projectRootWindow(messages, windowId) {
+    const matching = messages.filter((message) => isWindowBoot(message, windowId));
+    if (matching.length === 0)
+        return messages;
+    const activeBoot = matching[matching.length - 1];
+    const firstBoot = messages.findIndex((message) => isWindowBoot(message));
+    const withoutBoots = messages.filter((message) => !isWindowBoot(message));
+    return [...withoutBoots.slice(0, firstBoot), activeBoot, ...withoutBoots.slice(firstBoot)];
+}
+/** Usage for the selected window, excluding provider usage recorded before its marker. */
+export function windowUsage(ctx) {
+    const reset = currentReset(ctx);
+    if (!reset)
+        return ctx.getContextUsage();
+    const contextWindow = ctx.model?.contextWindow ?? ctx.getContextUsage()?.contextWindow;
+    if (!contextWindow)
+        return undefined;
+    const windowId = reset.data.windowId;
+    try {
+        const messages = projectWindow(ctx.sessionManager.buildSessionProjection().messages, windowId);
+        const { tokens } = estimateContextTokens(convertToLlm(messages));
+        return { tokens, contextWindow, percent: tokens / contextWindow * 100 };
+    }
+    catch {
+        // A marker can be durable before its boot when a process stops between the two
+        // public writes. Startup/tree repair will append the missing boot; until then the
+        // budget hook must not turn a recoverable partial append into a swallowed error.
+        return undefined;
+    }
+}

package/dist/src/context/prompts.js

@@ -0,0 +1,91 @@
+import { CONTEXT_WINDOW_OPEN_TAG, CONTEXT_WINDOW_CLOSE_TAG, POCKET_AGENT_LIMIT, POCKET_HUMAN_LIMIT, POCKET_MODEL_LIMIT, POCKET_PROJECT_LIMIT, POCKET_SESSION_LIMIT, PROTOCOL_BLOCK, GUIDANCE_OPEN_TAG, GUIDANCE_CLOSE_TAG } from "../protocol.js";
+/** Codex-style <context_window> identity block: the resolved agent and model names plus first/current/previous window ids. */
+function identityBlock(agentName, modelName, firstWindowId, currentWindowId, previousWindowId) {
+    const lines = [
+        `Agent name: ${agentName} (brain: ${modelName})`,
+        `First context window id: ${firstWindowId}`,
+        `Current context window id: ${currentWindowId}`,
+    ];
+    if (previousWindowId)
+        lines.push(`Previous context window id: ${previousWindowId}`);
+    return `${CONTEXT_WINDOW_OPEN_TAG}\n${lines.join("\n")}\n${CONTEXT_WINDOW_CLOSE_TAG}`;
+}
+function relativeTime(timestamp, now) {
+    const seconds = Math.trunc((timestamp - now) / 1000);
+    const [unit, size] = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]]
+        .find(([unit, size]) => Math.abs(seconds) >= size || unit === "s");
+    const amount = `${Math.abs(Math.trunc(seconds / size))}${unit}`;
+    return seconds > 0 ? `in ${amount}` : `${amount} ago`;
+}
+function rowsFor(snapshot, scope) {
+    return snapshot.homes.get(scope) ?? [];
+}
+function notesUnavailableNotice(snapshot) {
+    if (snapshot.unavailable.length === 0)
+        return undefined;
+    const homes = snapshot.unavailable.map((home) => home.label).join(", ");
+    return `Notes index incomplete: index for ${homes} unavailable during boot; notes_list can retry after recovery.`;
+}
+/**
+ * Boot notes index. Map residency ("地图在场"): fresh MAP.md bodies from the human, project,
+ * own-agent, and current-model homes are all injected, broadest first; stale maps are skipped
+ * per home, and the session home is never peeked — a session MAP.md is an ordinary note. The
+ * pocket then lists recent fresh notes under per-home quotas (POCKET_SESSION_LIMIT /
+ * POCKET_PROJECT_LIMIT / POCKET_HUMAN_LIMIT / POCKET_AGENT_LIMIT / POCKET_MODEL_LIMIT),
+ * most-recently-updated first within each home, one metadata line each: address, line count,
+ * UTF-8 byte count, relative update time at window open. Bodies never render
+ * in the pocket; stale notes are excluded; MAP.md itself never takes a pocket seat.
+ */
+function notesIndex(snapshot) {
+    const sections = [];
+    // Map residency ("地图在场"): scope-native maps, fresh ones injected broadest-first.
+    // A session MAP.md is an ordinary note, never resident; stale maps skip independently.
+    for (const scope of ["human", "project", "agent", "model"]) {
+        const toc = rowsFor(snapshot, scope).find((row) => row.path === "MAP.md");
+        if (toc && !toc.meta.stale) {
+            if (toc.body.length > 0)
+                sections.push(toc.body);
+        }
+    }
+    // listNotes is most-recently-updated first within each home. Per-home quotas keep session
+    // churn from evicting the durable homes; maps never take pocket seats.
+    const recentNotes = [
+        ...rowsFor(snapshot, "session").filter((row) => !row.meta.stale && row.path !== "MAP.md").slice(0, POCKET_SESSION_LIMIT),
+        ...rowsFor(snapshot, "project").filter((row) => !row.meta.stale && row.path !== "MAP.md").slice(0, POCKET_PROJECT_LIMIT),
+        ...rowsFor(snapshot, "human").filter((row) => !row.meta.stale && row.path !== "MAP.md").slice(0, POCKET_HUMAN_LIMIT),
+        ...rowsFor(snapshot, "agent").filter((row) => !row.meta.stale && row.path !== "MAP.md").slice(0, POCKET_AGENT_LIMIT),
+        ...rowsFor(snapshot, "model").filter((row) => !row.meta.stale && row.path !== "MAP.md").slice(0, POCKET_MODEL_LIMIT),
+    ];
+    if (recentNotes.length > 0) {
+        const lines = [`You find ${recentNotes.length} crumpled note${recentNotes.length === 1 ? "" : "s"} in your pocket (by prefix, most recent first within each: up to ${POCKET_SESSION_LIMIT} from this session, ${POCKET_PROJECT_LIMIT} from @project, ${POCKET_HUMAN_LIMIT} from @human, ${POCKET_AGENT_LIMIT} from @self, ${POCKET_MODEL_LIMIT} from @model). A note's content never appears here, so its name has to say what the note is about:`];
+        for (const row of recentNotes) {
+            lines.push(`- ${row.address} (${row.body.split("\n").length} lines, ${row.sizeBytes} UTF-8 bytes, updated ${relativeTime(row.meta.updated_at, snapshot.openedAt)})`);
+        }
+        sections.push(lines.join("\n"));
+    }
+    return sections.join("\n\n");
+}
+function notesHomeBlock() {
+    return "Note addresses: bare <vpath> is this session; @project/<vpath> is this project; @human/<vpath> is the human's cross-project notes; @self/<vpath> is your own (current agent); @model/<vpath> is the current model's. @self and @model resolve to who is running now. Any other @ prefix, or @ inside a vpath, is a hard error; there is no fallback across prefixes. Anything not matching these is a plain file — use the file tools.";
+}
+export function renderBootBlock(data) {
+    const parts = [];
+    parts.push(identityBlock(data.agentName, data.modelName, data.firstWindowId, data.currentWindowId, data.previousWindowId));
+    parts.push(notesHomeBlock());
+    const incomplete = notesUnavailableNotice(data.notes);
+    if (incomplete)
+        parts.push(incomplete);
+    const index = notesIndex(data.notes);
+    if (index)
+        parts.push(index);
+    parts.push(PROTOCOL_BLOCK);
+    return parts.join("\n\n");
+}
+/**
+ * Codex-equivalent low-budget reminder. The measured remaining count is frozen into
+ * the text at the crossing that fires it, so each persisted copy is a snapshot true
+ * at write time; get_context_remaining remains the live source for the current figure.
+ */
+export function tokenBudgetGuidance(remaining) {
+    return `${GUIDANCE_OPEN_TAG}\nYour brain is almost out of room — ${remaining} tokens left, and then your memory gets wiped. The wipe is automatic: there is no final turn to write then. Grab the notebook now — the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. Replacing an older checkpoint? Mark it stale. Then call wipe_memory yourself — anything you do after the checkpoint isn't in it.\n${GUIDANCE_CLOSE_TAG}`;
+}

package/dist/src/context/reset-artifacts.js

@@ -0,0 +1,86 @@
+import { randomUUID } from "node:crypto";
+import { BOOT_TYPE, CONTINUATION, CONTINUATION_TYPE, RESET_MARKER_TYPE } from "../protocol.js";
+import { currentWindowId, isWindowBootEntry, isWindowMarker, previousWindowId } from "./context-window.js";
+import { buildBootMessage, sendBoot } from "./boot.js";
+/** Match the hidden continuation entry that carries the one reset message. */
+export function isWindowContinuationEntry(entry) {
+    return entry.type === "custom_message" && entry.customType === CONTINUATION_TYPE;
+}
+/** The single continuation sender: the only reset prose persisted for a window. */
+export function sendContinuation(pi) {
+    pi.sendMessage({ customType: CONTINUATION_TYPE, content: CONTINUATION, display: false }, { triggerTurn: false });
+}
+/**
+ * The closed, ordered reset shape: marker, matching boot, continuation. This is the one
+ * source of the reset message and the one place that mints the new window identity.
+ */
+export function buildResetDrafts(ctx, notifyIncompleteNotes) {
+    const sessionPrefix = ctx.sessionManager.getSessionId().slice(0, 8);
+    const usedWindowIds = new Set(ctx.sessionManager.getBranch().filter(isWindowMarker).map((entry) => entry.data.windowId));
+    let windowId;
+    do {
+        windowId = `pcw:${sessionPrefix}:${randomUUID().slice(0, 8)}`;
+    } while (usedWindowIds.has(windowId));
+    const boot = buildBootMessage(ctx, windowId, currentWindowId(ctx), notifyIncompleteNotes);
+    return [
+        { type: "custom", customType: RESET_MARKER_TYPE, data: { windowId } },
+        { type: "custom_message", customType: BOOT_TYPE, content: boot.content, display: false, details: { windowId } },
+        { type: "custom_message", customType: CONTINUATION_TYPE, content: CONTINUATION, display: false },
+    ];
+}
+/** Persist the marker and send both hidden reset messages; returns the new window id. */
+export function persistManualReset(pi, ctx, notifyIncompleteNotes) {
+    const [marker, boot, continuation] = buildResetDrafts(ctx, notifyIncompleteNotes);
+    pi.appendEntry(marker.customType, marker.data);
+    pi.sendMessage({ customType: boot.customType, content: boot.content, display: boot.display, details: boot.details }, { triggerTurn: false });
+    pi.sendMessage({ customType: continuation.customType, content: continuation.content, display: continuation.display }, { triggerTurn: false });
+    return boot.details.windowId;
+}
+/**
+ * Inspect the persisted tail of a reset marker. It reports which reset messages are present
+ * only while the tail stays repairable: metadata may follow the marker, but real conversation,
+ * a foreign message, a later marker, or a misordered/duplicate reset artifact refuses repair.
+ */
+export function inspectResetTail(ctx, markerId, windowId) {
+    const branch = ctx.sessionManager.getBranch();
+    const markerIndex = branch.findIndex((entry) => entry.id === markerId);
+    if (markerIndex < 0)
+        return undefined;
+    let boot = false;
+    let continuation = false;
+    for (const entry of branch.slice(markerIndex + 1)) {
+        if (isWindowBootEntry(entry, windowId)) {
+            // The boot is unique and must precede the continuation; a repeat or a late
+            // boot would move the provider boundary or misorder the reset shape.
+            if (boot || continuation)
+                return undefined;
+            boot = true;
+            continue;
+        }
+        if (isWindowContinuationEntry(entry)) {
+            if (continuation || !boot)
+                return undefined;
+            continuation = true;
+            continue;
+        }
+        if (isWindowMarker(entry) || entry.type === "message" || entry.type === "custom_message" || entry.type === "compaction" || entry.type === "branch_summary") {
+            return undefined;
+        }
+    }
+    return { boot, continuation };
+}
+/** True once the marker's tail already carries its boot and continuation in a valid order. */
+export function resetTailCommitted(ctx, markerId, windowId) {
+    const tail = inspectResetTail(ctx, markerId, windowId);
+    return tail?.boot === true && tail.continuation === true;
+}
+/** Emit only the reset artifacts an incomplete tail is missing, in the closed order. */
+export function repairResetTail(pi, ctx, marker, notifyIncompleteNotes) {
+    const tail = inspectResetTail(ctx, marker.id, marker.data.windowId);
+    if (!tail || (tail.boot && tail.continuation))
+        return;
+    if (!tail.boot)
+        sendBoot(pi, buildBootMessage(ctx, marker.data.windowId, previousWindowId(ctx, marker.id), notifyIncompleteNotes));
+    if (!tail.continuation)
+        sendContinuation(pi);
+}