@jmanuelcorral/openteam 0.1.40 → 0.1.41

package/dist/storage/graph/importLegacy.d.ts

@@ -0,0 +1,62 @@
+import { type LedgerEntry } from "../../orchestrator/ledger";
+/**
+ * Importación **idempotente** y terminal del ledger legacy a la autoridad de
+ * Graph (GE-024).
+ *
+ * El ledger legacy solo registra desenlaces **terminales** por tarea. Esta capa
+ * mapea cada tarea terminal a un estado de run terminal (`completed`/`failed`)
+ * **una sola vez**, anclado por un `sourceDigest` (la línea de ledger canónica)
+ * y un `specDigest` (un descriptor sintético mínimo del run). Nunca inventa
+ * historia in-flight (no hay `running`/`dispatched`), salta los runs ya
+ * importados —de modo que un re-run es un no-op— y no transporta contenido
+ * crudo (solo identificadores y digests). Puro y determinista: sin I/O, reloj
+ * ni random; el único cómputo es el digest SHA-256.
+ */
+export declare const LEGACY_IMPORT_VERSION: 1;
+/** Estado terminal de un run importado (nunca in-flight). */
+export type LegacyRunStatus = "completed" | "failed";
+/**
+ * Registro de autoridad de un run legacy importado. Terminal y reference-only:
+ * identificadores más digests de origen y de spec; nunca contenido.
+ */
+export type LegacyImportRecordV1 = {
+    readonly version: typeof LEGACY_IMPORT_VERSION;
+    readonly runID: string;
+    readonly taskID: string;
+    readonly status: LegacyRunStatus;
+    /** Digest de la línea de ledger canónica que originó el import. */
+    readonly sourceDigest: string;
+    /** Digest del descriptor sintético mínimo del run importado. */
+    readonly specDigest: string;
+};
+/** `runID` determinista de un task legacy importado. */
+export declare function legacyRunID(taskID: string): string;
+/**
+ * Plan de importación (dry-run): solo los registros nuevos, los runs saltados y
+ * contadores. No lleva contenido de las tareas; sirve como informe de dry-run.
+ */
+export type LegacyImportPlan = {
+    /** Registros terminales nuevos a importar (excluye los ya presentes). */
+    readonly records: readonly LegacyImportRecordV1[];
+    /** `runID` de tareas terminales cuyo run ya estaba importado. */
+    readonly skipped: readonly string[];
+    /** Total de tareas terminales distintas en el ledger. */
+    readonly total: number;
+};
+/**
+ * Planifica la importación terminal del ledger. Deduplica por `taskID` (el
+ * último estado gana, igual que el ledger) y excluye los runs ya presentes en
+ * `existingRunIDs`, de modo que un re-run con la misma autoridad produce un
+ * plan vacío (no-op).
+ */
+export declare function planLegacyImport(input: {
+    entries: readonly LedgerEntry[];
+    existingRunIDs?: Iterable<string>;
+}): LegacyImportPlan;
+/**
+ * Aplica el plan mezclando sus registros con la autoridad existente, deduplicado
+ * por `runID` (el existente gana) y con orden estable por `runID`. Idempotente:
+ * aplicar un plan ya presente deja la autoridad igual.
+ */
+export declare function applyLegacyImport(existing: readonly LegacyImportRecordV1[], plan: LegacyImportPlan): readonly LegacyImportRecordV1[];
+//# sourceMappingURL=importLegacy.d.ts.map

package/dist/storage/graph/importLegacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"importLegacy.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/importLegacy.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,WAAW,EAGjB,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,qBAAqB,EAAG,CAAU,CAAC;AAEhD,6DAA6D;AAC7D,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,QAAQ,CAAC;AAErD;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,qBAAqB,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,mEAAmE;IACnE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,gEAAgE;IAChE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,wDAAwD;AACxD,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElD;AA4BD;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAClD,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IAChC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CACnC,GAAG,gBAAgB,CAiBnB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EACzC,IAAI,EAAE,gBAAgB,GACrB,SAAS,oBAAoB,EAAE,CAajC"}

package/dist/storage/graph/memoryGraphJournal.d.ts

