@astrosheep/pi-context 0.24.0 → 0.25.1

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

@@ -0,0 +1,182 @@
+import { isContextOverflow, isRecoverableLength } from "@earendil-works/pi-ai";
+import { currentReset } from "./context-window.js";
+function isAbort(message, outcome, ctx) {
+    return outcome === "aborted" || (message.role === "assistant" && message.stopReason === "aborted") || ctx.signal?.aborted === true;
+}
+function isOverflowLike(message, ctx) {
+    if (message.role !== "assistant")
+        return false;
+    return isContextOverflow(message, ctx.model?.contextWindow) ||
+        (ctx.model !== undefined && isRecoverableLength(message, ctx.model.maxTokens));
+}
+export function initialResetControl() {
+    return { request: "none", overflow: "idle" };
+}
+/**
+ * Pure reset-control transition. It performs no writes, no policy resolution of its own, and
+ * no UI work; every fact it reads is supplied by the caller. Callers can therefore drive the
+ * full transition table without a live Pi session.
+ */
+export function reduceResetControl(state, event) {
+    switch (event.type) {
+        case "request": {
+            if (state.request === "explicit")
+                return { state, effect: "already-requested" };
+            return { state: { ...state, request: "explicit" }, effect: "requested" };
+        }
+        case "turn_end": {
+            const facts = event.facts;
+            const requested = state.request === "explicit";
+            // The explicit request is consumed by the turn boundary whether or not it commits.
+            const request = "none";
+            if (facts.aborted) {
+                // An aborted turn drops the whole boundary: no explicit request, no overflow chain.
+                return { state: { request, overflow: "idle" }, effect: "none" };
+            }
+            if (facts.overflow) {
+                // A failure that Pi may recover natively: arm (or re-arm) the bounded settle path.
+                // A queued message, disabled mode, or disabled automatic reset leaves it disarmed.
+                const pending = !facts.queued && facts.enabled && facts.automaticResetEnabled;
+                const spent = state.overflow === "pending-spent" || state.overflow === "spent";
+                const overflow = pending
+                    ? (spent ? "pending-spent" : "pending")
+                    : (spent ? "spent" : "idle");
+                return { state: { request, overflow }, effect: "none" };
+            }
+            // Any non-overflow completed turn supersedes an older overflow failure. A non-overflow
+            // error leaves the armed overflow chain untouched for the settle boundary.
+            const overflow = facts.failed ? state.overflow : "idle";
+            if (!facts.enabled || facts.failed)
+                return { state: { request, overflow }, effect: "none" };
+            // Explicit and threshold resets both commit at turn_end, after incoming and budget drafts.
+            const commit = requested || facts.thresholdDue;
+            return { state: { request, overflow }, effect: commit ? "commit-boundary" : "none" };
+        }
+        case "before_settle": {
+            const facts = event.facts;
+            if (state.overflow !== "pending" && state.overflow !== "pending-spent")
+                return { state, effect: "none" };
+            // Let a queued turn run first; its own turn_end settles or clears this chain.
+            if (facts.queued)
+                return { state, effect: "none" };
+            const spent = state.overflow === "pending-spent";
+            if (!facts.enabled || !facts.automaticResetEnabled || facts.aborted) {
+                return { state: { ...state, overflow: spent ? "spent" : "idle" }, effect: "none" };
+            }
+            // The recovery is one-use per failure chain. Committing it spends the attempt.
+            return { state: { ...state, overflow: "spent" }, effect: spent ? "none" : "recover-overflow" };
+        }
+        case "settled":
+            // Settlement ends the failure chain but leaves a pending explicit request armed.
+            return { state: { ...state, overflow: "idle" }, effect: "none" };
+        case "abort":
+        case "clear":
+            return { state: initialResetControl(), effect: "none" };
+    }
+}
+/**
+ * Own reset requests at Pi 0.87 boundaries. Persisted windows are custom entries, not
+ * compaction summaries: turn_end commits explicit/threshold resets after a complete tool
+ * batch, while agent_before_settle commits the one bounded overflow recovery after Pi's
+ * native recovery attempt has been cancelled.
+ *
+ * This function is the effect adapter: it captures Pi events, translates them into pure
+ * reset-control transitions, and performs the resulting marker/boot/continuation writes and
+ * notifications. The decision of what to do lives entirely in `reduceResetControl`.
+ */
+export function registerResetLifecycle(pi, options) {
+    let sessionActive = true;
+    let control = initialResetControl();
+    const clear = () => { control = reduceResetControl(control, { type: "clear" }).state; };
+    const resetBoundaryResult = (entries, ctx) => {
+        try {
+            return { entries: [...entries, ...options.buildReset(ctx)], continue: true };
+        }
+        catch (error) {
+            ctx.ui.notify(`pi-context: could not build reset (${String(error)}).`, "warning");
+            // The incoming drafts and budget drafts are already valid work from this
+            // boundary. Preserve them, but do not claim a continuation when reset
+            // construction failed.
+            return entries.length > 0 ? { entries } : undefined;
+        }
+    };
+    pi.on("turn_end", (event, ctx) => {
+        if (!sessionActive)
+            return undefined;
+        const aborted = isAbort(event.message, event.outcome, ctx);
+        const stagedBudgetEntries = options.budget.consumeTurnEnd(ctx);
+        // Lifecycle owns whether drafts are acceptable for this turn. Budget only
+        // drains its instance-local staging, so aborts and disabled mode cannot commit it.
+        const budgetEntries = options.isEnabled() && !aborted ? stagedBudgetEntries : [];
+        const entries = [...(event.entries ?? []), ...budgetEntries];
+        const decision = reduceResetControl(control, {
+            type: "turn_end",
+            facts: {
+                aborted,
+                overflow: aborted ? false : isOverflowLike(event.message, ctx),
+                failed: event.outcome === "error",
+                enabled: options.isEnabled(),
+                get queued() { return event.context.pendingMessages.length > 0 || ctx.hasPendingMessages(); },
+                get automaticResetEnabled() { return options.budget.automaticResetEnabled(ctx); },
+                get thresholdDue() { return options.budget.resetDue(ctx); },
+            },
+        });
+        control = decision.state;
+        if (decision.effect === "commit-boundary")
+            return resetBoundaryResult(entries, ctx);
+        return entries.length > 0 ? { entries } : undefined;
+    });
+    pi.on("agent_before_settle", (event, ctx) => {
+        if (!sessionActive)
+            return undefined;
+        const decision = reduceResetControl(control, {
+            type: "before_settle",
+            facts: {
+                get queued() { return event.context.pendingMessages.length > 0 || ctx.hasPendingMessages(); },
+                get enabled() { return options.isEnabled(); },
+                get automaticResetEnabled() { return options.budget.automaticResetEnabled(ctx); },
+                get aborted() { return event.outcome === "aborted" || ctx.signal?.aborted === true; },
+            },
+        });
+        control = decision.state;
+        if (decision.effect !== "recover-overflow")
+            return undefined;
+        return resetBoundaryResult(event.entries, ctx);
+    });
+    pi.on("session_before_compact", (event, ctx) => {
+        if (!sessionActive)
+            return undefined;
+        if (event.signal.aborted)
+            return { cancel: true };
+        const markerExists = currentReset(ctx) !== undefined;
+        if (options.isEnabled() || markerExists) {
+            if (event.reason === "manual") {
+                ctx.ui.notify("pi-context: /compact is disabled while context windows are active; use /wipe-memory to start a fresh window.", "warning");
+            }
+            // Native compaction is cancelled here. Threshold resets are decided solely from
+            // completed-turn usage at turn_end, never from canonical pre-request history.
+            return { cancel: true };
+        }
+        return undefined;
+    });
+    pi.on("agent_end", (_event, ctx) => {
+        if (ctx.signal?.aborted)
+            clear();
+    });
+    pi.on("agent_settled", () => {
+        // A failed recovery chain is bounded to one reset/retry. Once Pi settles, a later
+        // user prompt starts a new chain; successful continuations clear this earlier.
+        control = reduceResetControl(control, { type: "settled" }).state;
+    });
+    pi.on("session_start", () => { clear(); sessionActive = true; });
+    pi.on("session_tree", clear);
+    pi.on("session_shutdown", () => { clear(); options.budget.clear(); sessionActive = false; });
+    return {
+        request() {
+            const decision = reduceResetControl(control, { type: "request" });
+            control = decision.state;
+            return decision.effect === "already-requested" ? "rollover_already_pending" : "rollover_requested";
+        },
+        clear,
+    };
+}

