@stigmer/runner 0.1.0-dev.20261017020314.g644422724c27

package/dist/__test-utils__/execution-record-fixture.d.ts

@@ -0,0 +1,121 @@
+/**
+ * The three resources of one execution, wired by id the way the turn
+ * runtime reads them (the session the execution's target names; the agent
+ * and version its status stamps, as the server stamps every turn at
+ * create; the session naming the same agent by reference), as an
+ * `ExecutionRecord` the hermetic client answers from.
+ *
+ * The turn's settings sit where the control plane writes them: the
+ * resolved settings on `status.run_config` and the lane's approval mode on
+ * `status.approval_mode`, both stamped at create; the message's own intents
+ * (the structured-output schema) on the spec. `requestRunConfig` fills the
+ * request's `spec.run_config`, which the runner must never read, so a test
+ * can make the request and the resolution disagree.
+ *
+ * Harness-agnostic: the record is the control plane's, and the runtime's
+ * phases read it the same way whatever engine runs the turn. A harness's
+ * driver supplies its own fixture ids and model (`execute-cursor/__test-
+ * utils__/hermetic-cursor.ts` `cursorExecutionRecord`); the runtime's own
+ * tests use the defaults. Ids are fixed so goldens are readable and
+ * byte-stable. `savedAgentFixture` builds a saved agent the record's agent
+ * can list as a subagent, at a version hash of its own.
+ */
+import { type JsonObject, type MessageInitShape } from "@bufbuild/protobuf";
+import { type RunConfig } from "@stigmer/apis/ai/stigmer/agentic/run/v1/invocation_pb";
+import { ApprovalMode } from "@stigmer/apis/ai/stigmer/agentic/run/v1/enum_pb";
+import type { WorkspaceEntry } from "@stigmer/apis/ai/stigmer/agentic/session/v1/workspace_pb";
+import { type Agent } from "@stigmer/apis/ai/stigmer/agentic/agent/v1/api_pb";
+import { AgentSpecSchema, type HookSource } from "@stigmer/apis/ai/stigmer/agentic/agent/v1/spec_pb";
+import { ExecutionRecord, type ExecutionRecordInput } from "./hermetic-activity.js";
+/** The ids a record's three resources carry. */
+export interface ExecutionRecordIds {
+    readonly org: string;
+    readonly executionId: string;
+    readonly sessionId: string;
+    readonly agentId: string;
+    readonly agentName: string;
+    /** The agent version the turn is stamped with (and the session pins). */
+    readonly agentVersionHash: string;
+}
+export declare const DEFAULT_RECORD_IDS: ExecutionRecordIds;
+export interface ExecutionRecordOptions {
+    /** The user's message for this execution. */
+    readonly message: string;
+    /** The agent's instructions (system prompt body). */
+    readonly instructions?: string;
+    /** Session workspace entries (a `local_path` entry gives the turn a substrate to capture into). */
+    readonly workspaceEntries?: WorkspaceEntry[];
+    /** `SessionSpec.file_review`: the turn's edits are offered for review after it. Off when omitted, as on the wire. */
+    readonly fileReview?: boolean;
+    /** The model the turn runs with (`status.run_config.model_name`); the pinned fixture model when omitted. */
+    readonly modelName?: string;
+    readonly autoApproveAll?: boolean;
+    /**
+     * `status.run_config.max_cost_usd`: the per-message cost budget the runtime
+     * enforces as a hard stop (cost-guard.ts). Omitted or 0 = no cap, the
+     * proto's default. Priced against the registry fixture's round numbers, so
+     * a scenario can state its overrun exactly (600 000 input tokens = $0.60).
+     */
+    readonly maxCostUsd?: number;
+    /**
+     * `status.run_config.max_tool_rounds`: the hard tool-round budget the engine
+     * enforces (native: the execution budget middleware's round count,
+     * `shared/tool-rounds.ts`).
+     * Omitted or 0 = unlimited, the proto's default. Clamped to the floor of 10
+     * by the runner, so a scenario that wants the limit reached scripts a model
+     * that keeps calling tools (`repeatLast`).
+     */
+    readonly maxToolRounds?: number;
+    /** `status.run_config.max_tool_result_chars`: the tool-result truncation bound; 0 = the platform default. */
+    readonly maxToolResultChars?: number;
+    /** `spec.structured_output_schema`: a JSON schema the agent's answer must match. */
+    readonly structuredOutputSchema?: JsonObject;
+    /** `status.approval_mode`, the lane's fact; UNSPECIFIED (the safe, asking default) when omitted. */
+    readonly approvalMode?: ApprovalMode;
+    /** The request's own `spec.run_config`; absent when omitted. The runner must never read it. */
+    readonly requestRunConfig?: RunConfig;
+    /**
+     * The saved agents the agent lists (`AgentSpec.subagents`), each listed at
+     * its `status.version_hash` and served by reference.
+     */
+    readonly subagents?: Agent[];
+    /** The agent's `AgentSpec.tools` ("only these"), in Claude Code's names. */
+    readonly tools?: string[];
+    /** The agent's `AgentSpec.disallowed_tools` ("never these"). */
+    readonly disallowedTools?: string[];
+    /** The turn's own `spec.tools`, narrowing the agent's for this message. */
+    readonly turnTools?: string[];
+    /** The turn's own `spec.disallowed_tools`. */
+    readonly turnDisallowedTools?: string[];
+    /** `spec.append_system_prompt`: text this message appends to the system prompt. */
+    readonly appendSystemPrompt?: string;
+    /**
+     * Skills the agent references (`AgentSpec.skill_refs`), each held by the
+     * control plane as a skill whose `SKILL.md` is `skillMd` (no artifact, so
+     * the mount is `SKILL.md` alone).
+     */
+    readonly skills?: ReadonlyArray<{
+        readonly slug: string;
+        readonly description: string;
+        readonly skillMd: string;
+    }>;
+    /** The agent's `AgentSpec.hooks`: plugin references and its own hooks block. */
+    readonly hooks?: HookSource[];
+    /**
+     * The built-in assistant: the session names NO agent and the turn's stamp
+     * is empty, so the record carries no agent and the activity must run on
+     * the one built-in prompt with the session's own tools. `instructions`
+     * and `subAgents` are ignored (there is no agent to declare them).
+     */
+    readonly builtInAssistant?: boolean;
+    /** The control plane's STOP lever; see `ExecutionRecordInput.controlSignal`. */
+    readonly controlSignal?: ExecutionRecordInput["controlSignal"];
+    readonly ids?: ExecutionRecordIds;
+}
+export declare function executionRecordFixture(options: ExecutionRecordOptions): ExecutionRecord;
+/**
+ * A saved agent a fixture's agent can list as a subagent (`subagents`): its
+ * slug is its name in the turn, and its version hash is derived from the
+ * slug, so the reference the parent pins is stable across runs.
+ */
+export declare function savedAgentFixture(slug: string, spec: MessageInitShape<typeof AgentSpecSchema>, org?: string): Agent;

