@jmanuelcorral/openteam 0.1.40 → 0.1.41

package/AGENTS.md

@@ -33,6 +33,21 @@ openteam is an opencode plugin built with **TypeScript + Bun** with **local-firs
 - TypeScript strict, ESM only, Zod at boundaries.
 - Biome governs lint/format; do not introduce ESLint/Prettier unless a new decision is made.
 
+## Test-first with Gherkin
+
+- **Default workflow for behavioral work is Test-First with Gherkin.** Before implementing a
+  story in `src/graph/**`, `src/context/**`, `src/storage/graph/**`, or `src/orchestrator/**`,
+  first write the `.feature` scenarios derived from the story's "Testable acceptance", watch
+  them fail, then implement until green.
+- Functional tests run on the in-repo, **dependency-free** Gherkin harness at
+  `tests/functional/gherkin/` (parser + runner). Do not add Cucumber or any BDD dependency:
+  it would violate the supply-chain policy.
+- Feature files live under `tests/functional/features/**`; step definitions are inlined in the
+  matching `tests/functional/*.test.ts` so they do not drag coverage. Steps drive the **real**
+  modules; only injected I/O ports (filesystem, clock, session client) may be deterministic fakes.
+- Backfill is incremental: as we touch or extend an area, add the missing Gherkin coverage and
+  pay down technical debt rather than leaving gaps.
+
 ## Non-negotiables
 
 - No merge without tests, coverage, typecheck, lint/format, and determinism green.

package/README.es.md

@@ -727,7 +727,7 @@ Consulta [docs/compatibility.md](docs/compatibility.md). Resumen verificado el `
 
 | Superficie | Versión / contrato |
 | --- | --- |
-| openteam | `0.1.40`; versión actual del paquete |
+| openteam | `0.1.41`; versión actual del paquete |
 | `@opencode-ai/plugin` | `1.17.13` |
 | `@opencode-ai/sdk` | `1.17.13` |
 | Hook de routing | `chat.message`; no `chat.params` para cambiar modelo |

package/README.md

@@ -344,7 +344,7 @@ See [docs/compatibility.md](docs/compatibility.md). Verified summary as of `2026
 
 | Surface | Version / contract |
 | --- | --- |
-| openteam | `0.1.40`; current package version |
+| openteam | `0.1.41`; current package version |
 | `@opencode-ai/plugin` | `1.17.13` |
 | `@opencode-ai/sdk` | `1.17.13` |
 | Routing hook | `chat.message`; not `chat.params` for model changes |

package/dist/cli.js

@@ -628,6 +628,11 @@ var PrivacyModeSchema = z3.enum([
   "off"
 ]);
 var BaselineModeSchema = z3.enum(["auto", "pinned"]);
