reflex-state 0.1.0-alpha.1

package/dist/pi/normalization.d.ts

@@ -0,0 +1,31 @@
+import type { AgentEndEvent as PiAgentEndEvent, ToolCallEvent as PiToolCallEvent, ToolResultEvent as PiToolResultEvent } from "@earendil-works/pi-coding-agent";
+import type { ReflexStateConfig } from "../core/config.js";
+import type { AgentEndEvent, SourceRef, ToolCallEvent, ToolResultEvent, UserPromptEvent } from "../core/types.js";
+interface NormalizerOptions {
+    readonly eventCount: number;
+    readonly turnIndex: number;
+    readonly config: ReflexStateConfig;
+    readonly now?: () => number;
+    readonly cwd?: string;
+}
+export declare class PiEventNormalizer {
+    private readonly options;
+    private ordinal;
+    private turnIndex;
+    constructor(options: NormalizerOptions);
+    prompt(text: string, timestamp?: number): UserPromptEvent;
+    call(event: PiToolCallEvent): ToolCallEvent;
+    result(event: PiToolResultEvent): ToolResultEvent;
+    end(messages: PiAgentEndEvent["messages"]): AgentEndEvent;
+    resume(reason?: "resume" | "branch_switch"): {
+        type: "session_resume";
+        reason: "resume" | "branch_switch";
+        id: `E${string}`;
+        timestamp: string;
+        turnIndex: number;
+        source: SourceRef;
+    };
+    private base;
+    private now;
+}
+export {};

package/dist/pi/normalization.js

@@ -0,0 +1,72 @@
+import { boundedInput, boundedText, createExcerpt, eventId, textContent } from "../core/events.js";
+export class PiEventNormalizer {
+    options;
+    ordinal;
+    turnIndex;
+    constructor(options) {
+        this.options = options;
+        this.ordinal = options.eventCount;
+        this.turnIndex = options.turnIndex;
+    }
+    prompt(text, timestamp = this.now()) {
+        this.turnIndex++;
+        return {
+            ...this.base({ kind: "user_prompt", timestamp }),
+            type: "user_prompt",
+            text: boundedText(text, this.options.config.limits.maxPromptChars),
+        };
+    }
+    call(event) {
+        const maxChars = this.options.config.limits.maxExcerptHeadChars +
+            this.options.config.limits.maxExcerptTailChars;
+        const input = event.input;
+        const command = typeof input.command === "string" ? input.command : undefined;
+        return {
+            ...this.base({ kind: "tool_call", toolCallId: event.toolCallId, timestamp: this.now() }),
+            type: "tool_call",
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            input: boundedInput(event.input, maxChars),
+            ...(command !== undefined && command.length > maxChars ? { commandTruncated: true } : {}),
+            ...(this.options.cwd ? { cwd: this.options.cwd } : {}),
+        };
+    }
+    result(event) {
+        return {
+            ...this.base({ kind: "tool_call", toolCallId: event.toolCallId, timestamp: this.now() }),
+            type: "tool_result",
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            isError: event.isError,
+            excerpt: createExcerpt(textContent(event.content), this.options.config.limits),
+        };
+    }
+    end(messages) {
+        const last = messages.findLast((message) => message.role === "assistant");
+        const stopReason = last?.role === "assistant" ? last.stopReason : "aborted";
+        return {
+            ...this.base({ kind: "assistant_message", timestamp: last?.timestamp ?? this.now() }),
+            type: "agent_end",
+            finalText: createExcerpt(last?.role === "assistant" ? textContent(last.content) : "", this.options.config.limits),
+            stopReason: stopReason === "toolUse" || stopReason === "pending" ? "aborted" : stopReason,
+        };
+    }
+    resume(reason = "resume") {
+        return {
+            ...this.base({ kind: "assistant_message", timestamp: this.now() }),
+            type: "session_resume",
+            reason,
+        };
+    }
+    base(source) {
+        return {
+            id: eventId(++this.ordinal),
+            timestamp: new Date(source.timestamp).toISOString(),
+            turnIndex: this.turnIndex,
+            source,
+        };
+    }
+    now() {
+        return (this.options.now ?? Date.now)();
+    }
+}

package/dist/pi/persistence.d.ts

