@jmanuelcorral/openteam 0.1.40 → 0.1.41

package/dist/graph/privacyPolicy.d.ts

@@ -0,0 +1,29 @@
+import type { PrivacyClass } from "../context/schema";
+/**
+ * Política pura de privacidad en el despacho de efectos. Deterministas: sin
+ * I/O, reloj ni random. Reexporta `assertReferenceOnly` para rechazar payloads
+ * con contenido crudo en la frontera de despacho.
+ */
+export { assertReferenceOnly } from "../context/redaction";
+/** Modo de privacidad efectivo (coincide con `config.privacyMode`). */
+export type PrivacyMode = "forceLocalOnSensitive" | "consentBeforeFrontier" | "off";
+/** Destino de ruta de un efecto. */
+export type RouteKind = "local" | "frontier";
+/** Error tipado de una violación de privacidad en el despacho. */
+export declare class PrivacyPolicyError extends Error {
+    readonly code: "sensitive-forced-local";
+    readonly detail: string;
+    constructor(detail: string);
+}
+/**
+ * `true` si una clase de privacidad puede planificar frontier bajo un modo. Un
+ * artefacto `sensitive` con `forceLocalOnSensitive` nunca puede ir a frontier.
+ */
+export declare function frontierAllowed(privacyClass: PrivacyClass, mode: PrivacyMode): boolean;
+/** Lanza si un despacho a frontier viola la política de privacidad. */
+export declare function assertPrivacyDispatch(input: {
+    privacyClass: PrivacyClass;
+    mode: PrivacyMode;
+    routeKind: RouteKind;
+}): void;
+//# sourceMappingURL=privacyPolicy.d.ts.map

package/dist/graph/privacyPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privacyPolicy.d.ts","sourceRoot":"","sources":["../../src/graph/privacyPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,uEAAuE;AACvE,MAAM,MAAM,WAAW,GACnB,uBAAuB,GACvB,uBAAuB,GACvB,KAAK,CAAC;AAEV,oCAAoC;AACpC,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;AAE7C,kEAAkE;AAClE,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM;CAM3B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,WAAW,GAChB,OAAO,CAET;AAED,uEAAuE;AACvE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,YAAY,EAAE,YAAY,CAAC;IAC3B,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;CACtB,GAAG,IAAI,CAOP"}

package/dist/graph/reducer.d.ts

@@ -0,0 +1,27 @@
+import type { GraphEventV1, GraphSpecV1 } from "./schema";
+import { type GraphState } from "./types";
+/**
+ * Reducer total y determinista de Graph V1.
+ *
+ * Aplica un evento a un estado y devuelve el nuevo estado, o lanza
+ * `ReducerError` cerrando en falso ante transiciones ilegales, conflictos de
+ * identidad o mutaciones post-terminales. Reaplicar un evento ya reflejado
+ * (misma operación/intento) es idempotente. Puro: sin I/O, reloj ni random.
+ */
+export type ReducerErrorCode = "run-mismatch" | "post-terminal" | "run-started-conflict" | "unknown-node" | "dependency-not-satisfied" | "dispatch-conflict" | "receipt-conflict" | "illegal-transition" | "incomplete-run";
+/** Error tipado de una transición inválida del reducer. */
+export declare class ReducerError extends Error {
+    readonly code: ReducerErrorCode;
+    readonly detail: string;
+    constructor(code: ReducerErrorCode, detail: string);
+}
+/** Estado inicial: todos los nodos `pending`, run `running`, sin eventos. */
+export declare function initialState(spec: GraphSpecV1): GraphState;
+/**
+ * Aplica un evento al estado. Idempotente ante duplicados exactos; cierra en
+ * falso ante conflictos, transiciones ilegales o mutación post-terminal.
+ */
+export declare function applyEvent(spec: GraphSpecV1, state: GraphState, event: GraphEventV1): GraphState;
+/** Hash SHA-256 determinista del estado reducido (orden de nodos estable). */
+export declare function stateHash(state: GraphState): string;
+//# sourceMappingURL=reducer.d.ts.map