package/dist/__test-utils__/execution-record-fixture.js

@@ -0,0 +1,134 @@
+/**
+ * The three resources of one execution, wired by id the way the turn
+ * runtime reads them (the session the execution's target names; the agent
+ * and version its status stamps, as the server stamps every turn at
+ * create; the session naming the same agent by reference), as an
+ * `ExecutionRecord` the hermetic client answers from.
+ *
+ * The turn's settings sit where the control plane writes them: the
+ * resolved settings on `status.run_config` and the lane's approval mode on
+ * `status.approval_mode`, both stamped at create; the message's own intents
+ * (the structured-output schema) on the spec. `requestRunConfig` fills the
+ * request's `spec.run_config`, which the runner must never read, so a test
+ * can make the request and the resolution disagree.
+ *
+ * Harness-agnostic: the record is the control plane's, and the runtime's
+ * phases read it the same way whatever engine runs the turn. A harness's
+ * driver supplies its own fixture ids and model (`execute-cursor/__test-
+ * utils__/hermetic-cursor.ts` `cursorExecutionRecord`); the runtime's own
+ * tests use the defaults. Ids are fixed so goldens are readable and
+ * byte-stable. `savedAgentFixture` builds a saved agent the record's agent
+ * can list as a subagent, at a version hash of its own.
+ */
+import { createHash } from "node:crypto";
+import { create } from "@bufbuild/protobuf";
+import { RunSchema, RunStatusSchema, } from "@stigmer/apis/ai/stigmer/agentic/run/v1/api_pb";
+import { RunSpecSchema } from "@stigmer/apis/ai/stigmer/agentic/run/v1/spec_pb";
+import { RunConfigSchema } from "@stigmer/apis/ai/stigmer/agentic/run/v1/invocation_pb";
+import { ApprovalMode } from "@stigmer/apis/ai/stigmer/agentic/run/v1/enum_pb";
+import { SessionSchema } from "@stigmer/apis/ai/stigmer/agentic/session/v1/api_pb";
+import { SessionSpecSchema } from "@stigmer/apis/ai/stigmer/agentic/session/v1/spec_pb";
+import { AgentSchema } from "@stigmer/apis/ai/stigmer/agentic/agent/v1/api_pb";
+import { SkillSchema } from "@stigmer/apis/ai/stigmer/agentic/skill/v1/api_pb";
+import { AgentSpecSchema } from "@stigmer/apis/ai/stigmer/agentic/agent/v1/spec_pb";
+import { ApiResourceKind } from "@stigmer/apis/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import { ApiResourceReferenceSchema } from "@stigmer/apis/ai/stigmer/commons/apiresource/io_pb";
+import { ApiResourceMetadataSchema } from "@stigmer/apis/ai/stigmer/commons/apiresource/metadata_pb";
+import { ExecutionRecord } from "./hermetic-activity.js";
+import { FIXTURE_MODEL } from "./model-registry-fixture.js";
+export const DEFAULT_RECORD_IDS = {
+    org: "hermetic-org",
+    executionId: "aex_hermetic_0001",
+    sessionId: "ses_hermetic_0001",
+    agentId: "agt_hermetic_0001",
+    agentName: "hermetic-agent",
+    agentVersionHash: "0".repeat(64),
+};
+export function executionRecordFixture(options) {
+    const ids = options.ids ?? DEFAULT_RECORD_IDS;
+    const builtIn = options.builtInAssistant === true;
+    const execution = create(RunSchema, {
+        metadata: create(ApiResourceMetadataSchema, { id: ids.executionId, org: ids.org, name: ids.executionId }),
+        spec: create(RunSpecSchema, {
+            target: { case: "sessionId", value: ids.sessionId },
+            message: options.message,
+            autoApproveAll: options.autoApproveAll ?? false,
+            runConfig: options.requestRunConfig,
+            // A `google.protobuf.Struct` field is a plain `JsonObject` in protobuf-es.
+            structuredOutputSchema: options.structuredOutputSchema,
+            tools: options.turnTools ?? [],
+            disallowedTools: options.turnDisallowedTools ?? [],
+            appendSystemPrompt: options.appendSystemPrompt ?? "",
+        }),
+        status: create(RunStatusSchema, {
+            agentId: builtIn ? "" : ids.agentId,
+            agentVersionHash: builtIn ? "" : ids.agentVersionHash,
+            runConfig: create(RunConfigSchema, {
+                modelName: options.modelName ?? FIXTURE_MODEL,
+                maxCostUsd: options.maxCostUsd ?? 0,
+                maxToolRounds: options.maxToolRounds ?? 0,
+                maxToolResultChars: options.maxToolResultChars ?? 0,
+            }),
+            approvalMode: options.approvalMode ?? ApprovalMode.UNSPECIFIED,
+        }),
+    });
+    const session = create(SessionSchema, {
+        metadata: create(ApiResourceMetadataSchema, { id: ids.sessionId, org: ids.org, name: ids.sessionId }),
+        spec: create(SessionSpecSchema, {
+            agentRef: builtIn
+                ? undefined
+                : create(ApiResourceReferenceSchema, { kind: ApiResourceKind.agent, org: ids.org, slug: ids.agentName }),
+            workspaceEntries: options.workspaceEntries ?? [],
+            fileReview: options.fileReview ?? false,
+        }),
+        status: {
+            agentId: builtIn ? "" : ids.agentId,
+            agentVersionHash: builtIn ? "" : ids.agentVersionHash,
+        },
+    });
+    if (builtIn) {
+        return new ExecutionRecord({
+            execution,
+            session,
+            agent: undefined,
+            controlSignal: options.controlSignal,
+        });
+    }
+    const agent = create(AgentSchema, {
+        metadata: create(ApiResourceMetadataSchema, { id: ids.agentId, org: ids.org, name: ids.agentName, slug: ids.agentName }),
+        spec: create(AgentSpecSchema, {
+            description: "Hermetic fixture agent",
+            instructions: options.instructions ?? "You are the hermetic fixture agent. Answer briefly.",
+            subagents: (options.subagents ?? []).map((subagent) => create(ApiResourceReferenceSchema, {
+                kind: ApiResourceKind.agent,
+                org: subagent.metadata?.org ?? ids.org,
+                slug: subagent.metadata?.slug ?? "",
+                version: subagent.status?.versionHash ?? "",
+            })),
+            tools: options.tools ?? [],
+            disallowedTools: options.disallowedTools ?? [],
+            hooks: options.hooks ?? [],
+            skillRefs: (options.skills ?? []).map((s) => create(ApiResourceReferenceSchema, { org: ids.org, slug: s.slug })),
+        }),
+    });
+    const skills = (options.skills ?? []).map((s) => create(SkillSchema, {
+        metadata: create(ApiResourceMetadataSchema, { id: `skill-${s.slug}`, org: ids.org, name: s.slug, slug: s.slug }),
+        spec: { name: s.slug, description: s.description, skillMd: s.skillMd },
+        status: { versionHash: `hash-${s.slug}` },
+    }));
+    return new ExecutionRecord({ execution, session, agent, controlSignal: options.controlSignal, skills, subagents: options.subagents ?? [] });
+}
+/**
+ * A saved agent a fixture's agent can list as a subagent (`subagents`): its
+ * slug is its name in the turn, and its version hash is derived from the
+ * slug, so the reference the parent pins is stable across runs.
+ */
+export function savedAgentFixture(slug, spec, org = DEFAULT_RECORD_IDS.org) {
+    const versionHash = createHash("sha256").update(`saved-agent:${slug}`).digest("hex");
+    return create(AgentSchema, {
+        metadata: create(ApiResourceMetadataSchema, { id: `agt_${slug}`, org, name: slug, slug }),
+        spec: create(AgentSpecSchema, spec),
+        status: { versionHash },
+    });
+}
+//# sourceMappingURL=execution-record-fixture.js.map

