@jmanuelcorral/openteam 0.1.37 → 0.1.40

package/dist/memory/types.d.ts

@@ -0,0 +1,159 @@
+import { z } from "zod";
+/**
+ * Modelo de memoria semántica de openteam (capa **long-term**). Tipos puros
+ * validados con Zod. Módulo puro: **sin I/O, red, reloj, random ni env vars** —
+ * los timestamps (epoch ms) los inyecta el productor, igual que en
+ * `telemetry/events.ts`.
+ *
+ * Privacidad: por defecto la memoria guarda estructura redactada + `sourceHash`
+ * (provenance), **nunca** el prompt crudo. El contenido literal (`object`,
+ * `preference`, `canonicalName`) solo se persiste si el proyecto activa
+ * `memory.semantic.storeContent`.
+ *
+ * Modelo **bitemporal** (inspirado en agent-memory-dotnet, simplificado):
+ * - valid-time (`validFrom`/`validUntil`): cuándo es cierto en el mundo modelado.
+ * - transaction-time (`createdAt`/`invalidatedAt`): cuándo lo creyó el sistema.
+ * La supersesión es **no destructiva**: el perdedor se marca `invalidatedAt` y
+ * apunta al ganador con `supersededBy`.
+ */
+export declare const MEMORY_SCHEMA_VERSION: 1;
+/**
+ * Clave de propietario (scope de proyecto o usuario). El sentinela
+ * `SHARED_OWNER_KEY` representa memoria compartida/global (visible por cualquier
+ * owner cuando el recall pide `includeShared`).
+ */
+export declare const SHARED_OWNER_KEY: "*";
+export declare const OwnerKeySchema: z.ZodString;
+export declare const MemoryKindSchema: z.ZodEnum<{
+    fact: "fact";
+    preference: "preference";
+    entity: "entity";
+}>;
+/** Hecho estructurado como triple sujeto-predicado-objeto (dueño-scoped). */
+export declare const FactSchema: z.ZodObject<{
+    id: z.ZodString;
+    ownerKey: z.ZodString;
+    confidence: z.ZodNumber;
+    validFrom: z.ZodNumber;
+    validUntil: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    createdAt: z.ZodNumber;
+    invalidatedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    sourceHash: z.ZodString;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"fact">;
+    subject: z.ZodString;
+    predicate: z.ZodString;
+    object: z.ZodString;
+    category: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/** Preferencia del usuario/proyecto en una categoría. */
+export declare const PreferenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    ownerKey: z.ZodString;
+    confidence: z.ZodNumber;
+    validFrom: z.ZodNumber;
+    validUntil: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    createdAt: z.ZodNumber;
+    invalidatedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    sourceHash: z.ZodString;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"preference">;
+    category: z.ZodString;
+    preference: z.ZodString;
+    context: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    lastAccessedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    accessCount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/** Entidad canónica (persona/objeto/lugar/evento/organización). */
+export declare const EntitySchema: z.ZodObject<{
+    id: z.ZodString;
+    ownerKey: z.ZodString;
+    confidence: z.ZodNumber;
+    validFrom: z.ZodNumber;
+    validUntil: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    createdAt: z.ZodNumber;
+    invalidatedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    sourceHash: z.ZodString;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"entity">;
+    canonicalName: z.ZodString;
+    type: z.ZodString;
+    aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const MemoryRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    ownerKey: z.ZodString;
+    confidence: z.ZodNumber;
+    validFrom: z.ZodNumber;
+    validUntil: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    createdAt: z.ZodNumber;
+    invalidatedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    sourceHash: z.ZodString;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"fact">;
+    subject: z.ZodString;
+    predicate: z.ZodString;
+    object: z.ZodString;
+    category: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    ownerKey: z.ZodString;
+    confidence: z.ZodNumber;
+    validFrom: z.ZodNumber;
+    validUntil: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    createdAt: z.ZodNumber;
+    invalidatedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    sourceHash: z.ZodString;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"preference">;
+    category: z.ZodString;
+    preference: z.ZodString;
+    context: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    lastAccessedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    accessCount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    ownerKey: z.ZodString;
+    confidence: z.ZodNumber;
+    validFrom: z.ZodNumber;
+    validUntil: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    createdAt: z.ZodNumber;
+    invalidatedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    sourceHash: z.ZodString;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"entity">;
+    canonicalName: z.ZodString;
+    type: z.ZodString;
+    aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>], "kind">;
+/** Consulta de recall (dueño-scoped, temporal y semántica). */
+export declare const RecallQuerySchema: z.ZodObject<{
+    ownerKey: z.ZodString;
+    kinds: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        fact: "fact";
+        preference: "preference";
+        entity: "entity";
+    }>>>;
+    asOf: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    minSimilarity: z.ZodDefault<z.ZodNumber>;
+    includeShared: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type MemoryKind = z.infer<typeof MemoryKindSchema>;
+export type Fact = z.infer<typeof FactSchema>;
+export type Preference = z.infer<typeof PreferenceSchema>;
+export type Entity = z.infer<typeof EntitySchema>;
+export type MemoryRecord = z.infer<typeof MemoryRecordSchema>;
+export type RecallQuery = z.infer<typeof RecallQuerySchema>;
+/** Vector de embedding (dimensiones configurables). */
+export type Embedding = readonly number[];
+/** Candidato de recall con su similitud ya calculada. */
+export type RecallCandidate = {
+    record: MemoryRecord;
+    similarity: number;
+};
+/** Resultado de recall rankeado (similitud + score combinado). */
+export type RecallResult = RecallCandidate & {
+    score: number;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/memory/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,qBAAqB,EAAG,CAAU,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAG,GAAY,CAAC;AAE7C,eAAO,MAAM,cAAc,aAAoB,CAAC;AAEhD,eAAO,MAAM,gBAAgB;;;;EAA2C,CAAC;AAiBzE,6EAA6E;AAC7E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;iBAMrB,CAAC;AAEH,yDAAyD;AACzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;iBAO3B,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;iBAKvB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAI7B,CAAC;AAEH,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAQ5B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,uDAAuD;AACvD,MAAM,MAAM,SAAS,GAAG,SAAS,MAAM,EAAE,CAAC;AAE1C,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,kEAAkE;AAClE,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG;IAC3C,KAAK,EAAE,MAAM,CAAC;CACf,CAAC"}

package/dist/memory/vector.d.ts

@@ -0,0 +1,18 @@
+import type { Embedding } from "./types";
+/**
+ * Álgebra vectorial **pura y determinista** para el recall semántico. Sin I/O ni
+ * dependencias nativas: implementa el motor por defecto de `VectorIndex`
+ * (ADR-3). Un adapter `sqlite-vec` podrá sustituirlo detrás de la misma interfaz
+ * para volúmenes altos, pero la semántica de similitud vive aquí.
+ */
+/** Producto escalar. Lanza si las dimensiones no coinciden (invariante de datos). */
+export declare function dot(a: Embedding, b: Embedding): number;
+/** Norma euclídea (L2). */
+export declare function norm(a: Embedding): number;
+/**
+ * Similitud coseno en `[-1, 1]`. Devuelve `0` si algún vector es nulo (norma 0),
+ * evitando divisiones por cero. El recall filtra por `minSimilarity`, así que los
+ * valores negativos (disimilares) quedan naturalmente excluidos.
+ */
+export declare function cosineSimilarity(a: Embedding, b: Embedding): number;
+//# sourceMappingURL=vector.d.ts.map

package/dist/memory/vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../src/memory/vector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;GAKG;AAEH,qFAAqF;AACrF,wBAAgB,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CAStD;AAED,2BAA2B;AAC3B,wBAAgB,IAAI,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAOzC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CAMnE"}

package/dist/orchestrator/roles.d.ts

@@ -34,7 +34,7 @@ export declare const AgentRoleProfileSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodLiteral<"auto">]>>;
     localFirst: z.ZodBoolean;
 }, z.core.$strip>;