package/dist/graph/reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/graph/reducer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAa,WAAW,EAAE,MAAM,UAAU,CAAC;AACrE,OAAO,EACL,KAAK,UAAU,EAGhB,MAAM,SAAS,CAAC;AAEjB;;;;;;;GAOG;AAEH,MAAM,MAAM,gBAAgB,GACxB,cAAc,GACd,eAAe,GACf,sBAAsB,GACtB,cAAc,GACd,0BAA0B,GAC1B,mBAAmB,GACnB,kBAAkB,GAClB,oBAAoB,GACpB,gBAAgB,CAAC;AAErB,2DAA2D;AAC3D,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM;CAMnD;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,CAM1D;AAoLD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,YAAY,GAClB,UAAU,CAkCZ;AAyBD,8EAA8E;AAC9E,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEnD"}

package/dist/graph/replay.d.ts

@@ -0,0 +1,20 @@
+import type { GraphEventV1, GraphSpecV1 } from "./schema";
+import type { GraphState } from "./types";
+/**
+ * Replay estricto de un journal de eventos sobre un spec.
+ *
+ * Exige secuencia contigua desde 0: cualquier hueco, reordenación o duplicado
+ * de `seq` cierra en falso. Los mismos bytes producen el mismo estado y el
+ * mismo hash. Puro: sin I/O, reloj ni random.
+ */
+/** Error tipado de un journal con secuencia inválida. */
+export declare class ReplayError extends Error {
+    readonly code: "sequence-gap";
+    readonly detail: string;
+    constructor(detail: string);
+}
+/** Reduce una secuencia estricta de eventos al estado final. */
+export declare function replay(spec: GraphSpecV1, events: readonly GraphEventV1[]): GraphState;
+/** Hash determinista del estado resultante del replay. */
+export declare function replayHash(spec: GraphSpecV1, events: readonly GraphEventV1[]): string;
+//# sourceMappingURL=replay.d.ts.map

package/dist/graph/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../src/graph/replay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;;;;;GAMG;AAEH,yDAAyD;AACzD,qBAAa,WAAY,SAAQ,KAAK;IACpC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM;CAM3B;AAED,gEAAgE;AAChE,wBAAgB,MAAM,CACpB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,SAAS,YAAY,EAAE,GAC9B,UAAU,CASZ;AAED,0DAA0D;AAC1D,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,SAAS,YAAY,EAAE,GAC9B,MAAM,CAER"}

package/dist/graph/reviewerPolicy.d.ts

@@ -0,0 +1,27 @@
+import type { GraphSpecV1 } from "./schema";
+import type { Capability } from "./types";
+/**
+ * Políticas puras de reviewer: independencia autor/reviewer y lockout de
+ * capacidades. Deterministas: sin I/O, reloj ni random.
+ */
+/** Capacidades que un reviewer puede planificar (solo lectura). */
+export declare const REVIEWER_ALLOWED_CAPABILITIES: readonly Capability[];
+export type ReviewerPolicyCode = "self-review" | "reviewer-capability" | "unassigned";
+/** Error tipado de una violación de política de reviewer. */
+export declare class ReviewerPolicyError extends Error {
+    readonly code: ReviewerPolicyCode;
+    readonly detail: string;
+    constructor(code: ReviewerPolicyCode, detail: string);
+}
+/** `true` si el reviewer no es el autor del artefacto que revisa. */
+export declare function reviewerCanReview(authorID: string, reviewerID: string): boolean;
+/** Lanza si autor y reviewer coinciden (self-review). */
+export declare function assertReviewerIndependence(authorID: string, reviewerID: string): void;
+/** Lanza si el reviewer planifica cualquier capacidad mutante. */
+export declare function assertReviewerCapabilities(planned: readonly Capability[]): void;
+/**
+ * Valida las asignaciones autor/reviewer del spec: cada reviewer debe estar
+ * asignado a alguien distinto del autor del nodo que revisa.
+ */
+export declare function assertReviewAssignments(spec: GraphSpecV1, assignments: Readonly<Record<string, string>>): void;
+//# sourceMappingURL=reviewerPolicy.d.ts.map

