@jmanuelcorral/openteam 0.1.40 → 0.1.42

package/dist/orchestrator/shadowComparator.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Comparador de **paridad shadow** y tally de proyección idempotente (GE-044).
+ *
+ * Compara un run legacy con su espejo shadow (sin efectos) sobre dimensiones
+ * **normalizadas**: estado terminal, orden de nodos, roles, modelos, número de
+ * fixes y outcome. La ausencia de evidencia en cualquier lado es
+ * `inconclusive`. El informe es **reference-only**: solo códigos y veredicto,
+ * nunca contenido crudo. El tally de proyección es **idempotente** por run: una
+ * proyección duplicada no vuelve a contar.
+ *
+ * Puro y determinista: sin I/O, reloj, random ni estado global.
+ */
+/** Rol normalizado de un nodo del run. */
+export type ShadowNodeRole = "implementer" | "reviewer";
+/** Estado terminal normalizado de un run. */
+export type ShadowRunStatus = "completed" | "failed" | "cancelled";
+/** Outcome normalizado del review de un run. */
+export type ShadowRunOutcome = "approved" | "rejected" | "inconclusive";
+/** Resumen normalizado de un nodo (solo referencias/etiquetas acotadas). */
+export type ShadowNodeSummary = {
+    readonly id: string;
+    readonly role: ShadowNodeRole;
+    readonly model: string;
+};
+/** Resumen normalizado de un run, apto para comparar paridad. */
+export type ShadowRunSummary = {
+    readonly runID: string;
+    readonly status: ShadowRunStatus;
+    readonly outcome: ShadowRunOutcome;
+    readonly fixes: number;
+    readonly nodes: readonly ShadowNodeSummary[];
+};
+/** Dimensión en la que legacy y shadow divergen. */
+export type ShadowDivergenceCode = "status" | "order" | "roles" | "models" | "fixes" | "outcome";
+/** Veredicto de paridad. */
+export type ShadowParityVerdict = "match" | "divergent" | "inconclusive";
+/** Informe reference-only de paridad shadow. */
+export type ShadowParityReport = {
+    readonly verdict: ShadowParityVerdict;
+    readonly divergences: readonly ShadowDivergenceCode[];
+};
+/**
+ * Compara la paridad entre el run legacy y su espejo shadow. Si falta evidencia
+ * en cualquier lado, el veredicto es `inconclusive`. En caso contrario reporta
+ * las dimensiones divergentes de forma determinista.
+ */
+export declare function compareShadowRun(legacy: ShadowRunSummary | undefined, shadow: ShadowRunSummary | undefined): ShadowParityReport;
+/** Acumulador idempotente de veredictos de paridad por run. */
+export type ShadowParityTally = {
+    readonly seen: ReadonlySet<string>;
+    readonly match: number;
+    readonly divergent: number;
+    readonly inconclusive: number;
+};
+/** Tally vacío. */
+export declare function emptyShadowTally(): ShadowParityTally;
+/**
+ * Proyecta un veredicto en el tally. **Idempotente por run**: si el `runID` ya
+ * se contabilizó, devuelve el tally intacto (no doble conteo).
+ */
+export declare function tallyShadowParity(tally: ShadowParityTally, runID: string, report: ShadowParityReport): ShadowParityTally;
+//# sourceMappingURL=shadowComparator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shadowComparator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/shadowComparator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,0CAA0C;AAC1C,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,UAAU,CAAC;AAExD,6CAA6C;AAC7C,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEnE,gDAAgD;AAChD,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,UAAU,GAAG,cAAc,CAAC;AAExE,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,iEAAiE;AACjE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC9C,CAAC;AAEF,oDAAoD;AACpD,MAAM,MAAM,oBAAoB,GAC5B,QAAQ,GACR,OAAO,GACP,OAAO,GACP,QAAQ,GACR,OAAO,GACP,SAAS,CAAC;AAEd,4BAA4B;AAC5B,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,WAAW,GAAG,cAAc,CAAC;AAEzE,gDAAgD;AAChD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACvD,CAAC;AASF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,MAAM,EAAE,gBAAgB,GAAG,SAAS,GACnC,kBAAkB,CA4CpB;AAED,+DAA+D;AAC/D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,mBAAmB;AACnB,wBAAgB,gBAAgB,IAAI,iBAAiB,CAEpD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,kBAAkB,GACzB,iBAAiB,CAanB"}