@@ -0,0 +1,11 @@
+import type { GraphSpecV1 } from "../../graph/schema";
+import { type GraphJournal } from "./provider";
+export type MemoryGraphJournalOptions = {
+    /** Journals crudos precargados (NDJSON) para tests de recuperación/corrupción. */
+    seed?: Record<string, {
+        spec: GraphSpecV1;
+        lines: readonly string[];
+    }>;
+};
+export declare function createMemoryGraphJournal(options?: MemoryGraphJournalOptions): GraphJournal;
+//# sourceMappingURL=memoryGraphJournal.d.ts.map

package/dist/storage/graph/memoryGraphJournal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryGraphJournal.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/memoryGraphJournal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,YAAY,CAAC;AAiBpB,MAAM,MAAM,yBAAyB,GAAG;IACtC,kFAAkF;IAClF,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC;QAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CACxE,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,yBAA8B,GACtC,YAAY,CA8Fd"}

package/dist/storage/graph/migrateLegacyBriefs.d.ts

@@ -0,0 +1,32 @@
+import type { StorageProvider } from "../provider";
+/** Plan (dry-run) de migración: solo rutas y conteo, nunca contenido. */
+export type BriefMigrationPlan = {
+    readonly workspaceDir: string;
+    readonly briefPaths: readonly string[];
+    readonly count: number;
+};
+/** Resultado de aplicar la migración: manifiestos escritos y conteo. */
+export type BriefMigrationReport = {
+    readonly workspaceDir: string;
+    readonly migrated: readonly string[];
+    readonly count: number;
+};
+/** Código de fallo fail-closed de la migración. */
+export type MigrationErrorCode = "unreadable" | "unknown-schema";
+/** Error tipado de una migración abortada (deja el crudo intacto). */
+export declare class MigrationError extends Error {
+    readonly code: MigrationErrorCode;
+    readonly path: string;
+    constructor(code: MigrationErrorCode, path: string);
+}
+/**
+ * Planifica la migración (dry-run). Lista los briefs crudos y devuelve sus
+ * rutas y conteo; **no** lee ni transporta el cuerpo de ningún brief.
+ */
+export declare function planLegacyBriefMigration(storage: StorageProvider, workspaceDir: string): Promise<BriefMigrationPlan>;
+/**
+ * Aplica la migración: por cada brief crudo escribe el manifiesto redactado y
+ * borra el crudo (sin backup). Idempotente y fail-closed.
+ */
+export declare function applyLegacyBriefMigration(storage: StorageProvider, workspaceDir: string): Promise<BriefMigrationReport>;
+//# sourceMappingURL=migrateLegacyBriefs.d.ts.map

package/dist/storage/graph/migrateLegacyBriefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrateLegacyBriefs.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/migrateLegacyBriefs.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AA4BnD,yEAAyE;AACzE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,wEAAwE;AACxE,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,mDAAmD;AACnD,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,gBAAgB,CAAC;AAEjE,sEAAsE;AACtE,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM;CAMnD;AA6CD;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,kBAAkB,CAAC,CAM7B;AAED;;;GAGG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,oBAAoB,CAAC,CAuB/B"}

package/dist/storage/graph/projections.d.ts

@@ -0,0 +1,31 @@
+import type { LegacyImportRecordV1, LegacyRunStatus } from "./importLegacy";
+/**
+ * Proyecciones **reconstruibles** de progreso y resumen sobre la autoridad de
+ * runs importados (GE-024).
+ *
+ * La autoridad (registros terminales de import) es la única fuente de verdad;
+ * estas proyecciones son estado derivado y desechable: se recalculan por
+ * completo desde la autoridad, sin persistencia propia. Puras y deterministas:
+ * mismo input, mismo output, con orden estable por `runID`.
+ */
+/** Proyección de progreso: contadores por estado terminal. */
+export type ProgressProjection = {
+    readonly total: number;
+    readonly completed: number;
+    readonly failed: number;
+};
+/** Entrada de resumen: estado terminal por run. */
+export type SummaryEntry = {
+    readonly runID: string;
+    readonly taskID: string;
+    readonly status: LegacyRunStatus;
+};
+/** Proyección de resumen: estado por run en orden estable por `runID`. */
+export type SummaryProjection = {
+    readonly runs: readonly SummaryEntry[];
+};
+/** Reconstruye los contadores de progreso desde la autoridad. */
+export declare function projectProgress(records: readonly LegacyImportRecordV1[]): ProgressProjection;
+/** Reconstruye el resumen por run desde la autoridad, ordenado por `runID`. */
+export declare function projectSummary(records: readonly LegacyImportRecordV1[]): SummaryProjection;
+//# sourceMappingURL=projections.d.ts.map