package/dist/__test-utils__/execution-record-fixture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-record-fixture.js","sourceRoot":"","sources":["../../src/__test-utils__/execution-record-fixture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,MAAM,EAA0C,MAAM,oBAAoB,CAAC;AACpF,OAAO,EACL,SAAS,EACT,eAAe,GAEhB,MAAM,gDAAgD,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAChF,OAAO,EAAE,eAAe,EAAkB,MAAM,uDAAuD,CAAC;AACxG,OAAO,EAAE,YAAY,EAAE,MAAM,iDAAiD,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAgB,MAAM,oDAAoD,CAAC;AACjG,OAAO,EAAE,iBAAiB,EAAE,MAAM,qDAAqD,CAAC;AAExF,OAAO,EAAE,WAAW,EAAc,MAAM,kDAAkD,CAAC;AAC3F,OAAO,EAAE,WAAW,EAAE,MAAM,kDAAkD,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAmB,MAAM,mDAAmD,CAAC;AACrG,OAAO,EAAE,eAAe,EAAE,MAAM,mFAAmF,CAAC;AACpH,OAAO,EAAE,0BAA0B,EAAE,MAAM,oDAAoD,CAAC;AAChG,OAAO,EAAE,yBAAyB,EAAE,MAAM,0DAA0D,CAAC;AAErG,OAAO,EAAE,eAAe,EAA6B,MAAM,wBAAwB,CAAC;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAa5D,MAAM,CAAC,MAAM,kBAAkB,GAAuB;IACpD,GAAG,EAAE,cAAc;IACnB,WAAW,EAAE,mBAAmB;IAChC,SAAS,EAAE,mBAAmB;IAC9B,OAAO,EAAE,mBAAmB;IAC5B,SAAS,EAAE,gBAAgB;IAC3B,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;CACjC,CAAC;AAyEF,MAAM,UAAU,sBAAsB,CAAC,OAA+B;IACpE,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,kBAAkB,CAAC;IAC9C,MAAM,OAAO,GAAG,OAAO,CAAC,gBAAgB,KAAK,IAAI,CAAC;IAClD,MAAM,SAAS,GAAQ,MAAM,CAAC,SAAS,EAAE;QACvC,QAAQ,EAAE,MAAM,CAAC,yBAAyB,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,WAAW,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,WAAW,EAAE,CAAC;QACzG,IAAI,EAAE,MAAM,CAAC,aAAa,EAAE;YAC1B,MAAM,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,CAAC,SAAS,EAAE;YACnD,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,KAAK;YAC/C,SAAS,EAAE,OAAO,CAAC,gBAAgB;YACnC,2EAA2E;YAC3E,sBAAsB,EAAE,OAAO,CAAC,sBAAsB;YACtD,KAAK,EAAE,OAAO,CAAC,SAAS,IAAI,EAAE;YAC9B,eAAe,EAAE,OAAO,CAAC,mBAAmB,IAAI,EAAE;YAClD,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,IAAI,EAAE;SACrD,CAAC;QACF,MAAM,EAAE,MAAM,CAAC,eAAe,EAAE;YAC9B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO;YACnC,gBAAgB,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,gBAAgB;YACrD,SAAS,EAAE,MAAM,CAAC,eAAe,EAAE;gBACjC,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,aAAa;gBAC7C,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,CAAC;gBACnC,aAAa,EAAE,OAAO,CAAC,aAAa,IAAI,CAAC;gBACzC,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,IAAI,CAAC;aACpD,CAAC;YACF,YAAY,EAAE,OAAO,CAAC,YAAY,IAAI,YAAY,CAAC,WAAW;SAC/D,CAAC;KACH,CAAC,CAAC;IACH,MAAM,OAAO,GAAY,MAAM,CAAC,aAAa,EAAE;QAC7C,QAAQ,EAAE,MAAM,CAAC,yBAAyB,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;QACrG,IAAI,EAAE,MAAM,CAAC,iBAAiB,EAAE;YAC9B,QAAQ,EAAE,OAAO;gBACf,CAAC,CAAC,SAAS;gBACX,CAAC,CAAC,MAAM,CAAC,0BAA0B,EAAE,EAAE,IAAI,EAAE,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;YAC1G,gBAAgB,EAAE,OAAO,CAAC,gBAAgB,IAAI,EAAE;YAChD,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,KAAK;SACxC,CAAC;QACF,MAAM,EAAE;YACN,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO;YACnC,gBAAgB,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,gBAAgB;SACtD;KACF,CAAC,CAAC;IACH,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,IAAI,eAAe,CAAC;YACzB,SAAS;YACT,OAAO;YACP,KAAK,EAAE,SAAS;YAChB,aAAa,EAAE,OAAO,CAAC,aAAa;SACrC,CAAC,CAAC;IACL,CAAC;IACD,MAAM,KAAK,GAAU,MAAM,CAAC,WAAW,EAAE;QACvC,QAAQ,EAAE,MAAM,CAAC,yBAAyB,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;QACxH,IAAI,EAAE,MAAM,CAAC,eAAe,EAAE;YAC5B,WAAW,EAAE,wBAAwB;YACrC,YAAY,EAAE,OAAO,CAAC,YAAY,IAAI,qDAAqD;YAC3F,SAAS,EAAE,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CACpD,MAAM,CAAC,0BAA0B,EAAE;gBACjC,IAAI,EAAE,eAAe,CAAC,KAAK;gBAC3B,GAAG,EAAE,QAAQ,CAAC,QAAQ,EAAE,GAAG,IAAI,GAAG,CAAC,GAAG;gBACtC,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,IAAI,IAAI,EAAE;gBACnC,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,IAAI,EAAE;aAC5C,CAAC,CACH;YACD,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,EAAE;YAC1B,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,EAAE;YAC9C,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,EAAE;YAC1B,SAAS,EAAE,CAAC,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,0BAA0B,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;SACjH,CAAC;KACH,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,CAAC,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAC9C,MAAM,CAAC,WAAW,EAAE;QAClB,QAAQ,EAAE,MAAM,CAAC,yBAAyB,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QAChH,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;QACtE,MAAM,EAAE,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE;KAC1C,CAAC,CACH,CAAC;IACF,OAAO,IAAI,eAAe,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,EAAE,EAAE,CAAC,CAAC;AAC9I,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,IAA8C,EAAE,GAAG,GAAG,kBAAkB,CAAC,GAAG;IAC1H,MAAM,WAAW,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrF,OAAO,MAAM,CAAC,WAAW,EAAE;QACzB,QAAQ,EAAE,MAAM,CAAC,yBAAyB,EAAE,EAAE,EAAE,EAAE,OAAO,IAAI,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QACzF,IAAI,EAAE,MAAM,CAAC,eAAe,EAAE,IAAI,CAAC;QACnC,MAAM,EAAE,EAAE,WAAW,EAAE;KACxB,CAAC,CAAC;AACL,CAAC"}

