@fastagent-sh/fastagent 0.24.3 → 0.25.0

package/dist/engines/pi/session-effects.d.ts

@@ -1,14 +0,0 @@
-/** Scoped acquisition of the two things a pi turn or control write owns: the session lease and the
- *  bound session. The Promise crossing itself is `src/effect-port.ts`. */
-import * as Effect from "effect/Effect";
-import type { PiAgentSessionFactory } from "./invoke-session.ts";
-import type { SessionInheritance } from "./session-inheritance.ts";
-import type { Lease } from "./turn-kit.ts";
-/** Admission was refused: another turn (or another write) holds this session. Its own tag because it
- *  is CONTROL FLOW — a caller answers it with `session_busy` and a retry — not a port failure. */
-export declare class SessionBusy extends Error {
-    readonly _tag = "SessionBusy";
-    constructor();
-}
-export declare function acquireSessionLease(lease: Lease, session: string): Effect.Effect<import("./turn-kit.ts").Release, SessionBusy, import("effect/Scope").Scope>;
-export declare function acquireSession(factory: PiAgentSessionFactory, session: string, inherit?: SessionInheritance): Effect.Effect<import("@earendil-works/pi-coding-agent").AgentSession, import("../../effect-port.ts").PortFailure, import("effect/Scope").Scope>;

package/dist/engines/pi/session-effects.js

@@ -1,30 +0,0 @@
-/** Scoped acquisition of the two things a pi turn or control write owns: the session lease and the
- *  bound session. The Promise crossing itself is `src/effect-port.ts`. */
-import * as Effect from "effect/Effect";
-import { port, portCleanup } from "../../effect-port.js";
-/** Admission was refused: another turn (or another write) holds this session. Its own tag because it
- *  is CONTROL FLOW — a caller answers it with `session_busy` and a retry — not a port failure. */
-export class SessionBusy extends Error {
-    _tag = "SessionBusy";
-    constructor() {
-        super("session busy: a turn or another write is already in flight");
-    }
-}
-export function acquireSessionLease(lease, session) {
-    return Effect.acquireRelease(Effect.suspend(() => {
-        const release = lease.tryAcquire(session);
-        return release ? Effect.succeed(release) : Effect.fail(new SessionBusy());
-    }), (release) => portCleanup("lease release", release));
-}
-export function acquireSession(factory, session, inherit) {
-    // Acquisition stays uninterruptible: a late factory may still publish durable state under the lease.
-    // The extension instances are this session's alone, so their end is its end: pi's `dispose()` does not tell them.
-    return Effect.acquireRelease(port(() => factory(session, inherit)), (bound) => portCleanup("dispose", async () => {
-        try {
-            await bound.extensionRunner.emit({ type: "session_shutdown", reason: "quit" });
-        }
-        finally {
-            bound.dispose();
-        }
-    }));
-}

package/dist/engines/pi/session-inheritance.d.ts

@@ -1,21 +0,0 @@
-import { type SessionManager } from "@earendil-works/pi-coding-agent";
-/** What a Caller names when a new session should start from an existing one. */
-export interface SessionInheritance {
-    parentSession: string;
-    /**
-     * Opaque markers that MAY locate the branch point on the parent's active path (searched in message content, first
-     * hit wins, most recent occurrence).
-     */
-    branchHints?: string[];
-}
-/** The branch point this inheritance should copy up to, and the parent's path. */
-export declare function inheritanceCut(parent: SessionManager, branchHints?: string[]): {
-    at: string;
-} | undefined;
-/**
- * Copy the parent's path up to `at` into `child`, entry by entry — what a backend with no FILE to fork has to do
- * instead.
- */
-export declare function copyBranchInto(parent: SessionManager, child: SessionManager, at: string): void;
-/** {@link copyBranchInto} plus the inheritance window — what a new THREAD gets and a fork does not. */
-export declare function copyBranchForInheritance(parent: SessionManager, child: SessionManager, at: string): void;

package/dist/engines/pi/session-inheritance.js

