@jmanuelcorral/openteam 0.1.38 → 0.1.41

package/dist/index.js

@@ -1,3 +1,6 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/index.ts
 import { dirname as dirname2 } from "node:path";
 
@@ -21,7 +24,7 @@ function buildOrchestratorAgent(frontier, options = {}) {
   ];
   const frontmatter = [
     "---",
-    'description: "Orquestador openteam estilo Squad: en cada petición comprueba si existe equipo; si no, entiende las tareas y crea el equipo de subagentes a demanda, planifica dependencias, paraleliza el trabajo independiente y mantiene el todo con el responsable de cada tarea, con routing local-first."',
+    'description: "Orquestador multiagente de openteam: en cada petición comprueba si existe equipo; si no, entiende las tareas y crea el equipo de subagentes a demanda, planifica dependencias, paraleliza el trabajo independiente y mantiene el todo con el responsable de cada tarea, con routing local-first."',
     "mode: primary",
     `model: ${model}`,
     "temperature: 0.2",
@@ -30,7 +33,7 @@ function buildOrchestratorAgent(frontier, options = {}) {
   ].join(`
 `);
   const body = [
-    "Eres el orquestador de **openteam**, al estilo Squad. Eres el único agente",
+    "Eres el orquestador multiagente de **openteam**. Eres el único agente",
     "primario: no existe un equipo precreado. Tú **construyes el equipo de",
     "subagentes a demanda** según el objetivo del usuario y del repositorio.",
     "",
@@ -56,7 +59,7 @@ function buildOrchestratorAgent(frontier, options = {}) {
     "",
     "## Casting: elige un universo y nombra al equipo",
     "",
-    "Como Squad, el equipo tiene una identidad temática persistente:",
+    "El equipo tiene una identidad temática persistente:",
     "",
     "1. Al crear el equipo por primera vez, **elige un universo** temático (p. ej.",
     "   una película, serie, cómic o mitología). Si el usuario tiene preferencia,",
@@ -333,6 +336,11 @@ var PrivacyModeSchema = z.enum([
   "off"
 ]);
 var BaselineModeSchema = z.enum(["auto", "pinned"]);
+var GraphModeSchema = z.enum(["off", "shadow", "active"]);
+var GraphConfigSchema = z.object({
+  mode: GraphModeSchema.default("off"),
+  killSwitch: z.boolean().default(false)
+});
 var ConsoleHostSchema = z.enum(["127.0.0.1", "localhost"]);
 var ConsoleConfigSchema = z.object({
   host: ConsoleHostSchema.default("127.0.0.1"),
@@ -379,6 +387,50 @@ var LocalRuntimeSchema = z.object({
   discovery: z.enum(["cli", "sdk", "manual"]).optional(),
   defaultModel: ModelRefSchema
 });
+var MemoryScopeSchema = z.enum(["project", "user"]);
+var MemoryExtractionModeSchema = z.enum([
+  "local",
+  "localWithFrontierFallback"
+]);
+var MemoryEmbeddingsProviderSchema = z.enum(["local", "none"]);
+var MemorySemanticSchema = z.object({
+  enabled: z.boolean().default(false),
+  storeContent: z.boolean().default(false),
+  logPath: z.string().min(1).default(".opencode/openteam/memory/records.jsonl"),
+  indexPath: z.string().min(1).default(".opencode/openteam/memory/index.sqlite"),
+  scope: MemoryScopeSchema.default("project"),
+  extraction: z.object({
+    mode: MemoryExtractionModeSchema.default("local"),
+    model: ModelRefSchema.nullable().default(null)
+  }).default({ mode: "local", model: null }),
+  embeddings: z.object({
+    provider: MemoryEmbeddingsProviderSchema.default("local"),
+    model: ModelRefSchema.nullable().default(null),
+    dim: z.number().int().positive().default(768)
+  }).default({ provider: "local", model: null, dim: 768 }),
+  recall: z.object({
+    maxResults: z.number().int().positive().default(8),
+    minSimilarity: z.number().min(0).max(1).default(0.2)
+  }).default({ maxResults: 8, minSimilarity: 0.2 }),
+  injection: z.object({
+    enabled: z.boolean().default(false),
+    maxChars: z.number().int().positive().default(1200),
+    maxItems: z.number().int().positive().default(8)
+  }).default({ enabled: false, maxChars: 1200, maxItems: 8 })
+}).default({
+  enabled: false,
+  storeContent: false,
+  logPath: ".opencode/openteam/memory/records.jsonl",
+  indexPath: ".opencode/openteam/memory/index.sqlite",
+  scope: "project",
+  extraction: { mode: "local", model: null },
+  embeddings: { provider: "local", model: null, dim: 768 },
+  recall: { maxResults: 8, minSimilarity: 0.2 },
+  injection: { enabled: false, maxChars: 1200, maxItems: 8 }
+});
+var MemoryConfigSchema = z.object({
+  semantic: MemorySemanticSchema
+});
 var OpenTeamConfigObjectSchema = z.object({
   baseline: z.object({
     mode: BaselineModeSchema.default("auto"),
@@ -429,9 +481,14 @@ var OpenTeamConfigObjectSchema = z.object({
   }).default({ hardStopOnBudgetExhaustion: false }),
   privacyMode: PrivacyModeSchema.default("forceLocalOnSensitive"),
   console: ConsoleConfigSchema,
-  storage: StorageConfigSchema
+  storage: StorageConfigSchema,
+  memory: MemoryConfigSchema.optional(),
+  graph: GraphConfigSchema.optional()
 });
 var OpenTeamConfigSchema = OpenTeamConfigObjectSchema;
+function resolveMemorySemantic(config) {
+  return config.memory?.semantic ?? MemorySemanticSchema.parse(undefined);
+}
 
 // src/config/persist.ts
 var DEFAULT_CONFIG_PATH = ".opencode/openteam.json";
@@ -447,9 +504,40 @@ async function writeOpenTeamConfigFile(config, path = DEFAULT_CONFIG_PATH, stora
 // src/commands/setup.ts
 var OPENCODE_CONFIG_PATH = "opencode.json";
 
+// src/config/migrations.ts
+var CURRENT_CONFIG_VERSION = 1;
+
+class ConfigMigrationError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "ConfigMigrationError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+function migrateConfig(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return raw;
+  }
+  const record = raw;
+  const version = record.configVersion;
+  if (version === undefined) {
+    return { ...record, configVersion: CURRENT_CONFIG_VERSION };
+  }
+  if (typeof version !== "number" || !Number.isInteger(version) || version < 1) {
+    throw new ConfigMigrationError("unknown-version", String(version));
+  }
+  if (version > CURRENT_CONFIG_VERSION) {
+    throw new ConfigMigrationError("unsupported-version", String(version));
+  }
+  return record;
+}
+
 // src/config/load.ts
 function loadOpenTeamConfig(raw) {
-  return OpenTeamConfigSchema.parse(raw ?? {});
+  return OpenTeamConfigSchema.parse(migrateConfig(raw ?? {}));
 }
 
 // src/local/openai-compatible.ts
@@ -459,6 +547,9 @@ function normalizeBaseURL(baseURL) {
 function modelsEndpoint(baseURL) {
   return `${normalizeBaseURL(baseURL)}/models`;
 }
+function embeddingsEndpoint(baseURL) {
+  return `${normalizeBaseURL(baseURL)}/embeddings`;
+}
 function errorMessage(error) {
   if (error instanceof Error) {
     return error.message;
@@ -1562,9 +1653,9 @@ var HELP = [
   "  openteam local on                 Reactiva el routing local-first",
   "  openteam doctor                   Diagnóstico de runtimes y config",
   "  openteam agents                   Lista los agentes y el LLM (local/frontier) de cada uno",
-  "  openteam console                  Lanza la Console web multi-sesión (Ctrl+C para parar; --open abre el navegador)",
-  "  openteam console --status         Muestra la config de la Console sin lanzarla",
-  "  openteam tunnel                   Expone la Console vía Dev Tunnels (--terminal expone opencode; Ctrl+C para cerrar)",
+  "  openteam console                  [alfa] Lanza la Console web multi-sesión (Ctrl+C para parar; --open abre el navegador)",
+  "  openteam console --status         [alfa] Muestra la config de la Console sin lanzarla",
+  "  openteam tunnel                   [alfa] Expone la Console vía Dev Tunnels (--terminal expone opencode; Ctrl+C para cerrar)",
   "  openteam mcp                      Servidor MCP de solo lectura (memoria del equipo) sobre stdio",
   "  openteam report                   Resumen de coste/ahorro (telemetría)",
   "  openteam yolo status              Muestra si el modo YOLO está activo",
@@ -1942,6 +2033,85 @@ function classifyHeuristic(task) {
   };
 }
 
+// src/router/modelSelection.ts
+function modelKey2(model) {
+  return `${model.providerID}/${model.modelID}`;
+}
+function sameModel(left, right) {
+  return left.providerID === right.providerID && left.modelID === right.modelID;
+}
+function compareModels(left, right) {
+  return modelKey2(left).localeCompare(modelKey2(right));
+}
+function uniqueModelSelections(models) {
+  const byKey = new Map;
+  for (const model of models) {
+    byKey.set(modelKey2(model), model);
+  }
+  return [...byKey.values()].sort(compareModels);
+}
+function localDefault(config) {
+  return config.local.runtimes.find((runtime) => runtime.enabled)?.defaultModel ?? config.router.localDefault;
+}
+function resolveConfiguredFrontierBaseline(config) {
+  if (config.baseline.mode === "pinned" && config.baseline.pinnedModel !== null) {
+    return config.baseline.pinnedModel;
+  }
+  return config.baseline.hardDefault;
+}
+function compareAvailableModels2(left, right) {
+  return compareModels(left, right);
+}
+function defaultAvailableModels2(config) {
+  return [
+    {
+      ...localDefault(config),
+      kind: "local",
+      available: true
+    },
+    {
+      ...resolveConfiguredFrontierBaseline(config),
+      kind: "frontier",
+      available: true
+    }
+  ].sort(compareAvailableModels2);
+}
+function availableModels(input) {
+  return (input.availableModels ?? defaultAvailableModels2(input.config)).slice().sort(compareAvailableModels2);
+}
+function listedModel(input, model) {
+  return availableModels(input).find((candidate) => sameModel(candidate, model));
+}
+function frontierAvailable(input, model) {
+  return listedModel(input, model)?.available !== false;
+}
+function localCandidateIsUsable(input, model) {
+  return model.kind === "local" && model.available && !(input.task.requiresTools === true && model.supportsTools === false);
+}
+function availableLocalFallbacks(input, selected) {
+  return uniqueModelSelections(availableModels(input).filter((model) => localCandidateIsUsable(input, model)).filter((model) => !sameModel(model, selected)).map((model) => ({
+    providerID: model.providerID,
+    modelID: model.modelID
+  })));
+}
+
+// src/router/cost.ts
+function modelProfile(input, model) {
+  return input.profiles?.find((profile) => sameModel(profile.ref, model));
+}
+function estimatedCostUSD(input, model) {
+  const profile = modelProfile(input, model);
+  if (profile === undefined) {
+    return 0;
+  }
+  const inputTokens = input.task.estimatedInputTokens ?? 0;
+  const outputTokens = input.task.estimatedOutputTokens ?? 0;
+  return inputTokens / 1e6 * profile.costPer1M.inputUSD + outputTokens / 1e6 * profile.costPer1M.outputUSD;
+}
+function roundUSD(value) {
+  return Math.round(value * 1000000000000) / 1000000000000;
+}
+
 // src/capabilities/select.ts
 var BLENDED_COST_INPUT_WEIGHT = 0.75;
 var BLENDED_COST_OUTPUT_WEIGHT = 1 - BLENDED_COST_INPUT_WEIGHT;
@@ -1973,7 +2143,7 @@ function deriveRequirement(tier, task) {
 function blendedCostPer1M(profile) {
   return profile.costPer1M.inputUSD * BLENDED_COST_INPUT_WEIGHT + profile.costPer1M.outputUSD * BLENDED_COST_OUTPUT_WEIGHT;
 }
-function modelKey2(profile) {
+function modelKey3(profile) {
   return `${profile.ref.providerID}/${profile.ref.modelID}`;
 }
 function compareCapableFrontier(req, left, right) {
@@ -1989,7 +2159,7 @@ function compareCapableFrontier(req, left, right) {
   if (reasoningWasteDelta !== 0) {
     return reasoningWasteDelta;
   }
-  return modelKey2(left).localeCompare(modelKey2(right));
+  return modelKey3(left).localeCompare(modelKey3(right));
 }
 function satisfiesRequirement(req, profile) {
   return profile.kind === "frontier" && profile.availability !== "unavailable" && profile.contextWindow >= req.minContextWindow && profile.reasoningTier >= req.minReasoningTier && profile.codeQualityTier >= req.minCodeQualityTier && (!req.needsTools || profile.supportsToolCalling) && (!req.needsVision || profile.supportsVision);
@@ -1999,13 +2169,7 @@ function selectCheapestCapableFrontier(req, profiles) {
   return selected?.ref ?? null;
 }
 
-// src/router/chooseModel.ts
-function resolveConfiguredFrontierBaseline(config) {
-  if (config.baseline.mode === "pinned" && config.baseline.pinnedModel !== null) {
-    return config.baseline.pinnedModel;
-  }
-  return config.baseline.hardDefault;
-}
+// src/router/frontierBaseline.ts
 function resolveFrontierBaseline(input, tier) {
   if (input.config.baseline.mode === "pinned" && input.config.baseline.pinnedModel !== null) {
     return { model: input.config.baseline.pinnedModel, rationale: [] };
@@ -2025,48 +2189,8 @@ function resolveFrontierBaseline(input, tier) {
   }
   return { model: input.config.baseline.hardDefault, rationale: [] };
 }
-function localDefault(config) {
-  return config.local.runtimes.find((runtime) => runtime.enabled)?.defaultModel ?? config.router.localDefault;
-}
-function modelKey3(model) {
-  return `${model.providerID}/${model.modelID}`;
-}
-function sameModel(left, right) {
-  return left.providerID === right.providerID && left.modelID === right.modelID;
-}
-function compareModels(left, right) {
-  return modelKey3(left).localeCompare(modelKey3(right));
-}
-function uniqueModelSelections(models) {
-  const byKey = new Map;
-  for (const model of models) {
-    byKey.set(modelKey3(model), model);
-  }
-  return [...byKey.values()].sort(compareModels);
-}
-function defaultAvailableModels2(config) {
-  return [
-    {
-      ...localDefault(config),
-      kind: "local",
-      available: true
-    },
-    {
-      ...resolveConfiguredFrontierBaseline(config),
-      kind: "frontier",
-      available: true
-    }
-  ].sort(compareAvailableModels2);
-}
-function compareAvailableModels2(left, right) {
-  return compareModels(left, right);
-}
-function availableModels(input) {
-  return (input.availableModels ?? defaultAvailableModels2(input.config)).slice().sort(compareAvailableModels2);
-}
-function listedModel(input, model) {
-  return availableModels(input).find((candidate) => sameModel(candidate, model));
-}
+
+// src/router/chooseModel.ts
 function localStatus(input, model) {
   const listed = listedModel(input, model);
   return {
@@ -2074,18 +2198,6 @@ function localStatus(input, model) {
     missingTools: input.task.requiresTools === true && listed?.supportsTools === false
   };
 }
-function frontierAvailable(input, model) {
-  return listedModel(input, model)?.available !== false;
-}
-function localCandidateIsUsable(input, model) {
-  return model.kind === "local" && model.available && !(input.task.requiresTools === true && model.supportsTools === false);
-}
-function availableLocalFallbacks(input, selected) {
-  return uniqueModelSelections(availableModels(input).filter((model) => localCandidateIsUsable(input, model)).filter((model) => !sameModel(model, selected)).map((model) => ({
-    providerID: model.providerID,
-    modelID: model.modelID
-  })));
-}
 function buildFallbackChain(input, selected, frontier, allowFrontier) {
   const chain = availableLocalFallbacks(input, selected);
   if (allowFrontier && !sameModel(frontier, selected) && frontierAvailable(input, frontier)) {
@@ -2141,21 +2253,6 @@ function resolveFrontierPrimary(input, frontier, rationale) {
 function tierForInput(input) {
   return input.tier ?? classifyHeuristic(input.task).tier;
 }
-function modelProfile(input, model) {
-  return input.profiles?.find((profile) => sameModel(profile.ref, model));
-}
-function estimatedCostUSD(input, model) {
-  const profile = modelProfile(input, model);
-  if (profile === undefined) {
-    return 0;
-  }
-  const inputTokens = input.task.estimatedInputTokens ?? 0;
-  const outputTokens = input.task.estimatedOutputTokens ?? 0;
-  return inputTokens / 1e6 * profile.costPer1M.inputUSD + outputTokens / 1e6 * profile.costPer1M.outputUSD;
-}
-function roundUSD(value) {
-  return Math.round(value * 1000000000000) / 1000000000000;
-}
 function finalizeDecision(input, tier, frontier, budgetAction, core) {
   const selectedCostUSD = estimatedCostUSD(input, core.selected);
   const baselineCostUSD = estimatedCostUSD(input, frontier.model);
@@ -2482,10 +2579,22 @@ function deriveTaskSignals(input, output) {
   }
   return signals;
 }
+function injectMemoryBlock(output, block) {
+  for (const part of output.parts) {
+    if (part.type === "text" && typeof part.text === "string") {
+      part.text = `${block}
+
+${part.text}`;
+      return true;
+    }
+  }
+  return false;
+}
 function createChatMessageHook(config, getAvailable, options = {}) {
   const sink = options.sink ?? createNullEventSink();
   const now = options.now ?? Date.now;
   return async (input, output) => {
+    const prompt = promptText(output);
     const signals = deriveTaskSignals(input, output);
     const decision2 = chooseModel({
       config,
@@ -2495,7 +2604,7 @@ function createChatMessageHook(config, getAvailable, options = {}) {
     output.message.model = decision2.selected;
     const telemetryContext = {
       ts: now(),
-      promptHash: hashPrompt(promptText(output)),
+      promptHash: hashPrompt(prompt),
       promptChars: signals.promptChars,
       sessionID: input.sessionID ?? output.message.sessionID
     };
@@ -2506,6 +2615,14 @@ function createChatMessageHook(config, getAvailable, options = {}) {
       telemetryContext.tokensOut = signals.estimatedOutputTokens;
     }
     emitTelemetry(sink, costRecordToRouteEvent(toCostRecord(decision2, telemetryContext)));
+    if (options.injectMemory !== undefined) {
+      try {
+        const block = await options.injectMemory(prompt);
+        if (block !== null && block.length > 0) {
+          injectMemoryBlock(output, block);
+        }
+      } catch {}
+    }
   };
 }
 function createHooks(config, getAvailable, options = {}) {
@@ -2514,6 +2631,247 @@ function createHooks(config, getAvailable, options = {}) {
   };
 }
 
+// src/memory/inject.ts
+var DEFAULT_INJECTION_PARAMS = {
+  maxChars: 1200,
+  header: "Contexto de memoria de openteam (solo referencia):",
+  maxItems: 8
+};
+function formatRecordLine(record) {
+  if (record.kind === "fact") {
+    const base = `- ${record.subject} ${record.predicate} ${record.object}`;
+    return record.category === null ? base : `${base} (${record.category})`;
+  }
+  if (record.kind === "preference") {
+    const base = `- [${record.category}] ${record.preference}`;
+    return record.context === null ? base : `${base} — ${record.context}`;
+  }
+  const aliases = record.aliases.length > 0 ? ` (alias: ${record.aliases.join(", ")})` : "";
+  return `- ${record.canonicalName} [${record.type}]${aliases}`;
+}
+function buildMemoryBlock(results, params = DEFAULT_INJECTION_PARAMS) {
+  if (results.length === 0) {
+    return null;
+  }
+  const lines = [];
+  let used = params.header.length;
+  for (const result of results) {
+    if (lines.length >= params.maxItems) {
+      break;
+    }
+    const line = formatRecordLine(result.record);
+    const cost = line.length + 1;
+    if (used + cost > params.maxChars) {
+      break;
+    }
+    lines.push(line);
+    used += cost;
+  }
+  if (lines.length === 0) {
+    return null;
+  }
+  return `${params.header}
+${lines.join(`
+`)}`;
+}
+
+// src/memory/types.ts
+import { z as z5 } from "zod";
+var SHARED_OWNER_KEY = "*";
+var OwnerKeySchema = z5.string().min(1);
+var MemoryKindSchema = z5.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z5.object({
+  id: z5.string().min(1),
+  ownerKey: OwnerKeySchema,
+  confidence: z5.number().min(0).max(1),
+  validFrom: z5.number().finite(),
+  validUntil: z5.number().finite().nullable().default(null),
+  createdAt: z5.number().finite(),
+  invalidatedAt: z5.number().finite().nullable().default(null),
+  sourceHash: z5.string().min(1),
+  supersededBy: z5.string().min(1).nullable().default(null)
+});
+var FactSchema = MemoryBaseSchema.extend({
+  kind: z5.literal("fact"),
+  subject: z5.string().min(1),
+  predicate: z5.string().min(1),
+  object: z5.string().min(1),
+  category: z5.string().min(1).nullable().default(null)
+});
+var PreferenceSchema = MemoryBaseSchema.extend({
+  kind: z5.literal("preference"),
+  category: z5.string().min(1),
+  preference: z5.string().min(1),
+  context: z5.string().min(1).nullable().default(null),
+  lastAccessedAt: z5.number().finite().nullable().default(null),
+  accessCount: z5.number().int().min(0).default(0)
+});
+var EntitySchema = MemoryBaseSchema.extend({
+  kind: z5.literal("entity"),
+  canonicalName: z5.string().min(1),
+  type: z5.string().min(1),
+  aliases: z5.array(z5.string().min(1)).default([])
+});
+var MemoryRecordSchema = z5.discriminatedUnion("kind", [
+  FactSchema,
+  PreferenceSchema,
+  EntitySchema
+]);
+var RecallQuerySchema = z5.object({
+  ownerKey: OwnerKeySchema,
+  kinds: z5.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z5.number().finite().nullable().default(null),
+  limit: z5.number().int().positive().default(8),
+  minSimilarity: z5.number().min(0).max(1).default(0.2),
+  includeShared: z5.boolean().default(true)
+});
+
+// src/memory/rank.ts
+var DAY_MS = 86400000;
+var DEFAULT_RANK_SIGNALS = {
+  similarityWeight: 1,
+  recencyWeight: 0.2,
+  accessWeight: 0.1,
+  recencyHalfLifeMs: 14 * DAY_MS
+};
+function recencyTimestamp(record) {
+  if (record.kind === "preference" && record.lastAccessedAt !== null) {
+    return record.lastAccessedAt;
+  }
+  return record.createdAt;
+}
+function recencyScore(record, signals) {
+  const ageMs = Math.max(0, signals.now - recencyTimestamp(record));
+  return 0.5 ** (ageMs / signals.recencyHalfLifeMs);
+}
+function accessScore(record) {
+  if (record.kind !== "preference") {
+    return 0;
+  }
+  return 1 - 1 / (1 + record.accessCount);
+}
+function scoreCandidate(candidate, signals) {
+  return signals.similarityWeight * candidate.similarity + signals.recencyWeight * recencyScore(candidate.record, signals) + signals.accessWeight * accessScore(candidate.record);
+}
+function rankRecall(candidates, signals) {
+  return candidates.map((candidate) => ({
+    ...candidate,
+    score: scoreCandidate(candidate, signals)
+  })).sort((a, b) => {
+    if (b.score !== a.score) {
+      return b.score - a.score;
+    }
+    return a.record.id < b.record.id ? -1 : a.record.id > b.record.id ? 1 : 0;
+  });
+}
+
+// src/memory/temporal.ts
+function isTransactionActiveAt(record, asOf) {
+  return record.invalidatedAt === null || record.invalidatedAt > asOf;
+}
+function isValidAt(record, asOf) {
+  if (record.validFrom > asOf) {
+    return false;
+  }
+  return record.validUntil === null || record.validUntil > asOf;
+}
+function isActiveAt(record, asOf) {
+  return isTransactionActiveAt(record, asOf) && isValidAt(record, asOf);
+}
+function filterActive(records, asOf) {
+  return records.filter((record) => isActiveAt(record, asOf));
+}
+function coalesceWindow(a, b) {
+  const validFrom = Math.min(a.validFrom, b.validFrom);
+  const validUntil = a.validUntil === null || b.validUntil === null ? null : Math.max(a.validUntil, b.validUntil);
+  return { validFrom, validUntil };
+}
+
+// src/memory/vector.ts
+function dot(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  let sum = 0;
+  for (let i = 0;i < a.length; i += 1) {
+    sum += a[i] * b[i];
+  }
+  return sum;
+}
+function norm(a) {
+  let sum = 0;
+  for (let i = 0;i < a.length; i += 1) {
+    const value = a[i];
+    sum += value * value;
+  }
+  return Math.sqrt(sum);
+}
+function cosineSimilarity(a, b) {
+  const denom = norm(a) * norm(b);
+  if (denom === 0) {
+    return 0;
+  }
+  return dot(a, b) / denom;
+}
+
+// src/memory/recall.ts
+function matchesScope(record, query) {
+  if (record.ownerKey === query.ownerKey) {
+    return true;
+  }
+  return query.includeShared && record.ownerKey === SHARED_OWNER_KEY;
+}
+function recall(records, queryEmbedding, query, deps) {
+  const asOf = query.asOf ?? deps.now;
+  const kinds = new Set(query.kinds);
+  const candidates = [];
+  for (const record of filterActive(records, asOf)) {
+    if (!kinds.has(record.kind) || !matchesScope(record, query)) {
+      continue;
+    }
+    const embedding = deps.embeddings.get(record.id);
+    if (embedding === undefined) {
+      continue;
+    }
+    const similarity = cosineSimilarity(queryEmbedding, embedding);
+    if (similarity < query.minSimilarity) {
+      continue;
+    }
+    candidates.push({ record, similarity });
+  }
+  const signals = {
+    now: deps.now,
+    ...deps.signals ?? DEFAULT_RANK_SIGNALS
+  };
+  return rankRecall(candidates, signals).slice(0, query.limit);
+}
+
+// src/storage/index/memoryRecall.ts
+async function recallMemory(deps, queryText, query) {
+  const [queryEmbedding] = await deps.embedder([queryText]);
+  if (queryEmbedding === undefined) {
+    return [];
+  }
+  const records = deps.index.allRecords();
+  const embeddings = deps.index.embeddingMap();
+  const recallDeps = deps.signals === undefined ? { embeddings, now: deps.now } : { embeddings, now: deps.now, signals: deps.signals };
+  return recall(records, queryEmbedding, query, recallDeps);
+}
+
+// src/plugin/memoryInject.ts
+function buildMemoryInjector(deps, policy) {
+  return async (queryText) => {
+    const query = RecallQuerySchema.parse({
+      ownerKey: policy.ownerKey,
+      limit: policy.maxResults,
+      minSimilarity: policy.minSimilarity,
+      includeShared: policy.includeShared
+    });
+    const results = await recallMemory({ index: deps.index, embedder: deps.embedder, now: deps.now() }, queryText, query);
+    return buildMemoryBlock(results, policy.injection);
+  };
+}
+
 // src/plugin/toolcalls.ts
 function key(sessionID, callID) {
   return `${sessionID}\x00${callID}`;
@@ -2546,6 +2904,414 @@ function createToolcallTracker(deps) {
   };
 }
 
+// src/local/embeddings.ts
+function parseEmbeddingsResponse(payload) {
+  if (typeof payload !== "object" || payload === null || !Array.isArray(payload.data)) {
+    throw new Error("Respuesta de /embeddings malformada: falta 'data'");
+  }
+  const data = payload.data;
+  return data.map((entry, index) => {
+    const embedding = typeof entry === "object" && entry !== null ? entry.embedding : undefined;
+    if (!Array.isArray(embedding) || !embedding.every((n) => typeof n === "number" && Number.isFinite(n))) {
+      throw new Error(`Respuesta de /embeddings malformada: vector inválido en índice ${index}`);
+    }
+    return embedding;
+  });
+}
+async function embedTexts(request, deps) {
+  if (request.texts.length === 0) {
+    return [];
+  }
+  let response;
+  try {
+    response = await deps.fetch(embeddingsEndpoint(request.baseURL), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json"
+      },
+      body: JSON.stringify({
+        model: request.modelID,
+        input: [...request.texts]
+      })
+    });
+  } catch (error) {
+    throw new Error(`Embeddings local falló: ${errorMessage(error)}`);
+  }
+  if (!response.ok) {
+    throw new Error(`Embeddings local falló: HTTP ${response.status} en /embeddings`);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (error) {
+    throw new Error(`Embeddings local falló: ${errorMessage(error)}`);
+  }
+  const vectors = parseEmbeddingsResponse(payload);
+  if (vectors.length !== request.texts.length) {
+    throw new Error(`Embeddings local devolvió ${vectors.length} vectores para ${request.texts.length} textos`);
+  }
+  return vectors;
+}
+function createLocalEmbedder(request, deps) {
+  return (texts) => embedTexts({ ...request, texts }, deps);
+}
+
+// src/storage/index/bunSqlite.ts
+async function createBunSqliteDatabase(path) {
+  const mod = await import("bun:sqlite");
+  return new mod.Database(path);
+}
+
+// src/memory/merge.ts
+var SEP = "\x00";
+function factSlotKey(fact) {
+  return [fact.subject, fact.predicate, fact.ownerKey].join(SEP);
+}
+function factValueKey(fact) {
+  return [factSlotKey(fact), fact.object].join(SEP);
+}
+function preferenceSlotKey(preference) {
+  return [preference.category, preference.ownerKey].join(SEP);
+}
+function preferenceValueKey(preference) {
+  return [preferenceSlotKey(preference), preference.preference].join(SEP);
+}
+function entitySlotKey(entity) {
+  return [entity.canonicalName, entity.type, entity.ownerKey].join(SEP);
+}
+function coalesceFact(existing, incoming) {
+  const window = coalesceWindow(existing, incoming);
+  return {
+    ...existing,
+    validFrom: window.validFrom,
+    validUntil: window.validUntil,
+    confidence: Math.max(existing.confidence, incoming.confidence)
+  };
+}
+function applyFact(state, incoming, now) {
+  const incomingSlot = factSlotKey(incoming);
+  const incomingValue = factValueKey(incoming);
+  const superseded = [];
+  const records = [];
+  let reaffirmed = false;
+  for (const fact of state) {
+    if (!isActiveAt(fact, now)) {
+      records.push(fact);
+      continue;
+    }
+    if (factValueKey(fact) === incomingValue) {
+      records.push(coalesceFact(fact, incoming));
+      reaffirmed = true;
+      continue;
+    }
+    if (factSlotKey(fact) === incomingSlot) {
+      const dead = {
+        ...fact,
+        invalidatedAt: now,
+        supersededBy: incoming.id
+      };
+      superseded.push(dead);
+      records.push(dead);
+      continue;
+    }
+    records.push(fact);
+  }
+  if (!reaffirmed) {
+    records.push(incoming);
+  }
+  return { records, superseded };
+}
+function applyPreference(state, incoming, now) {
+  const incomingSlot = preferenceSlotKey(incoming);
+  const incomingValue = preferenceValueKey(incoming);
+  const superseded = [];
+  const records = [];
+  let reaffirmed = false;
+  for (const preference of state) {
+    if (!isActiveAt(preference, now)) {
+      records.push(preference);
+      continue;
+    }
+    if (preferenceValueKey(preference) === incomingValue) {
+      records.push({
+        ...preference,
+        confidence: Math.max(preference.confidence, incoming.confidence)
+      });
+      reaffirmed = true;
+      continue;
+    }
+    if (preferenceSlotKey(preference) === incomingSlot) {
+      const dead = {
+        ...preference,
+        invalidatedAt: now,
+        supersededBy: incoming.id
+      };
+      superseded.push(dead);
+      records.push(dead);
+      continue;
+    }
+    records.push(preference);
+  }
+  if (!reaffirmed) {
+    records.push(incoming);
+  }
+  return { records, superseded };
+}
+function mergeAliases(existing, incoming) {
+  const seen = new Set(existing);
+  const merged = [...existing];
+  for (const alias of incoming) {
+    if (!seen.has(alias)) {
+      seen.add(alias);
+      merged.push(alias);
+    }
+  }
+  return merged;
+}
+function applyEntity(state, incoming, now) {
+  const incomingSlot = entitySlotKey(incoming);
+  const records = [];
+  let merged = false;
+  for (const entity of state) {
+    if (isActiveAt(entity, now) && entitySlotKey(entity) === incomingSlot) {
+      records.push({
+        ...entity,
+        aliases: mergeAliases(entity.aliases, incoming.aliases),
+        confidence: Math.max(entity.confidence, incoming.confidence)
+      });
+      merged = true;
+      continue;
+    }
+    records.push(entity);
+  }
+  if (!merged) {
+    records.push(incoming);
+  }
+  return { records, superseded: [] };
+}
+
+// src/memory/fold.ts
+function emptyState() {
+  return { facts: [], preferences: [], entities: [] };
+}
+function applyTombstone(state, tombstone) {
+  const mark = (records) => records.map((record) => record.id === tombstone.id ? {
+    ...record,
+    invalidatedAt: tombstone.invalidatedAt,
+    supersededBy: tombstone.supersededBy
+  } : record);
+  if (tombstone.kind === "fact") {
+    state.facts = mark(state.facts);
+  } else if (tombstone.kind === "preference") {
+    state.preferences = mark(state.preferences);
+  } else {
+    state.entities = mark(state.entities);
+  }
+}
+function foldAssertions(assertions) {
+  const state = emptyState();
+  for (const assertion of assertions) {
+    if (assertion.invalidatedAt !== null) {
+      applyTombstone(state, assertion);
+      continue;
+    }
+    if (assertion.kind === "fact") {
+      state.facts = applyFact(state.facts, assertion, assertion.createdAt).records;
+    } else if (assertion.kind === "preference") {
+      state.preferences = applyPreference(state.preferences, assertion, assertion.createdAt).records;
+    } else {
+      state.entities = applyEntity(state.entities, assertion, assertion.createdAt).records;
+    }
+  }
+  return state;
+}
+function allRecords(state) {
+  return [...state.facts, ...state.preferences, ...state.entities];
+}
+
+// src/memory/log.ts
+function parseMemoryLog(text) {
+  const records = [];
+  for (const line of text.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    let candidate;
+    try {
+      candidate = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const parsed = MemoryRecordSchema.safeParse(candidate);
+    if (parsed.success) {
+      records.push(parsed.data);
+    }
+  }
+  return records;
+}
+
+// src/storage/index/memoryIndex.ts
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS memory_records (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL,
+  owner_key TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  invalidated_at INTEGER,
+  payload TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_memory_owner ON memory_records(owner_key, kind);
+CREATE TABLE IF NOT EXISTS memory_embeddings (
+  record_id TEXT PRIMARY KEY,
+  dim INTEGER NOT NULL,
+  vector TEXT NOT NULL
+);
+`;
+var INSERT_SQL = `INSERT OR REPLACE INTO memory_records
+  (id, kind, owner_key, created_at, invalidated_at, payload)
+  VALUES (?, ?, ?, ?, ?, ?)`;
+var INSERT_EMBEDDING_SQL = `INSERT OR REPLACE INTO memory_embeddings
+  (record_id, dim, vector) VALUES (?, ?, ?)`;
+function insertRecords(db, records) {
+  const stmt = db.query(INSERT_SQL);
+  db.run("BEGIN");
+  try {
+    for (const record of records) {
+      stmt.run(record.id, record.kind, record.ownerKey, record.createdAt, record.invalidatedAt, JSON.stringify(record));
+    }
+    db.run("COMMIT");
+  } catch (error) {
+    db.run("ROLLBACK");
+    throw error;
+  }
+}
+function createMemoryIndex(db) {
+  db.exec(SCHEMA);
+  const allRecordsFn = () => {
+    const rows = db.query("SELECT payload FROM memory_records ORDER BY created_at ASC, id ASC").all();
+    const records = [];
+    for (const row of rows) {
+      let candidate;
+      try {
+        candidate = JSON.parse(row.payload);
+      } catch {
+        continue;
+      }
+      const parsed = MemoryRecordSchema.safeParse(candidate);
+      if (parsed.success) {
+        records.push(parsed.data);
+      }
+    }
+    return records;
+  };
+  const state = () => {
+    const facts = [];
+    const preferences = [];
+    const entities = [];
+    for (const record of allRecordsFn()) {
+      if (record.kind === "fact") {
+        facts.push(record);
+      } else if (record.kind === "preference") {
+        preferences.push(record);
+      } else {
+        entities.push(record);
+      }
+    }
+    return { facts, preferences, entities };
+  };
+  return {
+    rebuild(assertions) {
+      const folded = allRecords(foldAssertions(assertions));
+      db.run("DELETE FROM memory_records");
+      insertRecords(db, folded);
+    },
+    allRecords: allRecordsFn,
+    state,
+    activeAt(asOf) {
+      return filterActive(allRecordsFn(), asOf);
+    },
+    putEmbeddings(entries) {
+      const stmt = db.query(INSERT_EMBEDDING_SQL);
+      db.run("BEGIN");
+      try {
+        for (const entry of entries) {
+          stmt.run(entry.recordId, entry.vector.length, JSON.stringify(entry.vector));
+        }
+        db.run("COMMIT");
+      } catch (error) {
+        db.run("ROLLBACK");
+        throw error;
+      }
+    },
+    embeddingMap() {
+      const rows = db.query("SELECT record_id, vector FROM memory_embeddings").all();
+      const map = new Map;
+      for (const row of rows) {
+        try {
+          const vector = JSON.parse(row.vector);
+          if (Array.isArray(vector) && vector.every((n) => typeof n === "number")) {
+            map.set(row.record_id, vector);
+          }
+        } catch {}
+      }
+      return map;
+    },
+    pruneEmbeddings() {
+      const result = db.run("DELETE FROM memory_embeddings WHERE record_id NOT IN (SELECT id FROM memory_records)");
+      return typeof result?.changes === "number" ? result.changes : 0;
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+async function rebuildMemoryIndexFromStorage(index, logPath, deps) {
+  const text = await deps.storage.read(logPath) ?? "";
+  const assertions = parseMemoryLog(text);
+  index.rebuild(assertions);
+  return assertions.length;
+}
+
+// src/storage/index/memoryRuntime.ts
+async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
+  const semantic = resolveMemorySemantic(config);
+  if (!semantic.enabled || semantic.embeddings.provider === "none") {
+    return;
+  }
+  if (options.requireInjectionEnabled === true && !semantic.injection.enabled) {
+    return;
+  }
+  const runtime = config.local.runtimes.find((rt) => rt.enabled && rt.baseURL !== undefined);
+  if (runtime?.baseURL === undefined) {
+    return;
+  }
+  const modelID = semantic.embeddings.model?.modelID ?? runtime.defaultModel.modelID;
+  const openDatabase = deps.openDatabase ?? createBunSqliteDatabase;
+  const makeEmbedder = deps.createEmbedder ?? createLocalEmbedder;
+  const fetchImpl = deps.fetch ?? globalThis.fetch;
+  const now = deps.now ?? (() => Date.now());
+  try {
+    const db = await openDatabase(semantic.indexPath);
+    const index = createMemoryIndex(db);
+    await rebuildMemoryIndexFromStorage(index, semantic.logPath, {
+      storage: deps.storage
+    });
+    const embedder = makeEmbedder({ baseURL: runtime.baseURL, modelID }, { fetch: fetchImpl });
+    return {
+      index,
+      embedder,
+      now,
+      ownerKey: semantic.scope === "user" ? "user" : "project",
+      semantic
+    };
+  } catch {
+    return;
+  }
+}
+
 // src/index.ts
 function createShellExec($) {
   return async (command, args) => {
@@ -2565,6 +3331,24 @@ function logTelemetryError(error) {
   const message = error instanceof Error ? error.message : String(error);
   console.warn(`[openteam] telemetry write failed: ${message}`);
 }
+async function buildMemoryInjectorFromConfig(config, storage) {
+  const runtime = await buildMemoryRuntimeFromConfig(config, { storage }, { requireInjectionEnabled: true });
+  if (runtime === undefined) {
+    return;
+  }
+  const { index, embedder, now, ownerKey, semantic } = runtime;
+  return buildMemoryInjector({ index, embedder, now }, {
+    ownerKey,
+    minSimilarity: semantic.recall.minSimilarity,
+    maxResults: semantic.recall.maxResults,
+    includeShared: true,
+    injection: {
+      maxChars: semantic.injection.maxChars,
+      maxItems: semantic.injection.maxItems,
+      header: "Contexto de memoria de openteam (solo referencia):"
+    }
+  });
+}
 function telemetryOptions(rawOptions) {
   const telemetry = rawOptions !== null && typeof rawOptions === "object" && "telemetry" in rawOptions && rawOptions.telemetry !== null && typeof rawOptions.telemetry === "object" ? rawOptions.telemetry : {};
   const enabled = !("enabled" in telemetry) || telemetry.enabled !== false;
@@ -2645,7 +3429,8 @@ var server = async (ctx, rawOptions) => {
   const sessionsDir = telemetryOptions(rawOptions).sessionsDir;
   const storage = createFsStorageProvider(process.cwd());
   const sink = createEventSink(rawOptions, storage);
-  const hooks = createHooks(config, cache.get, { sink });
+  const injectMemory = await buildMemoryInjectorFromConfig(config, storage);
+  const hooks = createHooks(config, cache.get, injectMemory === undefined ? { sink } : { sink, injectMemory });
   const cliDeps = createCliDeps(config, registry, telemetryPath, sessionsDir, storage);
   const toolcalls = createToolcallTracker({ sink });
   const now = () => Date.now();