reflex-state 0.1.0-alpha.1

package/dist/pi/trace.js

@@ -0,0 +1,106 @@
+import { textContent } from "../core/events.js";
+import { isRecord } from "../core/serialization.js";
+import { PiEventNormalizer } from "./normalization.js";
+import { reconstruct } from "./persistence.js";
+export function exportSession(entries, options) {
+    const branch = selectBranch(entries, options.leaf);
+    const stored = branch.map((entry) => ({
+        type: String(entry.type),
+        ...(typeof entry.customType === "string" ? { customType: entry.customType } : {}),
+        data: entry.data,
+    }));
+    const restored = reconstruct(stored);
+    const hasRecords = stored.some((entry) => entry.customType === "reflex-state.transition" || entry.customType === "reflex-state.reset");
+    const header = entries.find((entry) => entry.type === "session");
+    return {
+        events: hasRecords && !restored.legacy
+            ? restored.transitions.map((record) => record.event)
+            : deriveEvents(branch, options.config),
+        transitions: restored.transitions,
+        cwd: typeof header?.cwd === "string" ? header.cwd : ".",
+        config: restored.transitions[0]?.config ?? options.config,
+        leaf: branch.at(-1)?.id ?? null,
+        formatVersion: restored.legacy ? 1 : 2,
+        legacy: restored.legacy,
+    };
+}
+function selectBranch(entries, leaf) {
+    const indexed = entries.filter((entry) => typeof entry.id === "string" && entry.type !== "session");
+    const byId = new Map(indexed.map((entry) => [entry.id, entry]));
+    if (byId.size !== indexed.length)
+        throw new Error("Duplicate Pi session entry ID");
+    let id = leaf ?? indexed.at(-1)?.id;
+    const branch = [];
+    const seen = new Set();
+    while (typeof id === "string") {
+        const entry = byId.get(id);
+        if (!entry || seen.has(id))
+            throw new Error("Missing or cyclic Pi branch entry");
+        seen.add(id);
+        branch.push(entry);
+        id = entry.parentId;
+    }
+    return branch.reverse();
+}
+function deriveEvents(branch, config) {
+    let timestamp = 0;
+    const normalizer = new PiEventNormalizer({
+        eventCount: 0,
+        turnIndex: 0,
+        config,
+        now: () => timestamp,
+    });
+    const events = [];
+    for (const entry of branch) {
+        if (entry.type !== "message" || !isRecord(entry.message))
+            continue;
+        const message = entry.message;
+        timestamp =
+            typeof message.timestamp === "number"
+                ? message.timestamp
+                : Date.parse(String(entry.timestamp));
+        if (!Number.isFinite(timestamp))
+            throw new Error("Invalid Pi message timestamp");
+        if (message.role === "user")
+            events.push(normalizer.prompt(textContent(message.content), timestamp));
+        if (message.role === "toolResult")
+            events.push(normalizer.result({
+                type: "tool_result",
+                toolCallId: string(message.toolCallId),
+                toolName: string(message.toolName),
+                input: {},
+                content: [{ type: "text", text: textContent(message.content) }],
+                isError: message.isError === true,
+                details: undefined,
+            }));
+        if (message.role === "assistant")
+            events.push(...assistantEvents(message, normalizer));
+    }
+    return events;
+}
+function assistantEvents(message, normalizer) {
+    const events = [];
+    if (!Array.isArray(message.content))
+        throw new Error("Invalid assistant content");
+    for (const block of message.content) {
+        if (!isRecord(block) || block.type !== "toolCall")
+            continue;
+        if (!isRecord(block.arguments))
+            throw new Error("Invalid tool arguments");
+        events.push(normalizer.call({
+            type: "tool_call",
+            toolCallId: string(block.id),
+            toolName: string(block.name),
+            input: block.arguments,
+        }));
+    }
+    if (["stop", "length", "error", "aborted"].includes(String(message.stopReason))) {
+        events.push(normalizer.end([message]));
+    }
+    return events;
+}
+function string(value) {
+    if (typeof value !== "string")
+        throw new Error("Invalid Pi tool reference");
+    return value;
+}

package/dist/replay/runner.d.ts

