@jmanuelcorral/openteam 0.1.38 → 0.1.41

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/storage/index/memoryConsolidate.d.ts

@@ -0,0 +1,24 @@
+import { type DecayParams } from "../../memory";
+import type { StorageProvider } from "../provider";
+/**
+ * Orquestación **I/O** de la consolidación (M5): lee el log de memoria, repliega
+ * el estado vigente, computa los tombstones por decay (núcleo puro `consolidate`)
+ * y los **anexa** al log append-only. El índice SQLite se reconstruye después
+ * (derivado); aquí solo se toca el log, la fuente de verdad.
+ *
+ * Idempotente: una segunda pasada sin cambios de reloj no produce tombstones
+ * nuevos (los ya invalidados se ignoran). Todo el determinismo vive en el core;
+ * el único I/O es leer/anexar el log vía el `StorageProvider` inyectado.
+ */
+export type ConsolidateMemoryDeps = {
+    storage: StorageProvider;
+    /** Instante de consolidación (epoch ms). */
+    now: number;
+    params?: DecayParams;
+};
+export type ConsolidationResult = {
+    /** Records olvidados (soft-invalidated) en esta pasada. */
+    forgotten: number;
+};
+export declare function runConsolidation(logPath: string, deps: ConsolidateMemoryDeps): Promise<ConsolidationResult>;
+//# sourceMappingURL=memoryConsolidate.d.ts.map

package/dist/storage/index/memoryConsolidate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryConsolidate.d.ts","sourceRoot":"","sources":["../../../src/storage/index/memoryConsolidate.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,WAAW,EAIjB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;;;;;;GASG;AAEH,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,eAAe,CAAC;IACzB,4CAA4C;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,mBAAmB,CAAC,CAW9B"}

package/dist/storage/index/memoryIndex.d.ts

@@ -0,0 +1,52 @@
+import { type MemoryState } from "../../memory/fold";
+import { type Embedding, type MemoryRecord } from "../../memory/types";
+import type { StorageProvider } from "../provider";
+import type { SqliteDatabase } from "./sqliteIndex";
+/**
+ * Índice SQLite **derivado** del log de memoria (`records.jsonl`). No es fuente de
+ * verdad: `rebuild` repliega las aserciones (vía `foldAssertions`) y materializa
+ * el estado vigente + histórico. Si el fichero se corrompe o se borra, se
+ * reconstruye desde el log sin pérdida.
+ *
+ * Los **embeddings** (M3) se persisten en una tabla aparte, keyed por `record.id`.
+ * A diferencia de los records, no son reconstruibles desde el log (el texto fuente
+ * no se persiste por privacidad): son un store derivado que requiere re-embedding.
+ *
+ * El driver SQLite se inyecta como `SqliteDatabase` (compatible con `bun:sqlite`),
+ * igual que `sqliteIndex.ts`, para no acoplar este módulo a un runtime concreto.
+ */
+/** Embedding asociado a un record (por `recordId`). */
+export type EmbeddingEntry = {
+    recordId: string;
+    vector: Embedding;
+};
+export type MemoryIndex = {
+    /** Vacía y repuebla el índice replegando `assertions` (derivado). */
+    rebuild: (assertions: readonly MemoryRecord[]) => void;
+    /** Todos los records materializados (vigentes + invalidados), orden estable. */
+    allRecords: () => MemoryRecord[];
+    /** Estado particionado por kind. */
+    state: () => MemoryState;
+    /** Records recuperables (bitemporalmente activos) en `asOf`. */
+    activeAt: (asOf: number) => MemoryRecord[];
+    /** Persiste (upsert) embeddings por `recordId`. */
+    putEmbeddings: (entries: readonly EmbeddingEntry[]) => void;
+    /** Mapa `recordId -> vector` para alimentar el recall puro. */
+    embeddingMap: () => Map<string, Embedding>;
+    /** Elimina embeddings huérfanos (sin record). Devuelve cuántos borró. */
+    pruneEmbeddings: () => number;
+    /** Cierra la conexión subyacente. */
+    close: () => void;
+};
+/** Crea el índice sobre una base de datos ya abierta y asegura el esquema. */
+export declare function createMemoryIndex(db: SqliteDatabase): MemoryIndex;
+export type RebuildMemoryDeps = {
+    storage: StorageProvider;
+};
+/**
+ * Reconstruye el índice desde el log de memoria leído por el `StorageProvider`.
+ * Devuelve el número de aserciones replegadas. Es la operación de "regenerar"
+ * tras un borrado del índice.
+ */
+export declare function rebuildMemoryIndexFromStorage(index: MemoryIndex, logPath: string, deps: RebuildMemoryDeps): Promise<number>;
+//# sourceMappingURL=memoryIndex.d.ts.map