package/dist/orchestrator/worktreeAdapter.d.ts

@@ -0,0 +1,39 @@
+import type { ExecLike } from "../local/foundry-local";
+/** Taxonomía cerrada de errores del adapter de worktrees. */
+export type WorktreeErrorCode = "invalid-run" | "git-failed" | "corrupt-list";
+/** Error tipado de una operación inválida del ciclo de vida del worktree. */
+export declare class WorktreeError extends Error {
+    readonly code: WorktreeErrorCode;
+    readonly detail: string;
+    constructor(code: WorktreeErrorCode, detail: string);
+}
+/** Información observada de un worktree del namespace de openteam. */
+export type WorktreeInfo = {
+    readonly runID: string;
+    /** Ruta reportada por git (separadores `/`, usable por `node:fs`). */
+    readonly path: string;
+    readonly head: string | undefined;
+    readonly detached: boolean;
+    readonly locked: boolean;
+};
+/** Configuración inyectada del adapter. */
+export type WorktreeAdapterConfig = {
+    readonly exec: ExecLike;
+    /** Working tree principal del repositorio (destino de `git -C`). */
+    readonly repoRoot: string;
+    /** Directorio raíz del namespace de worktrees por run. */
+    readonly worktreesDir: string;
+};
+/** Contrato del ciclo de vida idempotente y crash-safe de worktrees. */
+export interface WorktreeAdapter {
+    /** Crea (o adopta) el worktree del run; reconstruye tras crash. */
+    create(runID: string): Promise<WorktreeInfo>;
+    /** Lista los worktrees del namespace de openteam. */
+    list(): Promise<WorktreeInfo[]>;
+    /** Elimina el worktree del run (idempotente). */
+    remove(runID: string): Promise<void>;
+    /** Poda entradas administrativas huérfanas (idempotente). */
+    prune(): Promise<void>;
+}
+export declare function createWorktreeAdapter(config: WorktreeAdapterConfig): WorktreeAdapter;
+//# sourceMappingURL=worktreeAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"worktreeAdapter.d.ts","sourceRoot":"","sources":["../../src/orchestrator/worktreeAdapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAqCvD,6DAA6D;AAC7D,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,YAAY,GAAG,cAAc,CAAC;AAE9E,6EAA6E;AAC7E,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,sEAAsE;AACtE,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,2CAA2C;AAC3C,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,wEAAwE;AACxE,MAAM,WAAW,eAAe;IAC9B,mEAAmE;IACnE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAC7C,qDAAqD;IACrD,IAAI,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAChC,iDAAiD;IACjD,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,6DAA6D;IAC7D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AA2ED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,qBAAqB,GAC5B,eAAe,CA8IjB"}

package/dist/orchestrator/worktreeDispatch.d.ts