package/dist/__test-utils__/file-review-projection.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The server's side of file review, mirrored for the hermetic record — the
+ * ONE place a runner test stands in for the control plane's file record and
+ * decision core.
+ *
+ * Production: the runner sends the change sets its invocation captured on
+ * every status write (`RunStatus.file_changes`, `shared/filereview/record.ts`),
+ * and the server upserts them on the run by set id, so a set an earlier
+ * invocation sent stays. A person's Keep or Undo is the decision core's: it
+ * writes each decision into the session's log as
+ * `stigmer.file_review.decided`, and a later turn's start reads the undone
+ * sets' files back from the run's record and the decisions from the log and
+ * puts the files back (`harness/owed-undos.ts`). The hermetic
+ * `ExecutionRecord` is the server here, so it upserts the same way
+ * ({@link upsertFileChanges}) and decides only files the log holds no
+ * decision for ({@link decideCapturedFileChanges}).
+ *
+ * Mirrored, not imported: the runner is a standalone package and cannot
+ * reach the server's source. The conformance suite's file-review files
+ * (`test/conformance/src/suites-execution/agentexecution-file-review*`) are
+ * the arbiter that the two still agree, through the real server.
+ */
+import { type FileChangeSet } from "@stigmer/apis/ai/stigmer/agentic/run/v1/filereview_pb";
+/** The server's merge of a written record onto the held one: each set replaced by id, a new one appended, none removed. */
+export declare function upsertFileChanges(held: readonly FileChangeSet[], written: readonly FileChangeSet[]): FileChangeSet[];
+/** The paths a reviewer decides, by workspace-relative path (the change's `path_after || path_before`). */
+export interface FileReviewVerdicts {
+    readonly approve?: readonly string[];
+    readonly reject?: readonly string[];
+}
+/** One decision the decision core writes, as its `stigmer.file_review.decided` states it. */
+export interface KitFileDecision {
+    readonly changeSetId: string;
+    readonly fileChangeId: string;
+    readonly action: "keep" | "undo";
+    readonly expectedDigest: string;
+}
+/**
+ * What the server's decision core writes once every change of every
+ * captured set not yet decided has a per-file verdict: one file-scoped
+ * decision per change the log holds none for. A path in neither list is a
+ * test bug and throws (an undecided change is left as it is, which would
+ * hide the mistake). Returns the decisions, in order.
+ */
+export declare function decideCapturedFileChanges(fileChanges: readonly FileChangeSet[], decidedFileIds: ReadonlySet<string>, verdicts: FileReviewVerdicts): KitFileDecision[];