-export declare const SQUAD_ROLES: Record<string, AgentRoleProfile>;
+export declare const TEAM_ROLES: Record<string, AgentRoleProfile>;
 export declare function getRoleProfile(roleID: string): AgentRoleProfile | undefined;
 export declare function roleToRequirement(role: AgentRoleProfile, task: TaskSignals, tier?: ComplexityTier): CapabilityRequirement;
 //# sourceMappingURL=roles.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../src/orchestrator/roles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,cAAc,CAAC;IAC5B,gBAAgB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpC,kBAAkB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,yBAAyB,EAAE,OAAO,CAAC;IACnC,oBAAoB,EAAE,cAAc,EAAE,CAAC;IACvC,uBAAuB,EAAE,KAAK,CAAC,cAAc,GAAG,MAAM,CAAC,CAAC;IACxD,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAeF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;iBAYjC,CAAC;AAGH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAgFxD,CAAC;AAEF,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE3E;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,WAAW,EACjB,IAAI,CAAC,EAAE,cAAc,GACpB,qBAAqB,CAevB"}
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../src/orchestrator/roles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,cAAc,CAAC;IAC5B,gBAAgB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpC,kBAAkB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,yBAAyB,EAAE,OAAO,CAAC;IACnC,oBAAoB,EAAE,cAAc,EAAE,CAAC;IACvC,uBAAuB,EAAE,KAAK,CAAC,cAAc,GAAG,MAAM,CAAC,CAAC;IACxD,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAeF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;iBAYjC,CAAC;AAGH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAgFvD,CAAC;AAEF,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE3E;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,WAAW,EACjB,IAAI,CAAC,EAAE,cAAc,GACpB,qBAAqB,CAevB"}