+var GraphModeSchema = z3.enum(["off", "shadow", "active"]);
+var GraphConfigSchema = z3.object({
+  mode: GraphModeSchema.default("off"),
+  killSwitch: z3.boolean().default(false)
+});
 var ConsoleHostSchema = z3.enum(["127.0.0.1", "localhost"]);
 var ConsoleConfigSchema = z3.object({
   host: ConsoleHostSchema.default("127.0.0.1"),
@@ -769,7 +774,8 @@ var OpenTeamConfigObjectSchema = z3.object({
   privacyMode: PrivacyModeSchema.default("forceLocalOnSensitive"),
   console: ConsoleConfigSchema,
   storage: StorageConfigSchema,
-  memory: MemoryConfigSchema.optional()
+  memory: MemoryConfigSchema.optional(),
+  graph: GraphConfigSchema.optional()
 });
 var OpenTeamConfigSchema = OpenTeamConfigObjectSchema;
 function resolveMemorySemantic(config) {
@@ -5123,9 +5129,40 @@ async function runSetup(deps) {
   }
 }
 
+// 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/memory/types.ts

package/dist/commands/graph.d.ts

@@ -0,0 +1,65 @@
+import type { ConfigSource } from "../config/resolve";
+import type { GraphMode } from "../config/schema";
+import type { LeaseRecord } from "../storage/graph/workspaceLease";
+/**
+ * GE-045 — operator commands for the graph runtime as pure dry-run plans.
+ *
+ * These functions never touch I/O: the caller reads the journal, lease, and
+ * config health, hands a settled snapshot here, and this module renders the
+ * operator view and decides which action is safe. Execution (recover/cancel)
+ * happens in the wiring layer only when a plan authorises it.
+ *
+ * Safety contract:
+ *   - Commands are idempotent: a settled state plans `none`.
+ *   - Recovering a corrupt journal is blocked unless the operator explicitly
+ *     acknowledges the unsafe reconciliation.
+ *   - Cancelling a run held by another holder (a stale takeover) is blocked
+ *     unless the operator explicitly forces it.
+ */
+/** Health of the on-disk journal tail as classified by recovery. */
+export type GraphJournalHealth = "clean" | "recovered" | "corrupt";
+/** Settled, side-effect-free view of the graph runtime for the operator. */
+export type GraphHealthSnapshot = {
+    /** Where the effective graph config was resolved from. */
+    readonly source: ConfigSource;
+    /** Effective graph mode after config resolution. */
+    readonly effectiveMode: GraphMode;
+    /** Current workspace lease, or `undefined` when no run is active. */
+    readonly lease: LeaseRecord | undefined;
+    /** Journal tail health. */
+    readonly journal: GraphJournalHealth;
+    /** Committed effects still awaiting a receipt. */
+    readonly pendingEffects: number;
+    /** Effects whose outcome is unknown and require reconciliation. */
+    readonly unknownEffects: number;
+};
+/** Action an operator command would take, decided without executing it. */
+export type GraphActionKind = "none" | "recover" | "cancel" | "blocked";
+/** Result of planning an operator command. */
+export type GraphActionPlan = {
+    /** What the command would do. */
+    readonly kind: GraphActionKind;
+    /** Stable machine-readable reason for the decision. */
+    readonly reason: string;
+    /** `true` when the action preserves invariants without operator override. */
+    readonly safe: boolean;
+};
+/** Options for planning a journal recovery. */
+export type GraphRecoverOptions = {
+    /** Operator explicitly accepts an unsafe reconciliation of a corrupt tail. */
+    readonly acknowledgeUnsafe?: boolean;
+};
+/** Options for planning a run cancellation. */
+export type GraphCancelOptions = {
+    /** Identity of the operator requesting the cancel. */
+    readonly holder: string;
+    /** Operator explicitly accepts taking over a run held by someone else. */
+    readonly force?: boolean;
+};
+/** Render the operator-facing status view of a graph health snapshot. */
+export declare function renderGraphStatus(snapshot: GraphHealthSnapshot): string;
+/** Decide whether recovering the journal tail is a safe, idempotent action. */
+export declare function planGraphRecover(snapshot: GraphHealthSnapshot, options?: GraphRecoverOptions): GraphActionPlan;
+/** Decide whether cancelling the active run is a safe, idempotent action. */
+export declare function planGraphCancel(snapshot: GraphHealthSnapshot, options: GraphCancelOptions): GraphActionPlan;
+//# sourceMappingURL=graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/commands/graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEnE;;;;;;;;;;;;;;GAcG;AAEH,oEAAoE;AACpE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,WAAW,GAAG,SAAS,CAAC;AAEnE,4EAA4E;AAC5E,MAAM,MAAM,mBAAmB,GAAG;IAChC,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,oDAAoD;IACpD,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAC;IAClC,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,CAAC;IACxC,2BAA2B;IAC3B,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,kDAAkD;IAClD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,mEAAmE;IACnE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,2EAA2E;AAC3E,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAExE,8CAA8C;AAC9C,MAAM,MAAM,eAAe,GAAG;IAC5B,iCAAiC;IACjC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,+CAA+C;AAC/C,MAAM,MAAM,mBAAmB,GAAG;IAChC,8EAA8E;IAC9E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC,CAAC;AAEF,+CAA+C;AAC/C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAUF,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM,CAkBvE;AAED,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,GAAE,mBAAwB,GAChC,eAAe,CAejB;AAED,6EAA6E;AAC7E,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,kBAAkB,GAC1B,eAAe,CAejB"}

package/dist/config/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/config/load.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,UAAU,CAAC;AAErE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,cAAc,CAE/D;AAED,wBAAsB,sBAAsB,CAC1C,IAAI,SAA4B,EAChC,OAAO,GAAE,eAAwD,GAChE,OAAO,CAAC,cAAc,CAAC,CAMzB"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/config/load.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,UAAU,CAAC;AAErE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,cAAc,CAE/D;AAED,wBAAsB,sBAAsB,CAC1C,IAAI,SAA4B,EAChC,OAAO,GAAE,eAAwD,GAChE,OAAO,CAAC,cAAc,CAAC,CAMzB"}

package/dist/config/migrations.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Migración **versionada** de la config de openteam (GE-040).
+ *
+ * La config declara opcionalmente `configVersion`. Cuando falta se asume la
+ * versión actual (config legacy). Una versión no entera/positiva es
+ * `unknown-version`; una versión futura mayor que la soportada es
+ * `unsupported-version`. La migración es pura: normaliza la entrada para el
+ * parseo de esquema y **falla cerrado** ante versiones no soportadas, de modo
+ * que CLI y plugin comparten exactamente la misma resolución.
+ */
+/** Versión de config soportada por esta build. */
+export declare const CURRENT_CONFIG_VERSION: 1;
+/** Código de fallo de migración de config. */
+export type ConfigMigrationErrorCode = "unknown-version" | "unsupported-version";
+/** Error tipado de una migración de config rechazada. */
+export declare class ConfigMigrationError extends Error {
+    readonly code: ConfigMigrationErrorCode;
+    readonly detail: string;
+    constructor(code: ConfigMigrationErrorCode, detail: string);
+}
+/**
+ * Normaliza la config cruda a la versión actual. Devuelve la entrada intacta si
+ * no es un objeto (el parseo de esquema la rechazará); en caso contrario valida
+ * `configVersion` y falla cerrado ante versiones desconocidas o futuras.
+ */
+export declare function migrateConfig(raw: unknown): unknown;
+//# sourceMappingURL=migrations.d.ts.map

package/dist/config/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../src/config/migrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,kDAAkD;AAClD,eAAO,MAAM,sBAAsB,EAAG,CAAU,CAAC;AAEjD,8CAA8C;AAC9C,MAAM,MAAM,wBAAwB,GAChC,iBAAiB,GACjB,qBAAqB,CAAC;AAE1B,yDAAyD;AACzD,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,IAAI,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM;CAM3D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAoBnD"}

package/dist/config/resolve.d.ts

@@ -0,0 +1,34 @@
+import type { GraphMode, OpenTeamConfig } from "./schema";
+/**
+ * Resolver **efectivo** y compartido de la config de Graph (GE-040).
+ *
+ * CLI y plugin resuelven a través de esta única función, así que una misma
+ * config produce exactamente el mismo resultado en ambos. Reglas:
+ *
+ * - **Default off**: sin sección `graph`, el modo efectivo es `off`.
+ * - **Kill switch en vivo**: si `killSwitch` está activo, el modo efectivo es
+ *   `off` sea cual sea el modo configurado.
+ * - **Shadow sin executor**: solo `active` habilita el executor; `shadow` y
+ *   `off` no reciben executor.
+ * - **Fuente visible**: el origen de la config se propaga al resultado.
+ *
+ * Puro: sin I/O, reloj ni estado global.
+ */
+/** Origen de la config resuelta (para trazabilidad/observabilidad). */
+export type ConfigSource = "file" | "inline" | "default";
+/** Resolución efectiva de la config de Graph. */
+export type ResolvedGraphConfig = {
+    /** Modo declarado en la config (default `off`). */
+    readonly configuredMode: GraphMode;
+    /** Modo efectivo tras aplicar el kill switch. */
+    readonly effectiveMode: GraphMode;
+    /** Solo `active` habilita el executor. */
+    readonly executorEnabled: boolean;
+    /** Kill switch en vivo. */
+    readonly killSwitch: boolean;
+    /** Origen de la config. */
+    readonly source: ConfigSource;
+};
+/** Resuelve la config de Graph efectiva a partir de la config y su origen. */
+export declare function resolveGraphConfig(config: OpenTeamConfig, source: ConfigSource): ResolvedGraphConfig;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/config/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/config/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AAEH,uEAAuE;AACvE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEzD,iDAAiD;AACjD,MAAM,MAAM,mBAAmB,GAAG;IAChC,mDAAmD;IACnD,QAAQ,CAAC,cAAc,EAAE,SAAS,CAAC;IACnC,iDAAiD;IACjD,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAC;IAClC,0CAA0C;IAC1C,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,2BAA2B;IAC3B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,2BAA2B;IAC3B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B,CAAC;AAEF,8EAA8E;AAC9E,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,YAAY,GACnB,mBAAmB,CAWrB"}

package/dist/config/schema.d.ts

@@ -17,6 +17,27 @@ export declare const BaselineModeSchema: z.ZodEnum<{
     auto: "auto";
     pinned: "pinned";
 }>;
+/**
+ * Modo del subsistema Graph (GE-040). `off` mantiene el camino legacy; `shadow`
+ * observa sin ejecutar efectos; `active` habilita el executor. Default `off`.
+ */
+export declare const GraphModeSchema: z.ZodEnum<{
+    off: "off";
+    shadow: "shadow";
+    active: "active";
+}>;
+/**
+ * Sección `graph` de la config. Opcional: cuando falta, el resolver aplica
+ * `off`. Un `killSwitch` en vivo fuerza `off` sea cual sea el modo configurado.
+ */
+export declare const GraphConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        shadow: "shadow";
+        active: "active";
+    }>>;
+    killSwitch: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
 export declare const ConsoleHostSchema: z.ZodEnum<{
     "127.0.0.1": "127.0.0.1";
     localhost: "localhost";
@@ -298,6 +319,14 @@ export declare const OpenTeamConfigObjectSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    graph: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            shadow: "shadow";
+            active: "active";
+        }>>;
+        killSwitch: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /** Esquema público de la config de openteam. */
 export declare const OpenTeamConfigSchema: z.ZodObject<{
@@ -424,10 +453,20 @@ export declare const OpenTeamConfigSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    graph: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            shadow: "shadow";
+            active: "active";
+        }>>;
+        killSwitch: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ModelRef = z.infer<typeof ModelRefSchema>;
 export type RouterMode = z.infer<typeof RouterModeSchema>;
 export type PrivacyMode = z.infer<typeof PrivacyModeSchema>;