@@ -1,204 +0,0 @@
-import { estimateTokens } from "@earendil-works/pi-coding-agent";
-import { log } from "../../log.js";
-import { isConversationMessage, isPlaneMarker } from "./session-markers.js";
-/** Inheritance window: at most this many exchanges of the parent reach the child's model context. */
-const INHERIT_MAX_EXCHANGES = 50;
-/** …and at most roughly this many tokens (~1/4 of a 200K context: generous, not everything). */
-const INHERIT_MAX_TOKENS = 50_000;
-/**
- * Branch hints are IDS, not payloads: each one costs a scan over the parent's serialized path, and the wire accepts
- * arbitrary arrays.
- */
-const MAX_BRANCH_HINTS = 16;
-const MAX_BRANCH_HINT_CHARS = 128;
-function isUserMessage(entry) {
-    return entry?.type === "message" && entry.message?.role === "user";
-}
-/** Find the fork target on the parent's active path. */
-function locateBranchPoint(path, hints) {
-    const usable = hints
-        .filter((hint) => hint.length > 0 && hint.length <= MAX_BRANCH_HINT_CHARS)
-        .slice(0, MAX_BRANCH_HINTS);
-    if (usable.length < hints.length) {
-        log.warn(`[fastagent] ignored ${hints.length - usable.length} branch hint(s) (over ${MAX_BRANCH_HINTS} hints or ${MAX_BRANCH_HINT_CHARS} chars each) — hints are message ids, not payloads`);
-    }
-    if (usable.length === 0)
-        return undefined;
-    // Serialize each conversation message ONCE — the scan is hints × entries, and stringify must not sit in the inner
-    // loop. A hint is something a participant said, so the engine's own system entries are not searched: see
-    // `isConversationMessage` for what a hint landing in the assembled prompt would otherwise do here.
-    const serialized = path.map((entry) => (isConversationMessage(entry) ? JSON.stringify(entry.message) : ""));
-    for (const hint of usable) {
-        for (let i = path.length - 1; i >= 0; i--) {
-            if (!serialized[i]?.includes(hint))
-                continue;
-            let j = i + 1;
-            while (j < path.length && !isUserMessage(path[j]))
-                j++;
-            return path[j - 1]?.id;
-        }
-    }
-    return undefined;
-}
-/**
- * Bound what the child's MODEL CONTEXT starts with. Measured on pi's projection, what the model will actually see:
- * a `context_edit` omission (an abandoned retry or overflow attempt) costs nothing, and the engine's own `system`
- * entries are not history. The newest copied compaction (its summary, then the tail it retained) reaches the model
- * only while no window is cut: pi reads the NEWEST compaction alone, so a mark placed after it drops that tail. Its
- * summary, a few hundred tokens covering everything older, is carried into the mark instead.
- */
-function markInheritanceWindow(child) {
-    const path = child.getBranch();
-    const position = new Map(path.map((entry, i) => [entry.id, i]));
-    const latest = path.map((entry) => entry.type).lastIndexOf("compaction");
-    const previous = latest >= 0 ? path[latest] : undefined;
-    let summaryTokens = 0;
-    let tailTokens = 0;
-    let tailExchanges = 0;
-    const scanned = [];
-    for (const { sourceEntry, messages } of child.buildSessionProjection().entries) {
-        const tokens = messages.reduce((sum, message) => (message.role === "system" ? sum : sum + estimateTokens(message)), 0);
-        const startsExchange = sourceEntry.type === "message" && sourceEntry.message.role === "user" && messages.length > 0;
-        if (sourceEntry.id === previous?.id)
-            summaryTokens += tokens;
-        else if ((position.get(sourceEntry.id) ?? -1) < latest) {
-            // The retained tail: journal entries BEFORE the compaction that pi still projects.
-            tailTokens += tokens;
-            if (startsExchange)
-                tailExchanges++;
-        }
-        else
-            scanned.push({ id: sourceEntry.id, tokens, startsExchange });
-    }
-    const starts = [];
-    scanned.forEach((entry, i) => {
-        if (entry.startsExchange)
-            starts.push(i);
-    });
-    if (starts.length === 0)
-        return; // no exchange after the compaction to place a mark at
-    const suffixTokens = new Array(scanned.length + 1).fill(0);
-    for (let i = scanned.length - 1; i >= 0; i--) {
-        suffixTokens[i] = (suffixTokens[i + 1] ?? 0) + (scanned[i]?.tokens ?? 0);
-    }
-    const fits = (exchanges, tokens) => exchanges <= INHERIT_MAX_EXCHANGES && tokens <= INHERIT_MAX_TOKENS;
-    const everything = summaryTokens + tailTokens + (suffixTokens[0] ?? 0);
-    if (fits(tailExchanges + starts.length, everything))
-        return; // the whole visible history fits the window
-    // Cut: the tail goes, the summary stays (carried below). The newest exchange is the floor.
-    let chosen = starts.length - 1;
-    for (let k = starts.length - 2; k >= 0; k--) {
-        if (!fits(starts.length - k, summaryTokens + (suffixTokens[starts[k] ?? 0] ?? 0)))
-            break;
-        chosen = k;
-    }
-    // Without a compaction, a mark at the first exchange would hide nothing that costs tokens.
-    if (!previous && chosen === 0)
-        return;
-    const boundary = scanned[starts[chosen] ?? 0];
-    if (boundary === undefined)
-        return;
-    const hidden = tailExchanges + chosen;
-    const note = hidden > 0
-        ? `Inherited from the parent conversation; ${hidden} earlier exchange(s) are not shown.`
-        : "Inherited from the parent conversation; earlier messages are not shown.";
-    child.appendCompaction(previous ? `${previous.summary}\n\n${note}` : note, boundary.id, everything);
-}
-/** The branch point this inheritance should copy up to, and the parent's path. */
-export function inheritanceCut(parent, branchHints) {
-    const path = parent.getBranch();
-    const leaf = path[path.length - 1];
-    if (!leaf)
-        return undefined; // an empty parent has nothing to inherit
-    const hints = branchHints ?? [];
-    const at = locateBranchPoint(path, hints);
-    if (at === undefined && hints.length > 0) {
-        log.warn("[fastagent] no branch hint matched in the parent session — inheriting from its present");
-    }
-    return { at: at ?? leaf.id };
-}
-/**
- * Copy the parent's path up to `at` into `child`, entry by entry — what a backend with no FILE to fork has to do
- * instead.
- */
-export function copyBranchInto(parent, child, at) {
-    /**
-     * Parent entry id → the child's id for that entry: the copy mints its own, and a compaction points BACK into the
-     * path it was appended to.
-     */
-    const copied = new Map();
-    /** Ids of entries this copy did NOT append. */
-    let unanchored = [];
-    const record = (parentId, childId) => {
-        for (const id of unanchored)
-            copied.set(id, childId);
-        unanchored = [];
-        copied.set(parentId, childId);
-    };
-    // Typed by pi's own union, and exhaustive: a pi release that adds an entry type fails typecheck here instead of
-    // being dropped from every copied branch without a word.
-    for (const entry of parent.getBranch(at)) {
-        let childId;
-        switch (entry.type) {
-            case "message":
-                // Every message, INCLUDING the engine's system entries: the child starts from the prompt the parent was
-                // running under, and pi diffs its own sections against it, so the thread's first request carries that
-                // prompt once rather than twice.
-                childId = child.appendMessage(entry.message);
-                break;
-            case "custom_message":
-                // Model-visible history, unlike the `custom` entries below it: an extension injected it INTO the
-                // conversation, and the assistant messages answering it are being copied.
-                childId = child.appendCustomMessageEntry(entry.customType, entry.content, entry.display, entry.details);
-                break;
-            case "compaction":
-                // `firstKeptEntryId` is where the RETAINED TAIL starts — the entries pi did not summarize, which still reach
-                // the model.
-                childId = child.appendCompaction(entry.summary, copied.get(entry.firstKeptEntryId) ?? "", entry.tokensBefore, entry.details);
-                break;
-            case "context_edit": {
-                // pi omits an abandoned retry/overflow attempt from the model's context this way; dropping the edit would
-                // hand that attempt back to the copy. Its target is a message, which the copy always anchors.
-                const target = copied.get(entry.targetId);
-                if (target)
-                    childId = child.appendContextEdit(target, entry.replacement);
-                break;
-            }
-            case "model_change":
-                childId = child.appendModelChange(entry.provider, entry.modelId);
-                break;
-            case "thinking_level_change":
-                childId = child.appendThinkingLevelChange(entry.thinkingLevel);
-                break;
-            case "custom":
-                // The plane's markers describe the parent's RECORD, not the thread's history.
-                if (!isPlaneMarker(entry))
-                    childId = child.appendCustomEntry(entry.customType, entry.data);
-                break;
-            case "label":
-            case "session_info":
-            case "branch_summary":
-            case "usage":
-                break; // the parent's facts, not the thread's history
-            default: {
-                // Unreachable by type; a record written by a newer pi can still carry one, and refusing to start the thread
-                // over it would be worse than naming it.
-                const unhandled = entry;
-                log.warn(`[fastagent] inheritance skipped a session entry of unknown type "${unhandled.type}"`);
-            }
-        }
-        if (childId === undefined)
-            unanchored.push(entry.id);
-        else
-            record(entry.id, childId);
-    }
-}
-/** {@link copyBranchInto} plus the inheritance window — what a new THREAD gets and a fork does not. */
-export function copyBranchForInheritance(parent, child, at) {
-    copyBranchInto(parent, child, at);
-    markInheritanceWindow(child);
-}
-// There is deliberately NO file-level fork here. pi can copy a path into a new file (`createBranchedSession` +
-// `forkFrom`), but that pair writes the intermediate only when the copied path contains an ASSISTANT message — so
-// forking at a user entry hands `forkFrom` a path that does not exist, and the failure reads as retryable for a
-// condition no retry can change.

