reflex-state 0.1.0-alpha.1

package/dist/core/config.js

@@ -0,0 +1,27 @@
+export function defaultConfig() {
+    return {
+        enabled: true,
+        jev: {
+            enabled: true,
+            model: "jev-latest",
+            timeoutMs: 3000,
+            maxRetries: 0,
+            deadlineMs: 4000,
+            cooldownMs: 60_000,
+        },
+        thresholds: { noulAccept: 0.8, noulReject: 0.2, minChoiceConfidence: 0.65, minChoiceMargin: 0 },
+        limits: {
+            maxWorkingSetEvents: 16,
+            maxActiveBlockers: 8,
+            maxProjectedBlockers: 8,
+            maxExcerptHeadChars: 1200,
+            maxExcerptTailChars: 600,
+            maxPromptChars: 2000,
+            maxRecentUserPrompts: 3,
+            maxStateBlockChars: 6000,
+        },
+        projection: { enabled: false, mode: "append", placement: "last-message" },
+        shadowQuestions: ["phase"],
+        verificationCommands: { test: [], build: [], lint: [] },
+    };
+}

package/dist/core/config_validation.d.ts

@@ -0,0 +1,6 @@
+import type { ReflexStateConfig } from "./config.js";
+export declare function mergeConfig(base: ReflexStateConfig, input: unknown): {
+    config: ReflexStateConfig;
+    warnings: string[];
+    valid: boolean;
+};

package/dist/core/config_validation.js

@@ -0,0 +1,109 @@
+import { defaultConfig } from "./config.js";
+import { isRecord } from "./serialization.js";
+class InvalidConfigError extends Error {
+}
+export function mergeConfig(base, input) {
+    const warnings = [];
+    try {
+        if (containsCredential(input))
+            throw new InvalidConfigError("Credentials are not allowed in configuration files");
+        const normalized = normalizeAliases(input, warnings);
+        const merged = mergeValue(base, normalized, { path: "config", warnings });
+        const config = {
+            ...merged,
+            limits: {
+                ...merged.limits,
+                maxActiveBlockers: merged.limits.maxProjectedBlockers,
+            },
+        };
+        validateConfig(config);
+        return { config, warnings, valid: true };
+    }
+    catch (error) {
+        warnings.push(error instanceof InvalidConfigError ? error.message : "Invalid configuration");
+        return { config: defaultConfig(), warnings, valid: false };
+    }
+}
+function mergeValue(base, input, context) {
+    if (input === undefined)
+        return base;
+    if (Array.isArray(base)) {
+        if (!Array.isArray(input) || !input.every((value) => typeof value === "string"))
+            throw new InvalidConfigError("Expected string array at " + context.path);
+        return [...input];
+    }
+    if (!isRecord(base)) {
+        if (typeof input !== typeof base)
+            throw new InvalidConfigError("Invalid value type at " + context.path);
+        return input;
+    }
+    if (!isRecord(input))
+        throw new InvalidConfigError("Expected object at " + context.path);
+    for (const key of Object.keys(input)) {
+        if (!Object.hasOwn(base, key))
+            context.warnings.push("Unknown configuration key: " + context.path + "." + key.slice(0, 80));
+    }
+    return Object.fromEntries(Object.entries(base).map(([key, value]) => [
+        key,
+        mergeValue(value, input[key], { path: context.path + "." + key, warnings: context.warnings }),
+    ]));
+}
+function validateConfig(config) {
+    for (const value of Object.values(config.thresholds)) {
+        if (!Number.isFinite(value) || value < 0 || value > 1)
+            throw new InvalidConfigError("Thresholds must be between zero and one");
+    }
+    if (config.thresholds.noulReject >= config.thresholds.noulAccept)
+        throw new InvalidConfigError("noulReject must be below noulAccept");
+    for (const [key, value] of Object.entries(config.limits)) {
+        if (!Number.isSafeInteger(value) || value < (key === "maxExcerptTailChars" ? 0 : 1))
+            throw new InvalidConfigError("Invalid limit: " + key);
+    }
+    for (const key of ["timeoutMs", "deadlineMs", "cooldownMs"]) {
+        if (!Number.isSafeInteger(config.jev[key]) ||
+            config.jev[key] < 1 ||
+            config.jev[key] > 2_147_483_647)
+            throw new InvalidConfigError("Invalid Jev duration: " + key);
+    }
+    if (!Number.isSafeInteger(config.jev.maxRetries) || config.jev.maxRetries < 0)
+        throw new InvalidConfigError("Invalid retry count");
+    if (!config.jev.model.trim())
+        throw new InvalidConfigError("Jev model must not be empty");
+    if (!["append", "current-run"].includes(config.projection.mode) ||
+        !["last-message", "run-start"].includes(config.projection.placement))
+        throw new InvalidConfigError("Unsupported projection configuration");
+    if (config.shadowQuestions.some((question) => question !== "phase"))
+        throw new InvalidConfigError("Unsupported shadow question");
+    for (const expressions of Object.values(config.verificationCommands)) {
+        for (const expression of expressions) {
+            try {
+                new RegExp(expression);
+            }
+            catch {
+                throw new InvalidConfigError("Invalid verification command expression");
+            }
+        }
+    }
+}
+function normalizeAliases(input, warnings) {
+    if (!isRecord(input) || !isRecord(input.limits))
+        return input;
+    const limits = input.limits;
+    if (!Object.hasOwn(limits, "maxActiveBlockers"))
+        return input;
+    warnings.push("limits.maxActiveBlockers is deprecated; use limits.maxProjectedBlockers");
+    const nextLimits = { ...limits };
+    if (!Object.hasOwn(limits, "maxProjectedBlockers"))
+        nextLimits.maxProjectedBlockers = limits.maxActiveBlockers;
+    delete nextLimits.maxActiveBlockers;
+    return { ...input, limits: nextLimits };
+}
+function containsCredential(value) {
+    if (typeof value === "string")
+        return /\bsk-[a-zA-Z0-9_-]{8,}|\bAKIA[A-Z0-9]{16}\b|-----BEGIN [^-]*PRIVATE KEY|\bBearer\s+\S+/i.test(value);
+    if (Array.isArray(value))
+        return value.some(containsCredential);
+    if (!isRecord(value))
+        return false;
+    return Object.entries(value).some(([key, item]) => /api[_-]?key/i.test(key) || containsCredential(item));
+}