package/dist/src/context/runtime.js

@@ -0,0 +1,151 @@
+import { getCurrentSystemMessage, Type } from "@earendil-works/pi-ai";
+import { VERSION, defineTool } from "@earendil-works/pi-coding-agent";
+import { registerBudget } from "./budget.js";
+import { output } from "../tool-output.js";
+import { migrateLegacyHomes } from "../notes/paths.js";
+import { currentReset, isWindowMarker, projectRootWindow, projectWindow, rootWindowId } from "./context-window.js";
+import { registerResetLifecycle } from "./reset-lifecycle.js";
+import { buildResetDrafts, persistManualReset, resetTailCommitted } from "./reset-artifacts.js";
+import { ensureBoot } from "./boot.js";
+// The bundle captures its identity; direct source loads must not claim a built hash.
+const buildLabel = typeof __PI_CONTEXT_BUILD__ === "undefined"
+    ? "unbundled source (build unknown)"
+    : `${__PI_CONTEXT_BUILD__.version} · build ${__PI_CONTEXT_BUILD__.sourceHash.slice(0, 12)}`;
+function branchHasWindowMarker(ctx, fromId) {
+    return ctx.sessionManager.getBranch(fromId).some((entry) => isWindowMarker(entry));
+}
+/** Register the context-window runtime and its context-owned commands/tools. */
+export function registerContext(pi, settingsManager) {
+    let enabled = true;
+    let missingBootNotice;
+    const incompleteNotesNotified = new Set();
+    const pendingResetNotices = new Set();
+    // Announce only a fully committed reset (marker + matching boot + continuation), not a
+    // reset request or a partial boot repair.
+    const notifyCommittedResets = (ctx, addedWindowId) => {
+        if (addedWindowId)
+            pendingResetNotices.add(addedWindowId);
+        if (pendingResetNotices.size === 0)
+            return;
+        const branch = ctx.sessionManager.getBranch();
+        for (const windowId of pendingResetNotices) {
+            const marker = branch.find((entry) => isWindowMarker(entry) && entry.data.windowId === windowId);
+            if (!marker || !resetTailCommitted(ctx, marker.id, windowId))
+                continue;
+            pendingResetNotices.delete(windowId);
+            ctx.ui.notify(`pi-context: memory cleared · ${windowId}`, "info");
+        }
+    };
+    pi.on("turn_start", (_event, ctx) => notifyCommittedResets(ctx));
+    pi.on("agent_settled", (_event, ctx) => {
+        notifyCommittedResets(ctx);
+        pendingResetNotices.clear();
+    });
+    const notifyIncompleteNotes = (ctx, windowId, snapshot) => {
+        if (snapshot.unavailable.length === 0 || incompleteNotesNotified.has(windowId))
+            return;
+        incompleteNotesNotified.add(windowId);
+        const homes = snapshot.unavailable.map((home) => home.label).join(", ");
+        ctx.ui.notify(`pi-context: notes index incomplete for ${homes}; notes_list can retry after recovery.`, "warning");
+    };
+    const migrationWarning = migrateLegacyHomes();
+    if (migrationWarning)
+        console.warn(`pi-context: ${migrationWarning}`);
+    const budget = registerBudget(pi, () => enabled, settingsManager);
+    pi.on("session_start", (_event, ctx) => {
+        if (!enabled)
+            return;
+        missingBootNotice = undefined;
+        pendingResetNotices.clear();
+        ensureBoot(pi, ctx, notifyIncompleteNotes);
+    });
+    pi.on("session_tree", (_event, ctx) => {
+        missingBootNotice = undefined;
+        pendingResetNotices.clear();
+        if (enabled)
+            ensureBoot(pi, ctx, notifyIncompleteNotes);
+    });
+    // Pi's branch summarizer receives raw entries and bypasses context_with_system. Do not
+    // let a summary of a reset branch smuggle erased history back into the destination.
+    pi.on("session_before_tree", (event, ctx) => {
+        if (!event.preparation.userWantsSummary)
+            return undefined;
+        if (!branchHasWindowMarker(ctx) && !branchHasWindowMarker(ctx, event.preparation.targetId))
+            return undefined;
+        ctx.ui.notify("pi-context: skipped branch summary across a reset window; navigation continues without erased history.", "info");
+        return { summary: { summary: "" } };
+    });
+    // This is the final provider-facing projection. Reset windows cut at their matching boot;
+    // root windows only refresh a forked boot identity and retain the copied root transcript.
+    pi.on("context_with_system", (event, ctx) => {
+        const reset = currentReset(ctx);
+        const windowId = reset?.data.windowId ?? rootWindowId(ctx.sessionManager.getSessionId());
+        try {
+            return { messages: reset ? projectWindow(event.messages, windowId) : projectRootWindow(event.messages, windowId) };
+        }
+        catch (error) {
+            if (missingBootNotice !== windowId) {
+                missingBootNotice = windowId;
+                ctx.ui.notify(`pi-context: active context window ${windowId} has no visible boot; request cancelled safely. Use /wipe-memory to start another window.`, "error");
+            }
+            ctx.abort();
+            const safeHead = getCurrentSystemMessage(event.messages);
+            return { messages: safeHead ? [safeHead] : [] };
+        }
+    });
+    pi.registerCommand("pi-context", {
+        description: "Show loaded version/build and toggle pi-context context windows",
+        getArgumentCompletions: (prefix) => ["on", "off"].filter((a) => a.startsWith(prefix)).map((a) => ({ value: a, label: a })),
+        handler: async (args, cmdCtx) => {
+            const arg = args.trim().toLowerCase();
+            if (arg === "on") {
+                enabled = true;
+                ensureBoot(pi, cmdCtx, notifyIncompleteNotes);
+            }
+            else if (arg === "off") {
+                enabled = false;
+                budget.clear();
+                resets.clear();
+            }
+            else if (arg !== "") {
+                cmdCtx.ui.notify("Usage: /pi-context [on|off]", "error");
+                return;
+            }
+            cmdCtx.ui.notify(`pi-context: ${enabled ? "on" : "off"} · ${buildLabel} · Pi ${VERSION}`, "info");
+        },
+    });
+    pi.registerCommand("wipe-memory", {
+        description: "Persist a fresh context window without calling the model",
+        handler: async (_args, cmdCtx) => {
+            if (!enabled) {
+                cmdCtx.ui.notify("pi-context: /wipe-memory requires /pi-context on.", "error");
+                return;
+            }
+            await cmdCtx.waitForIdle();
+            if (!enabled)
+                return;
+            resets.clear();
+            notifyCommittedResets(cmdCtx, persistManualReset(pi, cmdCtx, notifyIncompleteNotes));
+        },
+    });
+    pi.registerTool(defineTool({
+        name: "wipe_memory",
+        label: "Wipe memory",
+        description: "Wipe your in-context memory and start a fresh context window. Your session, notes, and history survive.",
+        parameters: Type.Object({}, { additionalProperties: false }),
+        async execute() {
+            if (!enabled)
+                return output({ error: "pi-context is off (/pi-context on to enable)" });
+            return output({ status: resets.request() }, undefined, true);
+        },
+    }));
+    const resets = registerResetLifecycle(pi, {
+        isEnabled: () => enabled,
+        buildReset: (ctx) => {
+            const drafts = buildResetDrafts(ctx, notifyIncompleteNotes);
+            pendingResetNotices.add(drafts[1].details.windowId);
+            return drafts;
+        },
+        budget,
+    });
+}