package/dist/engines/pi/session-markers.d.ts

@@ -1,49 +0,0 @@
-/**
- * Which journal entries are POSITIONS, which are the control plane's own bookkeeping, and which are turns in the
- * CONVERSATION. pi's journal has one shape for everything, so the plane writes what it needs to remember into the
- * same log the conversation lives in (what fork a record is, and the anchor that makes a leaf move survive a
- * reopen) — and since 0.86 the ENGINE writes its own bookkeeping there too, as the `system` entries carrying the
- * assembled prompt. Three questions, one file: a reader of the journal answers them here or it answers them alone,
- * which is how one reader came to count the prompt as history.
- */
-import type { SessionManager } from "@earendil-works/pi-coding-agent";
-/** What pins a leaf move to disk. pi's `branch()` writes nothing. */
-export declare const LEAF_ANCHOR = "fastagent.leaf";
-/**
- * The CONTROL PLANE's bookkeeping — not a place in a conversation, so never published, never navigable, and never
- * copied by a fork.
- */
-export declare function isPlaneMarker(entry: {
-    type?: string;
-    customType?: string;
-}): boolean;
-/**
- * An entry that is a TURN IN THE CONVERSATION — what a reader counting, previewing or searching the history means
- * by "a message".
- *
- * The line it draws is the ENGINE's prompt state. Since pi 0.86 pi writes `system` messages into the same log the
- * conversation lives in, carrying the assembled prompt (system prompt, project context, skill and tool descriptions)
- * plus one more per prompt or tool-set change. They are bookkeeping, not something anyone said, and every reader
- * of the journal has to decide about them. Deciding once, here, is the point: the first reader that forgot cut
- * inheritance above every exchange and handed a new thread an empty history, with no diagnostic.
- */
-export declare function isConversationMessage(entry: {
-    type?: string;
-    message?: {
-        role?: string;
-    };
-}): boolean;
-/**
- * Every position a client may move the branch head to, and everything `entries()` publishes — ONE predicate, so
- * "anything published is navigable" holds by construction.
- */
-export declare function isNavigable(entry: {
-    type?: string;
-    customType?: string;
-}): boolean;
-/** The head a client SEES: the last publishable entry on the active path. */
-export declare function publishedLeaf(record: SessionManager): string | undefined;
-/** Stamp a fresh fork with where it came from. */
-export declare function stampProvenance(record: SessionManager, provenance: string): void;
-/** What fork this record IS, or undefined for a record that was not forked. */
-export declare function forkProvenance(record: SessionManager): string | undefined;