package/dist/graph/reviewerPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewerPolicy.d.ts","sourceRoot":"","sources":["../../src/graph/reviewerPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;;GAGG;AAEH,mEAAmE;AACnE,eAAO,MAAM,6BAA6B,EAAE,SAAS,UAAU,EAAa,CAAC;AAE7E,MAAM,MAAM,kBAAkB,GAC1B,aAAa,GACb,qBAAqB,GACrB,YAAY,CAAC;AAEjB,6DAA6D;AAC7D,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,IAAI,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM;CAMrD;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,OAAO,CAET;AAED,yDAAyD;AACzD,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,IAAI,CAIN;AAED,kEAAkE;AAClE,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,SAAS,UAAU,EAAE,GAC7B,IAAI,CAMN;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,EACjB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC5C,IAAI,CAYN"}

package/dist/graph/schema.d.ts

@@ -0,0 +1,220 @@
+import { z } from "zod";
+/**
+ * Esquemas Zod versionados de Graph V1: spec estático, nodos, roles y el sobre
+ * de eventos como unión discriminada exhaustiva.
+ *
+ * Superficie de validación pura: sin I/O, SDK, storage, router, telemetría,
+ * reloj, random ni env. `.strict()` en todos los objetos rechaza campos
+ * desconocidos —incluidos campos de contenido crudo— con un error tipado.
+ */
+export declare const GRAPH_SPEC_VERSION: 1;
+export declare const GRAPH_EVENT_VERSION: 1;
+/** Identificador de nodo/run: charset acotado y path-safe, determinista. */
+export declare const NodeIDSchema: z.ZodString;
+export type NodeID = z.infer<typeof NodeIDSchema>;
+/** Rol de un nodo: quién ejecuta el efecto. */
+export declare const NodeRoleSchema: z.ZodEnum<{
+    implementer: "implementer";
+    reviewer: "reviewer";
+}>;
+export type NodeRole = z.infer<typeof NodeRoleSchema>;
+/** ID de operación/intento: hex derivado de forma determinista (`ids.ts`). */
+export declare const OperationIDSchema: z.ZodString;
+export declare const AttemptIDSchema: z.ZodString;
+/** Taxonomía acotada de clases de error de un efecto. */
+export declare const ErrorClassSchema: z.ZodEnum<{
+    unknown: "unknown";
+    transient: "transient";
+    permanent: "permanent";
+    timeout: "timeout";
+    cancelled: "cancelled";
+}>;
+export type ErrorClass = z.infer<typeof ErrorClassSchema>;
+/**
+ * Nodo del grafo. Un `reviewer` referencia con `reviews` el nodo cuyo artefacto
+ * revisa; un `implementer` nunca lleva `reviews`.
+ */
+export declare const GraphNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        implementer: "implementer";
+        reviewer: "reviewer";
+    }>;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    anchor: z.ZodObject<{
+        taskID: z.ZodString;
+        specDigest: z.ZodString;
+    }, z.core.$strict>;
+    reviews: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type GraphNode = z.infer<typeof GraphNodeSchema>;
+/** Spec estático versionado de un run: un DAG con al menos un nodo. */
+export declare const GraphSpecV1Schema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    runID: z.ZodString;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        anchor: z.ZodObject<{
+            taskID: z.ZodString;
+            specDigest: z.ZodString;
+        }, z.core.$strict>;
+        reviews: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GraphSpecV1 = z.infer<typeof GraphSpecV1Schema>;
+export declare const RunStartedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"run.started">;
+    specDigest: z.ZodString;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>;
+export declare const NodeDispatchedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"node.dispatched">;
+    nodeID: z.ZodString;
+    operationID: z.ZodString;
+    attemptID: z.ZodString;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>;
+export declare const NodeSucceededEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"node.succeeded">;
+    nodeID: z.ZodString;
+    operationID: z.ZodString;
+    attemptID: z.ZodString;
+    artifact: z.ZodObject<{
+        uri: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+        mediaType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>;
+export declare const NodeFailedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"node.failed">;
+    nodeID: z.ZodString;
+    operationID: z.ZodString;
+    attemptID: z.ZodString;
+    errorClass: z.ZodEnum<{
+        unknown: "unknown";
+        transient: "transient";
+        permanent: "permanent";
+        timeout: "timeout";
+        cancelled: "cancelled";
+    }>;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>;
+export declare const NodeCancelledEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"node.cancelled">;
+    nodeID: z.ZodString;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>;
+export declare const RunCompletedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"run.completed">;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>;
+export declare const RunFailedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"run.failed">;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>;
+export declare const RunCancelledEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"run.cancelled">;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>;
+/** Unión discriminada exhaustiva de los eventos de Graph V1. */
+export declare const GraphEventV1Schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"run.started">;
+    specDigest: z.ZodString;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"node.dispatched">;
+    nodeID: z.ZodString;
+    operationID: z.ZodString;
+    attemptID: z.ZodString;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"node.succeeded">;
+    nodeID: z.ZodString;
+    operationID: z.ZodString;
+    attemptID: z.ZodString;
+    artifact: z.ZodObject<{
+        uri: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+        mediaType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"node.failed">;
+    nodeID: z.ZodString;
+    operationID: z.ZodString;
+    attemptID: z.ZodString;
+    errorClass: z.ZodEnum<{
+        unknown: "unknown";
+        transient: "transient";
+        permanent: "permanent";
+        timeout: "timeout";
+        cancelled: "cancelled";
+    }>;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"node.cancelled">;
+    nodeID: z.ZodString;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.completed">;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.failed">;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.cancelled">;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+}, z.core.$strict>], "type">;
+export type GraphEventV1 = z.infer<typeof GraphEventV1Schema>;
+export type GraphEventType = GraphEventV1["type"];
+/** Error tipado de validación de esquema Graph. */
+export declare class GraphSchemaError extends Error {
+    readonly code: "invalid-spec" | "invalid-event";
+    readonly issues: string[];
+    constructor(code: "invalid-spec" | "invalid-event", error: z.ZodError);
+}
+/** Parsea un spec, lanzando `GraphSchemaError` con `code="invalid-spec"`. */
+export declare function parseGraphSpec(input: unknown): GraphSpecV1;
+/** Parsea un evento, lanzando `GraphSchemaError` con `code="invalid-event"`. */
+export declare function parseGraphEvent(input: unknown): GraphEventV1;
+//# sourceMappingURL=schema.d.ts.map

package/dist/graph/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/graph/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB;;;;;;;GAOG;AAEH,eAAO,MAAM,kBAAkB,EAAG,CAAU,CAAC;AAC7C,eAAO,MAAM,mBAAmB,EAAG,CAAU,CAAC;AAE9C,4EAA4E;AAC5E,eAAO,MAAM,YAAY,aAIkC,CAAC;AAC5D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,+CAA+C;AAC/C,eAAO,MAAM,cAAc;;;EAAsC,CAAC;AAClE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,aAEsB,CAAC;AACrD,eAAO,MAAM,eAAe,aAEsB,CAAC;AAEnD,yDAAyD;AACzD,eAAO,MAAM,gBAAgB;;;;;;EAM3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;kBAQjB,CAAC;AACZ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,uEAAuE;AACvE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;kBAMnB,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAQ5D,eAAO,MAAM,qBAAqB;;;;;;kBAMvB,CAAC;AAEZ,eAAO,MAAM,yBAAyB;;;;;;;;kBAQ3B,CAAC;AAEZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;kBAS1B,CAAC;AAEZ,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;kBASvB,CAAC;AAEZ,eAAO,MAAM,wBAAwB;;;;;;kBAM1B,CAAC;AAEZ,eAAO,MAAM,uBAAuB;;;;;kBAEzB,CAAC;AAEZ,eAAO,MAAM,oBAAoB;;;;;kBAEtB,CAAC;AAEZ,eAAO,MAAM,uBAAuB;;;;;kBAEzB,CAAC;AAEZ,gEAAgE;AAChE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAS7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,cAAc,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;AAElD,mDAAmD;AACnD,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,eAAe,CAAC;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;gBAEd,IAAI,EAAE,cAAc,GAAG,eAAe,EAAE,KAAK,EAAE,CAAC,CAAC,QAAQ;CAMtE;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAM1D;AAED,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAM5D"}

package/dist/graph/types.d.ts

@@ -0,0 +1,40 @@
+import type { ErrorClass, GraphEventType, GraphEventV1, GraphNode, GraphSpecV1, NodeID, NodeRole } from "./schema";
+/**
+ * Tipos internos computados de Graph V1: estados de nodo/run, estado reducido y
+ * capacidades. No se parsean de entrada externa (los construye el reducer), por
+ * eso viven fuera de los esquemas Zod. Puro: sin I/O ni estado global.
+ */
+/** Estado persistente de un nodo. `pending` es el estado inicial. */
+export type NodeStatus = "pending" | "running" | "succeeded" | "failed" | "cancelled";
+/** Estado del run completo. */
+export type RunStatus = "running" | "completed" | "failed" | "cancelled";
+/** Estados terminales (no admiten más transiciones). */
+export declare const TERMINAL_NODE_STATUSES: ReadonlySet<NodeStatus>;
+export declare const TERMINAL_RUN_STATUSES: ReadonlySet<RunStatus>;
+/** Estado runtime de un nodo dentro del estado reducido. */
+export type NodeRuntimeState = {
+    status: NodeStatus;
+    attempts: number;
+    operationID?: string;
+    attemptID?: string;
+    artifactSha256?: string;
+};
+/** Estado reducido y determinista de un run. */
+export type GraphState = {
+    runID: string;
+    status: RunStatus;
+    /** Seq del último evento aplicado; -1 antes de `run.started`. */
+    seq: number;
+    specDigest?: string;
+    nodes: Record<string, NodeRuntimeState>;
+};
+/** Capacidad que un efecto puede planificar. */
+export type Capability = "read" | "edit" | "shell" | "network" | "destructive";
+/** Nodo listo para despacho, con sus IDs deterministas ya calculados. */
+export type ReadyNode = {
+    nodeID: NodeID;
+    operationID: string;
+    attemptID: string;
+};
+export type { ErrorClass, GraphEventType, GraphEventV1, GraphNode, GraphSpecV1, NodeID, NodeRole, };
+//# sourceMappingURL=types.d.ts.map

package/dist/graph/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/graph/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,cAAc,EACd,YAAY,EACZ,SAAS,EACT,WAAW,EACX,MAAM,EACN,QAAQ,EACT,MAAM,UAAU,CAAC;AAElB;;;;GAIG;AAEH,qEAAqE;AACrE,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,SAAS,GACT,WAAW,GACX,QAAQ,GACR,WAAW,CAAC;AAEhB,+BAA+B;AAC/B,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEzE,wDAAwD;AACxD,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,UAAU,CAGzD,CAAC;AACH,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,SAAS,CAIvD,CAAC;AAEH,4DAA4D;AAC5D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,gDAAgD;AAChD,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,CAAC;IAClB,iEAAiE;IACjE,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACzC,CAAC;AAEF,gDAAgD;AAChD,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,aAAa,CAAC;AAE/E,yEAAyE;AACzE,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,YAAY,EACV,UAAU,EACV,cAAc,EACd,YAAY,EACZ,SAAS,EACT,WAAW,EACX,MAAM,EACN,QAAQ,GACT,CAAC"}

package/dist/graph/validate.d.ts

@@ -0,0 +1,19 @@
+import type { GraphSpecV1 } from "./schema";
+/**
+ * Validación estructural pura de un `GraphSpecV1` ya conforme al esquema.
+ * Detecta de forma **determinista** duplicados, dependencias colgantes, ciclos,
+ * violaciones de rol/review y grafos desconectados. Sin I/O ni estado global.
+ */
+export type GraphValidationCode = "duplicate-node" | "missing-dependency" | "cycle" | "implementer-has-review" | "reviewer-missing-review" | "self-review" | "invalid-review-target" | "disconnected";
+/** Error tipado de validación estructural. */
+export declare class GraphValidationError extends Error {
+    readonly code: GraphValidationCode;
+    readonly detail: string;
+    constructor(code: GraphValidationCode, detail: string);
+}
+/**
+ * Valida la estructura del DAG. Lanza `GraphValidationError` en el primer fallo,
+ * en orden determinista. No devuelve nada si el spec es válido.
+ */
+export declare function validateGraphSpec(spec: GraphSpecV1): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/graph/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/graph/validate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvD;;;;GAIG;AAEH,MAAM,MAAM,mBAAmB,GAC3B,gBAAgB,GAChB,oBAAoB,GACpB,OAAO,GACP,wBAAwB,GACxB,yBAAyB,GACzB,aAAa,GACb,uBAAuB,GACvB,cAAc,CAAC;AAEnB,8CAA8C;AAC9C,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM;CAMtD;AAqHD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAMzD"}

package/dist/index.js

@@ -336,6 +336,11 @@ var PrivacyModeSchema = z.enum([
   "off"
 ]);
 var BaselineModeSchema = z.enum(["auto", "pinned"]);
+var GraphModeSchema = z.enum(["off", "shadow", "active"]);
+var GraphConfigSchema = z.object({
+  mode: GraphModeSchema.default("off"),
+  killSwitch: z.boolean().default(false)
+});
 var ConsoleHostSchema = z.enum(["127.0.0.1", "localhost"]);
 var ConsoleConfigSchema = z.object({
   host: ConsoleHostSchema.default("127.0.0.1"),
@@ -477,7 +482,8 @@ var OpenTeamConfigObjectSchema = z.object({
   privacyMode: PrivacyModeSchema.default("forceLocalOnSensitive"),
   console: ConsoleConfigSchema,
   storage: StorageConfigSchema,
-  memory: MemoryConfigSchema.optional()
+  memory: MemoryConfigSchema.optional(),
+  graph: GraphConfigSchema.optional()
 });
 var OpenTeamConfigSchema = OpenTeamConfigObjectSchema;
 function resolveMemorySemantic(config) {
@@ -498,9 +504,40 @@ async function writeOpenTeamConfigFile(config, path = DEFAULT_CONFIG_PATH, stora
 // src/commands/setup.ts
 var OPENCODE_CONFIG_PATH = "opencode.json";
 
+// src/config/migrations.ts
+var CURRENT_CONFIG_VERSION = 1;
+
+class ConfigMigrationError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "ConfigMigrationError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+function migrateConfig(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return raw;
+  }
+  const record = raw;
+  const version = record.configVersion;
+  if (version === undefined) {
+    return { ...record, configVersion: CURRENT_CONFIG_VERSION };
+  }
+  if (typeof version !== "number" || !Number.isInteger(version) || version < 1) {
+    throw new ConfigMigrationError("unknown-version", String(version));
+  }
+  if (version > CURRENT_CONFIG_VERSION) {
+    throw new ConfigMigrationError("unsupported-version", String(version));
+  }
+  return record;
+}
+
 // src/config/load.ts
 function loadOpenTeamConfig(raw) {
-  return OpenTeamConfigSchema.parse(raw ?? {});
+  return OpenTeamConfigSchema.parse(migrateConfig(raw ?? {}));
 }
 
 // src/local/openai-compatible.ts

package/dist/orchestrator/graphCancellation.d.ts

@@ -0,0 +1,84 @@
+import type { GraphState, NodeStatus, RunStatus } from "../graph/types";
+/**
+ * Políticas puras de cancelación, timeout y compleción tardía (GE-034).
+ *
+ * Deciden, sin I/O ni reloj, qué hacer ante tres situaciones del runtime de
+ * Graph. El runtime les inyecta la evidencia ya observada (estado del nodo, si
+ * ya se pidió el abort, si expiró la ventana de gracia) y aplica el resultado:
+ *
+ * - `timeoutAction`: en un timeout se pide **primero** el abort y solo se
+ *   reconcilia tras agotar una ventana de gracia acotada; un nodo no `running`
+ *   no tiene nada que expirar.
+ * - `planCancellation`: cancelar un run en curso cancela sus nodos `pending` y
+ *   `running` (así los `pending` no llegan a despacharse) y pide abort de los
+ *   `running`; cancelar un run ya terminal es un no-op idempotente.
+ * - `classifyLateCompletion`: un resultado que llega tarde se **audita** pero no
+ *   puede revivir un intento cancelado, superado (otro `attemptID`/`operationID`)
+ *   ni de un run ya terminal.
+ *
+ * Todo es determinista: la misma evidencia produce la misma decisión, de modo
+ * que se reproduce igual tras un reinicio.
+ */
+/** Acción de timeout sobre el nodo en vuelo. */
+export type TimeoutAction = "noop" | "request-abort" | "awaiting-grace" | "reconcile";
+/** Evidencia inyectada para decidir el timeout de un nodo. */
+export type TimeoutInput = {
+    readonly nodeStatus: NodeStatus;
+    /** `true` si el runtime ya solicitó el abort de este intento. */
+    readonly abortRequested: boolean;
+    /** `true` si la ventana de gracia acotada ya expiró. */
+    readonly graceExceeded: boolean;
+};
+/**
+ * Decide la acción de timeout. Solo un nodo `running` puede expirar: si aún no
+ * se pidió el abort, se pide; si ya se pidió, se espera hasta agotar la gracia y
+ * entonces se reconcilia. Un nodo no `running` es un no-op.
+ */
+export declare function timeoutAction(input: TimeoutInput): TimeoutAction;
+/** Plan determinista de cancelación de un run. */
+export type CancellationPlan = {
+    /** `true` si el run sigue en curso y debe marcarse `cancelled`. */
+    readonly cancelRun: boolean;
+    /** Nodos a marcar `cancelled` (los `pending` y `running`), en orden estable. */
+    readonly cancelNodeIDs: readonly string[];
+    /** Nodos `running` cuyo efecto debe abortarse, en orden estable. */
+    readonly abortNodeIDs: readonly string[];
+};
+/**
+ * Planifica la cancelación del run. Cancela los nodos `pending` (para que no
+ * lleguen a despacharse) y `running`, y pide abort de los `running`. Un run ya
+ * terminal no vuelve a cancelarse y no deja nodos por cancelar (idempotente).
+ */
+export declare function planCancellation(state: GraphState): CancellationPlan;
+/** Motivo por el que una compleción tardía se descarta. */
+export type LateCompletionReason = "run-terminal" | "unknown-node" | "not-running" | "superseded";
+/** Veredicto sobre un recibo que llega tarde. */
+export type LateCompletionVerdict = {
+    readonly kind: "apply";
+} | {
+    readonly kind: "stale";
+    readonly reason: LateCompletionReason;
+};
+/** Estado mínimo del nodo destino del recibo tardío. */
+export type LateCompletionNode = {
+    readonly status: NodeStatus;
+    readonly operationID?: string;
+    readonly attemptID?: string;
+};
+/** Entrada para clasificar una compleción tardía. */
+export type LateCompletionInput = {
+    readonly runStatus: RunStatus;
+    readonly node: LateCompletionNode | undefined;
+    readonly receipt: {
+        readonly operationID: string;
+        readonly attemptID: string;
+    };
+};
+/**
+ * Clasifica un recibo tardío. Solo se aplica al intento `running` vigente con
+ * `operationID`/`attemptID` coincidentes; en cualquier otro caso (run terminal,
+ * nodo desconocido, nodo no `running`, intento superado) se marca `stale` para
+ * auditarlo sin mutar el estado.
+ */
+export declare function classifyLateCompletion(input: LateCompletionInput): LateCompletionVerdict;
+//# sourceMappingURL=graphCancellation.d.ts.map

package/dist/orchestrator/graphCancellation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphCancellation.d.ts","sourceRoot":"","sources":["../../src/orchestrator/graphCancellation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAExE;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,gDAAgD;AAChD,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,eAAe,GACf,gBAAgB,GAChB,WAAW,CAAC;AAEhB,8DAA8D;AAC9D,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,iEAAiE;IACjE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,wDAAwD;IACxD,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,aAAa,CAQhE;AAED,kDAAkD;AAClD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,oEAAoE;IACpE,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,gBAAgB,CAiBpE;AAED,2DAA2D;AAC3D,MAAM,MAAM,oBAAoB,GAC5B,cAAc,GACd,cAAc,GACd,aAAa,GACb,YAAY,CAAC;AAEjB,iDAAiD;AACjD,MAAM,MAAM,qBAAqB,GAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;CAAE,CAAC;AAEtE,wDAAwD;AACxD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,qDAAqD;AACrD,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE;QAChB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,mBAAmB,GACzB,qBAAqB,CAkBvB"}

package/dist/orchestrator/graphEffects.d.ts

@@ -0,0 +1,63 @@
+import type { ContextRef, PrivacyClass } from "../context/schema";
+import { type PrivacyMode, type RouteKind } from "../graph/privacyPolicy";
+import type { ErrorClass, GraphNode } from "../graph/schema";
+/**
+ * `GraphEffectExecutor` — puerto del único efecto que el runtime de Graph
+ * (GE-031) ejecuta por nodo. El runtime commitea la intención (`node.dispatched`)
+ * en el journal **antes** de invocar `execute`, y el recibo (`node.succeeded` o
+ * `node.failed`) **después**; el executor solo produce el resultado del efecto.
+ *
+ * Este módulo es solo tipos: sin I/O, SDK, storage ni estado global. El runtime
+ * recibe un executor inyectado; en producción lo implementará el adaptador de
+ * sesión de opencode (GE-030), y en tests un doble determinista. Mantener el
+ * seam como puerto permite probar el runtime sin red ni SDK reales.
+ */
+/** Solicitud de ejecución de un efecto para un nodo e intento concretos. */
+export type EffectRequest = {
+    readonly runID: string;
+    readonly node: GraphNode;
+    readonly operationID: string;
+    readonly attemptID: string;
+};
+/** Recibo de un efecto: éxito con artefacto referenciado, o fallo clasificado. */
+export type EffectReceipt = {
+    readonly outcome: "succeeded";
+    readonly artifact: ContextRef;
+} | {
+    readonly outcome: "failed";
+    readonly errorClass: ErrorClass;
+};
+/** Ejecutor inyectable del efecto de un nodo. Determinista dado el request. */
+export interface GraphEffectExecutor {
+    execute(request: EffectRequest): Promise<EffectReceipt>;
+}
+/**
+ * Contexto de privacidad de un despacho: clase de privacidad del nodo, modo
+ * efectivo de la config y ruta preferida por el router. Deja al seam de efectos
+ * la decisión reference-only/frontier antes y después de invocar al executor.
+ */
+export type EffectDispatchContext = {
+    readonly privacyClass: PrivacyClass;
+    readonly mode: PrivacyMode;
+    readonly routeKind: RouteKind;
+};
+/**
+ * Resuelve la ruta **efectiva** de un despacho (GE-037). Si la política prohíbe
+ * frontier para la clase de privacidad bajo el modo activo, degrada a `local`
+ * en vez de lanzar: un nodo `sensitive` con `forceLocalOnSensitive` produce
+ * **cero** despachos a frontier. Puro y determinista.
+ */
+export declare function resolveDispatchRoute(privacyClass: PrivacyClass, mode: PrivacyMode, preferred: RouteKind): RouteKind;
+/**
+ * Gate de privacidad **antes** de invocar al executor: lanza
+ * `PrivacyPolicyError` si un nodo `sensitive` bajo `forceLocalOnSensitive`
+ * intenta una ruta frontier.
+ */
+export declare function assertDispatchAllowed(ctx: EffectDispatchContext): void;
+/**
+ * Gate reference-only **después** del executor: el recibo solo puede llevar una
+ * `ContextRef` (éxito) o una clase de error (fallo); lanza `RedactionError` si
+ * alguna estructura transporta un campo de contenido crudo.
+ */
+export declare function assertReceiptReferenceOnly(receipt: EffectReceipt): void;
+//# sourceMappingURL=graphEffects.d.ts.map

package/dist/orchestrator/graphEffects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphEffects.d.ts","sourceRoot":"","sources":["../../src/orchestrator/graphEffects.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,SAAS,EACf,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE7D;;;;;;;;;;GAUG;AAEH,4EAA4E;AAC5E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,kFAAkF;AAClF,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAEpE,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CACzD;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;CAC/B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,SAAS,GACnB,SAAS,CAIX;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,qBAAqB,GAAG,IAAI,CAEtE;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAEvE"}