reflex-state 0.1.0-alpha.1

package/dist/core/reducer.js

@@ -0,0 +1,206 @@
+export function initialState() {
+    return {
+        version: 2,
+        goal: null,
+        phase: "unknown",
+        taskStatus: "unknown",
+        modifiedFiles: [],
+        relevantFiles: [],
+        verification: {
+            build: { status: "not_run", freshness: "unknown" },
+            test: { status: "not_run", freshness: "unknown" },
+            lint: { status: "not_run", freshness: "unknown" },
+        },
+        activeBlockers: [],
+        workingSet: [],
+        observationGeneration: 0,
+        pendingChanges: [],
+        stateHealth: "valid",
+        cursor: { lastEventId: null, eventCount: 0, turnIndex: 0 },
+        lastUpdatedAt: "1970-01-01T00:00:00.000Z",
+    };
+}
+export function reduce(context) {
+    const { state, event, facts, now } = context;
+    const blockers = updatedBlockers(context);
+    const generation = (state.observationGeneration ?? 0) + (mutationAdvancesGeneration(state, event, facts) ? 1 : 0);
+    const pendingChanges = nextPendingChanges(state.pendingChanges ?? [], event, facts);
+    const verification = updatedVerification(context, generation, pendingChanges);
+    const completed = canComplete(context, blockers, pendingChanges);
+    const next = {
+        ...state,
+        goal: event.type === "user_prompt" ? event.id : state.goal,
+        cursor: {
+            lastEventId: event.id,
+            eventCount: Number(event.id.slice(1)),
+            turnIndex: event.turnIndex,
+        },
+        lastUpdatedAt: now,
+        phase: completed ? "done" : (facts.phaseProposal ?? state.phase),
+        verification,
+        modifiedFiles: uniqueRecent([...state.modifiedFiles, ...facts.fileChanges], 64).sort(),
+        relevantFiles: uniqueRecent([...state.relevantFiles, ...facts.filesRead], 32),
+        activeBlockers: blockers,
+        workingSet: boundedWorkingSet(context, blockers),
+        observationGeneration: generation,
+        pendingChanges,
+        stateHealth: event.type === "session_resume" ? "valid" : (state.stateHealth ?? "valid"),
+        taskStatus: derivedTaskStatus(context, { blocked: blockers.length > 0, completed }),
+    };
+    const changes = stateChanges(state, next);
+    return { state: next, changes };
+}
+function mutationAdvancesGeneration(state, event, facts) {
+    if (!facts.mutation)
+        return false;
+    if (event.type !== "tool_result")
+        return true;
+    return (!facts.mutation.operationId ||
+        !(state.pendingChanges ?? []).includes(facts.mutation.operationId));
+}
+export function admitsEvidence(event, facts) {
+    if (facts.fileChanges.length)
+        return true;
+    if (event.type !== "tool_result" || ["read", "grep", "find", "ls"].includes(event.toolName))
+        return false;
+    return event.isError || facts.verification !== undefined;
+}
+function updatedBlockers({ state, event, facts, decisions, evidence, }) {
+    const blockers = state.activeBlockers.filter((blocker) => {
+        if (facts.deterministicallyResolved.includes(blocker.eventId))
+            return false;
+        if (blocker.origin !== "tool_error" || event.type !== "tool_result" || event.isError)
+            return true;
+        return !decisions.resolvedBlockers.some((item) => item.eventId === blocker.eventId &&
+            evidence.has(blocker.eventId) &&
+            accepted(item.decision) === true);
+    });
+    if (facts.verification?.status === "failed") {
+        if (!facts.verification.attributable || !facts.verification.checkKey)
+            return blockers;
+        blockers.push({
+            eventId: event.id,
+            origin: "verification",
+            kind: facts.verification.kind,
+            checkKey: facts.verification.checkKey,
+            category: accepted(decisions.failureCategory) ?? "unknown",
+        });
+    }
+    else if (event.type === "tool_result" &&
+        event.isError &&
+        accepted(decisions.blockerIntroduced) === true) {
+        blockers.push({
+            eventId: event.id,
+            origin: "tool_error",
+            category: accepted(decisions.failureCategory) ?? "unknown",
+        });
+    }
+    return blockers;
+}
+function boundedWorkingSet(context, blockers) {
+    const { state, event, facts, decisions, config } = context;
+    let workingSet = state.workingSet.filter((id) => !facts.supersededInWorkingSet.includes(id));
+    if (admitsEvidence(event, facts) && !workingSet.includes(event.id))
+        workingSet.push(event.id);
+    const cap = config.limits.maxWorkingSetEvents;
+    if (workingSet.length <= cap)
+        return workingSet;
+    const resolved = state.activeBlockers.filter((old) => !blockers.some((blocker) => blocker.eventId === old.eventId));
+    workingSet = workingSet.filter((id) => !resolved.some((blocker) => blocker.eventId === id));
+    if (workingSet.length <= cap)
+        return workingSet;
+    workingSet = workingSet.filter((id) => !decisions.relevance.some((item) => item.eventId === id && accepted(item.decision) === false));
+    return workingSet.slice(-cap);
+}
+function derivedTaskStatus(context, outcome) {
+    if (context.event.type === "user_prompt")
+        return "in_progress";
+    if (outcome.blocked)
+        return "blocked";
+    if (outcome.completed)
+        return "completed";
+    if (context.event.type === "agent_end")
+        return "in_progress";
+    if (context.state.taskStatus === "completed")
+        return "completed";
+    return "in_progress";
+}
+function canComplete(context, blockers, pendingChanges) {
+    return (context.event.type === "agent_end" &&
+        context.event.stopReason === "stop" &&
+        blockers.length === 0 &&
+        pendingChanges.length === 0 &&
+        context.state.stateHealth === "valid" &&
+        context.state.observationGeneration !== undefined &&
+        context.state.pendingChanges !== undefined &&
+        accepted(context.decisions.taskComplete) === true);
+}
+function nextPendingChanges(pending, event, facts) {
+    const next = [...pending];
+    if (event.type === "tool_call" && facts.mutation && !next.includes(event.id))
+        next.push(event.id);
+    if (event.type === "tool_result" && facts.mutation?.operationId)
+        return next.filter((id) => id !== facts.mutation?.operationId);
+    return next;
+}
+function updatedVerification(context, generation, pendingChanges) {
+    const { state, event, facts } = context;
+    const next = {
+        build: { ...state.verification.build },
+        test: { ...state.verification.test },
+        lint: { ...state.verification.lint },
+    };
+    if (facts.mutation) {
+        for (const kind of ["build", "test", "lint"])
+            if (next[kind].status !== "not_run")
+                next[kind] = { ...next[kind], freshness: "stale" };
+    }
+    if (!facts.verification) {
+        if (event.type === "session_resume") {
+            for (const kind of ["build", "test", "lint"])
+                if (next[kind].status !== "not_run")
+                    next[kind] = { ...next[kind], freshness: "stale" };
+        }
+        return next;
+    }
+    const fact = facts.verification;
+    const current = next[fact.kind];
+    const { checkKey: _previousCheckKey, startedEvent: _previousStartedEvent, unknownReason: _previousUnknownReason, ...stable } = current;
+    next[fact.kind] = {
+        ...stable,
+        status: fact.status,
+        freshness: fact.freshness ?? (fact.status === "running" ? "unknown" : "current"),
+        evidence: event.id,
+        command: fact.command,
+        cwd: fact.cwd,
+        ...(fact.checkKey ? { checkKey: fact.checkKey } : {}),
+        ...(fact.startedEvent ? { startedEvent: fact.startedEvent } : {}),
+        ...(fact.observedGeneration !== undefined
+            ? { observedGeneration: fact.observedGeneration }
+            : event.type === "tool_call"
+                ? { observedGeneration: generation, startedEvent: event.id }
+                : {}),
+        attributable: fact.attributable,
+        ...(fact.unknownReason ? { unknownReason: fact.unknownReason } : {}),
+    };
+    if (event.type === "tool_result" && pendingChanges.length > 0) {
+        next[fact.kind] = {
+            ...next[fact.kind],
+            freshness: fact.attributable ? "stale" : "unknown",
+        };
+    }
+    return next;
+}
+function uniqueRecent(values, cap) {
+    return [...new Set([...values].reverse())].slice(0, cap).reverse();
+}
+function stateChanges(before, after) {
+    return Object.keys(after)
+        .filter((key) => key !== "lastUpdatedAt" &&
+        key !== "cursor" &&
+        JSON.stringify(before[key]) !== JSON.stringify(after[key]))
+        .map((key) => key + ": " + JSON.stringify(before[key]) + " -> " + JSON.stringify(after[key]));
+}
+function accepted(decision) {
+    return decision?.gate === "applied" && !decision.shadow ? decision.value : null;
+}