@@ -0,0 +1,50 @@
+import type { ReflexStateConfig } from "../core/config.js";
+import type { AgentEvent, StateTransitionRecord } from "../core/types.js";
+import type { StateUpdater } from "../core/updater.js";
+interface ReplayOptions {
+    readonly cwd: string;
+    readonly config: ReflexStateConfig;
+    readonly updater: StateUpdater;
+    readonly recording?: readonly StateTransitionRecord[];
+}
+export declare function replay(events: readonly AgentEvent[], options: ReplayOptions): Promise<{
+    state: import("../core/types.js").HotState;
+    transitions: StateTransitionRecord[];
+    metrics: {
+        events: number;
+        transitions: number;
+        jevCalls: number;
+        jevFailures: Record<string, number>;
+        questions: Record<string, number>;
+        applied: number;
+        uncertain: number;
+        shadowAgreement: number | undefined;
+        jevLatencyMs: {
+            mean: number | undefined;
+            p50: number | undefined;
+            p95: number | undefined;
+        };
+        jevInputTokens: number | undefined;
+        jevOutputTokens: number | undefined;
+        projection: {
+            calls: number;
+            last: import("../core/types.js").ProjectionMeasurement | undefined;
+            modes: Record<string, number>;
+            meanMessagesBefore: number | undefined;
+            meanMessagesAfter: number | undefined;
+            meanMessagesOmitted: number | undefined;
+            meanCharsBefore: number | undefined;
+            meanCharsAfter: number | undefined;
+            meanStateBlockChars: number | undefined;
+            fallbacks: Record<string, number>;
+        };
+        provider: {
+            calls: number;
+            input: number | undefined;
+            cacheRead: number | undefined;
+            cacheWrite: number | undefined;
+            output: number | undefined;
+        } | undefined;
+    };
+}>;
+export {};

package/dist/replay/runner.js

@@ -0,0 +1,21 @@
+import { StateEngine } from "../core/engine.js";
+import { Metrics } from "../core/metrics.js";
+export async function replay(events, options) {
+    const metrics = new Metrics();
+    const engine = new StateEngine({
+        ...options,
+        onTransition: (record) => metrics.transition(record),
+    });
+    const recording = new Map(options.recording?.map((record) => [record.event.id, record]));
+    const transitions = [];
+    for (const event of events) {
+        const record = recording.get(event.id);
+        if (record) {
+            if (record.after.version !== 2)
+                throw new Error("Unsupported legacy recorded replay");
+            await engine.configure(record.config, options.updater, record.cwd);
+        }
+        transitions.push(await engine.process(event));
+    }
+    return { state: engine.state, transitions, metrics: metrics.snapshot() };
+}

package/dist/replay/trace.d.ts

@@ -0,0 +1,2 @@
+export declare function parseEvents(text: string): import("../index.js").AgentEvent[];
+export declare function parseRecording(text: string): import("../index.js").StateTransitionRecord[];

package/dist/replay/trace.js

@@ -0,0 +1,7 @@
+import { parseEvent, parseJsonLines, parseTransition } from "../core/serialization.js";
+export function parseEvents(text) {
+    return parseJsonLines(text, parseEvent);
+}
+export function parseRecording(text) {
+    return parseJsonLines(text, parseTransition);
+}