@@ -0,0 +1,15 @@
+import type { AgentEvent, StateTransitionRecord } from "../core/types.js";
+interface StoredEntry {
+    readonly type: string;
+    readonly customType?: string;
+    readonly data?: unknown;
+}
+export declare function reconstruct(branch: readonly StoredEntry[]): {
+    state: import("../core/types.js").HotState;
+    events: Map<`E${string}`, AgentEvent>;
+    transitions: StateTransitionRecord[];
+    hasMeta: boolean;
+    legacy: boolean;
+};
+export declare function highestEventOrdinal(entries: readonly StoredEntry[]): number;
+export {};

package/dist/pi/persistence.js

@@ -0,0 +1,65 @@
+import { initialState } from "../core/reducer.js";
+import { isRecord, LegacyTraceError, parseTransition } from "../core/serialization.js";
+export function reconstruct(branch) {
+    let state = initialState();
+    const events = new Map();
+    const transitions = [];
+    let hasMeta = false;
+    let legacy = false;
+    for (const entry of branch) {
+        if (entry.type !== "custom")
+            continue;
+        if (entry.customType === "reflex-state.meta" &&
+            isRecord(entry.data) &&
+            entry.data.stateVersion === 2)
+            hasMeta = true;
+        if (entry.customType === "reflex-state.reset") {
+            state = initialState();
+            events.clear();
+            transitions.length = 0;
+            legacy = false;
+            continue;
+        }
+        if (entry.customType !== "reflex-state.transition")
+            continue;
+        let record;
+        try {
+            record = parseTransition(entry.data);
+        }
+        catch (error) {
+            if (error instanceof LegacyTraceError) {
+                legacy = true;
+                continue;
+            }
+            throw error;
+        }
+        if (legacy)
+            continue;
+        if (events.has(record.event.id))
+            throw new Error("Duplicate ReflexState event on branch");
+        state = record.after;
+        events.set(record.event.id, record.event);
+        transitions.push(record);
+    }
+    return {
+        state: legacy
+            ? { ...initialState(), stateHealth: "legacy_state_requires_reset" }
+            : state,
+        events,
+        transitions,
+        hasMeta,
+        legacy,
+    };
+}
+export function highestEventOrdinal(entries) {
+    let highest = 0;
+    for (const entry of entries) {
+        if (entry.type !== "custom" || entry.customType !== "reflex-state.transition")
+            continue;
+        const data = entry.data;
+        const id = isRecord(data) && isRecord(data.event) ? data.event.id : undefined;
+        if (typeof id === "string" && /^E\d+$/.test(id))
+            highest = Math.max(highest, Number(id.slice(1)));
+    }
+    return highest;
+}

package/dist/pi/projection.d.ts

@@ -0,0 +1,11 @@
+import type { ContextEvent } from "@earendil-works/pi-coding-agent";
+import type { ProjectionMeasurement } from "../core/types.js";
+import type { StateBlockContext } from "./state_block.js";
+type Message = ContextEvent["messages"][number];
+export declare function projectContext(messages: Message[], context: StateBlockContext & {
+    compacting?: boolean;
+}): {
+    messages: Message[];
+    measurement: ProjectionMeasurement;
+};
+export {};

package/dist/pi/projection.js