package/dist/__test-utils__/file-review-projection.js

@@ -0,0 +1,61 @@
+/**
+ * The server's side of file review, mirrored for the hermetic record — the
+ * ONE place a runner test stands in for the control plane's file record and
+ * decision core.
+ *
+ * Production: the runner sends the change sets its invocation captured on
+ * every status write (`RunStatus.file_changes`, `shared/filereview/record.ts`),
+ * and the server upserts them on the run by set id, so a set an earlier
+ * invocation sent stays. A person's Keep or Undo is the decision core's: it
+ * writes each decision into the session's log as
+ * `stigmer.file_review.decided`, and a later turn's start reads the undone
+ * sets' files back from the run's record and the decisions from the log and
+ * puts the files back (`harness/owed-undos.ts`). The hermetic
+ * `ExecutionRecord` is the server here, so it upserts the same way
+ * ({@link upsertFileChanges}) and decides only files the log holds no
+ * decision for ({@link decideCapturedFileChanges}).
+ *
+ * Mirrored, not imported: the runner is a standalone package and cannot
+ * reach the server's source. The conformance suite's file-review files
+ * (`test/conformance/src/suites-execution/agentexecution-file-review*`) are
+ * the arbiter that the two still agree, through the real server.
+ */
+import { clone } from "@bufbuild/protobuf";
+import { FileChangeSetSchema } from "@stigmer/apis/ai/stigmer/agentic/run/v1/filereview_pb";
+/** The server's merge of a written record onto the held one: each set replaced by id, a new one appended, none removed. */
+export function upsertFileChanges(held, written) {
+    const out = held.map((set) => clone(FileChangeSetSchema, set));
+    for (const set of written) {
+        const index = out.findIndex((h) => h.id === set.id);
+        if (index < 0)
+            out.push(clone(FileChangeSetSchema, set));
+        else
+            out[index] = clone(FileChangeSetSchema, set);
+    }
+    return out;
+}
+/**
+ * What the server's decision core writes once every change of every
+ * captured set not yet decided has a per-file verdict: one file-scoped
+ * decision per change the log holds none for. A path in neither list is a
+ * test bug and throws (an undecided change is left as it is, which would
+ * hide the mistake). Returns the decisions, in order.
+ */
+export function decideCapturedFileChanges(fileChanges, decidedFileIds, verdicts) {
+    const approve = new Set(verdicts.approve ?? []);
+    const reject = new Set(verdicts.reject ?? []);
+    const written = [];
+    for (const set of fileChanges) {
+        for (const change of set.changes) {
+            if (decidedFileIds.has(change.id))
+                continue;
+            const path = change.pathAfter || change.pathBefore;
+            const action = approve.has(path) ? "keep" : reject.has(path) ? "undo" : undefined;
+            if (action === undefined)
+                throw new Error(`decideCapturedFileChanges: no verdict for '${path}' in change set '${set.id}' (test bug)`);
+            written.push({ changeSetId: set.id, fileChangeId: change.id, action, expectedDigest: change.fileDigest });
+        }
+    }
+    return written;
+}
+//# sourceMappingURL=file-review-projection.js.map