package/dist/storage/index/memoryIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryIndex.d.ts","sourceRoot":"","sources":["../../../src/storage/index/memoryIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,KAAK,SAAS,EACd,KAAK,YAAY,EAElB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;;;;;;;;;;;GAYG;AAEH,uDAAuD;AACvD,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,qEAAqE;IACrE,OAAO,EAAE,CAAC,UAAU,EAAE,SAAS,YAAY,EAAE,KAAK,IAAI,CAAC;IACvD,gFAAgF;IAChF,UAAU,EAAE,MAAM,YAAY,EAAE,CAAC;IACjC,oCAAoC;IACpC,KAAK,EAAE,MAAM,WAAW,CAAC;IACzB,gEAAgE;IAChE,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,YAAY,EAAE,CAAC;IAC3C,mDAAmD;IACnD,aAAa,EAAE,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,KAAK,IAAI,CAAC;IAC5D,+DAA+D;IAC/D,YAAY,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC3C,yEAAyE;IACzE,eAAe,EAAE,MAAM,MAAM,CAAC;IAC9B,qCAAqC;IACrC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC;AAkDF,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,cAAc,GAAG,WAAW,CAmGjE;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,MAAM,CAAC,CAKjB"}

package/dist/storage/index/memoryRecall.d.ts

@@ -0,0 +1,23 @@
+import type { Embedder } from "../../local/embeddings";
+import type { RankSignals } from "../../memory/rank";
+import type { RecallQuery, RecallResult } from "../../memory/types";
+import type { MemoryIndex } from "./memoryIndex";
+/**
+ * Orquestación de recall semántico: embebe el texto de consulta con el
+ * `Embedder` local inyectado y delega el ranking al `recall` **puro** sobre los
+ * records + embeddings materializados en el índice. El core determinista no toca
+ * red; el único I/O es el embedding de la query.
+ */
+export type RecallMemoryDeps = {
+    index: MemoryIndex;
+    embedder: Embedder;
+    /** Instante de recall (epoch ms) cuando `query.asOf` es `null`. */
+    now: number;
+    signals?: Omit<RankSignals, "now">;
+};
+/**
+ * Recupera los records más relevantes para `queryText`. Devuelve `[]` si el
+ * embedder no produce vector para la consulta.
+ */
+export declare function recallMemory(deps: RecallMemoryDeps, queryText: string, query: RecallQuery): Promise<RecallResult[]>;
+//# sourceMappingURL=memoryRecall.d.ts.map

package/dist/storage/index/memoryRecall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryRecall.d.ts","sourceRoot":"","sources":["../../../src/storage/index/memoryRecall.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;GAKG;AAEH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;CACpC,CAAC;AAEF;;;GAGG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,gBAAgB,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC,YAAY,EAAE,CAAC,CAYzB"}

package/dist/storage/index/memoryRuntime.d.ts