+export type GraphMode = z.infer<typeof GraphModeSchema>;
+export type GraphConfig = z.infer<typeof GraphConfigSchema>;
 export type OpenTeamConfig = z.infer<typeof OpenTeamConfigSchema>;
 export type LocalRuntime = z.infer<typeof LocalRuntimeSchema>;
 export type ConsoleConfig = z.infer<typeof ConsoleConfigSchema>;

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/config/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;iBAGzB,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;EAA6C,CAAC;AAC3E,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAC;AACH,eAAO,MAAM,kBAAkB;;;EAA6B,CAAC;AAE7D,eAAO,MAAM,iBAAiB;;;EAAqC,CAAC;AAEpE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;kBAmC5B,CAAC;AAEL;;GAEG;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;kBAW5B,CAAC;AAWL,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAM7B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;EAA8B,CAAC;AAC7D,eAAO,MAAM,0BAA0B;;;EAGrC,CAAC;AACH,eAAO,MAAM,8BAA8B;;;EAA4B,CAAC;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkD7B,CAAC;AAEL;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE7B,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DrC,CAAC;AAEH,gDAAgD;AAChD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA6B,CAAC;AAE/D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,GACrB,oBAAoB,CAEtB"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/config/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;iBAGzB,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;EAA6C,CAAC;AAC3E,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAC;AACH,eAAO,MAAM,kBAAkB;;;EAA6B,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;EAAsC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;iBAG5B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;EAAqC,CAAC;AAEpE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;kBAmC5B,CAAC;AAEL;;GAEG;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;kBAW5B,CAAC;AAWL,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAM7B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;EAA8B,CAAC;AAC7D,eAAO,MAAM,0BAA0B;;;EAGrC,CAAC;AACH,eAAO,MAAM,8BAA8B;;;EAA4B,CAAC;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkD7B,CAAC;AAEL;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE7B,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgErC,CAAC;AAEH,gDAAgD;AAChD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA6B,CAAC;AAE/D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,GACrB,oBAAoB,CAEtB"}