package/dist/replay_cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/replay_cli.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+import { jsonLines, readConfigFile, traceMetadata, writeArtifacts } from "./cli_io.js";
+import { createUpdater } from "./composition.js";
+import { NoopStateUpdater, RecordedDecisionsUpdater } from "./core/updater.js";
+import { replay } from "./replay/runner.js";
+import { parseEvents, parseRecording } from "./replay/trace.js";
+import { redact } from "./typesafe/input.js";
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            updater: { type: "string", default: "noop" },
+            config: { type: "string" },
+            cwd: { type: "string" },
+            out: { type: "string", default: "replay-output" },
+        },
+    });
+    const input = positionals[0];
+    if (!input || positionals.length !== 1)
+        throw new Error("Usage: reflex-state-replay <events.jsonl> --updater noop|jev|recorded[:path] [--config file] [--cwd dir] [--out dir]");
+    const mode = values.updater;
+    if (mode !== "noop" && mode !== "jev" && mode !== "recorded" && !mode.startsWith("recorded:"))
+        throw new Error("Unknown updater");
+    const recordedPath = mode.startsWith("recorded")
+        ? mode.slice(9) || join(dirname(input), "transitions.jsonl")
+        : undefined;
+    const recording = recordedPath ? parseRecording(await readFile(recordedPath, "utf8")) : undefined;
+    const metadata = await traceMetadata(join(dirname(input), "trace_meta.json"));
+    const base = values.config
+        ? await readConfigFile(values.config)
+        : (metadata.config ?? (await readConfigFile(undefined)));
+    const config = {
+        ...base,
+        jev: {
+            ...base.jev,
+            enabled: process.env.REFLEX_STATE_DISABLE_JEV === "1" ? false : base.jev.enabled,
+        },
+    };
+    const updater = recording
+        ? new RecordedDecisionsUpdater(recording)
+        : mode === "jev"
+            ? createUpdater(config, console.error)
+            : new NoopStateUpdater();
+    const result = await replay(parseEvents(await readFile(input, "utf8")), {
+        cwd: values.cwd ?? metadata.cwd ?? process.cwd(),
+        config,
+        updater,
+        ...(recording ? { recording } : {}),
+    });
+    const summary = result.transitions.length +
+        " events; task " +
+        result.state.taskStatus +
+        "; Jev calls " +
+        result.metrics.jevCalls +
+        ".";
+    await writeArtifacts(values.out, {
+        "final_state.json": JSON.stringify(result.state, null, 2) + "\n",
+        "transitions.jsonl": jsonLines(result.transitions),
+        "metrics.json": JSON.stringify(result.metrics, null, 2) + "\n",
+        "summary.txt": summary + "\n",
+    }, [input, ...(recordedPath ? [recordedPath] : [])]);
+    console.log(JSON.stringify(result.state, null, 2));
+    console.error(summary + " Artifacts: " + values.out);
+}
+await main().catch((error) => {
+    console.error(redact(error instanceof Error ? error.message : "Replay failed"));
+    process.exitCode = 1;
+});

package/dist/typesafe/client.d.ts

@@ -0,0 +1,21 @@
+import type { ReflexStateConfig } from "../core/config.js";
+export type Question = {
+    readonly type: "noul";
+    readonly instructions: string;
+} | {
+    readonly type: "choice";
+    readonly instructions: string;
+    readonly criteria: Record<string, string>;
+};
+export interface SystemOneRequest {
+    readonly state: string;
+    readonly questions: Record<string, Question>;
+    readonly model: string;
+}
+export interface TypeSafeSystemOneClient {
+    systemOne(request: SystemOneRequest, options: {
+        signal: AbortSignal;
+    }): Promise<unknown>;
+}
+export declare function failureKind(error: unknown): string;
+export declare function createTypeSafeClient(config: ReflexStateConfig): TypeSafeSystemOneClient;

package/dist/typesafe/client.js

@@ -0,0 +1,49 @@
+import { TypeSafeClient, AuthenticationError, RateLimitError, APITimeoutError, APIConnectionError, BadRequestError, UnprocessableEntityError, InternalServerError, TypeSafeError, } from "@typesafe-ai/sdk";
+import { InvalidResponseError } from "./gating.js";
+export function failureKind(error) {
+    if (error instanceof AuthenticationError)
+        return "auth_error";
+    if (error instanceof APITimeoutError)
+        return "timeout";
+    if (error instanceof RateLimitError)
+        return "rate_limit";
+    if (error instanceof APIConnectionError)
+        return "connection_error";
+    if (error instanceof BadRequestError)
+        return "bad_request";
+    if (error instanceof UnprocessableEntityError)
+        return "unprocessable";
+    if (error instanceof InternalServerError)
+        return "server_error";
+    if (error instanceof InvalidResponseError)
+        return "invalid_response";
+    if (error instanceof Error && /api[_ ]?key/i.test(error.message))
+        return "auth_error";
+    if (error instanceof TypeSafeError)
+        return "sdk_error";
+    return "updater_error";
+}
+export function createTypeSafeClient(config) {
+    let client;
+    return {
+        systemOne(request, options) {
+            client ??= new TypeSafeClient({
+                defaultModel: config.jev.model,
+                timeout: config.jev.timeoutMs,
+                retry: { maxRetries: config.jev.maxRetries },
+                logLevel: "warn",
+                logger: {
+                    debug() { },
+                    info() { },
+                    warn() {
+                        console.warn("TypeSafe SDK warning");
+                    },
+                    error() {
+                        console.error("TypeSafe SDK error");
+                    },
+                },
+            });
+            return client.systemOne(request, options);
+        },
+    };
+}

package/dist/typesafe/deadline.d.ts