package/dist/storage/graph/projections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projections.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/projections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAE5E;;;;;;;;GAQG;AAEH,8DAA8D;AAC9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,mDAAmD;AACnD,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;CAClC,CAAC;AAEF,0EAA0E;AAC1E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,CAAC;CACxC,CAAC;AAEF,iEAAiE;AACjE,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,oBAAoB,EAAE,GACvC,kBAAkB,CAWpB;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,oBAAoB,EAAE,GACvC,iBAAiB,CASnB"}

package/dist/storage/graph/provider.d.ts

@@ -0,0 +1,52 @@
+import type { GraphEventV1, GraphSpecV1 } from "../../graph/schema";
+import type { GraphState } from "../../graph/types";
+/**
+ * `GraphJournal` — boundary de persistencia append-only del run de Graph.
+ *
+ * Modela un log de eventos por `runID` con dos garantías de integridad:
+ * - **Secuencia contigua**: los eventos se anexan con `seq` estrictamente
+ *   creciente desde 0 (concurrencia optimista sobre la cabeza del log).
+ * - **Escritor único (fencing)**: cada journal tiene un `writerToken` vigente;
+ *   un `takeOver` emite uno nuevo e invalida el anterior. Anexar con un token
+ *   caduco cierra en falso con `writer-conflict`.
+ *
+ * `load` reconstruye el estado reducido reproduciendo el journal; si el log
+ * almacenado es ilegible o produce transiciones ilegales, surface `corrupt`.
+ *
+ * Este módulo **no** contiene I/O: solo tipos. `router/` nunca lo importa. Los
+ * adapters concretos (`memoryGraphJournal`, futuros durables FS/SQLite) lo
+ * implementan y comparten `tests/storage/graph/contract.ts`.
+ */
+/** Taxonomía cerrada de errores del journal. */
+export type JournalErrorCode = "already-exists" | "not-found" | "writer-conflict" | "sequence-mismatch" | "duplicate-event" | "corrupt";
+/** Error tipado de una operación inválida sobre el journal. */
+export declare class JournalError extends Error {
+    readonly code: JournalErrorCode;
+    readonly detail: string;
+    constructor(code: JournalErrorCode, detail: string);
+}
+/** Referencia a un journal abierto por un escritor concreto. */
+export type GraphJournalHandle = {
+    readonly runID: string;
+    readonly writerToken: string;
+};
+/** Resultado de `load`: spec, eventos y estado reducido reproducido. */
+export type LoadedJournal = {
+    spec: GraphSpecV1;
+    events: GraphEventV1[];
+    state: GraphState;
+};
+/** Contrato del journal de eventos de un run de Graph. */
+export interface GraphJournal {
+    /** Crea un journal vacío para el run del spec; `already-exists` si ya existe. */
+    create(spec: GraphSpecV1): Promise<GraphJournalHandle>;
+    /** Toma el relevo como escritor único, emitiendo un token nuevo; `not-found` si falta. */
+    takeOver(runID: string): Promise<GraphJournalHandle>;
+    /** Anexa un evento en la posición `expectedSeq` (cabeza del log). */
+    append(handle: GraphJournalHandle, event: GraphEventV1, expectedSeq: number): Promise<void>;
+    /** Carga el journal y reproduce su estado; `not-found`/`corrupt` si procede. */
+    load(runID: string): Promise<LoadedJournal>;
+    /** `true` si existe un journal para el run. */
+    exists(runID: string): Promise<boolean>;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/storage/graph/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AAEH,gDAAgD;AAChD,MAAM,MAAM,gBAAgB,GACxB,gBAAgB,GAChB,WAAW,GACX,iBAAiB,GACjB,mBAAmB,GACnB,iBAAiB,GACjB,SAAS,CAAC;AAEd,+DAA+D;AAC/D,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,gEAAgE;AAChE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,wEAAwE;AACxE,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,KAAK,EAAE,UAAU,CAAC;CACnB,CAAC;AAEF,0DAA0D;AAC1D,MAAM,WAAW,YAAY;IAC3B,iFAAiF;IACjF,MAAM,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACvD,0FAA0F;IAC1F,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACrD,qEAAqE;IACrE,MAAM,CACJ,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,YAAY,EACnB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,gFAAgF;IAChF,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAC5C,+CAA+C;IAC/C,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACzC"}

package/dist/storage/graph/recovery.d.ts

@@ -0,0 +1,38 @@
+import type { GraphEventV1, GraphSpecV1 } from "../../graph/schema";
+import type { GraphState } from "../../graph/types";
+/**
+ * Recuperación determinista de un journal tras un fallo en un boundary de commit.
+ *
+ * Reproduce el prefijo autoritativo con una política de cola explícita:
+ * - una **cola parcial reconocida** (escritura truncada, sin `\n`) se descarta y
+ *   se recupera el prefijo confirmado (`tail: "recovered"`), de modo que el
+ *   intento truncado se puede reintentar sin duplicar autoridad;
+ * - un log limpio recupera todo commit confirmado (`tail: "clean"`).
+ *
+ * Cierra en falso sin adivinar ante una **corrupción intermedia** (frame ilegible
+ * en medio, cadena rota o checksum falseado) o una **ambigüedad de secuencia**
+ * (`seq` no contiguo), y también si el prefijo confirmado reproduce ilegalmente.
+ *
+ * Puro y determinista: sin I/O, reloj ni random. Opera sobre los bytes del
+ * journal para que la matriz de inyección de fallos sea byte a byte reproducible.
+ */
+/** Estado de la cola tras recuperar. */
+export type RecoveryTail = "clean" | "recovered";
+/** Resultado de recuperar un journal: prefijo autoritativo y estado reducido. */
+export type RecoveredJournal = {
+    events: GraphEventV1[];
+    state: GraphState;
+    digest: string;
+    tail: RecoveryTail;
+};
+/** Taxonomía cerrada de fallos irrecuperables (paran en vez de adivinar). */
+export type RecoveryErrorCode = "corrupt" | "sequence-ambiguity";
+/** Error tipado de un journal que no puede recuperarse de forma segura. */
+export declare class RecoveryError extends Error {
+    readonly code: RecoveryErrorCode;
+    readonly detail: string;
+    constructor(code: RecoveryErrorCode, detail: string);
+}
+/** Recupera el prefijo autoritativo y su estado desde los bytes del journal. */
+export declare function recoverJournal(spec: GraphSpecV1, text: string): RecoveredJournal;
+//# sourceMappingURL=recovery.d.ts.map

package/dist/storage/graph/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/recovery.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD;;;;;;;;;;;;;;;GAeG;AAEH,wCAAwC;AACxC,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,WAAW,CAAC;AAEjD,iFAAiF;AACjF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AAEF,6EAA6E;AAC7E,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,oBAAoB,CAAC;AAEjE,2EAA2E;AAC3E,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM;CAMpD;AAED,gFAAgF;AAChF,wBAAgB,cAAc,CAC5B,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,MAAM,GACX,gBAAgB,CAwBlB"}

package/dist/storage/graph/runRegistry.d.ts

@@ -0,0 +1,17 @@
+/** Error tipado de un registro de runs ilegible. */
+export declare class RunRegistryError extends Error {
+    readonly code = "corrupt";
+    readonly detail: string;
+    constructor(detail: string);
+}
+/** Contrato del registro de runs activos del workspace. */
+export interface RunRegistry {
+    /** Marca `runID` como activo (idempotente). */
+    markActive(runID: string): Promise<void>;
+    /** Marca `runID` como inactivo (idempotente). */
+    markInactive(runID: string): Promise<void>;
+    /** Lista los runs activos, ordenados. */
+    list(): Promise<string[]>;
+}
+export declare function createRunRegistry(root: string): RunRegistry;
+//# sourceMappingURL=runRegistry.d.ts.map

package/dist/storage/graph/runRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runRegistry.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/runRegistry.ts"],"names":[],"mappings":"AAqBA,oDAAoD;AACpD,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,aAAa;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM;CAK3B;AAED,2DAA2D;AAC3D,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,iDAAiD;IACjD,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,yCAAyC;IACzC,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CAC3B;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CA8C3D"}

package/dist/storage/graph/snapshot.d.ts

@@ -0,0 +1,44 @@
+import type { GraphEventV1, GraphSpecV1 } from "../../graph/schema";
+import type { GraphState } from "../../graph/types";
+/**
+ * Snapshots versionados del estado reducido con equivalencia al replay total.
+ *
+ * Un snapshot captura el `GraphState` tras aplicar los primeros `count` eventos
+ * junto al digest de cadena de ese prefijo (`prefixDigest`). Cargar puede así
+ * arrancar desde el snapshot y reproducir sólo la cola, obteniendo exactamente
+ * el mismo estado que reproducir el journal completo desde génesis.
+ *
+ * El journal sigue siendo la autoridad: el snapshot es un acelerador desechable.
+ * - Borrarlo no pierde autoridad: se recae al replay total del journal.
+ * - Un snapshot corrupto o de versión desconocida no se confía: se recae **sólo**
+ *   al replay estricto del journal (nunca a un estado a medio validar).
+ *
+ * La integridad se ancla con un checksum sobre el sobre y el hash del estado, y
+ * el `prefixDigest` ata el snapshot a un prefijo concreto del journal.
+ */
+export declare const SNAPSHOT_VERSION = 1;
+/** Snapshot del estado reducido en un punto del journal. */
+export type GraphSnapshot = {
+    version: number;
+    runID: string;
+    count: number;
+    prefixDigest: string;
+    state: GraphState;
+};
+/** Construye un snapshot puro tras los primeros `count` eventos del journal. */
+export declare function snapshotAt(spec: GraphSpecV1, events: readonly GraphEventV1[], count: number): GraphSnapshot;
+/** Persiste el snapshot de forma durable en `<root>/<runID>/snapshot.json`. */
+export declare function writeSnapshot(root: string, snapshot: GraphSnapshot): void;
+/**
+ * Lee el snapshot si es íntegro y de versión conocida; devuelve `undefined`
+ * (para recaer al replay) si falta, es ilegible, tiene versión desconocida o su
+ * checksum no cuadra.
+ */
+export declare function readSnapshot(root: string, runID: string): GraphSnapshot | undefined;
+/**
+ * Resuelve el estado del run: si el snapshot ata al prefijo del journal, arranca
+ * desde él y reproduce la cola; en cualquier otro caso recae al replay estricto
+ * y total del journal, que es la autoridad.
+ */
+export declare function resolveState(spec: GraphSpecV1, events: readonly GraphEventV1[], snapshot: GraphSnapshot | undefined): GraphState;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/storage/graph/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/snapshot.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIpD;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAIlC,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,UAAU,CAAC;CACnB,CAAC;AAkDF,gFAAgF;AAChF,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,SAAS,YAAY,EAAE,EAC/B,KAAK,EAAE,MAAM,GACZ,aAAa,CASf;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI,CAIzE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,aAAa,GAAG,SAAS,CA8B3B;AA4BD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,SAAS,YAAY,EAAE,EAC/B,QAAQ,EAAE,aAAa,GAAG,SAAS,GAClC,UAAU,CAKZ"}

package/dist/storage/graph/workspaceLease.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { type RunRegistry } from "./runRegistry";
+declare const leaseRecordSchema: z.ZodObject<{
+    runID: z.ZodString;
+    holder: z.ZodString;
+    token: z.ZodString;
+    released: z.ZodBoolean;
+}, z.core.$strip>;
+/** Registro persistido de un lease del workspace. */
+export type LeaseRecord = z.infer<typeof leaseRecordSchema>;
+/** Taxonomía cerrada de errores del lease. */
+export type LeaseErrorCode = "held" | "not-holder" | "not-found" | "corrupt";
+/** Error tipado de una operación inválida sobre el lease. */
+export declare class LeaseError extends Error {
+    readonly code: LeaseErrorCode;
+    readonly detail: string;
+    constructor(code: LeaseErrorCode, detail: string);
+}
+/** Concesión de un lease a un holder concreto. */
+export type LeaseHandle = {
+    readonly runID: string;
+    readonly holder: string;
+    readonly token: string;
+};
+/** Contrato del lease exclusivo del workspace. */
+export interface WorkspaceLease {
+    /** Adquiere el run para `holder`; readquisición del mismo holder es idempotente. */
+    acquire(runID: string, holder: string): Promise<LeaseHandle>;
+    /** Libera el run de forma durable; el registro deja de listarlo. */
+    release(handle: LeaseHandle): Promise<void>;
+    /** Devuelve el registro persistido del lease, o `undefined` si no existe. */
+    inspect(runID: string): Promise<LeaseRecord | undefined>;
+}
+export declare function createWorkspaceLease(root: string, registry?: RunRegistry): WorkspaceLease;
+export {};
+//# sourceMappingURL=workspaceLease.d.ts.map

package/dist/storage/graph/workspaceLease.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaceLease.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/workspaceLease.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAuBpE,QAAA,MAAM,iBAAiB;;;;;iBAKrB,CAAC;AAEH,qDAAqD;AACrD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,8CAA8C;AAC9C,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,YAAY,GAAG,WAAW,GAAG,SAAS,CAAC;AAE7E,6DAA6D;AAC7D,qBAAa,UAAW,SAAQ,KAAK;IACnC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM;CAMjD;AAED,kDAAkD;AAClD,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,kDAAkD;AAClD,MAAM,WAAW,cAAc;IAC7B,oFAAoF;IACpF,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7D,oEAAoE;IACpE,OAAO,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,6EAA6E;IAC7E,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;CAC1D;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,WAAqC,GAC9C,cAAc,CA0EhB"}

package/dist/storage/graph/writer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Primitiva de durabilidad del journal FS: escrituras que sólo retornan tras
+ * `fsync` del descriptor, de modo que el boundary de confirmación coincide con
+ * la persistencia real (no con el buffer del SO). Es la única razón por la que
+ * el journal no se apoya en `StorageProvider.append`, que no fuerza `fsync`.
+ *
+ * Aísla `node:fs` para que el resto del adapter permanezca declarativo. No
+ * interpreta contenido: sólo bytes, directorios y el boundary de flush.
+ */
+/** Crea el directorio (recursivo, idempotente). */
+export declare function ensureDir(dir: string): void;
+/** Escribe (trunca) un fichero y fuerza `fsync` antes de retornar. */
+export declare function writeDurable(file: string, content: string): void;
+/** Anexa al final de un fichero y fuerza `fsync` antes de retornar. */
+export declare function appendDurable(file: string, content: string): void;
+/** Lee el contenido UTF-8 de un fichero; `undefined` si no existe. */
+export declare function readText(file: string): string | undefined;
+/** `true` si la ruta existe (fichero o directorio). */
+export declare function pathExists(path: string): boolean;
+//# sourceMappingURL=writer.d.ts.map

package/dist/storage/graph/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/writer.ts"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AAEH,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAE3C;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAQhE;AAED,uEAAuE;AACvE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAQjE;AAED,sEAAsE;AACtE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKzD;AAED,uDAAuD;AACvD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD"}