package/dist/engines/pi/session-markers.js

@@ -1,60 +0,0 @@
-/**
- * "This record is a fork of X at Y." Its own entry rather than pi's header `parentSession`, which pi fills from its
- * own fork path and names a FILE, not the branch point idempotency needs.
- */
-const FORK_PROVENANCE = "fastagent.fork";
-/** What pins a leaf move to disk. pi's `branch()` writes nothing. */
-export const LEAF_ANCHOR = "fastagent.leaf";
-/**
- * The CONTROL PLANE's bookkeeping — not a place in a conversation, so never published, never navigable, and never
- * copied by a fork.
- */
-export function isPlaneMarker(entry) {
-    return entry.type === "custom" && (entry.customType === FORK_PROVENANCE || entry.customType === LEAF_ANCHOR);
-}
-/**
- * An entry that is a TURN IN THE CONVERSATION — what a reader counting, previewing or searching the history means
- * by "a message".
- *
- * The line it draws is the ENGINE's prompt state. Since pi 0.86 pi writes `system` messages into the same log the
- * conversation lives in, carrying the assembled prompt (system prompt, project context, skill and tool descriptions)
- * plus one more per prompt or tool-set change. They are bookkeeping, not something anyone said, and every reader
- * of the journal has to decide about them. Deciding once, here, is the point: the first reader that forgot cut
- * inheritance above every exchange and handed a new thread an empty history, with no diagnostic.
- */
-export function isConversationMessage(entry) {
-    return entry.type === "message" && entry.message?.role !== "system";
-}
-/**
- * Every position a client may move the branch head to, and everything `entries()` publishes — ONE predicate, so
- * "anything published is navigable" holds by construction.
- */
-export function isNavigable(entry) {
-    return entry.type !== "label" && !isPlaneMarker(entry);
-}
-/** The head a client SEES: the last publishable entry on the active path. */
-export function publishedLeaf(record) {
-    const path = record.getBranch();
-    for (let i = path.length - 1; i >= 0; i--) {
-        const entry = path[i];
-        if (entry && isNavigable(entry))
-            return entry.id;
-    }
-    return undefined;
-}
-/** Stamp a fresh fork with where it came from. */
-export function stampProvenance(record, provenance) {
-    record.appendCustomEntry(FORK_PROVENANCE, { provenance });
-}
-/** What fork this record IS, or undefined for a record that was not forked. */
-export function forkProvenance(record) {
-    let found;
-    for (const raw of record.getEntries()) {
-        if (raw.type !== "custom" || raw.customType !== FORK_PROVENANCE)
-            continue;
-        const value = raw.data?.provenance;
-        if (typeof value === "string")
-            found = value;
-    }
-    return found;
-}