package/dist/core/engine.d.ts

@@ -0,0 +1,28 @@
+import type { ReflexStateConfig } from "./config.js";
+import type { AgentEvent, EventId, HotState, StateTransitionRecord } from "./types.js";
+import type { StateUpdater } from "./updater.js";
+interface EngineOptions {
+    readonly cwd: string;
+    readonly config: ReflexStateConfig;
+    readonly updater: StateUpdater;
+    readonly state?: HotState;
+    readonly events?: ReadonlyMap<EventId, AgentEvent>;
+    readonly onTransition?: (record: StateTransitionRecord) => void | Promise<void>;
+}
+export declare class StateEngine {
+    private readonly options;
+    private currentState;
+    private readonly eventStore;
+    private pending;
+    private config;
+    private updater;
+    private cwd;
+    constructor(options: EngineOptions);
+    get state(): HotState;
+    get events(): ReadonlyMap<EventId, AgentEvent>;
+    process(event: AgentEvent, signal?: AbortSignal): Promise<StateTransitionRecord>;
+    idle(): Promise<void>;
+    configure(config: ReflexStateConfig, updater: StateUpdater, cwd?: string): Promise<void>;
+    private transition;
+}
+export {};

package/dist/core/engine.js

@@ -0,0 +1,72 @@
+import { extractFacts } from "./extraction.js";
+import { initialState, reduce } from "./reducer.js";
+export class StateEngine {
+    options;
+    currentState;
+    eventStore;
+    pending = Promise.resolve();
+    config;
+    updater;
+    cwd;
+    constructor(options) {
+        this.options = options;
+        this.currentState = options.state ?? initialState();
+        this.eventStore = new Map(options.events);
+        this.config = options.config;
+        this.updater = options.updater;
+        this.cwd = options.cwd;
+    }
+    get state() {
+        return this.currentState;
+    }
+    get events() {
+        return new Map(this.eventStore);
+    }
+    process(event, signal) {
+        const result = this.pending.then(() => this.transition(event, signal));
+        this.pending = result.catch(() => undefined);
+        return result;
+    }
+    async idle() {
+        await this.pending;
+    }
+    configure(config, updater, cwd = this.cwd) {
+        const result = this.pending.then(() => {
+            this.config = config;
+            this.updater = updater;
+            this.cwd = cwd;
+        });
+        this.pending = result;
+        return result;
+    }
+    async transition(event, signal) {
+        if (this.eventStore.has(event.id))
+            throw new Error("Duplicate event ID: " + event.id);
+        const context = {
+            state: this.currentState,
+            event,
+            evidence: this.eventStore,
+            config: this.config,
+            cwd: this.cwd,
+        };
+        const facts = extractFacts(context);
+        const decisions = await this.updater.evaluate({ ...context, facts }, signal);
+        const result = reduce({ ...context, facts, decisions, now: event.timestamp });
+        const record = {
+            id: "T" + event.id.slice(1),
+            timestamp: event.timestamp,
+            event,
+            after: result.state,
+            deterministicPhase: facts.phaseProposal ?? this.currentState.phase,
+            changes: result.changes,
+            decisions,
+            updater: this.updater.name,
+            config: this.config,
+            cwd: this.cwd,
+        };
+        await this.options.onTransition?.(record);
+        this.eventStore.set(event.id, event);
+        this.currentState = result.state;
+        return record;
+    }
+}