package/dist/core/serialization.d.ts

@@ -0,0 +1,11 @@
+import type { AgentEvent, StateTransitionRecord } from "./types.js";
+export declare class InvalidTraceError extends Error {
+    constructor(message: string);
+}
+export declare class LegacyTraceError extends Error {
+    constructor(message?: string);
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function parseJsonLines<T>(text: string, parse: (value: unknown) => T): T[];
+export declare function parseEvent(value: unknown): AgentEvent;
+export declare function parseTransition(value: unknown): StateTransitionRecord;

package/dist/core/serialization.js

@@ -0,0 +1,160 @@
+export class InvalidTraceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidTraceError";
+    }
+}
+export class LegacyTraceError extends Error {
+    constructor(message = "Legacy ReflexState state requires reset") {
+        super(message);
+        this.name = "LegacyTraceError";
+    }
+}
+export function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function parseJsonLines(text, parse) {
+    return text.split("\n").flatMap((line, index) => {
+        if (!line.trim())
+            return [];
+        try {
+            return [parse(JSON.parse(line))];
+        }
+        catch {
+            throw new InvalidTraceError("Invalid trace at line " + (index + 1));
+        }
+    });
+}
+export function parseEvent(value) {
+    if (!isRecord(value) ||
+        typeof value.id !== "string" ||
+        !/^E\d+$/.test(value.id) ||
+        typeof value.timestamp !== "string" ||
+        !Number.isFinite(Date.parse(value.timestamp)) ||
+        !Number.isSafeInteger(value.turnIndex) ||
+        Number(value.turnIndex) < 0 ||
+        !isRecord(value.source) ||
+        !["tool_call", "user_prompt", "assistant_message"].includes(String(value.source.kind)) ||
+        typeof value.source.timestamp !== "number" ||
+        !Number.isFinite(value.source.timestamp)) {
+        throw new InvalidTraceError("Invalid event envelope");
+    }
+    if (value.type === "user_prompt" && typeof value.text === "string")
+        return value;
+    if (value.type === "file_change" && strings(value.paths))
+        return value;
+    if (value.type === "session_resume" && ["resume", "branch_switch"].includes(String(value.reason)))
+        return value;
+    if (value.type === "agent_end" &&
+        excerpt(value.finalText) &&
+        ["stop", "length", "error", "aborted"].includes(String(value.stopReason)))
+        return value;
+    if (typeof value.toolCallId !== "string" || typeof value.toolName !== "string")
+        throw new InvalidTraceError("Invalid tool event");
+    if (value.type === "tool_call" &&
+        isRecord(value.input) &&
+        (value.commandTruncated === undefined || typeof value.commandTruncated === "boolean") &&
+        (value.cwd === undefined || typeof value.cwd === "string"))
+        return value;
+    if (value.type === "tool_result" && typeof value.isError === "boolean" && excerpt(value.excerpt))
+        return value;
+    throw new InvalidTraceError("Unknown or invalid event payload");
+}
+export function parseTransition(value) {
+    if (isRecord(value) && isRecord(value.after) && value.after.version === 1)
+        throw new LegacyTraceError();
+    if (!isRecord(value) ||
+        typeof value.id !== "string" ||
+        !/^T\d+$/.test(value.id) ||
+        typeof value.timestamp !== "string" ||
+        !Number.isFinite(Date.parse(value.timestamp)) ||
+        typeof value.updater !== "string" ||
+        typeof value.cwd !== "string" ||
+        !isRecord(value.config) ||
+        !strings(value.changes) ||
+        !isRecord(value.after) ||
+        !Number.isSafeInteger(value.after.version) ||
+        !isRecord(value.after.cursor) ||
+        !isRecord(value.after.verification) ||
+        !strings(value.after.workingSet) ||
+        !strings(value.after.modifiedFiles) ||
+        !strings(value.after.relevantFiles) ||
+        !Array.isArray(value.after.activeBlockers) ||
+        !isRecord(value.decisions) ||
+        !Array.isArray(value.decisions.resolvedBlockers) ||
+        !Array.isArray(value.decisions.relevance) ||
+        !isRecord(value.decisions.telemetry) ||
+        !strings(value.decisions.telemetry.questionIds)) {
+        throw new InvalidTraceError("Invalid or unsupported ReflexState transition");
+    }
+    if (value.after.version !== 2)
+        throw new InvalidTraceError("Unsupported ReflexState state version");
+    if (!Number.isSafeInteger(value.after.observationGeneration) ||
+        Number(value.after.observationGeneration) < 0 ||
+        !strings(value.after.pendingChanges) ||
+        !value.after.pendingChanges.every((id) => /^E\d+$/.test(id)) ||
+        !["valid", "legacy_state_requires_reset", "invalid"].includes(String(value.after.stateHealth)))
+        throw new InvalidTraceError("Invalid ReflexState state metadata");
+    if (!validCursor(value.after.cursor))
+        throw new InvalidTraceError("Invalid state cursor");
+    if (!validBlockers(value.after.activeBlockers))
+        throw new InvalidTraceError("Invalid blockers");
+    if (!validVerification(value.after.verification))
+        throw new InvalidTraceError("Invalid verification freshness");
+    parseEvent(value.event);
+    return value;
+}
+function strings(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function excerpt(value) {
+    return (isRecord(value) &&
+        typeof value.head === "string" &&
+        typeof value.sha256 === "string" &&
+        typeof value.truncated === "boolean" &&
+        Number.isSafeInteger(value.totalChars) &&
+        Number(value.totalChars) >= 0 &&
+        (value.tail === undefined || typeof value.tail === "string"));
+}
+function validCursor(value) {
+    return ((value.lastEventId === null ||
+        (typeof value.lastEventId === "string" && /^E\d+$/.test(value.lastEventId))) &&
+        Number.isSafeInteger(value.eventCount) &&
+        Number(value.eventCount) >= 0 &&
+        Number.isSafeInteger(value.turnIndex) &&
+        Number(value.turnIndex) >= 0);
+}
+function validBlockers(value) {
+    const categories = new Set([
+        "implementation",
+        "environment",
+        "dependency",
+        "test",
+        "permissions",
+        "network",
+        "unknown",
+    ]);
+    return value.every((item) => isRecord(item) &&
+        typeof item.eventId === "string" &&
+        /^E\d+$/.test(item.eventId) &&
+        typeof item.origin === "string" &&
+        (item.origin === "tool_error"
+            ? !Object.hasOwn(item, "kind")
+            : item.origin === "verification" &&
+                ["build", "test", "lint"].includes(String(item.kind)) &&
+                typeof item.checkKey === "string") &&
+        categories.has(String(item.category)));
+}
+function validVerification(value) {
+    return ["build", "test", "lint"].every((kind) => {
+        const item = value[kind];
+        return (isRecord(item) &&
+            ["not_run", "running", "passed", "failed", "unknown"].includes(String(item.status)) &&
+            ["current", "stale", "unknown"].includes(String(item.freshness)) &&
+            (item.evidence === undefined ||
+                (typeof item.evidence === "string" && /^E\d+$/.test(item.evidence))) &&
+            (item.checkKey === undefined || typeof item.checkKey === "string") &&
+            (item.command === undefined || typeof item.command === "string") &&
+            (item.cwd === undefined || typeof item.cwd === "string"));
+    });
+}

package/dist/core/state_view.d.ts

@@ -0,0 +1,27 @@
+import type { ReflexStateConfig } from "./config.js";
+import type { AgentEvent, Blocker, EventId, HotState } from "./types.js";
+interface BlockerView {
+    readonly unresolvedTotal: number;
+    readonly shownCount: number;
+    readonly omittedCount: number;
+    readonly blockers: readonly Blocker[];
+}
+interface WorkingSetView {
+    readonly total: number;
+    readonly shownCount: number;
+    readonly omittedCount: number;
+    readonly events: readonly EventId[];
+}
+export declare function blockerView(state: HotState, config: ReflexStateConfig): BlockerView;
+export declare function workingSetView(state: HotState, limit: number): WorkingSetView;
+export declare function stateView(state: HotState, evidence: ReadonlyMap<EventId, AgentEvent>, config: ReflexStateConfig): {
+    blockers: BlockerView;
+    workingSet: {
+        available: `E${string}`[];
+        total: number;
+        shownCount: number;
+        omittedCount: number;
+        events: readonly EventId[];
+    };
+};
+export {};

package/dist/core/state_view.js

@@ -0,0 +1,28 @@
+export function blockerView(state, config) {
+    const limit = config.limits.maxProjectedBlockers;
+    const blockers = state.activeBlockers.slice(-limit);
+    return {
+        unresolvedTotal: state.activeBlockers.length,
+        shownCount: blockers.length,
+        omittedCount: state.activeBlockers.length - blockers.length,
+        blockers,
+    };
+}
+export function workingSetView(state, limit) {
+    const events = state.workingSet.slice(-limit);
+    return {
+        total: state.workingSet.length,
+        shownCount: events.length,
+        omittedCount: state.workingSet.length - events.length,
+        events,
+    };
+}
+export function stateView(state, evidence, config) {
+    return {
+        blockers: blockerView(state, config),
+        workingSet: {
+            ...workingSetView(state, config.limits.maxWorkingSetEvents),
+            available: state.workingSet.filter((id) => evidence.has(id)),
+        },
+    };
+}

package/dist/core/types.d.ts

@@ -0,0 +1,188 @@
+import type { ReflexStateConfig } from "./config.js";
+export type EventId = `E${string}`;
+export type AgentPhase = "planning" | "exploring" | "editing" | "testing" | "debugging" | "done" | "unknown";
+export type TaskStatus = "in_progress" | "blocked" | "completed" | "unknown";
+export type VerificationKind = "build" | "test" | "lint";
+export type VerificationStatus = "not_run" | "running" | "passed" | "failed" | "unknown";
+export type VerificationFreshness = "current" | "stale" | "unknown";
+export type BlockerCategory = "implementation" | "environment" | "dependency" | "test" | "permissions" | "network" | "unknown";
+export interface SourceRef {
+    readonly kind: "tool_call" | "user_prompt" | "assistant_message";
+    readonly toolCallId?: string;
+    readonly timestamp: number;
+}
+export interface Excerpt {
+    readonly head: string;
+    readonly tail?: string;
+    readonly totalChars: number;
+    readonly sha256: string;
+    readonly truncated: boolean;
+}
+interface BaseEvent {
+    readonly id: EventId;
+    readonly timestamp: string;
+    readonly turnIndex: number;
+    readonly source: SourceRef;
+}
+export interface UserPromptEvent extends BaseEvent {
+    readonly type: "user_prompt";
+    readonly text: string;
+}
+export interface ToolCallEvent extends BaseEvent {
+    readonly type: "tool_call";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly input: Readonly<Record<string, unknown>>;
+    readonly commandTruncated?: boolean;
+    readonly cwd?: string;
+}
+export interface ToolResultEvent extends BaseEvent {
+    readonly type: "tool_result";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly isError: boolean;
+    readonly excerpt: Excerpt;
+}
+export interface AgentEndEvent extends BaseEvent {
+    readonly type: "agent_end";
+    readonly finalText: Excerpt;
+    readonly stopReason: "stop" | "length" | "error" | "aborted";
+}
+export interface FileChangeEvent extends BaseEvent {
+    readonly type: "file_change";
+    readonly paths: readonly string[];
+}
+export interface SessionResumeEvent extends BaseEvent {
+    readonly type: "session_resume";
+    readonly reason: "resume" | "branch_switch";
+}
+export type AgentEvent = UserPromptEvent | ToolCallEvent | ToolResultEvent | AgentEndEvent | FileChangeEvent | SessionResumeEvent;
+export interface VerificationState {
+    readonly status: VerificationStatus;
+    readonly freshness?: VerificationFreshness;
+    readonly evidence?: EventId;
+    readonly command?: string;
+    readonly cwd?: string;
+    readonly checkKey?: string;
+    readonly observedGeneration?: number;
+    readonly startedEvent?: EventId;
+    readonly attributable?: boolean;
+    readonly unknownReason?: string;
+}
+export type Blocker = {
+    readonly eventId: EventId;
+    readonly category: BlockerCategory;
+} & ({
+    readonly origin: "verification";
+    readonly kind: VerificationKind;
+    readonly checkKey?: string;
+} | {
+    readonly origin: "tool_error";
+    readonly kind?: never;
+});
+export interface HotState {
+    readonly version: 2;
+    readonly goal: EventId | null;
+    readonly phase: AgentPhase;
+    readonly taskStatus: TaskStatus;
+    readonly modifiedFiles: readonly string[];
+    readonly relevantFiles: readonly string[];
+    readonly verification: Readonly<Record<VerificationKind, VerificationState>>;
+    readonly activeBlockers: readonly Blocker[];
+    readonly workingSet: readonly EventId[];
+    readonly observationGeneration?: number;
+    readonly pendingChanges?: readonly EventId[];
+    readonly stateHealth?: "valid" | "legacy_state_requires_reset" | "invalid";
+    readonly cursor: {
+        readonly lastEventId: EventId | null;
+        readonly eventCount: number;
+        readonly turnIndex: number;
+    };
+    readonly lastUpdatedAt: string;
+}
+export interface VerificationFact {
+    readonly kind: VerificationKind;
+    readonly status: VerificationStatus;
+    readonly command: string;
+    readonly cwd: string;
+    readonly compound: boolean;
+    readonly attributable: boolean;
+    readonly checkKey?: string;
+    readonly unknownReason?: string;
+    readonly startedEvent?: EventId;
+    readonly observedGeneration?: number;
+    readonly freshness?: VerificationFreshness;
+}
+export interface MutationFact {
+    readonly operationId?: EventId;
+    readonly possible: boolean;
+    readonly completed: boolean;
+    readonly paths: readonly string[];
+}
+export interface DeterministicFacts {
+    readonly fileChanges: readonly string[];
+    readonly filesRead: readonly string[];
+    readonly exitCode?: number;
+    readonly verification?: VerificationFact;
+    readonly mutation?: MutationFact;
+    readonly phaseProposal: AgentPhase | null;
+    readonly deterministicallyResolved: readonly EventId[];
+    readonly supersededInWorkingSet: readonly EventId[];
+}
+export type Gate = "applied" | "uncertain" | "skipped" | "error";
+export interface GatedDecision<T> {
+    readonly value: T | null;
+    readonly gate: Gate;
+    readonly probability?: number;
+    readonly confidence?: number;
+    readonly probabilities?: Readonly<Record<string, number>>;
+    readonly shadow?: boolean;
+}
+export interface SemanticDecisions {
+    readonly blockerIntroduced?: GatedDecision<boolean>;
+    readonly failureCategory?: GatedDecision<BlockerCategory>;
+    readonly resolvedBlockers: readonly {
+        readonly eventId: EventId;
+        readonly decision: GatedDecision<boolean>;
+    }[];
+    readonly relevance: readonly {
+        readonly eventId: EventId;
+        readonly decision: GatedDecision<boolean>;
+    }[];
+    readonly taskComplete?: GatedDecision<boolean>;
+    readonly phaseShadow?: GatedDecision<AgentPhase>;
+    readonly telemetry: {
+        readonly latencyMs?: number;
+        readonly inputTokens?: number;
+        readonly outputTokens?: number;
+        readonly model?: string;
+        readonly error?: string;
+        readonly responseShape?: Readonly<Record<string, string>>;
+        readonly questionsAsked: number;
+        readonly questionIds: readonly string[];
+    };
+}
+export interface ProjectionMeasurement {
+    readonly mode?: "disabled" | "append" | "current-run";
+    readonly messagesBefore: number;
+    readonly messagesAfter: number;
+    readonly messagesOmitted?: number;
+    readonly charsBefore: number;
+    readonly charsAfter: number;
+    readonly stateBlockChars?: number;
+    readonly fallback?: string;
+}
+export interface StateTransitionRecord {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly event: AgentEvent;
+    readonly after: HotState;
+    readonly deterministicPhase?: AgentPhase;
+    readonly changes: readonly string[];
+    readonly decisions: SemanticDecisions;
+    readonly updater: string;
+    readonly config: ReflexStateConfig;
+    readonly cwd: string;
+    readonly projection?: ProjectionMeasurement;
+}
+export {};

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/updater.d.ts

@@ -0,0 +1,31 @@
+import type { ReflexStateConfig } from "./config.js";
+import type { StateTransitionRecord } from "./types.js";
+import type { AgentEvent, DeterministicFacts, EventId, HotState, SemanticDecisions } from "./types.js";
+export interface StateUpdateContext {
+    readonly state: HotState;
+    readonly event: AgentEvent;
+    readonly facts: DeterministicFacts;
+    readonly evidence: ReadonlyMap<EventId, AgentEvent>;
+    readonly config: ReflexStateConfig;
+}
+export interface StateUpdater {
+    readonly name: string;
+    readonly health?: UpdaterHealth;
+    evaluate(context: StateUpdateContext, signal?: AbortSignal): Promise<SemanticDecisions>;
+}
+export interface UpdaterHealth {
+    readonly status: "ok" | "degraded" | "disabled";
+    readonly circuit: "closed" | "open" | "half_open";
+    readonly reason?: string;
+}
+export declare function emptyDecisions(): SemanticDecisions;
+export declare class NoopStateUpdater implements StateUpdater {
+    readonly name = "noop";
+    evaluate(): Promise<SemanticDecisions>;
+}
+export declare class RecordedDecisionsUpdater implements StateUpdater {
+    readonly name = "recorded";
+    private readonly records;
+    constructor(records: readonly StateTransitionRecord[]);
+    evaluate(context: StateUpdateContext): Promise<SemanticDecisions>;
+}