package/dist/src/context/thresholds.js

@@ -0,0 +1,62 @@
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
+import { PI_CONTEXT_SETTINGS_KEY, DEFAULT_RESERVE_TOKENS, DEFAULT_REMINDER_MARGIN_TOKENS, WARNING_RUNWAY_TOKENS } from "../protocol.js";
+import { mergePiContextSettings } from "../settings.js";
+/** A margin is usable only as a positive integer; anything else is ignored. */
+function validMargin(raw) {
+    if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw <= 0)
+        return undefined;
+    return raw;
+}
+/**
+ * Pure derivation of the thresholds from Pi's reserve: the reminder fires at reserve
+ * plus the pi-context margin, the warning steer at reserve plus WARNING_RUNWAY_TOKENS.
+ * An invalid margin degrades to the default and reports one warning. Automatic
+ * threshold/overflow handling is represented by reset lifecycle boundary drafts;
+ * no compaction summary is generated.
+ */
+export function deriveThresholds(reserveTokens, margins) {
+    const warnings = [];
+    const reminderKey = `${PI_CONTEXT_SETTINGS_KEY}.reminderMarginTokens`;
+    let reminderMargin;
+    if (margins.reminderMarginTokens === undefined)
+        reminderMargin = DEFAULT_REMINDER_MARGIN_TOKENS;
+    else {
+        const parsed = validMargin(margins.reminderMarginTokens);
+        if (parsed === undefined) {
+            warnings.push(`pi-context: ${reminderKey} must be a positive integer; using default ${DEFAULT_REMINDER_MARGIN_TOKENS}.`);
+            reminderMargin = DEFAULT_REMINDER_MARGIN_TOKENS;
+        }
+        else
+            reminderMargin = parsed;
+    }
+    return { thresholds: { reminder: reserveTokens + reminderMargin, reserve: reserveTokens, warning: reserveTokens + WARNING_RUNWAY_TOKENS }, warnings };
+}
+function readThresholdSettingsFromManager(ctx, settingsManager) {
+    // Resolve the active provider/model override from the public settings API.
+    const model = ctx.model;
+    const compaction = settingsManager.getCompactionSettings(model ? { provider: model.provider, id: model.id } : undefined);
+    const derived = deriveThresholds(compaction.reserveTokens, mergePiContextSettings(settingsManager.getGlobalSettings(), settingsManager.getProjectSettings()));
+    return { thresholds: derived.thresholds, automatic: compaction.enabled, warnings: derived.warnings };
+}
+/**
+ * Resolve policy from either the explicitly supplied SDK authority or Pi's default
+ * file-backed settings. The caller owns diagnostics and any lifecycle caching.
+ */
+export function readThresholdSettings(ctx, settingsManager) {
+    try {
+        if (settingsManager)
+            return readThresholdSettingsFromManager(ctx, settingsManager);
+        return readThresholdSettingsFromManager(ctx, SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() }));
+    }
+    catch (error) {
+        return {
+            thresholds: {
+                reminder: DEFAULT_RESERVE_TOKENS + DEFAULT_REMINDER_MARGIN_TOKENS,
+                reserve: DEFAULT_RESERVE_TOKENS,
+                warning: DEFAULT_RESERVE_TOKENS + WARNING_RUNWAY_TOKENS,
+            },
+            automatic: true,
+            warnings: [`pi-context: could not read settings; using defaults (${String(error)}).`],
+        };
+    }
+}