package/dist/telemetry/graphProjection.d.ts

@@ -0,0 +1,36 @@
+import type { ErrorClass, GraphEventType, GraphEventV1 } from "../graph/schema";
+/**
+ * Proyección de telemetría **reference-only** de eventos de Graph (GE-037).
+ *
+ * `projectGraphEvent` mapea un evento validado a un registro de telemetría con
+ * un conjunto de campos **allow-listed y acotados**: envoltura (`v`, `seq`,
+ * `runID`, `type`) más identificadores/digests concretos según el tipo. Nunca
+ * copia el evento entero ni transporta contenido crudo; el artefacto se reduce
+ * a su referencia (`uri`, `sha256`, `bytes`). Un guard final rechaza cualquier
+ * campo de contenido crudo. Puro y determinista: sin I/O, reloj ni random.
+ */
+/** Registro de telemetría de un evento Graph: solo campos allow-listed. */
+export type GraphTelemetryRecord = {
+    readonly v: number;
+    readonly seq: number;
+    readonly runID: string;
+    readonly type: GraphEventType;
+    readonly nodeID?: string;
+    readonly operationID?: string;
+    readonly attemptID?: string;
+    readonly errorClass?: ErrorClass;
+    readonly specDigest?: string;
+    readonly artifact?: {
+        readonly uri: string;
+        readonly sha256: string;
+        readonly bytes: number;
+    };
+};
+/**
+ * Proyecta un evento Graph a un registro de telemetría reference-only. Solo
+ * emite los campos allow-listed presentes en el evento y reduce el artefacto a
+ * su referencia; el guard reference-only asegura que ningún derivado futuro
+ * introduzca contenido crudo.
+ */
+export declare function projectGraphEvent(event: GraphEventV1): GraphTelemetryRecord;
+//# sourceMappingURL=graphProjection.d.ts.map

package/dist/telemetry/graphProjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphProjection.d.ts","sourceRoot":"","sources":["../../src/telemetry/graphProjection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEhF;;;;;;;;;GASG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAClB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;KACxB,CAAC;CACH,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,oBAAoB,CAe3E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmanuelcorral/openteam",
-  "version": "0.1.40",
+  "version": "0.1.41",
   "packageManager": "bun@1.3.14",
   "description": "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
   "license": "MIT",