package/dist/plugin/hooks.d.ts

@@ -7,8 +7,21 @@ export type ChatMessageHook = NonNullable<Hooks["chat.message"]>;
 export type ChatMessageHookOptions = {
     sink?: EventSink;
     now?: () => number;
+    /**
+     * Inyección de memoria M6 (opt-in). Dado el texto del prompt, devuelve un bloque
+     * de contexto a **prepender** al primer part de texto, o `null` para no inyectar.
+     * Se invoca **después** de elegir modelo y emitir telemetría, de modo que no
+     * altera el determinismo del router ni el hash del prompt.
+     */
+    injectMemory?: (queryText: string) => Promise<string | null>;
 };
 export declare function deriveTaskSignals(input: Parameters<ChatMessageHook>[0], output: Parameters<ChatMessageHook>[1]): TaskSignals;
+/**
+ * Prepend el bloque de memoria al primer part de texto del mensaje. Devuelve
+ * `true` si inyectó. No añade parts nuevos (superficie de contrato acotada:
+ * mutar `text` de un part existente), y es un no-op si no hay part de texto.
+ */
+export declare function injectMemoryBlock(output: Parameters<ChatMessageHook>[1], block: string): boolean;
 export declare function createChatMessageHook(config: OpenTeamConfig, getAvailable: AvailabilityProvider, options?: ChatMessageHookOptions): ChatMessageHook;
 export declare function createHooks(config: OpenTeamConfig, getAvailable: AvailabilityProvider, options?: ChatMessageHookOptions): Hooks;
 //# sourceMappingURL=hooks.d.ts.map

package/dist/plugin/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/plugin/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;AAEjE,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB,CAAC;AA8CF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EACrC,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,GACrC,WAAW,CAqBb;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,oBAAoB,EAClC,OAAO,GAAE,sBAA2B,GACnC,eAAe,CAiCjB;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,oBAAoB,EAClC,OAAO,GAAE,sBAA2B,GACnC,KAAK,CAIP"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/plugin/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;AAEjE,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC9D,CAAC;AA8CF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EACrC,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,GACrC,WAAW,CAqBb;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EACtC,KAAK,EAAE,MAAM,GACZ,OAAO,CAQT;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,oBAAoB,EAClC,OAAO,GAAE,sBAA2B,GACnC,eAAe,CA+CjB;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,oBAAoB,EAClC,OAAO,GAAE,sBAA2B,GACnC,KAAK,CAIP"}

package/dist/plugin/memoryInject.d.ts

@@ -0,0 +1,25 @@
+import type { Embedder } from "../local/embeddings";
+import { type MemoryInjectionParams } from "../memory/inject";
+import type { MemoryIndex } from "../storage/index/memoryIndex";
+/**
+ * Compone el callback `injectMemory` de M6 (push a `chat.message`) a partir del
+ * índice de memoria, un `Embedder` local y la política de recall/inyección.
+ * Aísla el wiring para que `index.ts` sea un caller fino y esto quede cubierto
+ * por tests. El único I/O es el embedding de la query (dentro de `recallMemory`);
+ * el formateo del bloque es puro (`buildMemoryBlock`).
+ */
+export type MemoryInjectorDeps = {
+    index: MemoryIndex;
+    embedder: Embedder;
+    /** Reloj inyectado (epoch ms) para el `asOf` "ahora". */
+    now: () => number;
+};
+export type MemoryInjectorPolicy = {
+    ownerKey: string;
+    minSimilarity: number;
+    maxResults: number;
+    includeShared: boolean;
+    injection: MemoryInjectionParams;
+};
+export declare function buildMemoryInjector(deps: MemoryInjectorDeps, policy: MemoryInjectorPolicy): (queryText: string) => Promise<string | null>;
+//# sourceMappingURL=memoryInject.d.ts.map

