@jmanuelcorral/openteam 0.1.38 → 0.1.41

package/dist/cli.js

@@ -628,6 +628,11 @@ var PrivacyModeSchema = z3.enum([
   "off"
 ]);
 var BaselineModeSchema = z3.enum(["auto", "pinned"]);
+var GraphModeSchema = z3.enum(["off", "shadow", "active"]);
+var GraphConfigSchema = z3.object({
+  mode: GraphModeSchema.default("off"),
+  killSwitch: z3.boolean().default(false)
+});
 var ConsoleHostSchema = z3.enum(["127.0.0.1", "localhost"]);
 var ConsoleConfigSchema = z3.object({
   host: ConsoleHostSchema.default("127.0.0.1"),
@@ -674,6 +679,50 @@ var LocalRuntimeSchema = z3.object({
   discovery: z3.enum(["cli", "sdk", "manual"]).optional(),
   defaultModel: ModelRefSchema
 });
+var MemoryScopeSchema = z3.enum(["project", "user"]);
+var MemoryExtractionModeSchema = z3.enum([
+  "local",
+  "localWithFrontierFallback"
+]);
+var MemoryEmbeddingsProviderSchema = z3.enum(["local", "none"]);
+var MemorySemanticSchema = z3.object({
+  enabled: z3.boolean().default(false),
+  storeContent: z3.boolean().default(false),
+  logPath: z3.string().min(1).default(".opencode/openteam/memory/records.jsonl"),
+  indexPath: z3.string().min(1).default(".opencode/openteam/memory/index.sqlite"),
+  scope: MemoryScopeSchema.default("project"),
+  extraction: z3.object({
+    mode: MemoryExtractionModeSchema.default("local"),
+    model: ModelRefSchema.nullable().default(null)
+  }).default({ mode: "local", model: null }),
+  embeddings: z3.object({
+    provider: MemoryEmbeddingsProviderSchema.default("local"),
+    model: ModelRefSchema.nullable().default(null),
+    dim: z3.number().int().positive().default(768)
+  }).default({ provider: "local", model: null, dim: 768 }),
+  recall: z3.object({
+    maxResults: z3.number().int().positive().default(8),
+    minSimilarity: z3.number().min(0).max(1).default(0.2)
+  }).default({ maxResults: 8, minSimilarity: 0.2 }),
+  injection: z3.object({
+    enabled: z3.boolean().default(false),
+    maxChars: z3.number().int().positive().default(1200),
+    maxItems: z3.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 = z3.object({
+  semantic: MemorySemanticSchema
+});
 var OpenTeamConfigObjectSchema = z3.object({
   baseline: z3.object({
     mode: BaselineModeSchema.default("auto"),
@@ -724,9 +773,14 @@ var OpenTeamConfigObjectSchema = z3.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/telemetry/events.ts
 var EVENT_SCHEMA_VERSION = 1;
@@ -1182,6 +1236,208 @@ import {
   createServer as createHttpServer
 } from "node:http";
 
+// src/console/assets.ts
+var CONSOLE_STYLE = `
+:root{color-scheme:dark;--bg:#0f1115;--panel:#171a21;--fg:#e6e8eb;--muted:#8b929c;--good:#3fb950;--local:#58a6ff;--frontier:#d29922;--line:#262b34}
+*{box-sizing:border-box}
+body{margin:0;background:var(--bg);color:var(--fg);font:14px/1.5 ui-sans-serif,system-ui,Segoe UI,Roboto,sans-serif}
+header{padding:16px 24px;border-bottom:1px solid var(--line);display:flex;justify-content:space-between;align-items:baseline;gap:12px;flex-wrap:wrap}
+header h1{font-size:18px;margin:0}
+header .meta{color:var(--muted);font-size:12px}
+main{display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:16px;padding:24px}
+.panel{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:16px}
+.panel h2{font-size:14px;margin:0 0 12px;color:var(--muted);text-transform:uppercase;letter-spacing:.04em}
+.grid{display:grid;grid-template-columns:repeat(2,1fr);gap:10px}
+.stat{display:flex;flex-direction:column;gap:2px}
+.stat .k{color:var(--muted);font-size:12px}
+.stat .v{font-size:18px;font-weight:600}
+.good{color:var(--good)}
+.local{color:var(--local)}
+.frontier{color:var(--frontier)}
+.muted{color:var(--muted)}
+table{width:100%;border-collapse:collapse;font-size:13px}
+th,td{text-align:left;padding:6px 8px;border-bottom:1px solid var(--line)}
+th{color:var(--muted);font-weight:600}
+.hash{font-family:ui-monospace,Consolas,monospace;color:var(--muted)}
+.progress{height:10px;background:#0b0d11;border-radius:6px;overflow:hidden;border:1px solid var(--line)}
+.progress .bar{height:100%;background:var(--good)}
+ul.items,ul.timeline{list-style:none;margin:8px 0 0;padding:0;max-height:320px;overflow:auto}
+ul.items li,ul.timeline li{padding:4px 0;border-bottom:1px solid var(--line)}
+ul.items li.done{color:var(--muted)}
+ul.items .box{font-family:monospace}
+.who{color:var(--local)}
+.tag{color:var(--frontier);font-size:12px}
+.kind{display:inline-block;min-width:66px;color:var(--muted);font-size:12px}
+code{font-family:ui-monospace,Consolas,monospace;background:#0b0d11;padding:1px 5px;border-radius:4px}
+.mono{font-family:ui-monospace,Consolas,monospace;font-size:12px}
+.tabs{display:flex;gap:6px;padding:12px 24px 0;flex-wrap:wrap;border-bottom:1px solid var(--line)}
+.tabs .tab{background:var(--panel);color:var(--fg);border:1px solid var(--line);border-bottom:none;border-radius:8px 8px 0 0;padding:8px 14px;cursor:pointer;font:inherit;display:flex;align-items:center;gap:6px}
+.tabs .tab.active{background:var(--bg);border-color:var(--local);color:var(--fg)}
+.dot{width:8px;height:8px;border-radius:50%;display:inline-block;background:var(--muted)}
+.badge{font-size:11px;padding:1px 8px;border-radius:10px;border:1px solid var(--line);color:var(--muted);vertical-align:middle}
+.status-running{background:var(--good)}
+.badge.status-running{color:var(--good);border-color:var(--good)}
+.status-idle{background:var(--muted)}
+.badge.status-idle{color:var(--muted)}
+.status-waiting-input{background:var(--frontier)}
+.badge.status-waiting-input{color:var(--frontier);border-color:var(--frontier)}
+.status-ended{background:#6e7681}
+.badge.status-ended{color:#6e7681}
+.term .termlog{background:#0b0d11;border:1px solid var(--line);border-radius:8px;padding:10px;max-height:340px;overflow:auto;font-family:ui-monospace,Consolas,monospace;font-size:12px;white-space:pre-wrap}
+.term .tl{padding:1px 0}
+.term .tl.input{color:var(--local)}
+.term .tl.tool{color:var(--frontier)}
+.term .tl.status{color:var(--muted)}
+.term .tl.error{color:#f85149}
+.term .tl.permission{color:var(--frontier);font-weight:600}
+.term form.terminput{display:flex;gap:8px;margin-top:10px}
+.term form.terminput input{flex:1;background:#0b0d11;color:var(--fg);border:1px solid var(--line);border-radius:8px;padding:8px 10px;font:inherit}
+.term form.terminput button{background:var(--local);color:#04122b;border:none;border-radius:8px;padding:8px 16px;cursor:pointer;font:inherit;font-weight:600}
+.pty .ptylog{background:#05070a;border:1px solid var(--line);border-radius:8px;padding:10px;max-height:340px;overflow:auto;font-family:ui-monospace,Consolas,monospace;font-size:12px;white-space:pre-wrap;color:#c8d1dc}
+.pty form.ptyinput{display:flex;gap:8px;margin-top:10px}
+.pty form.ptyinput input{flex:1;background:#05070a;color:var(--fg);border:1px solid var(--line);border-radius:8px;padding:8px 10px;font:inherit}
+.pty form.ptyinput button,.pty .pty-start{background:var(--frontier);color:#1a1200;border:none;border-radius:8px;padding:8px 16px;cursor:pointer;font:inherit;font-weight:600;margin-top:8px}
+.pty .pty-start:disabled{opacity:.5;cursor:default}
+`;
+var CONSOLE_CLIENT_JS = `
+(function(){
+  var authTok='';
+  try{
+    var qp=new URLSearchParams(window.location.search).get('token');
+    if(qp){authTok='?token='+encodeURIComponent(qp)}
+  }catch(e){/* ignore */}
+  function reloadIfChanged(prev){
+    fetch('/api/state'+authTok).then(function(r){return r.json()}).then(function(s){
+      if(s.generatedAt!==prev){location.reload()}
+    }).catch(function(){});
+  }
+  var current=document.documentElement.getAttribute('data-generated')||'';
+  if('EventSource' in window){
+    try{
+      var es=new EventSource('/events'+authTok);
+      es.addEventListener('state',function(){location.reload()});
+      es.onerror=function(){/* fallback below */};
+    }catch(e){/* ignore */}
+  }
+  var ms=parseInt(document.documentElement.getAttribute('data-refresh')||'2000',10);
+  setInterval(function(){reloadIfChanged(current)},isNaN(ms)?2000:Math.max(250,ms));
+
+  function selectTab(name){
+    var tabs=document.querySelectorAll('#tabbar .tab');
+    for(var i=0;i<tabs.length;i++){tabs[i].classList.toggle('active',tabs[i].getAttribute('data-tab')===name)}
+    var views=document.querySelectorAll('main .view');
+    var matched=false;
+    for(var j=0;j<views.length;j++){
+      var show=views[j].getAttribute('data-view')===name;
+      views[j].hidden=!show;
+      if(show){matched=true;if(name!=='all'){connectTerminal(views[j],name)}}
+    }
+    if(!matched){return false}
+    try{sessionStorage.setItem('openteam.tab',name)}catch(e){}
+    return true;
+  }
+  function connectTerminal(view,id){
+    if(view.__wired){return}
+    var root=document.documentElement;
+    var token=root.getAttribute('data-token');
+    if(root.getAttribute('data-terminal')!=='1'||!token){return}
+    var log=view.querySelector('.termlog');
+    if(!log){return}
+    view.__wired=true;
+    function append(cls,text){
+      var line=document.createElement('div');
+      line.className='tl '+cls;line.textContent=text;
+      log.appendChild(line);log.scrollTop=log.scrollHeight;
+    }
+    var q='/console/session/'+encodeURIComponent(id);
+    var tk='token='+encodeURIComponent(token);
+    if('EventSource' in window){
+      try{
+        var es=new EventSource(q+'/stream?'+tk);
+        es.addEventListener('frame',function(e){try{var f=JSON.parse(e.data);append(f.kind,f.text)}catch(_){}}); 
+        es.onerror=function(){/* reconecta solo */};
+      }catch(_){/* ignore */}
+    }
+    var form=view.querySelector('form.terminput');
+    if(form){
+      form.addEventListener('submit',function(e){
+        e.preventDefault();
+        var inp=form.querySelector('input[name=text]');
+        var text=inp.value;
+        if(!text){return}
+        inp.value='';append('input','› '+text);
+        fetch(q+'/input?'+tk,{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({text:text})})
+          .then(function(r){if(!r.ok){append('error','✖ envío rechazado ('+r.status+')')}})
+          .catch(function(){append('error','✖ no se pudo enviar')});
+      });
+    }
+    connectPty(view,id,q,tk);
+  }
+  function connectPty(view,id,q,tk){
+    var root=document.documentElement;
+    if(root.getAttribute('data-pty')!=='1'){return}
+    var pane=view.querySelector('.pty');
+    if(!pane){return}
+    var log=pane.querySelector('.ptylog');
+    var startBtn=pane.querySelector('.pty-start');
+    var input=pane.querySelector('form.ptyinput');
+    function plog(text){
+      var d=document.createElement('span');d.textContent=text;
+      log.appendChild(d);log.scrollTop=log.scrollHeight;
+    }
+    if(!startBtn){return}
+    startBtn.addEventListener('click',function(){
+      startBtn.disabled=true;plog('Abriendo shell…
+');
+      fetch(q+'/pty?'+tk,{method:'POST',headers:{'content-type':'application/json'},body:'{}'})
+        .then(function(r){return r.ok?r.json():Promise.reject(r.status)})
+        .then(function(info){openPtyWs(info.wsUrl)})
+        .catch(function(s){plog('✖ no se pudo abrir PTY ('+s+')
+');startBtn.disabled=false});
+    });
+    function openPtyWs(url){
+      try{
+        var ws=new WebSocket(url);
+        ws.binaryType='arraybuffer';
+        ws.onmessage=function(e){
+          var data=e.data;
+          if(data instanceof ArrayBuffer){data=new TextDecoder().decode(new Uint8Array(data))}
+          plog(data);
+        };
+        ws.onclose=function(){plog('
+[shell cerrada]
+');startBtn.disabled=false};
+        ws.onerror=function(){plog('
+✖ error de WebSocket
+')};
+        if(input){
+          input.hidden=false;
+          input.addEventListener('submit',function(e){
+            e.preventDefault();
+            var c=input.querySelector('input[name=cmd]');
+            if(!c.value){return}
+            ws.send(c.value+'\r');c.value='';
+          });
+        }
+      }catch(_){plog('
+✖ WebSocket no disponible
+');startBtn.disabled=false}
+    }
+  }
+  var bar=document.getElementById('tabbar');
+  if(bar){
+    bar.addEventListener('click',function(e){
+      var t=e.target;
+      while(t&&t!==bar&&!t.getAttribute('data-tab')){t=t.parentNode}
+      if(t&&t.getAttribute('data-tab')){selectTab(t.getAttribute('data-tab'))}
+    });
+  }
+  var saved='all';
+  try{saved=sessionStorage.getItem('openteam.tab')||'all'}catch(e){}
+  if(!selectTab(saved)){selectTab('all')}
+})();
+`;
+
 // src/console/render.ts
 var TIERS = [
   "trivial",
@@ -1497,201 +1753,6 @@ function sessionView(tab, terminalEnabled, ptyEnabled) {
   ].join("");
   return `<div class="view" data-view="${escapeHtml(tab.sessionID)}" hidden>${body}</div>`;
 }
-var STYLE = `
-:root{color-scheme:dark;--bg:#0f1115;--panel:#171a21;--fg:#e6e8eb;--muted:#8b929c;--good:#3fb950;--local:#58a6ff;--frontier:#d29922;--line:#262b34}
-*{box-sizing:border-box}
-body{margin:0;background:var(--bg);color:var(--fg);font:14px/1.5 ui-sans-serif,system-ui,Segoe UI,Roboto,sans-serif}
-header{padding:16px 24px;border-bottom:1px solid var(--line);display:flex;justify-content:space-between;align-items:baseline;gap:12px;flex-wrap:wrap}
-header h1{font-size:18px;margin:0}
-header .meta{color:var(--muted);font-size:12px}
-main{display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:16px;padding:24px}
-.panel{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:16px}
-.panel h2{font-size:14px;margin:0 0 12px;color:var(--muted);text-transform:uppercase;letter-spacing:.04em}
-.grid{display:grid;grid-template-columns:repeat(2,1fr);gap:10px}
-.stat{display:flex;flex-direction:column;gap:2px}
-.stat .k{color:var(--muted);font-size:12px}
-.stat .v{font-size:18px;font-weight:600}
-.good{color:var(--good)}
-.local{color:var(--local)}
-.frontier{color:var(--frontier)}
-.muted{color:var(--muted)}
-table{width:100%;border-collapse:collapse;font-size:13px}
-th,td{text-align:left;padding:6px 8px;border-bottom:1px solid var(--line)}
-th{color:var(--muted);font-weight:600}
-.hash{font-family:ui-monospace,Consolas,monospace;color:var(--muted)}
-.progress{height:10px;background:#0b0d11;border-radius:6px;overflow:hidden;border:1px solid var(--line)}
-.progress .bar{height:100%;background:var(--good)}
-ul.items,ul.timeline{list-style:none;margin:8px 0 0;padding:0;max-height:320px;overflow:auto}
-ul.items li,ul.timeline li{padding:4px 0;border-bottom:1px solid var(--line)}
-ul.items li.done{color:var(--muted)}
-ul.items .box{font-family:monospace}
-.who{color:var(--local)}
-.tag{color:var(--frontier);font-size:12px}
-.kind{display:inline-block;min-width:66px;color:var(--muted);font-size:12px}
-code{font-family:ui-monospace,Consolas,monospace;background:#0b0d11;padding:1px 5px;border-radius:4px}
-.mono{font-family:ui-monospace,Consolas,monospace;font-size:12px}
-.tabs{display:flex;gap:6px;padding:12px 24px 0;flex-wrap:wrap;border-bottom:1px solid var(--line)}
-.tabs .tab{background:var(--panel);color:var(--fg);border:1px solid var(--line);border-bottom:none;border-radius:8px 8px 0 0;padding:8px 14px;cursor:pointer;font:inherit;display:flex;align-items:center;gap:6px}
-.tabs .tab.active{background:var(--bg);border-color:var(--local);color:var(--fg)}
-.dot{width:8px;height:8px;border-radius:50%;display:inline-block;background:var(--muted)}
-.badge{font-size:11px;padding:1px 8px;border-radius:10px;border:1px solid var(--line);color:var(--muted);vertical-align:middle}
-.status-running{background:var(--good)}
-.badge.status-running{color:var(--good);border-color:var(--good)}
-.status-idle{background:var(--muted)}
-.badge.status-idle{color:var(--muted)}
-.status-waiting-input{background:var(--frontier)}
-.badge.status-waiting-input{color:var(--frontier);border-color:var(--frontier)}
-.status-ended{background:#6e7681}
-.badge.status-ended{color:#6e7681}
-.term .termlog{background:#0b0d11;border:1px solid var(--line);border-radius:8px;padding:10px;max-height:340px;overflow:auto;font-family:ui-monospace,Consolas,monospace;font-size:12px;white-space:pre-wrap}
-.term .tl{padding:1px 0}
-.term .tl.input{color:var(--local)}
-.term .tl.tool{color:var(--frontier)}
-.term .tl.status{color:var(--muted)}
-.term .tl.error{color:#f85149}
-.term .tl.permission{color:var(--frontier);font-weight:600}
-.term form.terminput{display:flex;gap:8px;margin-top:10px}
-.term form.terminput input{flex:1;background:#0b0d11;color:var(--fg);border:1px solid var(--line);border-radius:8px;padding:8px 10px;font:inherit}
-.term form.terminput button{background:var(--local);color:#04122b;border:none;border-radius:8px;padding:8px 16px;cursor:pointer;font:inherit;font-weight:600}
-.pty .ptylog{background:#05070a;border:1px solid var(--line);border-radius:8px;padding:10px;max-height:340px;overflow:auto;font-family:ui-monospace,Consolas,monospace;font-size:12px;white-space:pre-wrap;color:#c8d1dc}
-.pty form.ptyinput{display:flex;gap:8px;margin-top:10px}
-.pty form.ptyinput input{flex:1;background:#05070a;color:var(--fg);border:1px solid var(--line);border-radius:8px;padding:8px 10px;font:inherit}
-.pty form.ptyinput button,.pty .pty-start{background:var(--frontier);color:#1a1200;border:none;border-radius:8px;padding:8px 16px;cursor:pointer;font:inherit;font-weight:600;margin-top:8px}
-.pty .pty-start:disabled{opacity:.5;cursor:default}
-`;
-var CLIENT_JS = `
-(function(){
-  function reloadIfChanged(prev){
-    fetch('/api/state').then(function(r){return r.json()}).then(function(s){
-      if(s.generatedAt!==prev){location.reload()}
-    }).catch(function(){});
-  }
-  var current=document.documentElement.getAttribute('data-generated')||'';
-  if('EventSource' in window){
-    try{
-      var es=new EventSource('/events');
-      es.addEventListener('state',function(){location.reload()});
-      es.onerror=function(){/* fallback below */};
-    }catch(e){/* ignore */}
-  }
-  var ms=parseInt(document.documentElement.getAttribute('data-refresh')||'2000',10);
-  setInterval(function(){reloadIfChanged(current)},isNaN(ms)?2000:Math.max(250,ms));
-
-  function selectTab(name){
-    var tabs=document.querySelectorAll('#tabbar .tab');
-    for(var i=0;i<tabs.length;i++){tabs[i].classList.toggle('active',tabs[i].getAttribute('data-tab')===name)}
-    var views=document.querySelectorAll('main .view');
-    var matched=false;
-    for(var j=0;j<views.length;j++){
-      var show=views[j].getAttribute('data-view')===name;
-      views[j].hidden=!show;
-      if(show){matched=true;if(name!=='all'){connectTerminal(views[j],name)}}
-    }
-    if(!matched){return false}
-    try{sessionStorage.setItem('openteam.tab',name)}catch(e){}
-    return true;
-  }
-  function connectTerminal(view,id){
-    if(view.__wired){return}
-    var root=document.documentElement;
-    var token=root.getAttribute('data-token');
-    if(root.getAttribute('data-terminal')!=='1'||!token){return}
-    var log=view.querySelector('.termlog');
-    if(!log){return}
-    view.__wired=true;
-    function append(cls,text){
-      var line=document.createElement('div');
-      line.className='tl '+cls;line.textContent=text;
-      log.appendChild(line);log.scrollTop=log.scrollHeight;
-    }
-    var q='/console/session/'+encodeURIComponent(id);
-    var tk='token='+encodeURIComponent(token);
-    if('EventSource' in window){
-      try{
-        var es=new EventSource(q+'/stream?'+tk);
-        es.addEventListener('frame',function(e){try{var f=JSON.parse(e.data);append(f.kind,f.text)}catch(_){}}); 
-        es.onerror=function(){/* reconecta solo */};
-      }catch(_){/* ignore */}
-    }
-    var form=view.querySelector('form.terminput');
-    if(form){
-      form.addEventListener('submit',function(e){
-        e.preventDefault();
-        var inp=form.querySelector('input[name=text]');
-        var text=inp.value;
-        if(!text){return}
-        inp.value='';append('input','› '+text);
-        fetch(q+'/input?'+tk,{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({text:text})})
-          .then(function(r){if(!r.ok){append('error','✖ envío rechazado ('+r.status+')')}})
-          .catch(function(){append('error','✖ no se pudo enviar')});
-      });
-    }
-    connectPty(view,id,q,tk);
-  }
-  function connectPty(view,id,q,tk){
-    var root=document.documentElement;
-    if(root.getAttribute('data-pty')!=='1'){return}
-    var pane=view.querySelector('.pty');
-    if(!pane){return}
-    var log=pane.querySelector('.ptylog');
-    var startBtn=pane.querySelector('.pty-start');
-    var input=pane.querySelector('form.ptyinput');
-    function plog(text){
-      var d=document.createElement('span');d.textContent=text;
-      log.appendChild(d);log.scrollTop=log.scrollHeight;
-    }
-    if(!startBtn){return}
-    startBtn.addEventListener('click',function(){
-      startBtn.disabled=true;plog('Abriendo shell…
-');
-      fetch(q+'/pty?'+tk,{method:'POST',headers:{'content-type':'application/json'},body:'{}'})
-        .then(function(r){return r.ok?r.json():Promise.reject(r.status)})
-        .then(function(info){openPtyWs(info.wsUrl)})
-        .catch(function(s){plog('✖ no se pudo abrir PTY ('+s+')
-');startBtn.disabled=false});
-    });
-    function openPtyWs(url){
-      try{
-        var ws=new WebSocket(url);
-        ws.binaryType='arraybuffer';
-        ws.onmessage=function(e){
-          var data=e.data;
-          if(data instanceof ArrayBuffer){data=new TextDecoder().decode(new Uint8Array(data))}
-          plog(data);
-        };
-        ws.onclose=function(){plog('
-[shell cerrada]
-');startBtn.disabled=false};
-        ws.onerror=function(){plog('
-✖ error de WebSocket
-')};
-        if(input){
-          input.hidden=false;
-          input.addEventListener('submit',function(e){
-            e.preventDefault();
-            var c=input.querySelector('input[name=cmd]');
-            if(!c.value){return}
-            ws.send(c.value+'\r');c.value='';
-          });
-        }
-      }catch(_){plog('
-✖ WebSocket no disponible
-');startBtn.disabled=false}
-    }
-  }
-  var bar=document.getElementById('tabbar');
-  if(bar){
-    bar.addEventListener('click',function(e){
-      var t=e.target;
-      while(t&&t!==bar&&!t.getAttribute('data-tab')){t=t.parentNode}
-      if(t&&t.getAttribute('data-tab')){selectTab(t.getAttribute('data-tab'))}
-    });
-  }
-  var saved='all';
-  try{saved=sessionStorage.getItem('openteam.tab')||'all'}catch(e){}
-  if(!selectTab(saved)){selectTab('all')}
-})();
-`;
 function renderConsoleHtml(state, options = {}) {
   const refreshMs = options.refreshMs ?? 2000;
   const terminalEnabled = options.terminalEnabled === true;
@@ -1720,7 +1781,7 @@ function renderConsoleHtml(state, options = {}) {
     '<meta charset="utf-8">',
     '<meta name="viewport" content="width=device-width,initial-scale=1">',
     "<title>openteam console</title>",
-    `<style>${STYLE}</style>`,
+    `<style>${CONSOLE_STYLE}</style>`,
     "</head>",
     "<body>",
     "<header>",
@@ -1729,7 +1790,7 @@ function renderConsoleHtml(state, options = {}) {
     "</header>",
     tabBar(state.sessionsDetail),
     `<main>${body}</main>`,
-    `<script>${CLIENT_JS}</script>`,
+    `<script>${CONSOLE_CLIENT_JS}</script>`,
     "</body>",
     "</html>"
   ].join("");
@@ -2359,6 +2420,18 @@ var HTML_HEADERS = { "content-type": "text/html; charset=utf-8" };
 function isAddressInUse(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EADDRINUSE";
 }
+function bearerFromHeader3(request) {
+  const header = request.headers.authorization;
+  if (typeof header !== "string" || !header.startsWith("Bearer ")) {
+    return;
+  }
+  const value = header.slice("Bearer ".length).trim();
+  return value.length === 0 ? undefined : value;
+}
+function readAuthorized(request, url, token) {
+  const provided = tokenFromQuery(url.searchParams) ?? bearerFromHeader3(request);
+  return provided !== undefined && safeEqualToken(provided, token);
+}
 async function renderState(deps) {
   return renderConsoleHtml(buildConsoleState(await deps.readSnapshot()), {
     refreshMs: deps.config.refreshMs,
@@ -2426,6 +2499,11 @@ async function createConsoleServer(deps) {
       return;
     }
     const path = url2.pathname;
+    const remoteToken = deps.storageApi?.token;
+    if (remoteToken !== undefined && (path === "/" || path === "/index.html" || path === "/api/state" || path === "/events") && !readAuthorized(request, url2, remoteToken)) {
+      response.writeHead(401, JSON_HEADERS3).end(JSON.stringify({ error: "unauthorized" }));
+      return;
+    }
     if (path === "/" || path === "/index.html") {
       response.writeHead(200, HTML_HEADERS).end(await renderState(deps));
       return;
@@ -2465,7 +2543,12 @@ async function createConsoleServer(deps) {
       break;
     }
     if (await tryListen(server, deps.config.host, port)) {
-      boundPort = port;
+      const address = server.address();
+      if (typeof address !== "object" || address === null) {
+        server.close();
+        throw new Error("console: bound address is unavailable");
+      }
+      boundPort = address.port;
       bound = true;
       break;
     }
@@ -2899,6 +2982,8 @@ async function runConsoleServe(deps, options) {
   deps.log("Escuchando en loopback. Pulsa Ctrl+C para parar.");
   if (config.console.remoteStorage) {
     deps.log("Storage remoto expuesto en /storage/* (read-only, requiere token).");
+    deps.log("La consola y el estado exigen token; ábrela con la URL firmada:");
+    deps.log(`  ${runtime.url}/?token=${token}`);
   }
   if (config.storage.sqliteIndex.enabled) {
     const buildIndex = deps.buildSqliteIndex ?? buildSqliteIndexFromConfig;
@@ -3220,6 +3305,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;
@@ -4031,7 +4119,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",
@@ -4040,7 +4128,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.",
     "",
@@ -4066,7 +4154,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,",
@@ -4251,9 +4339,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",
@@ -4497,6 +4585,32 @@ async function writeOpenTeamConfigFile(config, path = DEFAULT_CONFIG_PATH, stora
   await storage.write(path, serializeOpenTeamConfig(config));
 }
 
+// src/commands/frontierCatalog.ts
+function weightedCost(inputUSD, outputUSD) {
+  return 0.75 * inputUSD + 0.25 * outputUSD;
+}
+function profileWeightedCost(profile) {
+  return weightedCost(profile.costPer1M.inputUSD, profile.costPer1M.outputUSD);
+}
+function sortFrontierByCost(profiles) {
+  return [...profiles].sort((a, b) => profileWeightedCost(a) - profileWeightedCost(b));
+}
+function isFreeFrontier(profile) {
+  return profile.costPer1M.inputUSD === 0 && profile.costPer1M.outputUSD === 0;
+}
+function frontierCostLabel(profile) {
+  if (isFreeFrontier(profile)) {
+    return "gratis";
+  }
+  return `$${profile.costPer1M.inputUSD}/$${profile.costPer1M.outputUSD} por 1M`;
+}
+function frontierProviders(profiles) {
+  return [...new Set(profiles.map((profile) => profile.ref.providerID))].sort((a, b) => a.localeCompare(b));
+}
+function frontierModelsForProvider(profiles, providerID) {
+  return sortFrontierByCost(profiles.filter((profile) => profile.ref.providerID === providerID));
+}
+
 // src/commands/slashCommand.ts
 var OPENTEAM_COMMAND_DIR = ".opencode/command";
 var OPENTEAM_COMMAND_PATH = `${OPENTEAM_COMMAND_DIR}/openteam.md`;
@@ -4580,30 +4694,6 @@ var KNOWN_RUNTIMES = [
     dynamicPort: true
   }
 ];
-function weightedCost(inputUSD, outputUSD) {
-  return 0.75 * inputUSD + 0.25 * outputUSD;
-}
-function profileWeightedCost(profile) {
-  return weightedCost(profile.costPer1M.inputUSD, profile.costPer1M.outputUSD);
-}
-function sortFrontierByCost(profiles) {
-  return [...profiles].sort((a, b) => profileWeightedCost(a) - profileWeightedCost(b));
-}
-function isFreeFrontier(profile) {
-  return profile.costPer1M.inputUSD === 0 && profile.costPer1M.outputUSD === 0;
-}
-function frontierCostLabel(profile) {
-  if (isFreeFrontier(profile)) {
-    return "gratis";
-  }
-  return `$${profile.costPer1M.inputUSD}/$${profile.costPer1M.outputUSD} por 1M`;
-}
-function frontierProviders(profiles) {
-  return [...new Set(profiles.map((profile) => profile.ref.providerID))].sort((a, b) => a.localeCompare(b));
-}
-function frontierModelsForProvider(profiles, providerID) {
-  return sortFrontierByCost(profiles.filter((profile) => profile.ref.providerID === providerID));
-}
 function knownRuntime(id) {
   const found = KNOWN_RUNTIMES.find((runtime) => runtime.id === id);
   if (found === undefined) {
@@ -5039,9 +5129,244 @@ async function runSetup(deps) {
   }
 }
 
+// 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/memory/types.ts
+import { z as z6 } from "zod";
+var SHARED_OWNER_KEY = "*";
+var OwnerKeySchema = z6.string().min(1);
+var MemoryKindSchema = z6.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z6.object({
+  id: z6.string().min(1),
+  ownerKey: OwnerKeySchema,
+  confidence: z6.number().min(0).max(1),
+  validFrom: z6.number().finite(),
+  validUntil: z6.number().finite().nullable().default(null),
+  createdAt: z6.number().finite(),
+  invalidatedAt: z6.number().finite().nullable().default(null),
+  sourceHash: z6.string().min(1),
+  supersededBy: z6.string().min(1).nullable().default(null)
+});
+var FactSchema = MemoryBaseSchema.extend({
+  kind: z6.literal("fact"),
+  subject: z6.string().min(1),
+  predicate: z6.string().min(1),
+  object: z6.string().min(1),
+  category: z6.string().min(1).nullable().default(null)
+});
+var PreferenceSchema = MemoryBaseSchema.extend({
+  kind: z6.literal("preference"),
+  category: z6.string().min(1),
+  preference: z6.string().min(1),
+  context: z6.string().min(1).nullable().default(null),
+  lastAccessedAt: z6.number().finite().nullable().default(null),
+  accessCount: z6.number().int().min(0).default(0)
+});
+var EntitySchema = MemoryBaseSchema.extend({
+  kind: z6.literal("entity"),
+  canonicalName: z6.string().min(1),
+  type: z6.string().min(1),
+  aliases: z6.array(z6.string().min(1)).default([])
+});
+var MemoryRecordSchema = z6.discriminatedUnion("kind", [
+  FactSchema,
+  PreferenceSchema,
+  EntitySchema
+]);
+var RecallQuerySchema = z6.object({
+  ownerKey: OwnerKeySchema,
+  kinds: z6.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z6.number().finite().nullable().default(null),
+  limit: z6.number().int().positive().default(8),
+  minSimilarity: z6.number().min(0).max(1).default(0.2),
+  includeShared: z6.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/mcp/semanticRecall.ts
+function buildSemanticRecall(deps, policy) {
+  return async ({ queryText, kinds, limit }) => {
+    const query = RecallQuerySchema.parse({
+      ownerKey: policy.ownerKey,
+      kinds,
+      asOf: policy.asOf ?? null,
+      limit,
+      minSimilarity: policy.minSimilarity,
+      includeShared: policy.includeShared
+    });
+    const recallDeps = deps.signals === undefined ? { index: deps.index, embedder: deps.embedder, now: deps.now() } : {
+      index: deps.index,
+      embedder: deps.embedder,
+      now: deps.now(),
+      signals: deps.signals
+    };
+    return recallMemory(recallDeps, queryText, query);
+  };
 }
 
 // src/mcp/teamMemory.ts
@@ -5133,6 +5458,45 @@ var MCP_TOOLS = [
     inputSchema: { type: "object", properties: {} }
   }
 ];
+var RECALL_QUERY_PROP = {
+  query: {
+    type: "string",
+    description: "Texto de consulta para el recall semántico."
+  },
+  ...LIMIT_PROP
+};
+var MEMORY_TOOLS = [
+  {
+    name: "recall_facts",
+    description: "Hechos relevantes (sujeto-predicado-objeto) para la consulta, por similitud semántica. Contenido redactado salvo storeContent.",
+    inputSchema: {
+      type: "object",
+      properties: { ...RECALL_QUERY_PROP },
+      required: ["query"]
+    }
+  },
+  {
+    name: "recall_preferences",
+    description: "Preferencias del usuario/proyecto relevantes para la consulta, por similitud semántica.",
+    inputSchema: {
+      type: "object",
+      properties: { ...RECALL_QUERY_PROP },
+      required: ["query"]
+    }
+  },
+  {
+    name: "similar_tasks",
+    description: "Memoria (hechos/preferencias/entidades) relevante a una tarea, por similitud semántica; útil para reutilizar contexto previo.",
+    inputSchema: {
+      type: "object",
+      properties: { ...RECALL_QUERY_PROP },
+      required: ["query"]
+    }
+  }
+];
+function availableTools(deps) {
+  return deps.recallSemantic === undefined ? MCP_TOOLS : [...MCP_TOOLS, ...MEMORY_TOOLS];
+}
 function response(id, result) {
   return { jsonrpc: "2.0", id, result };
 }
@@ -5148,7 +5512,58 @@ function optionalString(value) {
 function optionalLimit(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
+var DEFAULT_RECALL_LIMIT = 8;
+function projectRecall(results) {
+  return results.map(({ record, similarity, score }) => {
+    const base = {
+      id: record.id,
+      kind: record.kind,
+      ownerKey: record.ownerKey,
+      confidence: record.confidence,
+      similarity,
+      score
+    };
+    if (record.kind === "fact") {
+      return {
+        ...base,
+        subject: record.subject,
+        predicate: record.predicate,
+        object: record.object,
+        category: record.category
+      };
+    }
+    if (record.kind === "preference") {
+      return {
+        ...base,
+        category: record.category,
+        preference: record.preference
+      };
+    }
+    return { ...base, canonicalName: record.canonicalName, type: record.type };
+  });
+}
+async function callSemanticRecall(recall2, kinds, args) {
+  const query = optionalString(args.query);
+  if (query === undefined) {
+    return textContent({ error: "requiere 'query'" });
+  }
+  const limit = optionalLimit(args.limit) ?? DEFAULT_RECALL_LIMIT;
+  const results = await recall2({ queryText: query, kinds, limit });
+  return textContent(projectRecall(results));
+}
 async function callTool(name, args, deps) {
+  if (deps.recallSemantic !== undefined) {
+    switch (name) {
+      case "recall_facts":
+        return callSemanticRecall(deps.recallSemantic, ["fact"], args);
+      case "recall_preferences":
+        return callSemanticRecall(deps.recallSemantic, ["preference"], args);
+      case "similar_tasks":
+        return callSemanticRecall(deps.recallSemantic, ["fact", "preference", "entity"], args);
+      default:
+        break;
+    }
+  }
   const memory = await deps.readMemory();
   switch (name) {
     case "list_decisions": {
@@ -5189,7 +5604,7 @@ async function handleMcpMessage(message, deps) {
         serverInfo
       });
     case "tools/list":
-      return response(id, { tools: MCP_TOOLS });
+      return response(id, { tools: availableTools(deps) });
     case "tools/call": {
       const params = message.params ?? {};
       const name = optionalString(params.name);
@@ -5258,6 +5673,456 @@ async function* linesFromReadable(readable) {
   }
 }
 
+// src/memory/consolidate.ts
+var DAY_MS2 = 86400000;
+var DEFAULT_DECAY_PARAMS = {
+  halfLifeMs: 90 * DAY_MS2,
+  forgetThreshold: 0.05
+};
+function lastReinforcedAt(record) {
+  if (record.kind === "preference" && record.lastAccessedAt !== null) {
+    return record.lastAccessedAt;
+  }
+  return record.createdAt;
+}
+function decayedConfidence(record, now, params = DEFAULT_DECAY_PARAMS) {
+  const ageMs = Math.max(0, now - lastReinforcedAt(record));
+  return record.confidence * 0.5 ** (ageMs / params.halfLifeMs);
+}
+function consolidate(records, now, params = DEFAULT_DECAY_PARAMS) {
+  const tombstones = [];
+  for (const record of records) {
+    if (!isTransactionActiveAt(record, now)) {
+      continue;
+    }
+    if (decayedConfidence(record, now, params) < params.forgetThreshold) {
+      tombstones.push({ ...record, invalidatedAt: now, supersededBy: null });
+    }
+  }
+  return tombstones;
+}
+
+// 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 serializeAssertion(record) {
+  return JSON.stringify(record);
+}
+function parseMemoryLog(text2) {
+  const records = [];
+  for (const line of text2.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/memoryConsolidate.ts
+async function runConsolidation(logPath, deps) {
+  const params = deps.params ?? DEFAULT_DECAY_PARAMS;
+  const text2 = await deps.storage.read(logPath) ?? "";
+  const state = foldAssertions(parseMemoryLog(text2));
+  const tombstones = consolidate(allRecords(state), deps.now, params);
+  if (tombstones.length === 0) {
+    return { forgotten: 0 };
+  }
+  const appended = `${tombstones.map(serializeAssertion).join(`
+`)}
+`;
+  await deps.storage.append(logPath, appended);
+  return { forgotten: tombstones.length };
+}
+
+// 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 response2;
+  try {
+    response2 = 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 (!response2.ok) {
+    throw new Error(`Embeddings local falló: HTTP ${response2.status} en /embeddings`);
+  }
+  let payload;
+  try {
+    payload = await response2.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/memoryIndex.ts
+var SCHEMA2 = `
+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_SQL2 = `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_SQL2);
+  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(SCHEMA2);
+  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 text2 = await deps.storage.read(logPath) ?? "";
+  const assertions = parseMemoryLog(text2);
+  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/web/git.ts
 function createGitLastCommit(exec) {
   return async () => {
@@ -5298,6 +6163,18 @@ async function loadConfig(path) {
   const content = await storage.read(path);
   return content === undefined ? loadOpenTeamConfig({}) : loadOpenTeamConfig(JSON.parse(content));
 }
+async function buildMcpSemanticRecall(config) {
+  const runtime = await buildMemoryRuntimeFromConfig(config, { storage });
+  if (runtime === undefined) {
+    return;
+  }
+  const { index, embedder, now, ownerKey, semantic } = runtime;
+  return buildSemanticRecall({ index, embedder, now }, {
+    ownerKey,
+    minSimilarity: semantic.recall.minSimilarity,
+    includeShared: true
+  });
+}
 async function openBrowser(url) {
   if (process.platform === "win32") {
     await nodeExec("cmd", ["/c", "start", "", url]);
@@ -5424,17 +6301,31 @@ async function main() {
     return;
   }
   if (argv[0] === "mcp") {
+    const mcpConfig = await loadConfig(DEFAULT_CONFIG_PATH);
+    const recallSemantic = await buildMcpSemanticRecall(mcpConfig);
     await runMcpStdio({
       readMemory: async () => buildTeamMemory(await readSessionEvents(DEFAULT_SESSIONS_DIR, {
         storage,
         legacyTelemetryPath: DEFAULT_TELEMETRY_PATH
-      }))
+      })),
+      ...recallSemantic === undefined ? {} : { recallSemantic }
     }, {
       lines: linesFromReadable(process.stdin),
       write: (line) => process.stdout.write(line)
     });
     return;
   }
+  if (argv[0] === "memory" && argv[1] === "consolidate") {
+    const memConfig = await loadConfig(DEFAULT_CONFIG_PATH);
+    const semantic = resolveMemorySemantic(memConfig);
+    const result2 = await runConsolidation(semantic.logPath, {
+      storage,
+      now: Date.now()
+    });
+    process.stdout.write(`Consolidación de memoria: ${result2.forgotten} record(s) olvidado(s).
+`);
+    return;
+  }
   const result = await runCli(argv, deps);
   process.stdout.write(`${result.stdout}
 `);