package/dist/__test-utils__/file-review-projection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-review-projection.js","sourceRoot":"","sources":["../../src/__test-utils__/file-review-projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAsB,MAAM,uDAAuD,CAAC;AAEhH,2HAA2H;AAC3H,MAAM,UAAU,iBAAiB,CAAC,IAA8B,EAAE,OAAiC;IACjG,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,mBAAmB,EAAE,GAAG,CAAC,CAAC,CAAC;IAC/D,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC1B,MAAM,KAAK,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC;QACpD,IAAI,KAAK,GAAG,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,EAAE,GAAG,CAAC,CAAC,CAAC;;YACpD,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,mBAAmB,EAAE,GAAG,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAgBD;;;;;;GAMG;AACH,MAAM,UAAU,yBAAyB,CACvC,WAAqC,EACrC,cAAmC,EACnC,QAA4B;IAE5B,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;IAChD,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;IAC9C,MAAM,OAAO,GAAsB,EAAE,CAAC;IACtC,KAAK,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;QAC9B,KAAK,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;YACjC,IAAI,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;gBAAE,SAAS;YAC5C,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,UAAU,CAAC;YACnD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;YAClF,IAAI,MAAM,KAAK,SAAS;gBAAE,MAAM,IAAI,KAAK,CAAC,8CAA8C,IAAI,oBAAoB,GAAG,CAAC,EAAE,cAAc,CAAC,CAAC;YACtI,OAAO,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,GAAG,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;QAC5G,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/__test-utils__/harness-contract/types.d.ts