@@ -0,0 +1,159 @@
+import { boundedText, textContent } from "../core/events.js";
+import { stateBlock } from "./state_block.js";
+export function projectContext(messages, context) {
+    if (!context.config.enabled || !context.config.projection.enabled)
+        return projectionResult(messages, messages, "disabled", "disabled");
+    if (context.state.stateHealth && context.state.stateHealth !== "valid")
+        return projectionResult(messages, messages, context.state.stateHealth, context.config.projection.mode);
+    if (context.compacting)
+        return projectionResult(messages, messages, "compacting", "disabled");
+    const runs = splitRuns(messages);
+    const current = runs.at(-1);
+    if (!current || !containsGoal(current.messages, context))
+        return projectionResult(messages, messages, "missing_user_prompt", context.config.projection.mode);
+    if (!completeExchanges(current.messages))
+        return projectionResult(messages, messages, "incomplete_exchange", context.config.projection.mode);
+    const retained = context.config.projection.mode === "append"
+        ? messages
+        : retainRecentRuns(messages, runs, context);
+    if (!retained)
+        return projectionResult(messages, messages, "unsafe_boundary", "current-run");
+    const target = placementTarget(retained, current, context);
+    if (!target)
+        return projectionResult(messages, messages, "unsupported_placement", context.config.projection.mode);
+    const block = stateBlock({
+        ...context,
+        projectionMode: context.config.projection.mode,
+        messagesOmitted: messages.length - retained.length,
+    });
+    if (!block)
+        return projectionResult(messages, messages, "state_block_budget", context.config.projection.mode);
+    const projected = addBlock(retained, target, block);
+    return projectionResult(messages, projected, undefined, context.config.projection.mode, block.length);
+}
+function splitRuns(messages) {
+    const runs = [];
+    let start = -1;
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        if (!message)
+            continue;
+        if (message.role === "user" && start < 0)
+            start = index;
+        if (start >= 0 && isTerminalAssistant(message)) {
+            runs.push({ start, end: index + 1, messages: messages.slice(start, index + 1) });
+            start = -1;
+        }
+    }
+    if (start >= 0)
+        runs.push({ start, end: messages.length, messages: messages.slice(start) });
+    return runs;
+}
+function retainRecentRuns(messages, runs, context) {
+    if (runs.length <= 2)
+        return runs.every((run) => completeExchanges(run.messages)) ? messages : undefined;
+    const first = runs.at(-2);
+    const last = runs.at(-1);
+    if (!first || !last)
+        return undefined;
+    if (runs[0]?.start !== 0)
+        return undefined;
+    const omitted = messages.slice(0, first.start);
+    if (omitted.some((message) => !isSafeToOmit(message)))
+        return undefined;
+    if (runs.slice(0, -2).some((run) => !completeExchanges(run.messages)))
+        return undefined;
+    if (messages.slice(last.end).length > 0)
+        return undefined;
+    if (!completeExchanges(first.messages) || !completeExchanges(last.messages))
+        return undefined;
+    if (!containsGoal(last.messages, context))
+        return undefined;
+    return messages.slice(first.start, last.end);
+}
+function isSafeToOmit(message) {
+    return ["user", "assistant", "toolResult", "bashExecution"].includes(message.role);
+}
+function placementTarget(retained, current, context) {
+    const first = current.messages.find((message) => message.role === "user");
+    const last = current.messages.at(-1);
+    const index = context.config.projection.placement === "run-start"
+        ? first
+            ? retained.indexOf(first)
+            : -1
+        : last
+            ? retained.indexOf(last)
+            : -1;
+    const message = retained[index];
+    return message && (message.role === "user" || message.role === "toolResult")
+        ? { index, message }
+        : undefined;
+}
+function isTerminalAssistant(message) {
+    return (message.role === "assistant" &&
+        "stopReason" in message &&
+        message.stopReason !== "toolUse" &&
+        message.stopReason !== "pending");
+}
+function addBlock(messages, target, block) {
+    if (target.message.role !== "user" && target.message.role !== "toolResult")
+        return messages;
+    const content = typeof target.message.content === "string"
+        ? [{ type: "text", text: target.message.content }]
+        : [...target.message.content];
+    const result = messages.slice();
+    result[target.index] = {
+        ...target.message,
+        content: [...content, { type: "text", text: block }],
+    };
+    return result;
+}
+function containsGoal(messages, context) {
+    const goal = context.state.goal ? context.evidence.get(context.state.goal) : undefined;
+    if (context.state.goal && goal?.type !== "user_prompt")
+        return false;
+    return messages.some((message) => message.role === "user" &&
+        (!goal ||
+            (goal.type === "user_prompt" &&
+                boundedText(textContent(message.content), context.config.limits.maxPromptChars) ===
+                    goal.text)));
+}
+function completeExchanges(messages) {
+    const pending = new Map();
+    const seen = new Set();
+    for (const message of messages) {
+        if (message.role === "assistant") {
+            if (pending.size)
+                return false;
+            for (const block of message.content) {
+                if (block.type !== "toolCall")
+                    continue;
+                if (seen.has(block.id))
+                    return false;
+                seen.add(block.id);
+                pending.set(block.id, block.name);
+            }
+        }
+        if (message.role === "toolResult") {
+            if (pending.get(message.toolCallId) !== message.toolName)
+                return false;
+            pending.delete(message.toolCallId);
+        }
+    }
+    return pending.size === 0;
+}
+function projectionResult(before, messages, fallback, mode = "current-run", stateBlockChars) {
+    return {
+        messages,
+        measurement: {
+            mode,
+            messagesBefore: before.length,
+            messagesAfter: messages.length,
+            messagesOmitted: before.length - messages.length,
+            charsBefore: JSON.stringify(before).length,
+            charsAfter: JSON.stringify(messages).length,
+            ...(stateBlockChars === undefined ? {} : { stateBlockChars }),
+            ...(fallback ? { fallback } : {}),
+        },
+    };
+}