@@ -0,0 +1,84 @@
+import type { WorktreeBinding } from "../storage/graph/worktreeRegistry";
+/**
+ * Seam de despacho al worktree del run (GE-073, D-W3).
+ *
+ * Decide, para un efecto del runtime de Graph, el `directory` con el que se crea
+ * la sub-sesión hija (`query.directory`) y verifica la correlación del contrato
+ * `PluginInput.directory`/`worktree` (GE-005). Es lógica pura y determinista:
+ * sin I/O, SDK, reloj ni estado global; el probe de salud del worktree y la
+ * consulta al registro (GE-072) los hace el llamante y entrega sus resultados
+ * como datos.
+ *
+ * Invariante de UX-neutralidad: con el aislamiento **desactivado**
+ * (`graph.worktrees.enabled` = `false`, el default) el directorio resuelto es
+ * exactamente el del workspace actual, de modo que el despacho es idéntico al
+ * de hoy. Con el aislamiento activo se exige un worktree sano vinculado al run
+ * y se cierra en falso (`WorktreeDispatchError`) si falta la vinculación, el
+ * directorio desapareció (`missing`) o está sucio (`unclean`). Ninguna ruta viva
+ * llama todavía a este seam; lo consumirá la integración del executor.
+ */
+/** Salud observada del worktree de un run (resultado del probe del llamante). */
+export type WorktreeHealth = "ready" | "missing" | "unclean";
+/** Estado del despacho respecto al aislamiento por worktree del run. */
+export type WorktreeDispatchState = {
+    readonly kind: "disabled";
+} | {
+    readonly kind: "unbound";
+} | {
+    readonly kind: "missing";
+    readonly worktreePath: string;
+} | {
+    readonly kind: "unclean";
+    readonly worktreePath: string;
+} | {
+    readonly kind: "ready";
+    readonly worktreePath: string;
+};
+/** Taxonomía cerrada de fallos al vincular el despacho a un worktree. */
+export type WorktreeDispatchErrorCode = "unbound" | "missing" | "unclean" | "mismatch";
+/** Error tipado de un despacho que no puede vincularse a un worktree sano. */
+export declare class WorktreeDispatchError extends Error {
+    readonly code: WorktreeDispatchErrorCode;
+    readonly detail: string;
+    constructor(code: WorktreeDispatchErrorCode, detail: string);
+}
+/** Directorio efectivo del despacho de un efecto. */
+export type DispatchDirectory = {
+    /**
+     * Directorio a pasar como `query.directory`. `undefined` = raíz del workspace
+     * (comportamiento actual cuando el aislamiento está desactivado).
+     */
+    readonly directory: string | undefined;
+    /** Worktree correlacionado; `undefined` salvo con aislamiento activo. */
+    readonly worktree: string | undefined;
+};
+/** Correlación observada del contrato `PluginInput` de una sub-sesión. */
+export type ObservedWorktreeCorrelation = {
+    readonly directory: string;
+    readonly worktree: string;
+};
+/**
+ * Combina el flag de aislamiento, la vinculación del registro (GE-072) y la
+ * salud observada del worktree en un estado de despacho. Cierra en falso por
+ * defecto: una salud ausente o desconocida se trata como `missing`.
+ */
+export declare function worktreeDispatchState(input: {
+    readonly enabled: boolean;
+    readonly binding: WorktreeBinding | undefined;
+    readonly health: WorktreeHealth | undefined;
+}): WorktreeDispatchState;
+/**
+ * Resuelve el directorio efectivo del despacho. Con el aislamiento desactivado
+ * devuelve el `workspaceDirectory` tal cual (idéntico al comportamiento actual);
+ * con un worktree sano devuelve su ruta como `directory` y `worktree`; en
+ * cualquier otro estado cierra en falso con `WorktreeDispatchError`.
+ */
+export declare function resolveDispatchDirectory(state: WorktreeDispatchState, workspaceDirectory: string | undefined): DispatchDirectory;
+/**
+ * Verifica la correlación del contrato `PluginInput` (GE-005): el
+ * `directory`/`worktree` observado de la sub-sesión debe coincidir con el
+ * worktree leaseado del run. Lanza `WorktreeDispatchError("mismatch")` si
+ * alguno difiere; comparación de rutas normalizada por plataforma.
+ */
+export declare function assertWorktreeCorrelation(observed: ObservedWorktreeCorrelation, leasedWorktree: string): void;
+//# sourceMappingURL=worktreeDispatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"worktreeDispatch.d.ts","sourceRoot":"","sources":["../../src/orchestrator/worktreeDispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE;;;;;;;;;;;;;;;;;GAiBG;AAEH,iFAAiF;AACjF,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;AAE7D,wEAAwE;AACxE,MAAM,MAAM,qBAAqB,GAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,yEAAyE;AACzE,MAAM,MAAM,yBAAyB,GACjC,SAAS,GACT,SAAS,GACT,SAAS,GACT,UAAU,CAAC;AAEf,8EAA8E;AAC9E,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,IAAI,EAAE,yBAAyB,EAAE,MAAM,EAAE,MAAM;CAM5D;AAED,qDAAqD;AACrD,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC,CAAC;AAEF,0EAA0E;AAC1E,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AAUF;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,CAAC;CAC7C,GAAG,qBAAqB,CAgBxB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,qBAAqB,EAC5B,kBAAkB,EAAE,MAAM,GAAG,SAAS,GACrC,iBAAiB,CAanB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,2BAA2B,EACrC,cAAc,EAAE,MAAM,GACrB,IAAI,CAaN"}