package/dist/core/events.d.ts

@@ -0,0 +1,7 @@
+import type { ReflexStateConfig } from "./config.js";
+import type { EventId, Excerpt } from "./types.js";
+export declare function eventId(ordinal: number): EventId;
+export declare function createExcerpt(text: string, limits: ReflexStateConfig["limits"]): Excerpt;
+export declare function boundedText(text: string, limit: number): string;
+export declare function textContent(content: unknown): string;
+export declare function boundedInput(input: Readonly<Record<string, unknown>>, maxChars: number): Record<string, unknown>;

package/dist/core/events.js

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+export function eventId(ordinal) {
+    return ("E" + String(ordinal).padStart(4, "0"));
+}
+export function createExcerpt(text, limits) {
+    const truncated = text.length > limits.maxExcerptHeadChars + limits.maxExcerptTailChars;
+    return {
+        head: truncated ? text.slice(0, limits.maxExcerptHeadChars) : text,
+        ...(truncated && limits.maxExcerptTailChars
+            ? { tail: text.slice(-limits.maxExcerptTailChars) }
+            : {}),
+        totalChars: text.length,
+        sha256: createHash("sha256").update(text).digest("hex"),
+        truncated,
+    };
+}
+export function boundedText(text, limit) {
+    if (text.length <= limit)
+        return text;
+    const marker = "\n[truncated]\n";
+    if (limit <= marker.length)
+        return text.slice(0, limit);
+    const available = limit - marker.length;
+    const head = Math.ceil((available * 2) / 3);
+    const tail = available - head;
+    return text.slice(0, head) + marker + (tail ? text.slice(-tail) : "");
+}
+export function textContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .flatMap((block) => {
+        if (!block || typeof block !== "object" || !("type" in block) || block.type !== "text")
+            return [];
+        return "text" in block && typeof block.text === "string" ? [block.text] : [];
+    })
+        .join("\n");
+}
+export function boundedInput(input, maxChars) {
+    return boundedValue(input, maxChars, 0);
+}
+function boundedValue(value, maxChars, depth) {
+    if (typeof value === "string")
+        return boundedText(value, maxChars);
+    if (depth > 5)
+        return "[truncated]";
+    if (Array.isArray(value))
+        return value.slice(0, 64).map((item) => boundedValue(item, maxChars, depth + 1));
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value)
+            .slice(0, 64)
+            .map(([key, item]) => [key, boundedValue(item, maxChars, depth + 1)]));
+    return value;
+}