package/dist/plugin/memoryInject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryInject.d.ts","sourceRoot":"","sources":["../../src/plugin/memoryInject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAoB,KAAK,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAEhF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAGhE;;;;;;GAMG;AAEH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,yDAAyD;IACzD,GAAG,EAAE,MAAM,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,qBAAqB,CAAC;CAClC,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,kBAAkB,EACxB,MAAM,EAAE,oBAAoB,GAC3B,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAe/C"}

package/dist/router/chooseModel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chooseModel.d.ts","sourceRoot":"","sources":["../../src/router/chooseModel.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAIV,eAAe,EACf,YAAY,EACb,MAAM,SAAS,CAAC;AAoXjB,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,eAAe,CA8HhE"}
+{"version":3,"file":"chooseModel.d.ts","sourceRoot":"","sources":["../../src/router/chooseModel.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAIV,eAAe,EACf,YAAY,EACb,MAAM,SAAS,CAAC;AAsMjB,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,eAAe,CA8HhE"}

package/dist/router/cost.d.ts

@@ -0,0 +1,4 @@
+import type { ModelSelection, RoutingInput } from "./types";
+export declare function estimatedCostUSD(input: RoutingInput, model: ModelSelection): number;
+export declare function roundUSD(value: number): number;
+//# sourceMappingURL=cost.d.ts.map

package/dist/router/cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../src/router/cost.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAW5D,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,cAAc,GACpB,MAAM,CAcR;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9C"}

package/dist/router/frontierBaseline.d.ts

@@ -0,0 +1,13 @@
+import type { ComplexityTier } from "../capabilities/types";
+import type { ModelSelection, RoutingInput } from "./types";
+/**
+ * Resolución pura del baseline frontier (cheapest-capable o pinned). Vive
+ * separada del resto del router para aislar la dependencia del catálogo de
+ * capacidades. Sin I/O ni estado.
+ */
+export type FrontierResolution = {
+    model: ModelSelection;
+    rationale: string[];
+};
+export declare function resolveFrontierBaseline(input: RoutingInput, tier: ComplexityTier): FrontierResolution;
+//# sourceMappingURL=frontierBaseline.d.ts.map

package/dist/router/frontierBaseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontierBaseline.d.ts","sourceRoot":"","sources":["../../src/router/frontierBaseline.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5D;;;;GAIG;AAEH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,cAAc,CAAC;IACtB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,cAAc,GACnB,kBAAkB,CA4BpB"}

package/dist/router/modelSelection.d.ts

@@ -0,0 +1,18 @@
+import type { ModelRef, OpenTeamConfig } from "../config/schema";
+import type { AvailableModel, ModelSelection, RoutingInput } from "./types";
+/**
+ * Utilidades puras de selección de modelos para el router: identidad,
+ * comparación, deduplicación y resolución de los modelos disponibles.
+ * Sin I/O, sin reloj, sin aleatoriedad — igual que el resto de `router/`.
+ */
+export declare function modelKey(model: ModelSelection): string;
+export declare function sameModel(left: ModelRef, right: ModelSelection): boolean;
+export declare function compareModels(left: ModelSelection, right: ModelSelection): number;
+export declare function uniqueModelSelections(models: ModelSelection[]): ModelSelection[];
+export declare function localDefault(config: OpenTeamConfig): ModelSelection;
+export declare function resolveConfiguredFrontierBaseline(config: OpenTeamConfig): ModelSelection;
+export declare function availableModels(input: RoutingInput): AvailableModel[];
+export declare function listedModel(input: RoutingInput, model: ModelSelection): AvailableModel | undefined;
+export declare function frontierAvailable(input: RoutingInput, model: ModelSelection): boolean;
+export declare function availableLocalFallbacks(input: RoutingInput, selected: ModelSelection): ModelSelection[];
+//# sourceMappingURL=modelSelection.d.ts.map

package/dist/router/modelSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelSelection.d.ts","sourceRoot":"","sources":["../../src/router/modelSelection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5E;;;;GAIG;AAEH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAEtD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAExE;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,cAAc,GACpB,MAAM,CAER;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,EAAE,GACvB,cAAc,EAAE,CAQlB;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAKnE;AAED,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,cAAc,GACrB,cAAc,CAShB;AAwBD,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,cAAc,EAAE,CAIrE;AAED,wBAAgB,WAAW,CACzB,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,cAAc,GACpB,cAAc,GAAG,SAAS,CAI5B;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,cAAc,GACpB,OAAO,CAET;AAaD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,cAAc,GACvB,cAAc,EAAE,CAUlB"}

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/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.37",
-  "description": "Plugin opencode de routing coste-consciente local-first con orquestación Squad.",
+  "version": "0.1.40",
+  "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",