package/dist/orchestrator/worktreeReconciler.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Reconciliador de worktrees huérfanos tras un crash (GE-074, D-W4).
+ *
+ * Sigue el mismo contrato dry-run que los comandos de operador (GE-045,
+ * `src/commands/graph.ts`): es **lógica pura y determinista** que recibe un
+ * snapshot ya observado (worktrees listados por el adapter GE-071, qué runs
+ * siguen activos según el registro de runs GE-025, y el estado de merge-back
+ * probado por el llamante) y decide, sin ejecutar, qué acción es segura para
+ * cada worktree. La ejecución real (`prune`/merge-back) vive en la capa de
+ * wiring y sólo cuando el plan la autoriza.
+ *
+ * Política de reconciliación:
+ * - **Run activo** → `retain`: nunca se toca un worktree cuyo run sigue vivo.
+ * - **Huérfano limpio y sin commits** → `prune`: eliminación segura y reportada.
+ * - **Huérfano limpio con commits** → `merge-back`: explícito e idempotente;
+ *   nunca descarta en silencio la rama del run. Una segunda pasada, cuando la
+ *   rama ya está integrada (`alreadyMerged`), planifica `prune` en vez de
+ *   volver a fusionar.
+ * - **Sucio o ambiguo** → `block`: se detiene para una decisión del operador.
+ *
+ * Invariante de UX-neutralidad (D-W4): con `graph.worktrees.enabled` = `false`
+ * (el default) el reconciliador es un **no-op** — devuelve un informe vacío, no
+ * planifica ni crea ni poda ningún worktree. Ninguna ruta viva lo llama todavía.
+ */
+/** Estado de merge-back observado de un worktree (probe de git del llamante). */
+export type WorktreeMergeState = "clean-empty" | "clean-ahead" | "dirty";
+/** Snapshot observado de un worktree candidato a reconciliar. */
+export type WorktreeObservation = {
+    readonly runID: string;
+    readonly path: string;
+    /** El run sigue activo según el registro de runs (lease vigente). */
+    readonly runActive: boolean;
+    /** Estado de merge-back observado. */
+    readonly mergeState: WorktreeMergeState;
+    /**
+     * Sólo relevante con `mergeState: "clean-ahead"`: la rama del run ya está
+     * integrada en la base, de modo que la reconciliación es idempotente y puede
+     * podar en vez de volver a fusionar.
+     */
+    readonly alreadyMerged?: boolean;
+};
+/** Acción planificada para un worktree, decidida sin ejecutarla. */
+export type WorktreeReconcileAction = "retain" | "prune" | "merge-back" | "block";
+/** Plan de reconciliación de un worktree concreto. */
+export type WorktreeReconcilePlan = {
+    readonly runID: string;
+    readonly path: string;
+    readonly action: WorktreeReconcileAction;
+    /** Razón estable y machine-readable de la decisión. */
+    readonly reason: string;
+    /** `true` cuando la acción preserva invariantes sin override del operador. */
+    readonly safe: boolean;
+};
+/** Informe agregado de la reconciliación. */
+export type WorktreeReconcileReport = {
+    /** Estado del flag de aislamiento en el momento de reconciliar. */
+    readonly enabled: boolean;
+    /** Plan por worktree, en el orden observado. */
+    readonly plans: readonly WorktreeReconcilePlan[];
+    readonly retained: number;
+    readonly pruned: number;
+    readonly mergeBack: number;
+    readonly blocked: number;
+};
+/**
+ * Planifica la reconciliación de un conjunto de worktrees observados. Con el
+ * aislamiento desactivado devuelve un informe vacío (no-op). Puro: no ejecuta
+ * git ni toca I/O.
+ */
+export declare function planWorktreeReconciliation(input: {
+    readonly enabled: boolean;
+    readonly worktrees: readonly WorktreeObservation[];
+}): WorktreeReconcileReport;
+//# sourceMappingURL=worktreeReconciler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"worktreeReconciler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/worktreeReconciler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,iFAAiF;AACjF,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG,aAAa,GAAG,OAAO,CAAC;AAEzE,iEAAiE;AACjE,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,sCAAsC;IACtC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAEF,oEAAoE;AACpE,MAAM,MAAM,uBAAuB,GAC/B,QAAQ,GACR,OAAO,GACP,YAAY,GACZ,OAAO,CAAC;AAEZ,sDAAsD;AACtD,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,6CAA6C;AAC7C,MAAM,MAAM,uBAAuB,GAAG;IACpC,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAkCF;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACpD,GAAG,uBAAuB,CAwB1B"}

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

