@jmanuelcorral/openteam 0.1.40 → 0.1.42

package/dist/graph/events.d.ts

@@ -0,0 +1,25 @@
+import type { ContextRef } from "../context/schema";
+import type { ErrorClass, GraphEventType, GraphEventV1 } from "./schema";
+/**
+ * Constructores y type guards para el sobre de eventos de Graph V1.
+ *
+ * Los constructores producen literales ya conformes al esquema (no validan;
+ * validar es `parseGraphEvent`). Puro: sin I/O ni estado global.
+ */
+/** Lista exhaustiva de tipos de evento, en orden estable. */
+export declare const EVENT_TYPES: readonly GraphEventType[];
+export declare function runStarted(runID: string, seq: number, specDigest: string): GraphEventV1;
+export declare function nodeDispatched(runID: string, seq: number, nodeID: string, operationID: string, attemptID: string): GraphEventV1;
+export declare function nodeSucceeded(runID: string, seq: number, nodeID: string, operationID: string, attemptID: string, artifact: ContextRef): GraphEventV1;
+export declare function nodeFailed(runID: string, seq: number, nodeID: string, operationID: string, attemptID: string, errorClass: ErrorClass): GraphEventV1;
+export declare function nodeCancelled(runID: string, seq: number, nodeID: string): GraphEventV1;
+export declare function runCompleted(runID: string, seq: number): GraphEventV1;
+export declare function runFailed(runID: string, seq: number): GraphEventV1;
+export declare function runCancelled(runID: string, seq: number): GraphEventV1;
+/** Evento que afecta a un nodo concreto (lleva `nodeID`). */
+export type NodeEvent = Extract<GraphEventV1, {
+    nodeID: string;
+}>;
+export declare function isNodeEvent(event: GraphEventV1): event is NodeEvent;
+export declare function isRunEvent(event: GraphEventV1): boolean;
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/graph/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGzE;;;;;GAKG;AAEH,6DAA6D;AAC7D,eAAO,MAAM,WAAW,EAAE,SAAS,cAAc,EAShD,CAAC;AAEF,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,GACjB,YAAY,CAQd;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,YAAY,CAUd;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,UAAU,GACnB,YAAY,CAWd;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,UAAU,GACrB,YAAY,CAWd;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GACb,YAAY,CAEd;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,YAAY,CAErE;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,YAAY,CAElE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,YAAY,CAErE;AAED,6DAA6D;AAC7D,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAElE,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,IAAI,SAAS,CAOnE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAEvD"}

package/dist/graph/ids.d.ts

@@ -0,0 +1,5 @@
+/** ID estable del efecto de un nodo, opcionalmente por revisión. */
+export declare function operationID(runID: string, nodeID: string, revision?: number): string;
+/** ID del intento `attempt` (>= 0) de una operación dada. */
+export declare function attemptID(operation: string, attempt: number): string;
+//# sourceMappingURL=ids.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/graph/ids.ts"],"names":[],"mappings":"AAYA,oEAAoE;AACpE,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,SAAI,GACX,MAAM,CAKR;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpE"}

package/dist/graph/planner.d.ts

@@ -0,0 +1,15 @@
+import type { GraphSpecV1 } from "./schema";
+import type { GraphState, ReadyNode } from "./types";
+/**
+ * Planificador determinista del conjunto listo (ready-set).
+ *
+ * Un nodo está listo si el run sigue `running`, el nodo está `pending` y todas
+ * sus dependencias están `succeeded`. El orden es estable (por id). La
+ * cancelación del run —o de una dependencia— bloquea el despacho. IDs
+ * reproducibles vía `ids.ts`. Puro: sin I/O, reloj ni random.
+ */
+/** IDs de nodo listos, en orden estable. */
+export declare function readyNodeIDs(spec: GraphSpecV1, state: GraphState): string[];
+/** Plan de despacho: nodos listos con sus IDs deterministas de operación. */
+export declare function plan(spec: GraphSpecV1, state: GraphState): ReadyNode[];
+//# sourceMappingURL=planner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../src/graph/planner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAErD;;;;;;;GAOG;AAEH,4CAA4C;AAC5C,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAiB3E;AAED,6EAA6E;AAC7E,wBAAgB,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,GAAG,SAAS,EAAE,CAUtE"}