package/dist/context/redaction.d.ts

@@ -0,0 +1,48 @@
+import type { ContextRef, ManifestEntry } from "./schema";
+/**
+ * Utilidades de **redacción** del seam de contexto.
+ *
+ * Calcula digests SHA-256 estables y construye entradas de manifiesto a partir
+ * de contenido en memoria **sin persistirlo**. También ofrece un guard que
+ * rechaza estructuras con campos de contenido crudo, para mantener journal,
+ * snapshots y telemetría solo con referencias.
+ *
+ * Cómputo determinista: `node:crypto` y `Buffer` no son I/O, reloj ni random.
+ */
+/** Error tipado de una violación de la política reference-only. */
+export declare class RedactionError extends Error {
+    readonly code: "raw-content";
+    readonly key: string;
+    constructor(key: string);
+}
+/** Digest SHA-256 en hex minúscula de una cadena UTF-8. */
+export declare function sha256Hex(input: string): string;
+/** Par digest + tamaño en bytes UTF-8 de un contenido en memoria. */
+export type Digest = {
+    sha256: string;
+    bytes: number;
+};
+/** Deriva el digest y el tamaño UTF-8 de un contenido, sin almacenarlo. */
+export declare function digestUtf8(text: string): Digest;
+/**
+ * Construye una entrada de manifiesto redactada a partir de contenido en
+ * memoria. Incluye la `ContextRef` solo si se aporta una referencia estable.
+ */
+export declare function buildManifestEntry(label: string, text: string, ref?: ContextRef): ManifestEntry;
+/**
+ * Proyección **reference-only** de una `ContextRef`: solo localización lógica,
+ * digest y tamaño. Descarta `mediaType` para mantener la telemetría acotada;
+ * nunca transporta contenido.
+ */
+export declare function redactedRef(ref: ContextRef): {
+    uri: string;
+    sha256: string;
+    bytes: number;
+};
+/**
+ * Recorre una estructura y lanza `RedactionError` si encuentra alguna clave de
+ * contenido crudo. Guard barato para journal/snapshots/telemetría; no valida
+ * esquema, solo ausencia de campos crudos.
+ */
+export declare function assertReferenceOnly(value: unknown): void;
+//# sourceMappingURL=redaction.d.ts.map