package/dist/engines/pi/session-settings.d.ts

@@ -1,67 +0,0 @@
-/** What a session is SET TO, and what it may be set to. */
-import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import { type Models } from "@earendil-works/pi-ai";
-import type { SessionManager } from "@earendil-works/pi-coding-agent";
-import type { ModelDescriptor } from "../../session.ts";
-import type { AnyModel } from "./models.ts";
-export declare const THINKING_LEVELS: ReadonlySet<ThinkingLevel>;
-/**
- * Models as a client's picker shows them, ordered by spec: the ONE description both listings give
- * (`capabilities().allowedModels` and `availableModelsFromDir`). Its levels come from the function
- * `resolveSessionSettings` reads, so a picker offers what `state()` will then report. A model that declares no name or
- * context window (an extension's virtual model may not: pi reads the window as 0) leaves the field out rather than
- * inventing one.
- */
-export declare function describeModels(models: readonly AnyModel[]): ModelDescriptor[];
-/** The shape both override consumers walk — a session entry, structurally. */
-export interface OverrideEntryLike {
-    type: string;
-    provider?: string;
-    modelId?: string;
-    thinkingLevel?: string;
-}
-/**
- * The last entry of each kind wins, and a malformed one reads as ABSENT rather than falling through to an earlier
- * record.
- */
-export declare function lastOverrideEntries(entries: OverrideEntryLike[]): {
-    model?: {
-        provider: string;
-        modelId: string;
-    };
-    thinkingLevel?: string;
-};
-export interface SessionSettings {
-    model: AnyModel;
-    /** Already clamped to what {@link model} supports. */
-    thinkingLevel: ThinkingLevel;
-    /** What `update({ thinkingLevel })` accepts for this session. */
-    availableThinkingLevels: string[];
-    /** Recorded overrides that could not be applied. */
-    dropped?: {
-        model?: string;
-        thinkingLevel?: {
-            recorded: string;
-            running: string;
-            known: boolean;
-        };
-    };
-}
-/**
- * `defaults` is the assembly's configured pair — what a session with no overrides runs on. An agent may set no default
- * model, so a session runs on the model it records, else the default, else none: undefined then, and the session
- * cannot run until it is given one ({@link MissingModel}).
- */
-export declare function resolveSessionSettings(entries: OverrideEntryLike[], models: Models, defaults: {
-    model?: AnyModel;
-    thinkingLevel: ThinkingLevel;
-}): SessionSettings | undefined;
-/**
- * A turn has no model to run on: its session records none this registry knows, and the agent sets no default. Its own
- * class so the invoke answers it with `missing_model` instead of a prose failure.
- */
-export declare class MissingModel extends Error {
-    constructor(session: string, entries: OverrideEntryLike[]);
-}
-/** The entries on the session's ACTIVE path, root→leaf — what every last-wins settings read walks. */
-export declare function activePath(record: SessionManager, from?: string): OverrideEntryLike[];