@@ -0,0 +1,188 @@
+/**
+ * The test-facing seam of the harness contract kit.
+ *
+ * `HarnessAdapter.runTurn(input, sink)` gives a test no way to make the
+ * engine DO anything: propose a gated action, emit usage, hang, fail. The
+ * approval-contract kit met the same problem with `GatewaySubstrate` — a
+ * small interface each real substrate adapts so one invariant catalog can
+ * drive all of them. This is that seam for harnesses: a
+ * {@link HarnessContractSubject} owns the ENGINE (what the next turn will
+ * do), and the kit owns everything the runtime would own (the sink, the
+ * `TurnInput`, the state id threading, the reinvocation).
+ *
+ * The scenario vocabulary is deliberately small and engine-neutral: it says
+ * what the kit needs to PROVOKE, never how an engine behaves. The scripted
+ * fake consumes it directly; a real harness's subject translates it onto that
+ * harness's own double (the Cursor subject onto the scripted `@cursor/sdk`
+ * agent of `execute-cursor/__test-utils__/`). One vocabulary, not one per
+ * engine, so the kit cannot drift from what the fake can do.
+ *
+ * Gated actions reuse `ProposedAction` from `approval-contract/types.ts`, the
+ * taxonomy-free action every enforcement substrate already translates, so the
+ * two kits speak of the same logical side effect and neither restates the
+ * HITL taxonomy.
+ */
+import type { Config } from "../../config.js";
+import type { HarnessName } from "../../harness/registry.js";
+import type { FailureSurface, HarnessAdapter, UsageDelta } from "../../harness/types.js";
+import type { ProposedAction } from "../approval-contract/types.js";
+import type { TurnInputFixtureOverrides } from "../turn-input-fixture.js";
+import type { ApprovalAction } from "../../gen/turn/ai/stigmer/runner/turn/v1/enum_pb.js";
+/**
+ * One thing the engine does during a turn. A turn plays its steps in order
+ * and ends `completed` when none is left, unless a step ends it first.
+ *
+ *  - `say`: the engine emits assistant text (a transcript row).
+ *  - `propose`: the engine reaches a gated side effect identified by
+ *    `toolCallId`. Undecided → the turn ends `awaiting_approval` and later
+ *    steps do not run; APPROVE → the effect runs once and the turn continues;
+ *    REJECT / SKIP → the effect never runs and the turn continues. WHICH
+ *    kinds a harness gates is the harness's policy and the workspace's
+ *    posture: a `shell` is gated by every harness in every posture; a `write`
+ *    is gated only outside apply-then-review capture (a git tree, or artifact
+ *    storage), so an arm that must gate on every subject proposes a `shell`.
+ *  - `read`: the engine performs an UNGATED read of `path` — a tool-call row
+ *    that runs at once, never pauses, and is the discrete event every harness
+ *    flushes a persist on (the lever an arm pulls when it needs the control
+ *    plane to answer a mid-turn persist).
+ *  - `usage`: the engine reports one turn's token counts.
+ *  - `hang`: the engine makes no further progress until told to stop. The
+ *    step that the stop-signal invariants and the runtime's stall watchdog
+ *    are built around; it must be parked on the signal, never on a timer.
+ *  - `fail`: the engine fails with a message the adapter can name; the turn
+ *    ends `failed` on the given surface (`engine` unless the scenario says
+ *    otherwise — the runtime's three failure copies are its own invariant).
+ *  - `cancelled`: the engine ends its own run cancelled with nothing to
+ *    wait for (an SDK-side cancel); the turn ends `cancelled`. Not every
+ *    engine can end itself (a LangGraph run is stopped only by the runtime's
+ *    signal and settles `interrupted`), so a subject that cannot produce it
+ *    says so and the runtime arm is reported SKIPPED there.
+ *  - `limit`: the engine exhausts the tool-round budget the execution set and
+ *    stops at a step boundary with its work checkpointed; the turn ends
+ *    `tool_call_limit`. Not every engine has such a budget (Cursor's SDK does
+ *    not), so a subject that cannot produce it says so and the runtime arm
+ *    is reported SKIPPED there.
+ */
+export type ScenarioStep = {
+    readonly kind: "say";
+    readonly text: string;
+} | {
+    readonly kind: "propose";
+    readonly toolCallId: string;
+    readonly action: ProposedAction;
+    readonly flows?: boolean;
+} | {
+    readonly kind: "read";
+    readonly toolCallId: string;
+    readonly path: string;
+} | {
+    readonly kind: "usage";
+    readonly delta: UsageDelta;
+} | {
+    readonly kind: "hang";
+} | {
+    readonly kind: "fail";
+    readonly message: string;
+    readonly surface: FailureSurface;
+} | {
+    readonly kind: "cancelled";
+} | {
+    readonly kind: "limit";
+};
+/** One turn's worth of engine behaviour. */
+export type TurnScenario = readonly ScenarioStep[];
+/** Step builders — the vocabulary a kit invariant reads as. */
+export declare const scenario: {
+    readonly say: (text: string) => ScenarioStep;
+    readonly propose: (toolCallId: string, action: ProposedAction) => ScenarioStep;
+    /**
+     * A `write` the arm EXPECTS to flow under apply-then-review capture (a git
+     * work tree, or artifact storage): the engine performs it at once, the row
+     * completes, and the RUNTIME captures it for review after the turn
+     * (`harness/capture.ts`). The arm states the posture rather than the
+     * subject inferring it, so a subject that gates a flowing write is caught,
+     * not accommodated. The bytes written are the engine's own; the arm
+     * asserts the captured PATH and the reconcile's effect, never the content.
+     */
+    readonly flowingWrite: (toolCallId: string, path: string) => ScenarioStep;
+    readonly read: (toolCallId: string, path: string) => ScenarioStep;
+    readonly usage: (delta: UsageDelta) => ScenarioStep;
+    readonly hang: () => ScenarioStep;
+    readonly fail: (message: string, surface?: FailureSurface) => ScenarioStep;
+    readonly cancelled: () => ScenarioStep;
+    readonly limit: () => ScenarioStep;
+};
+/**
+ * What the engine can know about the turn it is about to play, handed to the
+ * subject with every {@link HarnessContractSubject.arrange}: which execution
+ * and session it serves (a real engine is per session — its handle is parked
+ * under the session, its workspace and hook state live under the session —
+ * so a subject arranges THAT session's engine, never "the next turn"), and
+ * the approval decisions the prompt will carry (the runtime's
+ * `approvalAnswersOf` over the modelled log and the persisted status — the
+ * one map both drivers call). A subject whose engine cannot re-run a settled action, or
+ * whose model is told not to perform a skipped one, reads its decision here
+ * instead of parsing the prompt for it.
+ */
+export interface EngineView {
+    readonly executionId: string;
+    readonly sessionId: string;
+    readonly approvalDecisions: ReadonlyMap<string, ApprovalAction>;
+}
+/**
+ * What a subject may say about the record its engine is handed, laid UNDER
+ * the driver's own facts: the five it threads (`executionId`, `threadId`,
+ * `turnSeq`, `sessionId`, `approvalDecisions`) and the persisted status it
+ * seeds are the kit's bookkeeping and never a subject's to state.
+ */
+export type SubjectInputOverrides = Omit<TurnInputFixtureOverrides, "executionId" | "threadId" | "turnSeq" | "sessionId" | "approvalDecisions" | "persistedStatus">;
+/**
+ * One adapter under test, with the engine controls the kit needs. Adapters
+ * translate scenarios into their own double's drives and report what the
+ * double observed; they never reimplement contract behaviour.
+ *
+ * The kit owns the adapter's lifetime: it boots the adapter before the first
+ * turn and shuts it down after the last (the registry boots every adapter
+ * before the worker polls, and a real adapter refuses a turn before boot).
+ * The exported assertion functions therefore REQUIRE a booted adapter.
+ */
+export interface HarnessContractSubject {
+    /** Stable name, used in suite titles and every assertion message. */
+    readonly name: string;
+    /** The registry row this adapter fills; the runtime half selects the activity by it. */
+    readonly harness: HarnessName;
+    /** The adapter under test — the real implementation of the contract. */
+    readonly adapter: HarnessAdapter;
+    /** What `adapter.boot` needs. The subject knows its adapter's fields; the kit does not. */
+    readonly config: Config;
+    /**
+     * Arrange the engine so that the NEXT `runTurn` for `view.sessionId` plays
+     * `turn` — REPLACING whatever was arranged for that session and not yet
+     * played (a turn interrupted before its engine ran leaves no stale script
+     * behind). Called by the kit before every `runTurn`, including a
+     * reinvocation (the engine re-reaches the same gated call on resume, so the
+     * same proposal is arranged again).
+     */
+    arrange(turn: TurnScenario, view: EngineView): void;
+    /**
+     * What this engine needs the record to say beyond the driver's facts (the
+     * model the adapter validates, the workspace its gate installs into). A
+     * subject whose engine reads nothing of the record omits it.
+     */
+    inputOverrides?(view: EngineView): SubjectInputOverrides;
+    /**
+     * Resolves the next time a turn parks on a `hang` step — the moment the
+     * kit stops a turn from the outside, and the moment the runtime half
+     * delivers a cancellation, a drain or the clock tick that trips the stall
+     * watchdog. A real engine reaches its hang only after real setup (file
+     * writes, catalog fetches); a stop delivered any earlier would land in that
+     * setup and prove nothing about the hang. Never a timer.
+     */
+    whenHanging(): Promise<void>;
+    /**
+     * How many times the side effect behind `toolCallId` actually ran, as the
+     * subject's double observed it. The safety-critical observable; zero for an
+     * id the engine never reached.
+     */
+    executionCount(toolCallId: string): number;
+}