package/dist/core/extraction.d.ts

@@ -0,0 +1,10 @@
+import type { ReflexStateConfig } from "./config.js";
+import type { AgentEvent, DeterministicFacts, EventId, HotState } from "./types.js";
+export interface ExtractionContext {
+    readonly state: HotState;
+    readonly event: AgentEvent;
+    readonly evidence: ReadonlyMap<EventId, AgentEvent>;
+    readonly cwd: string;
+    readonly config: ReflexStateConfig;
+}
+export declare function extractFacts(context: ExtractionContext): DeterministicFacts;

package/dist/core/extraction.js

@@ -0,0 +1,119 @@
+import { relative, resolve } from "node:path";
+import { verificationFact } from "./verification.js";
+export function extractFacts(context) {
+    const { event } = context;
+    const exitCode = resultExitCode(event);
+    const call = relatedCall(context);
+    const observedCall = call && call.cwd ? call : call ? { ...call, cwd: context.cwd } : undefined;
+    const paths = callPaths(context);
+    const fileChanges = changedPaths(context);
+    const generation = context.state.observationGeneration ?? 0;
+    const started = observedCall ? startedVerification(context, observedCall.id) : undefined;
+    const verification = verificationFact(event, observedCall, context.config, generation, context.state.pendingChanges ?? [], started);
+    const mutation = mutationFact(context, call, fileChanges);
+    return {
+        fileChanges,
+        filesRead: event.type === "tool_call" && call?.toolName === "read" ? paths : [],
+        phaseProposal: phaseProposal(event, verification),
+        deterministicallyResolved: verification?.status === "passed" &&
+            verification.freshness === "current" &&
+            verification.checkKey
+            ? context.state.activeBlockers
+                .filter((blocker) => blocker.origin === "verification" && blocker.checkKey === verification.checkKey)
+                .map((blocker) => blocker.eventId)
+            : [],
+        supersededInWorkingSet: context.state.workingSet.filter((id) => {
+            const previous = context.evidence.get(id);
+            if (!previous)
+                return false;
+            const previousContext = { ...context, event: previous };
+            if (verification &&
+                event.type === "tool_result" &&
+                previous.type === "tool_result" &&
+                verificationFact(previous, withCwd(relatedCall(previousContext), context.cwd), context.config, context.state.observationGeneration ?? 0, [])?.checkKey === verification.checkKey)
+                return true;
+            const oldPaths = changedPaths(previousContext);
+            return oldPaths.length > 0 && oldPaths.every((path) => fileChanges.includes(path));
+        }),
+        ...(exitCode === undefined ? {} : { exitCode }),
+        ...(verification ? { verification } : {}),
+        ...(mutation ? { mutation } : {}),
+    };
+}
+function withCwd(call, cwd) {
+    return call && call.cwd ? call : call ? { ...call, cwd } : undefined;
+}
+function phaseProposal(event, verification) {
+    if (event.type === "user_prompt")
+        return "planning";
+    if (verification?.status === "failed")
+        return "debugging";
+    if (verification?.status === "running")
+        return "testing";
+    if (event.type === "file_change")
+        return "editing";
+    if (event.type !== "tool_call" && event.type !== "tool_result")
+        return null;
+    if (["read", "grep", "find", "ls"].includes(event.toolName))
+        return "exploring";
+    if (["edit", "write"].includes(event.toolName))
+        return "editing";
+    return null;
+}
+function relatedCall(context) {
+    const { event, evidence } = context;
+    if (event.type === "tool_call")
+        return event;
+    if (event.type !== "tool_result")
+        return undefined;
+    return [...evidence.values()]
+        .reverse()
+        .find((candidate) => candidate.type === "tool_call" &&
+        candidate.toolCallId === event.toolCallId &&
+        candidate.toolName === event.toolName);
+}
+function resultExitCode(event) {
+    if (event.type !== "tool_result" || !event.isError || event.toolName !== "bash")
+        return undefined;
+    const text = event.excerpt.head + (event.excerpt.tail ? "\n" + event.excerpt.tail : "");
+    const match = /(?:^|\n)Command exited with code (\d+)\s*$/.exec(text);
+    return match ? Number(match[1]) : undefined;
+}
+function callPaths(context) {
+    const call = relatedCall(context);
+    return typeof call?.input.path === "string" ? normalizePaths([call.input.path], context.cwd) : [];
+}
+function changedPaths(context) {
+    const { event } = context;
+    if (event.type === "file_change")
+        return normalizePaths(event.paths, context.cwd);
+    if (event.type !== "tool_result" || event.isError || !["edit", "write"].includes(event.toolName))
+        return [];
+    return callPaths(context);
+}
+function startedVerification(context, callId) {
+    const running = Object.values(context.state.verification).find((verification) => verification.startedEvent === callId);
+    return running?.startedEvent
+        ? {
+            eventId: running.startedEvent,
+            generation: running.observedGeneration ?? context.state.observationGeneration ?? 0,
+            ...(running.checkKey ? { checkKey: running.checkKey } : {}),
+        }
+        : undefined;
+}
+function mutationFact(context, call, paths) {
+    const { event } = context;
+    if (event.type === "file_change")
+        return { operationId: event.id, possible: true, completed: true, paths };
+    if (!call || !["bash", "edit", "write"].includes(call.toolName))
+        return undefined;
+    if (event.type === "tool_call")
+        return { operationId: event.id, possible: true, completed: false, paths: [] };
+    if (event.type === "tool_result")
+        return { operationId: call.id, possible: true, completed: true, paths };
+    return undefined;
+}
+function normalizePaths(paths, cwd) {
+    const root = resolve("/", cwd);
+    return paths.map((path) => relative(root, resolve(root, path)));
+}