package/dist/pi/runtime.d.ts

@@ -0,0 +1,35 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ReflexStateConfig } from "../core/config.js";
+import { StateEngine } from "../core/engine.js";
+import { Metrics } from "../core/metrics.js";
+import type { AgentEvent, HotState } from "../core/types.js";
+import type { StateUpdater } from "../core/updater.js";
+import { PiEventNormalizer } from "./normalization.js";
+export type UpdaterFactory = (config: ReflexStateConfig, notify: (message: string) => void) => StateUpdater;
+export declare class SessionRuntime {
+    private readonly options;
+    engine: StateEngine;
+    normalizer: PiEventNormalizer;
+    metrics: Metrics;
+    compacting: boolean;
+    projectionSafe: boolean;
+    expectedPrompt: string | undefined;
+    private currentConfig;
+    private updater;
+    private historyRecords;
+    constructor(options: {
+        pi: ExtensionAPI;
+        ctx: ExtensionContext;
+        config: ReflexStateConfig;
+        createUpdater: UpdaterFactory;
+    });
+    get config(): ReflexStateConfig;
+    get state(): HotState;
+    get history(): import("../core/types.js").StateTransitionRecord[];
+    get health(): import("../core/updater.js").UpdaterHealth;
+    record(event: AgentEvent, ctx: ExtensionContext): Promise<void>;
+    toggle(target: "projection" | "jev", enabled: boolean): Promise<void>;
+    reset(): Promise<void>;
+    widget(ctx: ExtensionContext): void;
+    private restore;
+}

package/dist/pi/runtime.js

@@ -0,0 +1,139 @@
+import { StateEngine } from "../core/engine.js";
+import { Metrics } from "../core/metrics.js";
+import { blockerView } from "../core/state_view.js";
+import { PiEventNormalizer } from "./normalization.js";
+import { highestEventOrdinal, reconstruct } from "./persistence.js";
+export class SessionRuntime {
+    options;
+    engine;
+    normalizer;
+    metrics = new Metrics();
+    compacting = false;
+    projectionSafe = true;
+    expectedPrompt;
+    currentConfig;
+    updater;
+    historyRecords;
+    constructor(options) {
+        this.options = options;
+        this.currentConfig = options.config;
+        this.updater = options.createUpdater(options.config, (message) => options.ctx.ui.notify(message, "warning"));
+        const restored = this.restore();
+        this.engine = restored.engine;
+        this.normalizer = restored.normalizer;
+        this.historyRecords = restored.transitions;
+        this.projectionSafe = !restored.legacy && restored.engine.state.stateHealth === "valid";
+        if (restored.legacy)
+            options.ctx.ui.notify("legacy_state_requires_reset", "warning");
+        else if (restored.engine.state.stateHealth !== "valid")
+            options.ctx.ui.notify("invalid_state_requires_reset", "warning");
+    }
+    get config() {
+        return this.currentConfig;
+    }
+    get state() {
+        return this.engine.state;
+    }
+    get history() {
+        return this.historyRecords.slice();
+    }
+    get health() {
+        return (this.updater.health ?? { status: "disabled", circuit: "closed", reason: "configuration" });
+    }
+    async record(event, ctx) {
+        if (!this.config.enabled || !this.projectionSafe)
+            return;
+        try {
+            await this.engine.process(event, ctx.signal);
+        }
+        catch (error) {
+            this.projectionSafe = false;
+            throw error;
+        }
+        this.widget(ctx);
+    }
+    async toggle(target, enabled) {
+        const config = {
+            ...this.config,
+            [target]: { ...this.config[target], enabled },
+        };
+        const updater = target === "jev"
+            ? this.options.createUpdater(config, (message) => this.options.ctx.ui.notify(message, "warning"))
+            : this.updater;
+        await this.engine.configure(config, updater);
+        this.currentConfig = config;
+        this.updater = updater;
+    }
+    async reset() {
+        await this.engine.idle();
+        this.options.pi.appendEntry("reflex-state.reset", { reason: "user" });
+        this.metrics = new Metrics();
+        const restored = this.restore();
+        this.engine = restored.engine;
+        this.normalizer = restored.normalizer;
+        this.historyRecords = restored.transitions;
+        this.projectionSafe = !restored.legacy && restored.engine.state.stateHealth === "valid";
+    }
+    widget(ctx) {
+        if (!ctx.hasUI)
+            return;
+        const last = this.historyRecords.findLast((record) => record.decisions.telemetry.questionsAsked > 0)?.decisions.telemetry;
+        const projection = this.metrics.lastProjection;
+        const latency = last?.latencyMs === undefined ? "" : " " + Math.round(last.latencyMs) + "ms";
+        const counts = projection
+            ? " | ctx " + projection.messagesBefore + "→" + projection.messagesAfter + " msgs"
+            : "";
+        const test = this.state.verification.test;
+        const testStatus = test.status + (test.freshness && test.freshness !== "current" ? "/" + test.freshness : "");
+        const blockers = blockerView(this.state, this.config);
+        ctx.ui.setWidget("reflex-state", [
+            "ReflexState " +
+                (this.config.enabled ? this.state.phase : "disabled") +
+                " | tests " +
+                testStatus +
+                " | blockers " +
+                blockers.shownCount +
+                "/" +
+                blockers.unresolvedTotal +
+                " | Jev " +
+                this.health.status +
+                latency +
+                counts,
+        ]);
+    }
+    restore() {
+        const { pi, ctx } = this.options;
+        const restored = reconstruct(ctx.sessionManager.getBranch());
+        for (const record of restored.transitions)
+            this.metrics.transition(record);
+        let hasMeta = restored.hasMeta;
+        const engine = new StateEngine({
+            cwd: ctx.cwd,
+            config: this.config,
+            updater: this.updater,
+            state: restored.state,
+            events: restored.events,
+            onTransition: (record) => {
+                if (!hasMeta) {
+                    pi.appendEntry("reflex-state.meta", {
+                        specVersion: "0.1",
+                        stateVersion: 2,
+                        config: this.config,
+                        piVersion: "0.83.0",
+                    });
+                    hasMeta = true;
+                }
+                pi.appendEntry("reflex-state.transition", record);
+                restored.transitions.push(record);
+                this.metrics.transition(record);
+            },
+        });
+        const normalizer = new PiEventNormalizer({
+            config: this.config,
+            cwd: ctx.cwd,
+            eventCount: highestEventOrdinal(ctx.sessionManager.getEntries()),
+            turnIndex: restored.state.cursor.turnIndex,
+        });
+        return { engine, normalizer, transitions: restored.transitions, legacy: restored.legacy };
+    }
+}