package/dist/engines/pi/session-settings.js

@@ -1,119 +0,0 @@
-import { clampThinkingLevel, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
-/** Which strings are levels at all — the vocabulary. */
-const ALL_THINKING_LEVELS = {
-    off: true,
-    minimal: true,
-    low: true,
-    medium: true,
-    high: true,
-    xhigh: true,
-    max: true,
-};
-export const THINKING_LEVELS = new Set(Object.keys(ALL_THINKING_LEVELS));
-/**
- * Models as a client's picker shows them, ordered by spec: the ONE description both listings give
- * (`capabilities().allowedModels` and `availableModelsFromDir`). Its levels come from the function
- * `resolveSessionSettings` reads, so a picker offers what `state()` will then report. A model that declares no name or
- * context window (an extension's virtual model may not: pi reads the window as 0) leaves the field out rather than
- * inventing one.
- */
-export function describeModels(models) {
-    return models
-        .map((model) => ({
-        spec: `${model.provider}/${model.id}`,
-        ...(model.name ? { name: model.name } : {}),
-        thinkingLevels: getSupportedThinkingLevels(model),
-        ...(model.contextWindow > 0 ? { contextWindow: model.contextWindow } : {}),
-    }))
-        .sort((a, b) => (a.spec < b.spec ? -1 : a.spec > b.spec ? 1 : 0));
-}
-/**
- * The last entry of each kind wins, and a malformed one reads as ABSENT rather than falling through to an earlier
- * record.
- */
-export function lastOverrideEntries(entries) {
-    let model;
-    let modelSeen = false;
-    let thinkingLevel;
-    let thinkingSeen = false;
-    for (let i = entries.length - 1; i >= 0 && !(modelSeen && thinkingSeen); i--) {
-        const e = entries[i];
-        if (!modelSeen && e?.type === "model_change") {
-            modelSeen = true;
-            if (e.provider !== undefined && e.modelId !== undefined)
-                model = { provider: e.provider, modelId: e.modelId };
-        }
-        if (!thinkingSeen && e?.type === "thinking_level_change") {
-            thinkingSeen = true;
-            if (e.thinkingLevel !== undefined)
-                thinkingLevel = e.thinkingLevel;
-        }
-    }
-    return { model, thinkingLevel };
-}
-/**
- * `defaults` is the assembly's configured pair — what a session with no overrides runs on. An agent may set no default
- * model, so a session runs on the model it records, else the default, else none: undefined then, and the session
- * cannot run until it is given one ({@link MissingModel}).
- */
-export function resolveSessionSettings(entries, models, defaults) {
-    const recorded = lastOverrideEntries(entries);
-    const dropped = {};
-    // A registry change across deploys must not brick the conversation.
-    let model = defaults.model;
-    if (recorded.model) {
-        const found = models.getModel(recorded.model.provider, recorded.model.modelId);
-        if (found)
-            model = found;
-        else
-            dropped.model = `${recorded.model.provider}/${recorded.model.modelId}`;
-    }
-    if (!model)
-        return undefined;
-    const availableThinkingLevels = getSupportedThinkingLevels(model);
-    let thinkingLevel = clampThinkingLevel(model, defaults.thinkingLevel);
-    if (recorded.thinkingLevel !== undefined) {
-        const level = recorded.thinkingLevel;
-        if (!THINKING_LEVELS.has(level)) {
-            dropped.thinkingLevel = { recorded: level, running: thinkingLevel, known: false };
-        }
-        else {
-            // pi's clamp takes the lowest supported level AT OR ABOVE the recorded one, falling back downward only when
-            // nothing is above.
-            thinkingLevel = clampThinkingLevel(model, level);
-            if (thinkingLevel !== level) {
-                dropped.thinkingLevel = { recorded: level, running: thinkingLevel, known: true };
-            }
-        }
-    }
-    return {
-        model,
-        thinkingLevel,
-        availableThinkingLevels,
-        ...(dropped.model || dropped.thinkingLevel ? { dropped } : {}),
-    };
-}
-/**
- * A turn has no model to run on: its session records none this registry knows, and the agent sets no default. Its own
- * class so the invoke answers it with `missing_model` instead of a prose failure.
- */
-export class MissingModel extends Error {
-    constructor(session, entries) {
-        const recorded = lastOverrideEntries(entries).model;
-        super(`session "${session}" has no model: ${recorded
-            ? `the model it records, ${recorded.provider}/${recorded.modelId}, is not one this agent knows,`
-            : "it records none,"} and the agent sets no default — give the session one (session control's update({ model })), or the agent ` +
-            `a default ("model" in fastagent.config.ts, or FASTAGENT_MODEL)`);
-    }
-}
-/** The entries on the session's ACTIVE path, root→leaf — what every last-wins settings read walks. */
-export function activePath(record, from) {
-    // `from` asks a different question: the path a leaf move is ABOUT to make active, which a caller validating a patch
-    // needs before the move exists.
-    const path = record.getBranch(from);
-    const root = path[0];
-    if (root?.parentId != null) {
-        throw new Error(`session entry "${root.parentId}" is missing from the journal (parent of "${root.id}")`);
-    }
-    return path;
-}

package/dist/engines/pi/session-store.d.ts

@@ -1,69 +0,0 @@
-import { SessionManager } from "@earendil-works/pi-coding-agent";
-import type { SessionSummary, SessionUpdateField } from "../../session.ts";
-import { type OverrideEntryLike } from "./session-settings.ts";
-import { type SessionInheritance } from "./session-inheritance.ts";
-/** The session RECORDS, as operations rather than as pi handles. */
-export interface PiSessionRecordStore {
-    openOrCreate(sessionId: string, inherit?: SessionInheritance): Promise<SessionManager>;
-    /**
-     * OPEN-EXISTING sibling: an unknown session answers undefined, never creates one. The reads and every write that
-     * needs history go through it; creating is `openOrCreate`'s.
-     */
-    openIfExists(sessionId: string): Promise<SessionManager | undefined>;
-    /** Write session properties, in the order pi's leaf pointer requires, and report what LANDED. */
-    applyProperties(sessionId: string, writes: PropertyWrites): Promise<AppliedProperties | undefined>;
-    /** Every record this store holds, in CALLER ids. */
-    list(): Promise<SessionSummary[]>;
-    /**
-     * Copy `from`'s history up to entry `at` into a new record named `into`, stamped with `provenance` so a repeat of
-     * the SAME fork can be recognised as one ({@link forkProvenance}) instead of becoming a second record or an
-     * overwrite.
-     */
-    fork(from: string, at: string, into: string, provenance: string): Promise<void>;
-    delete(sessionId: string): Promise<boolean>;
-}
-/** A validated property patch, in the shape a RECORD takes it. */
-export interface PropertyWrites {
-    name?: string;
-    model?: {
-        provider: string;
-        id: string;
-    };
-    thinkingLevel?: string;
-    leafEntryId?: string;
-}
-/** What a property write actually did, and what the record holds after it. */
-interface AppliedProperties {
-    /** In write order. */
-    landed: SessionUpdateField[];
-    /** Why the rest stopped, if anything did. */
-    failure?: unknown;
-    /**
-     * The record AFTER the writes — what the caller reports, rather than echoing the request. pi rewrites a name
-     * (newlines collapse, ends trim), so the request is not what was stored.
-     */
-    name?: string;
-    leafEntryId?: string;
-    /**
-     * The active path after the writes, for a caller that resolves settings against a model registry this layer has no
-     * business knowing.
-     */
-    path?: OverrideEntryLike[];
-}
-/** A Caller's session id, as a name pi will accept. */
-export declare function piSessionId(sessionId: string): string;
-/**
- * {@link piSessionId} backwards — what `list()` needs, because a session id belongs to the CALLER and a record name is
- * storage detail.
- */
-export declare function callerSessionId(recordId: string): string | undefined;
-/** Disk-backed store under `dir`: restart the process, conversations continue. */
-export declare function piSessionRecordStore(options: {
-    dir: string;
-    cwd?: string;
-}): PiSessionRecordStore;
-/** In-process store: continuity lives and dies with the instance. */
-export declare function piInMemorySessionRecordStore(options?: {
-    cwd?: string;
-}): PiSessionRecordStore;
-export {};