package/dist/core/metrics.d.ts

@@ -0,0 +1,52 @@
+import type { GatedDecision, ProjectionMeasurement, SemanticDecisions, StateTransitionRecord } from "./types.js";
+export declare function decisionEntries(decisions: SemanticDecisions): [string, GatedDecision<unknown>][];
+export declare class Metrics {
+    private readonly records;
+    private readonly projections;
+    private readonly providerUsage;
+    transition(record: StateTransitionRecord): void;
+    projection(measurement: ProjectionMeasurement): void;
+    get lastProjection(): ProjectionMeasurement | undefined;
+    provider(usage: {
+        input: number;
+        cacheRead: number;
+        cacheWrite: number;
+        output: number;
+    }): void;
+    snapshot(): {
+        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: 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;
+    };
+}

package/dist/core/metrics.js

@@ -0,0 +1,100 @@
+export function decisionEntries(decisions) {
+    const entries = [
+        ["blocker_introduced", decisions.blockerIntroduced],
+        ["failure_category", decisions.failureCategory],
+        ["task_complete", decisions.taskComplete],
+        ["phase_shadow", decisions.phaseShadow],
+        ...decisions.resolvedBlockers.map((item) => [
+            "resolves_" + item.eventId,
+            item.decision,
+        ]),
+        ...decisions.relevance.map((item) => [
+            "relevant_" + item.eventId,
+            item.decision,
+        ]),
+    ];
+    return entries.filter((entry) => entry[1] !== undefined);
+}
+export class Metrics {
+    records = [];
+    projections = [];
+    providerUsage = [];
+    transition(record) {
+        this.records.push(record);
+    }
+    projection(measurement) {
+        this.projections.push(measurement);
+    }
+    get lastProjection() {
+        return this.projections.at(-1);
+    }
+    provider(usage) {
+        this.providerUsage.push(usage);
+    }
+    snapshot() {
+        const telemetry = this.records.map((record) => record.decisions.telemetry);
+        const decisions = this.records.flatMap((record) => decisionEntries(record.decisions));
+        const latencies = numbers(telemetry.map((entry) => entry.latencyMs)).sort((a, b) => a - b);
+        const shadows = this.records.filter((record) => record.decisions.phaseShadow?.value != null && record.deterministicPhase !== undefined);
+        return {
+            events: this.records.length,
+            transitions: this.records.length,
+            jevCalls: telemetry.filter((entry) => entry.questionsAsked > 0).length,
+            jevFailures: counts(telemetry.flatMap((entry) => entry.error && entry.questionsAsked > 0 ? [entry.error] : [])),
+            questions: counts(telemetry.flatMap((entry) => entry.questionIds)),
+            applied: decisions.filter(([, decision]) => decision.gate === "applied" && !decision.shadow)
+                .length,
+            uncertain: decisions.filter(([, decision]) => decision.gate === "uncertain").length,
+            shadowAgreement: shadows.length
+                ? shadows.filter((record) => record.decisions.phaseShadow?.value === record.deterministicPhase).length / shadows.length
+                : undefined,
+            jevLatencyMs: {
+                mean: mean(latencies),
+                p50: percentile(latencies, 0.5),
+                p95: percentile(latencies, 0.95),
+            },
+            jevInputTokens: sumAvailable(telemetry.map((entry) => entry.inputTokens)),
+            jevOutputTokens: sumAvailable(telemetry.map((entry) => entry.outputTokens)),
+            projection: {
+                calls: this.projections.length,
+                last: this.lastProjection,
+                modes: counts(this.projections.flatMap((entry) => (entry.mode ? [entry.mode] : []))),
+                meanMessagesBefore: mean(this.projections.map((entry) => entry.messagesBefore)),
+                meanMessagesAfter: mean(this.projections.map((entry) => entry.messagesAfter)),
+                meanMessagesOmitted: mean(this.projections.flatMap((entry) => entry.messagesOmitted === undefined ? [] : [entry.messagesOmitted])),
+                meanCharsBefore: mean(this.projections.map((entry) => entry.charsBefore)),
+                meanCharsAfter: mean(this.projections.map((entry) => entry.charsAfter)),
+                meanStateBlockChars: mean(this.projections.flatMap((entry) => entry.stateBlockChars === undefined ? [] : [entry.stateBlockChars])),
+                fallbacks: counts(this.projections.flatMap((entry) => (entry.fallback ? [entry.fallback] : []))),
+            },
+            provider: this.providerUsage.length
+                ? {
+                    calls: this.providerUsage.length,
+                    input: sumAvailable(this.providerUsage.map((usage) => usage.input)),
+                    cacheRead: sumAvailable(this.providerUsage.map((usage) => usage.cacheRead)),
+                    cacheWrite: sumAvailable(this.providerUsage.map((usage) => usage.cacheWrite)),
+                    output: sumAvailable(this.providerUsage.map((usage) => usage.output)),
+                }
+                : undefined,
+        };
+    }
+}
+function numbers(values) {
+    return values.filter((value) => value !== undefined && Number.isFinite(value));
+}
+function sumAvailable(values) {
+    const available = numbers(values);
+    return available.length ? available.reduce((sum, value) => sum + value, 0) : undefined;
+}
+function mean(values) {
+    return values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : undefined;
+}
+function percentile(sorted, fraction) {
+    return sorted[Math.max(0, Math.ceil(sorted.length * fraction) - 1)];
+}
+function counts(values) {
+    const result = {};
+    for (const value of values)
+        result[value] = (result[value] ?? 0) + 1;
+    return result;
+}

package/dist/core/reducer.d.ts

@@ -0,0 +1,18 @@
+import type { ReflexStateConfig } from "./config.js";
+import type { AgentEvent, DeterministicFacts, EventId, HotState, SemanticDecisions } from "./types.js";
+interface ReductionContext {
+    readonly state: HotState;
+    readonly event: AgentEvent;
+    readonly facts: DeterministicFacts;
+    readonly decisions: SemanticDecisions;
+    readonly evidence: ReadonlyMap<EventId, AgentEvent>;
+    readonly config: ReflexStateConfig;
+    readonly now: string;
+}
+export declare function initialState(): HotState;
+export declare function reduce(context: ReductionContext): {
+    state: HotState;
+    changes: string[];
+};
+export declare function admitsEvidence(event: AgentEvent, facts: DeterministicFacts): boolean;
+export {};