package/dist/pi/state_block.d.ts

@@ -0,0 +1,10 @@
+import type { ReflexStateConfig } from "../core/config.js";
+import type { AgentEvent, EventId, HotState } from "../core/types.js";
+export interface StateBlockContext {
+    readonly state: HotState;
+    readonly evidence: ReadonlyMap<EventId, AgentEvent>;
+    readonly config: ReflexStateConfig;
+    readonly projectionMode?: "append" | "current-run";
+    readonly messagesOmitted?: number;
+}
+export declare function stateBlock(context: StateBlockContext): string | undefined;

package/dist/pi/state_block.js

@@ -0,0 +1,123 @@
+import { boundedText } from "../core/events.js";
+import { blockerView, workingSetView } from "../core/state_view.js";
+export function stateBlock(context) {
+    const { state, evidence, config } = context;
+    const blockers = blockerView(state, config);
+    const workingSet = workingSetView(state, config.limits.maxWorkingSetEvents);
+    const requests = [...evidence.values()]
+        .filter((event) => event.type === "user_prompt")
+        .slice(-config.limits.maxRecentUserPrompts)
+        .map((event) => ({ event: event.id, text: event.text }));
+    const evidenceIds = uniqueEvidenceIds(state, blockers.blockers, workingSet.events);
+    let excerptLimit = 1200;
+    let blockerLimit = blockers.blockers.length;
+    let workingLimit = workingSet.events.length;
+    const render = () => {
+        const shownBlockers = blockers.blockers.slice(-blockerLimit);
+        const shownWorking = workingSet.events.slice(-workingLimit);
+        const displayed = new Set([
+            ...shownBlockers.map((item) => item.eventId),
+            ...shownWorking,
+            ...failedEvidence(state),
+        ]);
+        const evidenceItems = [...evidenceIds]
+            .filter((id) => displayed.has(id) || shownBlockers.some((item) => item.eventId === id))
+            .map((id) => [id, evidenceItem(evidence.get(id), evidence, excerptLimit)]);
+        return ("<reflex-state>\n" +
+            JSON.stringify({
+                note: context.projectionMode === "append"
+                    ? "This block augments the complete conversation history."
+                    : "This block describes the current execution state; older history may be omitted in current-run mode.",
+                projection_mode: context.projectionMode ?? config.projection.mode,
+                history_omitted: (context.messagesOmitted ?? 0) > 0,
+                messages_omitted: context.messagesOmitted ?? 0,
+                goal: state.goal,
+                phase: state.phase,
+                task_status: state.taskStatus,
+                state_health: state.stateHealth ?? "valid",
+                observation_generation: state.observationGeneration ?? 0,
+                pending_changes: state.pendingChanges ?? [],
+                modified_files: state.modifiedFiles,
+                verification: state.verification,
+                blockers: {
+                    unresolved_total: blockers.unresolvedTotal,
+                    shown_count: shownBlockers.length,
+                    omitted_count: blockers.unresolvedTotal - shownBlockers.length,
+                    items: shownBlockers,
+                },
+                working_set: {
+                    total: workingSet.total,
+                    shown_count: shownWorking.length,
+                    omitted_count: workingSet.omittedCount + (workingSet.events.length - shownWorking.length),
+                    items: shownWorking.map((id) => evidenceItem(evidence.get(id), evidence, excerptLimit)),
+                },
+                recent_user_requests: requests,
+                evidence: Object.fromEntries(evidenceItems),
+            }, null, 2) +
+            "\n</reflex-state>");
+    };
+    let block = render();
+    while (block.length > config.limits.maxStateBlockChars && excerptLimit > 80) {
+        excerptLimit = Math.floor(excerptLimit / 2);
+        block = render();
+    }
+    while (block.length > config.limits.maxStateBlockChars && workingLimit > 0) {
+        workingLimit--;
+        block = render();
+    }
+    while (block.length > config.limits.maxStateBlockChars && blockerLimit > 0) {
+        blockerLimit--;
+        block = render();
+    }
+    return block.length <= config.limits.maxStateBlockChars ? block : undefined;
+}
+function uniqueEvidenceIds(state, blockers, workingSet) {
+    return [
+        ...new Set([...blockers.map((item) => item.eventId), ...workingSet, ...failedEvidence(state)]),
+    ];
+}
+function failedEvidence(state) {
+    return Object.values(state.verification).flatMap((item) => item.status === "failed" && item.evidence ? [item.evidence] : []);
+}
+function evidenceItem(event, evidence, excerptLimit) {
+    if (!event)
+        return { available: false, reason: "evidence_unavailable" };
+    const related = relatedCall(event, evidence);
+    const item = { id: event.id, type: event.type };
+    if (event.type === "tool_call") {
+        item.tool = event.toolName;
+        item.command =
+            typeof event.input.command === "string" ? boundedText(event.input.command, 400) : undefined;
+        item.path = typeof event.input.path === "string" ? event.input.path : undefined;
+        item.truncated = event.commandTruncated === true;
+    }
+    if (event.type === "tool_result") {
+        item.tool = event.toolName;
+        item.error = event.isError;
+        item.excerpt = excerptText(event, excerptLimit);
+        item.truncated = event.excerpt.truncated;
+        if (!related)
+            item.related_call = { available: false, reason: "related_call_unavailable" };
+    }
+    if (event.type === "file_change") {
+        item.paths = event.paths;
+        item.truncated = false;
+    }
+    if (related && related.id !== event.id) {
+        item.related_call = evidenceItem(related, evidence, Math.min(excerptLimit, 400));
+    }
+    return item;
+}
+function relatedCall(event, evidence) {
+    if (event.type === "tool_call")
+        return event;
+    if (event.type !== "tool_result")
+        return undefined;
+    return [...evidence.values()].find((candidate) => candidate.type === "tool_call" &&
+        candidate.toolCallId === event.toolCallId &&
+        candidate.toolName === event.toolName);
+}
+function excerptText(event, limit) {
+    const text = event.excerpt.head + (event.excerpt.tail ? "\n[excerpt gap]\n" + event.excerpt.tail : "");
+    return boundedText(text, limit);
+}

package/dist/pi/trace.d.ts

@@ -0,0 +1,14 @@
+import type { ReflexStateConfig } from "../core/config.js";
+import type { AgentEvent } from "../core/types.js";
+export declare function exportSession(entries: readonly Record<string, unknown>[], options: {
+    leaf?: string;
+    config: ReflexStateConfig;
+}): {
+    events: AgentEvent[];
+    transitions: import("../core/types.js").StateTransitionRecord[];
+    cwd: string;
+    config: ReflexStateConfig;
+    leaf: {} | null;
+    formatVersion: number;
+    legacy: boolean;
+};