package/dist/graph/policies.d.ts

@@ -0,0 +1,34 @@
+import type { ErrorClass } from "./schema";
+/**
+ * Políticas puras de transición y reintento. Deterministas: sin reloj, jitter
+ * oculto ni random. Incluye la taxonomía reutilizable, el límite por defecto y
+ * el backoff determinista (GE-033); el runtime aplica límites y expone el
+ * retardo sin dormir por su cuenta.
+ */
+/** Límite de intentos por defecto para un error reintentable. */
+export declare const DEFAULT_RETRY_LIMIT = 3;
+/** Número de revisiones por defecto que puede encadenar un rechazo (GE-036). */
+export declare const DEFAULT_REVISION_LIMIT = 2;
+/**
+ * `true` si se permite otra revisión: `currentRevision` (revisiones ya hechas,
+ * 0 la implementación inicial) aún no alcanza el límite. Determinista.
+ */
+export declare function revisionAllowed(currentRevision: number, limit?: number): boolean;
+/** Base en milisegundos del backoff exponencial determinista. */
+export declare const DEFAULT_BACKOFF_BASE_MS = 100;
+/**
+ * Retardo determinista (ms) antes del intento `attempt` (índice basado en 0).
+ * El primer intento (`attempt <= 0`) no espera; a partir de ahí crece de forma
+ * exponencial (`base * 2^(attempt-1)`). Función pura: sin reloj, jitter ni
+ * random, de modo que la misma secuencia se reproduce tras un reinicio. El
+ * runtime la expone en el resultado del paso; no duerme por su cuenta.
+ */
+export declare function backoffDelayMs(attempt: number, baseMs?: number): number;
+/** `true` si la clase de error justifica un reintento con nuevo intento. */
+export declare function isRetryableError(errorClass: ErrorClass): boolean;
+/**
+ * `true` si se permite otro intento: el error es reintentable y aún no se han
+ * agotado los intentos. `attempts` es el número de intentos ya consumidos.
+ */
+export declare function retryAllowed(errorClass: ErrorClass, attempts: number, limit?: number): boolean;
+//# sourceMappingURL=policies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"policies.d.ts","sourceRoot":"","sources":["../../src/graph/policies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C;;;;;GAKG;AAEH,iEAAiE;AACjE,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,gFAAgF;AAChF,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,eAAe,EAAE,MAAM,EACvB,KAAK,GAAE,MAA+B,GACrC,OAAO,CAET;AAED,iEAAiE;AACjE,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,MAAgC,GACvC,MAAM,CAKR;AAED,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAEhE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,MAAM,EAChB,KAAK,GAAE,MAA4B,GAClC,OAAO,CAET"}

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,14 @@ 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),
+  worktrees: z.object({
+    enabled: z.boolean().default(false)
+  }).default({ enabled: false })
+});
 var ConsoleHostSchema = z.enum(["127.0.0.1", "localhost"]);
 var ConsoleConfigSchema = z.object({
   host: ConsoleHostSchema.default("127.0.0.1"),
@@ -348,7 +356,10 @@ var ConsoleConfigSchema = z.object({
   terminal: z.object({
     enabled: z.boolean().default(true),
     pty: z.boolean().optional()
-  }).default({ enabled: true })
+  }).default({ enabled: true }),
+  graphView: z.object({
+    enabled: z.boolean().default(false)
+  }).optional()
 }).default({
   host: "127.0.0.1",
   port: 4599,
@@ -477,7 +488,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 +510,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