@@ -0,0 +1,8 @@
+export declare class RequestCancelledError extends Error {
+    readonly kind: "timeout" | "aborted";
+    constructor(kind: "timeout" | "aborted");
+}
+export declare function withinDeadline<T>(operation: (signal: AbortSignal) => Promise<T>, options: {
+    deadlineMs: number;
+    signal?: AbortSignal | undefined;
+}): Promise<T>;

package/dist/typesafe/deadline.js

@@ -0,0 +1,35 @@
+export class RequestCancelledError extends Error {
+    kind;
+    constructor(kind) {
+        super(kind);
+        this.kind = kind;
+        this.name = "RequestCancelledError";
+    }
+}
+export async function withinDeadline(operation, options) {
+    const controller = new AbortController();
+    const cancelled = Promise.withResolvers();
+    const abort = () => {
+        controller.abort(new RequestCancelledError("aborted"));
+    };
+    const reject = () => {
+        cancelled.reject(controller.signal.reason);
+    };
+    controller.signal.addEventListener("abort", reject, { once: true });
+    options.signal?.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(() => controller.abort(new RequestCancelledError("timeout")), options.deadlineMs);
+    if (options.signal?.aborted)
+        abort();
+    try {
+        const request = Promise.resolve().then(() => {
+            controller.signal.throwIfAborted();
+            return operation(controller.signal);
+        });
+        return await Promise.race([request, cancelled.promise]);
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", abort);
+        controller.signal.removeEventListener("abort", reject);
+    }
+}

package/dist/typesafe/decisions.d.ts

@@ -0,0 +1,5 @@
+import type { ReflexStateConfig } from "../core/config.js";
+import type { SemanticDecisions } from "../core/types.js";
+export declare function decodeDecisions(response: unknown, ids: readonly string[], thresholds: ReflexStateConfig["thresholds"]): SemanticDecisions;
+export declare function errorDecisions(ids: readonly string[], error: string): SemanticDecisions;
+export declare function describeResponse(response: unknown, ids: readonly string[]): Record<string, string>;

package/dist/typesafe/decisions.js