@@ -0,0 +1,41 @@
+import type { MemorySemanticConfig, OpenTeamConfig } from "../../config/schema";
+import { createLocalEmbedder, type Embedder } from "../../local/embeddings";
+import type { StorageProvider } from "../provider";
+import { createBunSqliteDatabase } from "./bunSqlite";
+import { type MemoryIndex } from "./memoryIndex";
+/**
+ * Runtime de memoria semántica ya materializado: índice SQLite reconstruido +
+ * embedder local + reloj. Es la base común que consumen tanto el recall del MCP
+ * (`buildSemanticRecall`) como la inyección M6 (`buildMemoryInjector`), evitando
+ * duplicar el wiring de I/O en `cli.ts` e `index.ts`.
+ */
+export type MemoryRuntime = {
+    index: MemoryIndex;
+    embedder: Embedder;
+    now: () => number;
+    ownerKey: "user" | "project";
+    semantic: MemorySemanticConfig;
+};
+export type BuildMemoryRuntimeDeps = {
+    storage: StorageProvider;
+    fetch?: typeof globalThis.fetch;
+    now?: () => number;
+    /** Inyectable en tests; por defecto abre `bun:sqlite`. */
+    openDatabase?: typeof createBunSqliteDatabase;
+    /** Inyectable en tests; por defecto crea el embedder local. */
+    createEmbedder?: typeof createLocalEmbedder;
+};
+export type BuildMemoryRuntimeOptions = {
+    /** Si `true`, además exige `injection.enabled` (uso de la inyección M6). */
+    requireInjectionEnabled?: boolean;
+};
+/**
+ * Construye (opt-in) el runtime de memoria semántica a partir de la config. Todo
+ * el I/O (SQLite + embeddings) queda aislado aquí. Devuelve `undefined` —
+ * degradación segura, sin lanzar— si la memoria semántica está desactivada, si
+ * no hay proveedor de embeddings local, si (con `requireInjectionEnabled`) la
+ * inyección está desactivada, si no hay runtime local con `baseURL`, o si el
+ * índice SQLite no puede abrirse (p. ej. sin `bun:sqlite`).
+ */
+export declare function buildMemoryRuntimeFromConfig(config: OpenTeamConfig, deps: BuildMemoryRuntimeDeps, options?: BuildMemoryRuntimeOptions): Promise<MemoryRuntime | undefined>;
+//# sourceMappingURL=memoryRuntime.d.ts.map

package/dist/storage/index/memoryRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryRuntime.d.ts","sourceRoot":"","sources":["../../../src/storage/index/memoryRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEhF,OAAO,EAAE,mBAAmB,EAAE,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAEL,KAAK,WAAW,EAEjB,MAAM,eAAe,CAAC;AAEvB;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,oBAAoB,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,eAAe,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAChC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,0DAA0D;IAC1D,YAAY,CAAC,EAAE,OAAO,uBAAuB,CAAC;IAC9C,+DAA+D;IAC/D,cAAc,CAAC,EAAE,OAAO,mBAAmB,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,4EAA4E;IAC5E,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAsB,4BAA4B,CAChD,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,sBAAsB,EAC5B,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAyCpC"}

package/dist/telemetry/events.d.ts

@@ -4,7 +4,9 @@ import { z } from "zod";
  * de estos eventos (JSONL) que el console agrega. Discriminados por `type`.
  *
  * Privacidad: **nunca** contienen texto de prompt, argumentos de tool ni salida
- * en claro; solo `promptHash`, contadores y resúmenes ya redactados.
+ * en claro; solo `promptHash`, contadores y resúmenes ya redactados. La garantía
+ * es el **no-almacenamiento** del prompt crudo; `promptHash` es solo un id de
+ * correlación no-criptográfico (ver `telemetry/hash.ts`), no una ofuscación.
  *
  * Módulo puro: sin I/O, red, reloj, random ni env vars.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/telemetry/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,EAAG,CAAU,CAAC;AAW/C,yEAAyE;AACzE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB3B,CAAC;AAEH,+EAA+E;AAC/E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAc7B,CAAC;AAEH,sEAAsE;AACtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;iBAS9B,CAAC;AAEH,iEAAiE;AACjE,eAAO,MAAM,kBAAkB;;;;;;;;;iBAM7B,CAAC;AAEH,yEAAyE;AACzE,eAAO,MAAM,mBAAmB;;;;;;;;iBAK9B,CAAC;AAEH,0DAA0D;AAC1D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;iBAK9B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;iBAMrC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQ9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,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,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,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/telemetry/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,EAAG,CAAU,CAAC;AAW/C,yEAAyE;AACzE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB3B,CAAC;AAEH,+EAA+E;AAC/E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAc7B,CAAC;AAEH,sEAAsE;AACtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;iBAS9B,CAAC;AAEH,iEAAiE;AACjE,eAAO,MAAM,kBAAkB;;;;;;;;;iBAM7B,CAAC;AAEH,yEAAyE;AACzE,eAAO,MAAM,mBAAmB;;;;;;;;iBAK9B,CAAC;AAEH,0DAA0D;AAC1D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;iBAK9B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;iBAMrC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQ9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,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,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,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC"}

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/dist/telemetry/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/telemetry/hash.ts"],"names":[],"mappings":"AAGA,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CASjD"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/telemetry/hash.ts"],"names":[],"mappings":"AAmBA,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CASjD"}