@@ -0,0 +1,52 @@
+import type { GraphEventV1 } from "../../graph/schema";
+/**
+ * Códec estricto del journal de Graph: framing versionado con cadena de digest.
+ *
+ * Cada evento se serializa como un **frame** NDJSON con `{ v, seq, prev, sum,
+ * event }`, donde `sum = sha256(prev ∥ canonical(event))` y `prev` es el `sum`
+ * del frame anterior (o `GENESIS_DIGEST` en el primero). La cadena hace el log
+ * a prueba de manipulación: reescribir o reordenar un frame rompe el enlace.
+ *
+ * Reglas de decodificación (fail-closed salvo la cola parcial):
+ * - Sólo los frames **terminados en `\n`** son autoritativos.
+ * - Un segmento final sin `\n` es una **cola parcial reconocida** (escritura
+ *   truncada) y se descarta sin error, señalando `partialTail`.
+ * - Frame ilegible/estructura inválida o basura intermedia → `bad-frame`.
+ * - `v` desconocido → `bad-version`; `seq` no contiguo → `bad-sequence`;
+ *   `prev` que no enlaza → `chain-break`; `sum` que no cuadra → `bad-checksum`.
+ *
+ * Puro y determinista: sin I/O, reloj ni random; sólo SHA-256 y serialización.
+ */
+export declare const CODEC_VERSION: 1;
+/** Digest raíz de la cadena (antes del primer frame). */
+export declare const GENESIS_DIGEST: string;
+/** Digest de cadena de un frame dado su predecesor y su evento. */
+export declare function frameDigest(prev: string, event: GraphEventV1): string;
+/** Códigos de fallo de decodificación (todos cierran en falso). */
+export type JournalCodecErrorCode = "bad-frame" | "bad-version" | "bad-sequence" | "chain-break" | "bad-checksum";
+/** Error tipado de un frame corrupto o inconsistente. */
+export declare class JournalCodecError extends Error {
+    readonly code: JournalCodecErrorCode;
+    readonly detail: string;
+    constructor(code: JournalCodecErrorCode, detail: string);
+}
+/** Un frame codificado más el digest de cadena que produce. */
+export type EncodedFrame = {
+    line: string;
+    digest: string;
+};
+/** Codifica un frame para `event` en la posición `seq` sobre `prev`. */
+export declare function encodeFrame(prev: string, seq: number, event: GraphEventV1): EncodedFrame;
+/** Codifica una secuencia completa desde génesis a stream NDJSON con framing. */
+export declare function encodeJournal(events: readonly GraphEventV1[]): string;
+/** Resultado de decodificar un journal: prefijo válido y estado de la cola. */
+export type DecodedJournal = {
+    events: GraphEventV1[];
+    /** Cabeza de la cadena tras el último frame válido (génesis si vacío). */
+    digest: string;
+    /** `true` si se descartó una cola parcial reconocida (escritura truncada). */
+    partialTail: boolean;
+};
+/** Decodifica un stream NDJSON con framing en su prefijo válido de eventos. */
+export declare function decodeJournal(text: string): DecodedJournal;
+//# sourceMappingURL=codec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/codec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD;;;;;;;;;;;;;;;;;GAiBG;AAEH,eAAO,MAAM,aAAa,EAAG,CAAU,CAAC;AAExC,yDAAyD;AACzD,eAAO,MAAM,cAAc,QAAiD,CAAC;AAsB7E,mEAAmE;AACnE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,MAAM,CAErE;AAED,mEAAmE;AACnE,MAAM,MAAM,qBAAqB,GAC7B,WAAW,GACX,aAAa,GACb,cAAc,GACd,aAAa,GACb,cAAc,CAAC;AAEnB,yDAAyD;AACzD,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,IAAI,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM;CAMxD;AAED,+DAA+D;AAC/D,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wEAAwE;AACxE,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,YAAY,GAClB,YAAY,CAId;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CASrE;AAED,+EAA+E;AAC/E,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAkDF,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAc1D"}

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

@@ -0,0 +1,3 @@
+import { type GraphJournal } from "./provider";
+export declare function createFsGraphJournal(root: string): GraphJournal;
+//# sourceMappingURL=fsGraphJournal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fsGraphJournal.d.ts","sourceRoot":"","sources":["../../../src/storage/graph/fsGraphJournal.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,YAAY,CAAC;AA6BpB,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CA2G/D"}

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