package/dist/src/dream/cli.js

@@ -6,7 +6,7 @@ import { acquireLock, failLock, lastRunPath, releaseLock } from "./lock.js";
 import { materialGate, timeGate } from "./gates.js";
 import { loadPlaybook, runDreamer } from "./runner.js";
 import { gitCommit } from "./git.js";
-import { readDreamerSettings } from "../thresholds.js";
+import { readDreamerSettings } from "./settings.js";
 import { doctor } from "./doctor.js";
 import { notesRoot } from "../notes/paths.js";
 function args(argv) { const out = {}; for (let i = 0; i < argv.length; i++) {

package/dist/src/dream/doctor.js

@@ -1,6 +1,7 @@
 import { existsSync, lstatSync, readFileSync, readdirSync } from "node:fs";
 import { basename, join, relative } from "node:path";
-import { assertAddress } from "../notes/address.js";
+import { ADDRESS_FORMS, assertAddress } from "../notes/address.js";
+import { SLUG_PATTERN } from "../notes/paths.js";
 /** Read-only diagnostics. Never follows symlinks or acquires/removes a dream lock. */
 export function doctor(home) {
     const issues = [];
@@ -56,7 +57,15 @@ export function doctor(home) {
                 continue;
             try {
                 const parsed = assertAddress(address);
-                const targetHome = parsed.scope === "personal" ? join(home, "personal") : parsed.scope === "project" ? project : root;
+                // Relative homes (@self/, @model/) name whoever is running; a static doctor
+                // cannot resolve them, so only absolute links are checked.
+                if ((parsed.scope === "agent" || parsed.scope === "model") && parsed.who === undefined)
+                    continue;
+                const targetHome = parsed.scope === "human" ? join(home, "human")
+                    : parsed.scope === "project" ? project
+                        : parsed.scope === "agent" ? join(home, "agents", parsed.who)
+                            : parsed.scope === "model" ? join(home, "models", parsed.who)
+                                : root;
                 if (!targetHome) {
                     report(path, `${address}: project context unavailable; use a resolvable reference`);
                     continue;
@@ -65,7 +74,7 @@ export function doctor(home) {
                     report(path, `${address}: target missing; update or remove the reference`);
             }
             catch {
-                report(path, `${address}: invalid address; use bare, @project/ or @personal/ addresses`);
+                report(path, `${address}: invalid address; ${ADDRESS_FORMS}`);
             }
         }
     };
@@ -92,7 +101,11 @@ export function doctor(home) {
             const path = join(home, name);
             inspect(path, () => {
                 if (name === "global") {
-                    report(path, "legacy home; manually migrate to personal/ without overwriting existing files");
+                    report(path, "legacy home; manually migrate to human/ without overwriting existing files");
+                    return;
+                }
+                if (name === "personal") {
+                    report(path, "legacy home; migrate to human/ (rename the directory), merging by hand if human/ already exists");
                     return;
                 }
                 if (name === ".dream.lock") {
@@ -102,11 +115,26 @@ export function doctor(home) {
                 }
                 if ([".git", "dreams", "snapshots", "trash", ".dream.lock.last-run"].includes(name))
                     return;
-                if (name === "personal") {
+                if (name === "human") {
                     if (directory(path))
                         walk(path, path);
                     return;
                 }
+                if (name === "agents" || name === "models") {
+                    if (!directory(path))
+                        return;
+                    for (const slug of readdirSync(path)) {
+                        const dir = join(path, slug);
+                        inspect(dir, () => {
+                            if (!SLUG_PATTERN.test(slug))
+                                report(dir, `invalid ${name.slice(0, -1)} slug; expected [a-z0-9-]`);
+                            if (!directory(dir))
+                                return;
+                            walk(dir, dir);
+                        });
+                    }
+                    return;
+                }
                 if (name === "project" || name === "pi") {
                     if (!directory(path))
                         return;
@@ -130,7 +158,7 @@ export function doctor(home) {
                     }
                     return;
                 }
-                report(path, "unexpected root entry; expected personal/, project/, pi/session/ or dream artifacts");
+                report(path, "unexpected root entry; expected human/, project/, agents/, models/, pi/session/ or dream artifacts");
             });
         }
     });

package/dist/src/dream/runner.js

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import { lstat, mkdir, realpath } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { createAgentSession, createEditToolDefinition, createWriteToolDefinition, ModelRuntime, resolveModelScopeWithDiagnostics, SessionManager } from "@earendil-works/pi-coding-agent";
-import { contentText } from "../history.js";
+import { contentText } from "../history/history.js";
 export const DREAMER_TOOLS = ["read", "grep", "find", "ls", "write", "edit"];
 function isOutside(notesHome, target) {
     const fromHome = relative(notesHome, target);

package/dist/src/dream/settings.js

@@ -0,0 +1,30 @@
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
+import { PI_CONTEXT_DREAMER_KEY, PI_CONTEXT_SETTINGS_KEY } from "../protocol.js";
+import { mergePiContextSettings } from "../settings.js";
+/**
+ * `pi-context.dreamer` is a non-empty model pattern. Anything else present is ignored
+ * with one warning; absent means no configured pattern, so the automatic model applies.
+ */
+export function deriveDreamer(settings) {
+    const raw = settings.dreamer;
+    if (raw === undefined)
+        return { warnings: [] };
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        return { warnings: [`pi-context: ${PI_CONTEXT_SETTINGS_KEY}.${PI_CONTEXT_DREAMER_KEY} must be a non-empty string; ignoring it.`] };
+    }
+    return { pattern: raw.trim(), warnings: [] };
+}
+/**
+ * Resolve the configurable dreamer model from Pi settings for a CLI invocation: global
+ * `~/.pi/agent/settings.json` merged with the project's `.pi/settings.json`, project
+ * values winning per key. A settings read failure degrades to no pattern with one warning.
+ */
+export function readDreamerSettings(cwd = process.cwd()) {
+    try {
+        const settingsManager = SettingsManager.create(cwd, undefined, { projectTrusted: true });
+        return deriveDreamer(mergePiContextSettings(settingsManager.getGlobalSettings(), settingsManager.getProjectSettings()));
+    }
+    catch (error) {
+        return { warnings: [`pi-context: could not read settings; using the automatic dreamer model (${String(error)}).`] };
+    }
+}

package/dist/src/{history-tools.js → history/history-tools.js}

@@ -1,7 +1,7 @@
 import { Type } from "@earendil-works/pi-ai";
 import { defineTool } from "@earendil-works/pi-coding-agent";
-import { output, outputRaw, page, middleTruncate, prefixFit, earliestMatchOffsetChars, readCharacterWindow, readWindowBlock, withinTextBudget, DEFAULT_READ_WINDOW_CHARS, HISTORY_PREVIEW_CHARS, MAX_READ_WINDOW_CHARS } from "./tool-output.js";
-import { positiveInteger, recentFirst, nullableString, role, cursor, searchQuery, searchQueries } from "./tool-schema.js";
+import { output, outputRaw, page, middleTruncate, prefixFit, earliestMatchOffsetChars, readCharacterWindow, readWindowBlock, withinTextBudget, DEFAULT_READ_WINDOW_CHARS, HISTORY_PREVIEW_CHARS, MAX_READ_WINDOW_CHARS } from "../tool-output.js";
+import { positiveInteger, recentFirst, nullableString, role, cursor, searchQuery, searchQueries } from "../tool-schema.js";
 import { historyFromSession, filteredItems, visibleItem, allItems, vacuousRoleToolCombo, unknownWindowId } from "./history.js";
 /**
  * Shrink one page item to fit the wire budget. `truncated`/`total_chars` stay honest: the
@@ -48,7 +48,7 @@ export function registerHistoryTools(pi) {
     pi.registerTool(defineTool({
         name: "history_list",
         label: "History list items",
-        description: "List durable session items, including items before compaction, using opaque item and window IDs; the role parameter's description enumerates the six roles. Every item carries truncated and total_chars: when truncated is true, truncated_content is a plain prefix of the item's content with no marker, and total_chars is its full code-point length. max_chars_per_item: 1 therefore yields pure addresses you can resolve with history_read.",
+        description: "List durable session items, including items from earlier reset windows, using opaque item and window IDs; native compaction and branch summaries remain history items in their current window. The role parameter's description enumerates the six roles. Every item carries truncated and total_chars: when truncated is true, truncated_content is a plain prefix of the item's content with no marker, and total_chars is its full code-point length. max_chars_per_item: 1 therefore yields pure addresses you can resolve with history_read.",
         parameters: Type.Object({ limit: positiveInteger(), cursor: cursor(), recent_first: recentFirst(), role: Type.Optional(role), tool_name: nullableString(), window_id: nullableString(), max_chars_per_item: positiveInteger() }, { additionalProperties: false }),
         async execute(_id, params, _signal, _update, ctx) {
             const invalid = vacuousRoleToolCombo(params);

package/dist/src/{history.js → history/history.js}

@@ -1,5 +1,5 @@
-import { RESET_V2 } from "./protocol.js";
-import { HISTORY_PREVIEW_CHARS } from "./tool-output.js";
+import { isWindowMarker, rootWindowId } from "../context/context-window.js";
+import { HISTORY_PREVIEW_CHARS } from "../tool-output.js";
 function isTextContent(part) {
     return typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string";
 }
@@ -69,37 +69,22 @@ function toolCallItems(windowId, entry, message) {
     }
     return items;
 }
-/** The extension-owned window id baked onto a reset-v2 compaction entry, if present. */
-export function resetV2WindowId(details) {
-    if (typeof details !== "object" || details === null)
-        return undefined;
-    const candidate = details;
-    if (candidate.piContext !== RESET_V2 || typeof candidate.windowId !== "string")
-        return undefined;
-    return candidate.windowId;
-}
-/** A compaction entry's window id: the extension-minted id for reset-v2, else Pi's entry id. */
-export function windowIdOf(sessionId, entry) {
-    return resetV2WindowId(entry.details) ?? `pcw:${sessionId.slice(0, 8)}:${entry.id}`;
-}
-/** Mint the durable identity of a session's root history window. */
-export function rootWindowId(sessionId) {
-    return `pcw:${sessionId.slice(0, 8)}:root`;
-}
 /** Build durable, on-demand history directly from every entry on the current session branch. */
 export function historyFromSession(ctx) {
     const sessionId = ctx.sessionManager.getSessionId();
     let window = { windowId: rootWindowId(sessionId), items: [] };
     const windows = [window];
     for (const entry of ctx.sessionManager.getBranch()) {
-        if (entry.type === "compaction") {
-            window = { windowId: windowIdOf(sessionId, entry), createdAt: entry.timestamp, items: [] };
+        if (isWindowMarker(entry)) {
+            window = { windowId: entry.data.windowId, createdAt: entry.timestamp, items: [] };
             windows.push(window);
+            continue;
+        }
+        if (entry.type === "compaction" || entry.type === "branch_summary") {
             window.items.push({
                 windowId: window.windowId,
                 itemId: entry.id,
-                // A reset-v2 compaction is authored by this extension; a native Pi compaction is not.
-                role: resetV2WindowId(entry.details) === undefined ? "system" : "developer",
+                role: "system",
                 content: entry.summary,
                 createdAt: entry.timestamp,
             });
@@ -190,26 +175,3 @@ export function filteredItems(ctx, params) {
         items.reverse();
     return items;
 }
-/** 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 (entry.type === "compaction")
-            break;
-        if (entry.type === "custom_message" && entry.customType === customType)
-            return true;
-    }
-    return false;
-}
-/** Cheap current-window lookup: scan the branch tail for the latest compaction entry. */
-export function currentWindowId(ctx) {
-    const sessionId = ctx.sessionManager.getSessionId();
-    const branch = ctx.sessionManager.getBranch();
-    for (let i = branch.length - 1; i >= 0; i--) {
-        const entry = branch[i];
-        if (entry?.type === "compaction")
-            return windowIdOf(sessionId, entry);
-    }
-    return rootWindowId(sessionId);
-}