package/dist/__test-utils__/harness-contract/types.js

@@ -0,0 +1,64 @@
+/**
+ * The test-facing seam of the harness contract kit.
+ *
+ * `HarnessAdapter.runTurn(input, sink)` gives a test no way to make the
+ * engine DO anything: propose a gated action, emit usage, hang, fail. The
+ * approval-contract kit met the same problem with `GatewaySubstrate` — a
+ * small interface each real substrate adapts so one invariant catalog can
+ * drive all of them. This is that seam for harnesses: a
+ * {@link HarnessContractSubject} owns the ENGINE (what the next turn will
+ * do), and the kit owns everything the runtime would own (the sink, the
+ * `TurnInput`, the state id threading, the reinvocation).
+ *
+ * The scenario vocabulary is deliberately small and engine-neutral: it says
+ * what the kit needs to PROVOKE, never how an engine behaves. The scripted
+ * fake consumes it directly; a real harness's subject translates it onto that
+ * harness's own double (the Cursor subject onto the scripted `@cursor/sdk`
+ * agent of `execute-cursor/__test-utils__/`). One vocabulary, not one per
+ * engine, so the kit cannot drift from what the fake can do.
+ *
+ * Gated actions reuse `ProposedAction` from `approval-contract/types.ts`, the
+ * taxonomy-free action every enforcement substrate already translates, so the
+ * two kits speak of the same logical side effect and neither restates the
+ * HITL taxonomy.
+ */
+/** Step builders — the vocabulary a kit invariant reads as. */
+export const scenario = {
+    say(text) {
+        return { kind: "say", text };
+    },
+    propose(toolCallId, action) {
+        return { kind: "propose", toolCallId, action };
+    },
+    /**
+     * A `write` the arm EXPECTS to flow under apply-then-review capture (a git
+     * work tree, or artifact storage): the engine performs it at once, the row
+     * completes, and the RUNTIME captures it for review after the turn
+     * (`harness/capture.ts`). The arm states the posture rather than the
+     * subject inferring it, so a subject that gates a flowing write is caught,
+     * not accommodated. The bytes written are the engine's own; the arm
+     * asserts the captured PATH and the reconcile's effect, never the content.
+     */
+    flowingWrite(toolCallId, path) {
+        return { kind: "propose", toolCallId, action: { kind: "write", resource: path }, flows: true };
+    },
+    read(toolCallId, path) {
+        return { kind: "read", toolCallId, path };
+    },
+    usage(delta) {
+        return { kind: "usage", delta };
+    },
+    hang() {
+        return { kind: "hang" };
+    },
+    fail(message, surface = "engine") {
+        return { kind: "fail", message, surface };
+    },
+    cancelled() {
+        return { kind: "cancelled" };
+    },
+    limit() {
+        return { kind: "limit" };
+    },
+};
+//# sourceMappingURL=types.js.map

package/dist/__test-utils__/harness-contract/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/__test-utils__/harness-contract/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AA0DH,+DAA+D;AAC/D,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,GAAG,CAAC,IAAY;QACd,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAC/B,CAAC;IACD,OAAO,CAAC,UAAkB,EAAE,MAAsB;QAChD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IACjD,CAAC;IACD;;;;;;;;OAQG;IACH,YAAY,CAAC,UAAkB,EAAE,IAAY;QAC3C,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACjG,CAAC;IACD,IAAI,CAAC,UAAkB,EAAE,IAAY;QACnC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;IAC5C,CAAC;IACD,KAAK,CAAC,KAAiB;QACrB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAClC,CAAC;IACD,IAAI;QACF,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAC1B,CAAC;IACD,IAAI,CAAC,OAAe,EAAE,UAA0B,QAAQ;QACtD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;IAC5C,CAAC;IACD,SAAS;QACP,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IAC/B,CAAC;IACD,KAAK;QACH,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAC3B,CAAC;CACO,CAAC"}