package/dist/web/server.d.ts

@@ -39,6 +39,10 @@ export type ConsoleServer = {
  * loopback. Sirve `/` (HTML), `/api/state` (JSON), `/events` (SSE) y `/healthz`.
  * Solo lectura: cualquier método ≠ GET → 405; ruta desconocida → 404. Con
  * `autoPortFallback` prueba puertos sucesivos si el preferido está ocupado.
+ *
+ * Cuando se inyecta `storageApi` (exposición remota opt-in), las rutas de lectura
+ * (`/`, `/api/state`, `/events`) además exigen token (bearer o `?token=`); sin él
+ * → 401. En modo loopback puro (sin `storageApi`) esas rutas quedan abiertas.
  */
 export declare function createConsoleServer(deps: ConsoleServerDeps): Promise<ConsoleServer>;
 //# sourceMappingURL=server.d.ts.map

package/dist/web/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/web/server.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,IAAI,gBAAgB,EAIjC,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGtD,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAW3E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,iEAAiE;IACjE,YAAY,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC;IAC3C,MAAM,EAAE,aAAa,CAAC;IACtB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,OAAO,gBAAgB,CAAC;IACvC,sCAAsC;IACtC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,8EAA8E;IAC9E,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,eAAe,EAAE,OAAO,CAAC;QACzB,+DAA+D;QAC/D,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,aAAa,CAAC;QAClD,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAC;KACnD,CAAC;IACF;;;OAGG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC;AA2DF;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,aAAa,CAAC,CAmIxB"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/web/server.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,IAAI,gBAAgB,EAIjC,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAItD,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAW3E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,iEAAiE;IACjE,YAAY,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC;IAC3C,MAAM,EAAE,aAAa,CAAC;IACtB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,OAAO,gBAAgB,CAAC;IACvC,sCAAsC;IACtC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,8EAA8E;IAC9E,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,eAAe,EAAE,OAAO,CAAC;QACzB,+DAA+D;QAC/D,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,aAAa,CAAC;QAClD,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAC;KACnD,CAAC;IACF;;;OAGG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC;AAmFF;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,aAAa,CAAC,CA2JxB"}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@jmanuelcorral/openteam",
-  "version": "0.1.38",
-  "description": "Plugin opencode de routing coste-consciente local-first con orquestación Squad.",
+  "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",
   "author": "Jose Manuel Corral",
   "repository": {
@@ -22,11 +23,11 @@
     "lm-studio",
     "foundry-local",
     "cost-optimization",
-    "squad"
+    "multi-agent"
   ],
   "engines": {
     "bun": ">=1.3",
-    "node": ">=20"
+    "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
   },
   "type": "module",
   "main": "./dist/index.js",
@@ -51,8 +52,10 @@
     ".opencode/command/openteam.md"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   },
+  "trustedDependencies": [],
   "sideEffects": false,
   "scripts": {
     "prebuild": "bun run clean",
@@ -63,12 +66,17 @@
     "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "test": "bun test",
     "test:cov": "bun test --coverage",
+    "coverage:check": "node scripts/check-coverage.mjs",
     "typecheck": "tsc --noEmit",
     "lint": "biome check .",
     "format:check": "biome format .",
+    "docs:install": "cd docs && bun install --frozen-lockfile --ignore-scripts",
+    "docs:dev": "cd docs && bun run docs:dev",
+    "docs:build": "cd docs && bun run docs:build",
+    "docs:preview": "cd docs && bun run docs:preview",
     "prepublishOnly": "bun run build",
     "link:local": "bun run build && npm link",
-    "prepare": "node -e \"try{require('node:child_process').execSync('git config core.hooksPath .githooks',{stdio:'ignore'})}catch{}\""
+    "hooks:install": "git config core.hooksPath .githooks"
   },
   "dependencies": {
     "@clack/prompts": "1.7.0",