@@ -0,0 +1,94 @@
+import { isRecord } from "../core/serialization.js";
+import { emptyDecisions } from "../core/updater.js";
+import { gateChoice, gateNoul, InvalidResponseError } from "./gating.js";
+import { categories, phases } from "./questions.js";
+export function decodeDecisions(response, ids, thresholds) {
+    const result = record(response);
+    const answers = record(result.answers);
+    const usage = result.usage === undefined ? {} : record(result.usage);
+    return {
+        ...emptyDecisions(),
+        ...(ids.includes("blocker_introduced")
+            ? { blockerIntroduced: gateNoul(answers.blocker_introduced, thresholds) }
+            : {}),
+        ...(ids.includes("failure_category")
+            ? { failureCategory: gateChoice(answers.failure_category, categories, thresholds) }
+            : {}),
+        ...(ids.includes("task_complete")
+            ? { taskComplete: gateNoul(answers.task_complete, thresholds) }
+            : {}),
+        ...(ids.includes("phase_shadow")
+            ? { phaseShadow: { ...gateChoice(answers.phase_shadow, phases, thresholds), shadow: true } }
+            : {}),
+        resolvedBlockers: ids
+            .filter((id) => id.startsWith("resolves_"))
+            .map((id) => ({
+            eventId: id.slice(9),
+            decision: gateNoul(answers[id], thresholds),
+        })),
+        relevance: ids
+            .filter((id) => id.startsWith("relevant_"))
+            .map((id) => ({
+            eventId: id.slice(9),
+            decision: gateNoul(answers[id], thresholds),
+        })),
+        telemetry: {
+            questionsAsked: ids.length,
+            questionIds: ids,
+            ...(typeof result.model === "string" ? { model: result.model } : {}),
+            ...(measured(usage.input_tokens) ? { inputTokens: usage.input_tokens } : {}),
+            ...(measured(usage.output_tokens) ? { outputTokens: usage.output_tokens } : {}),
+        },
+    };
+}
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new InvalidResponseError();
+    return value;
+}
+export function errorDecisions(ids, error) {
+    const decision = { value: null, gate: "error" };
+    return {
+        ...emptyDecisions(),
+        ...(ids.includes("blocker_introduced") ? { blockerIntroduced: decision } : {}),
+        ...(ids.includes("failure_category") ? { failureCategory: decision } : {}),
+        ...(ids.includes("task_complete") ? { taskComplete: decision } : {}),
+        ...(ids.includes("phase_shadow") ? { phaseShadow: { ...decision, shadow: true } } : {}),
+        resolvedBlockers: ids
+            .filter((id) => id.startsWith("resolves_"))
+            .map((id) => ({ eventId: id.slice(9), decision })),
+        relevance: ids
+            .filter((id) => id.startsWith("relevant_"))
+            .map((id) => ({ eventId: id.slice(9), decision })),
+        telemetry: { questionsAsked: ids.length, questionIds: ids, error },
+    };
+}
+function measured(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+export function describeResponse(response, ids) {
+    const root = isRecord(response) ? response : {};
+    const answers = isRecord(root.answers) ? root.answers : {};
+    const shape = {
+        response: valueType(response),
+        answers: valueType(root.answers),
+        usage: valueType(root.usage),
+    };
+    for (const id of ids) {
+        const answer = answers[id];
+        shape["answers." + id] = valueType(answer);
+        if (!isRecord(answer))
+            continue;
+        for (const field of ["noul", "choice", "confidence", "probabilities"])
+            if (Object.hasOwn(answer, field))
+                shape["answers." + id + "." + field] = valueType(answer[field]);
+    }
+    return shape;
+}
+function valueType(value) {
+    if (value === undefined)
+        return "missing";
+    if (value === null)
+        return "null";
+    return Array.isArray(value) ? "array" : typeof value;
+}

package/dist/typesafe/gating.d.ts

@@ -0,0 +1,7 @@
+import type { ReflexStateConfig } from "../core/config.js";
+import type { GatedDecision } from "../core/types.js";
+export declare class InvalidResponseError extends Error {
+    constructor();
+}
+export declare function gateNoul(answer: unknown, thresholds: ReflexStateConfig["thresholds"]): GatedDecision<boolean>;
+export declare function gateChoice<T extends string>(answer: unknown, choices: readonly T[], thresholds: ReflexStateConfig["thresholds"]): GatedDecision<T>;

package/dist/typesafe/gating.js

@@ -0,0 +1,48 @@
+export class InvalidResponseError extends Error {
+    constructor() {
+        super("Invalid response shape from TypeSafe");
+        this.name = "InvalidResponseError";
+    }
+}
+export function gateNoul(answer, thresholds) {
+    const probability = object(answer).noul;
+    if (!isProbability(probability))
+        throw new InvalidResponseError();
+    if (probability >= thresholds.noulAccept)
+        return { value: true, gate: "applied", probability };
+    if (probability <= thresholds.noulReject)
+        return { value: false, gate: "applied", probability };
+    return { value: null, gate: "uncertain", probability };
+}
+export function gateChoice(answer, choices, thresholds) {
+    const response = object(answer);
+    const choice = choices.find((value) => value === response.choice);
+    const confidence = response.confidence;
+    const distribution = object(response.probabilities);
+    if (!choice || !isProbability(confidence))
+        throw new InvalidResponseError();
+    const probabilities = {};
+    for (const label of choices) {
+        const probability = distribution[label];
+        if (!isProbability(probability))
+            throw new InvalidResponseError();
+        probabilities[label] = probability;
+    }
+    const margin = (probabilities[choice] ?? 0) -
+        Math.max(0, ...choices.filter((label) => label !== choice).map((label) => probabilities[label] ?? 0));
+    const applied = confidence >= thresholds.minChoiceConfidence && margin >= thresholds.minChoiceMargin;
+    return {
+        value: applied ? choice : null,
+        gate: applied ? "applied" : "uncertain",
+        confidence,
+        probabilities,
+    };
+}
+function object(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new InvalidResponseError();
+    return value;
+}
+function isProbability(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}

package/dist/typesafe/input.d.ts

@@ -0,0 +1,3 @@
+import type { StateUpdateContext } from "../core/updater.js";
+export declare function redact(text: string): string;
+export declare function buildInput(context: StateUpdateContext): string;

package/dist/typesafe/input.js

@@ -0,0 +1,115 @@
+import { buildRequestPlan } from "./request_plan.js";
+export function redact(text) {
+    return text
+        .replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?(?:-----END [^-]*PRIVATE KEY-----\s*|$)/g, "[REDACTED]")
+        .replace(/\bsk-[a-zA-Z0-9_-]{8,}/g, "[REDACTED]")
+        .replace(/\bAKIA[A-Z0-9]{16}\b/g, "[REDACTED]")
+        .replace(/\bBearer\s+[^\s"'<>]+/gi, "Bearer [REDACTED]")
+        .replace(/^(\s*(?:export\s+)?[A-Z][A-Z0-9_]*\s*=).*$/gm, "$1[REDACTED]");
+}
+export function buildInput(context) {
+    let excerptLimit = 1800;
+    while (true) {
+        const input = JSON.stringify(sanitize(inputObject(context, excerptLimit)));
+        if (Buffer.byteLength(input) <= 24_000)
+            return input;
+        if (excerptLimit === 0)
+            throw new Error("input_budget_exceeded");
+        excerptLimit = Math.floor(excerptLimit / 2);
+    }
+}
+function inputObject(context, excerptLimit) {
+    const { state, event, facts, evidence, config } = context;
+    const plan = buildRequestPlan(context);
+    const sources = new Map(evidence);
+    sources.set(event.id, event);
+    const goal = state.goal ? evidence.get(state.goal) : undefined;
+    const related = plan.evidenceIds.flatMap((id) => {
+        const source = sources.get(id);
+        return source && !isReadResult(source) ? [[id, inputEvent(source, excerptLimit)]] : [];
+    });
+    const call = event.type === "tool_result"
+        ? [...sources.values()].find((source) => source.type === "tool_call" && source.toolCallId === event.toolCallId)
+        : undefined;
+    return {
+        schema: {
+            phase: "Current activity; done means the user's goal is complete.",
+            blocker: "An unresolved obstacle backed by an event. Verification-origin blockers are resolved by code.",
+            verification: "Observed overall command outcome; compound commands do not prove every segment ran.",
+        },
+        request_plan: {
+            questions: plan.items.map((item) => ({
+                id: item.id,
+                kind: item.kind,
+                evidence: item.requiredEvidence,
+            })),
+            skipped: plan.skipped,
+        },
+        goal: goal?.type === "user_prompt"
+            ? { id: goal.id, text: redact(goal.text).slice(0, config.limits.maxPromptChars) }
+            : null,
+        current_state: {
+            phase: state.phase,
+            taskStatus: state.taskStatus,
+            verification: state.verification,
+            activeBlockers: {
+                unresolvedTotal: state.activeBlockers.length,
+                shown: state.activeBlockers.slice(-config.limits.maxProjectedBlockers),
+                omitted: Math.max(0, state.activeBlockers.length - config.limits.maxProjectedBlockers),
+            },
+            modifiedFiles: state.modifiedFiles,
+        },
+        latest_event: {
+            ...inputEvent(event, excerptLimit),
+            verification: facts.verification,
+            exitCode: facts.exitCode,
+            command: call?.type === "tool_call" && typeof call.input.command === "string"
+                ? redact(call.input.command).slice(0, 2000)
+                : undefined,
+        },
+        evidence: Object.fromEntries(related),
+    };
+}
+function inputEvent(event, excerptLimit) {
+    if (event.type === "tool_result")
+        return {
+            id: event.id,
+            type: event.type,
+            toolName: event.toolName,
+            isError: event.isError,
+            excerpt: ["bash", "edit", "write"].includes(event.toolName)
+                ? excerptText(event.excerpt, excerptLimit)
+                : undefined,
+        };
+    if (event.type === "agent_end")
+        return {
+            id: event.id,
+            type: event.type,
+            stopReason: event.stopReason,
+            finalText: excerptText(event.finalText, excerptLimit),
+        };
+    if (event.type === "user_prompt")
+        return { id: event.id, type: event.type, text: redact(event.text).slice(0, excerptLimit) };
+    if (event.type === "file_change")
+        return { id: event.id, type: event.type, paths: event.paths };
+    if (event.type === "session_resume")
+        return { id: event.id, type: event.type, reason: event.reason };
+    return { id: event.id, type: event.type, toolName: event.toolName };
+}
+function excerptText(excerpt, limit) {
+    const text = redact(excerpt.head + (excerpt.tail ? "\n[excerpt gap]\n" + excerpt.tail : ""));
+    return boundedText(text, limit);
+}
+function isReadResult(event) {
+    return event.type === "tool_result" && ["read", "grep", "find", "ls"].includes(event.toolName);
+}
+function sanitize(value) {
+    if (typeof value === "string")
+        return redact(value);
+    if (Array.isArray(value))
+        return value.map(sanitize);
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sanitize(item)]));
+    return value;
+}
+import { boundedText } from "../core/events.js";