package/dist/context/redaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.d.ts","sourceRoot":"","sources":["../../src/context/redaction.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE1D;;;;;;;;;GASG;AAEH,mEAAmE;AACnE,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;gBAET,GAAG,EAAE,MAAM;CAMxB;AAED,2DAA2D;AAC3D,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,qEAAqE;AACrE,MAAM,MAAM,MAAM,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,2EAA2E;AAC3E,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK/C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,GAAG,CAAC,EAAE,UAAU,GACf,aAAa,CAKf;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,UAAU,GAAG;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAEA;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAkBxD"}

package/dist/context/schema.d.ts

@@ -0,0 +1,115 @@
+import { z } from "zod";
+/**
+ * Esquemas Zod del **seam de contexto** de Graph V1.
+ *
+ * Este módulo es la capa base pura: define referencias, digests y clases de
+ * privacidad que el resto de Graph consume. Solo transporta **referencias y
+ * digests**; nunca contenido crudo (brief, prompt, findings o salida del
+ * modelo). Todos los objetos usan `.strict()`, de modo que cualquier campo
+ * desconocido —incluidos campos de contenido crudo— falla con un error tipado.
+ *
+ * Prohibido en `src/context/**`: Prefill, llamadas al modelo, cache warming,
+ * filesystem y telemetría. `sha256Hex`/`digestUtf8` viven en `redaction.ts` y
+ * solo hacen cómputo determinista.
+ */
+/** Clase de privacidad de un artefacto o contrato de contexto. */
+export declare const PrivacyClassSchema: z.ZodEnum<{
+    public: "public";
+    internal: "internal";
+    sensitive: "sensitive";
+}>;
+export type PrivacyClass = z.infer<typeof PrivacyClassSchema>;
+/** Digest SHA-256 en hex minúscula (exactamente 64 caracteres). */
+export declare const Sha256Schema: z.ZodString;
+export type Sha256 = z.infer<typeof Sha256Schema>;
+/**
+ * Identificador estable (taskID, etiquetas de manifiesto). No es contenido:
+ * charset acotado y longitud limitada para mantener el seam determinista.
+ */
+export declare const IdentifierSchema: z.ZodString;
+export type Identifier = z.infer<typeof IdentifierSchema>;
+/**
+ * `TaskAnchor` — referencia estable a la tarea/spec que ancla un nodo. Solo
+ * identificador y digest; nunca contenido.
+ */
+export declare const TaskAnchorSchema: z.ZodObject<{
+    taskID: z.ZodString;
+    specDigest: z.ZodString;
+}, z.core.$strict>;
+export type TaskAnchor = z.infer<typeof TaskAnchorSchema>;
+/**
+ * `ContextRef` — referencia acotada a contenido por digest. No transporta el
+ * contenido: solo su localización lógica, digest SHA-256 y tamaño en bytes.
+ */
+export declare const ContextRefSchema: z.ZodObject<{
+    uri: z.ZodString;
+    sha256: z.ZodString;
+    bytes: z.ZodNumber;
+    mediaType: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ContextRef = z.infer<typeof ContextRefSchema>;
+/**
+ * Entrada de un manifiesto de artefactos: etiqueta estable, digest y tamaño;
+ * opcionalmente una `ContextRef` estable cuando el input persiste como
+ * referencia revalidable. Nunca lleva título, extracto ni contenido.
+ */
+export declare const ManifestEntrySchema: z.ZodObject<{
+    label: z.ZodString;
+    sha256: z.ZodString;
+    bytes: z.ZodNumber;
+    ref: z.ZodOptional<z.ZodObject<{
+        uri: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+        mediaType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ManifestEntry = z.infer<typeof ManifestEntrySchema>;
+/**
+ * Manifiesto redactado de inputs seleccionados: versión, taskID, clase de
+ * privacidad y entradas ordenadas. El orden más los digests bastan para probar
+ * exactamente qué inputs se seleccionaron, sin exponer su contenido.
+ */
+export declare const ArtifactManifestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    taskID: z.ZodString;
+    privacyClass: z.ZodEnum<{
+        public: "public";
+        internal: "internal";
+        sensitive: "sensitive";
+    }>;
+    entries: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+        ref: z.ZodOptional<z.ZodObject<{
+            uri: z.ZodString;
+            sha256: z.ZodString;
+            bytes: z.ZodNumber;
+            mediaType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ArtifactManifest = z.infer<typeof ArtifactManifestSchema>;
+/**
+ * `NodeContextContract` — único seam de contexto de V1. Identifica referencias
+ * acotadas y digests; no hace fetch, prefill, warm, cache, summarize ni reserva
+ * de tokens.
+ */
+export declare const NodeContextContractSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    refs: z.ZodArray<z.ZodObject<{
+        uri: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+        mediaType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    privacyClass: z.ZodEnum<{
+        public: "public";
+        internal: "internal";
+        sensitive: "sensitive";
+    }>;
+    maxInputTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type NodeContextContract = z.infer<typeof NodeContextContractSchema>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/context/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;GAYG;AAEH,kEAAkE;AAClE,eAAO,MAAM,kBAAkB;;;;EAA8C,CAAC;AAC9E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,mEAAmE;AACnE,eAAO,MAAM,YAAY,aAEmC,CAAC;AAC7D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,aAIkC,CAAC;AAChE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;kBAKlB,CAAC;AACZ,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;kBAOlB,CAAC;AACZ,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;kBAOrB,CAAC;AACZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;kBAOxB,CAAC;AACZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;kBAO3B,CAAC;AACZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/context/types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Superficie de tipos del seam de contexto. Reexporta los tipos inferidos de
+ * los esquemas Zod para que el resto de Graph importe tipos sin acoplarse al
+ * detalle de validación, y expone el tipo `Digest` de `redaction.ts`.
+ */
+export type { Digest } from "./redaction";
+export type { ArtifactManifest, ContextRef, Identifier, ManifestEntry, NodeContextContract, PrivacyClass, Sha256, TaskAnchor, } from "./schema";
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/context/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,YAAY,EACV,gBAAgB,EAChB,UAAU,EACV,UAAU,EACV,aAAa,EACb,mBAAmB,EACnB,YAAY,EACZ,MAAM,EACN,UAAU,GACX,MAAM,UAAU,CAAC"}

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"}