spectoflow 0.32.0 → 0.34.0

package/lib/dashboard/ops.js

@@ -18,10 +18,13 @@ const orchestrator = require('./orchestrator');
 const adapters = require('../adapters');
 const detect = require('../detect');
 const brain = require('../brain');
+const projectMemory = require('../project-memory');
 const brainSetup = require('../brain-setup');
 const globalConfig = require('../global-config');
 const workflowDetect = require('../workflow-detect');
 const runnerTrust = require('../runner-trust');
+const isolation = require('./isolation');
+const worktree = require('../worktree');
 
 const PKG_VERSION = require('../../package.json').version;
 
@@ -74,6 +77,7 @@ function writeConfig(root, patch, detectOpts) {
   if (typeof patch.activeTab === 'string' && patch.activeTab.trim()) cfg.activeTab = patch.activeTab.trim();
   if (typeof patch.chatOpen === 'boolean') cfg.chatOpen = patch.chatOpen;
   if (typeof patch.workflowAutoEnable === 'boolean') cfg.workflowAutoEnable = patch.workflowAutoEnable;
+  if (typeof patch.memoryAutoAdd === 'boolean') cfg.memoryAutoAdd = patch.memoryAutoAdd;
   // kanbanColumns: reject the whole patch (leave the current value untouched) rather than silently
   // filtering out bad entries — an invalid/unknown status id here means the client sent something it
   // shouldn't have, and a real product-safety rule (never persist zero visible columns) applies too.
@@ -141,6 +145,17 @@ function writeConfig(root, patch, detectOpts) {
   fs.writeFileSync(cp, JSON.stringify(cfg, null, 2) + '\n');
   return cfg;
 }
+const localOnly = (ctx) => { if (ctx && ctx.remote) throw new OpError(404, 'Unknown operation.'); };
+const gitOp = (fn) => { try { return fn(); } catch (e) { if (e instanceof worktree.GitError) throw new OpError(e.status, e.message); throw e; } };
+// project.read runs on every change: ask git whether this is a repository at most every 30s.
+const gitRepoSeen = new Map();
+function gitRepoCached(root) {
+  const hit = gitRepoSeen.get(root);
+  if (hit && Date.now() - hit.at < 30000) return hit.value;
+  const value = worktree.isRepo(root);
+  gitRepoSeen.set(root, { at: Date.now(), value });
+  return value;
+}
 const filesResult = (r) => { if (r.error) bad(r.error); return r; };
 const changed = (ctx, result) => { ctx.emit({ type: 'change' }); return result; };
 
@@ -150,8 +165,12 @@ const changed = (ctx, result) => { ctx.emit({ type: 'change' }); return result;
 // watches ~/.spectoflow/brain.md and tells local tabs only, whoever wrote it (page, MCP, run line).
 function brainOp(ctx, fn) {
   if (ctx && ctx.remote) throw new OpError(404, 'Unknown operation.');
-  try { return fn(); } catch (e) { if (e.status && !(e instanceof OpError)) throw new OpError(e.status, e.message); throw e; }
+  return storeOp(fn);
 }
+const storeOp = (fn) => { try { return fn(); } catch (e) { if (e.status && !(e instanceof OpError)) throw new OpError(e.status, e.message); throw e; } };
+// The project memory is the project's (.spectoflow/memory.md, committed): gated like any project read/write,
+// online included. Only `memory.move` touches the personal brain, so only it is local.
+const memOp = (root, ctx, fn) => { const r = storeOp(() => fn(projectMemory.fileFor(root))); ctx.emit({ type: 'change' }); return r; };
 
 const ops = {
   'project.read': async (root) => {
@@ -166,6 +185,7 @@ const ops = {
     p.todayDate = todayLocal();
     p.untrustedRunners = runnerTrust.untrusted(root, p.config);
     p.kitVersion = PKG_VERSION;
+    p.git = gitRepoCached(root);
     return p;
   },
   'agentfile.read': async (root, { path: rel }) => readAgentFile(root, rel),
@@ -243,6 +263,21 @@ const ops = {
     return changed(ctx, { fromVersion: r.fromVersion, toVersion: r.toVersion, refreshed: r.refreshed.length + r.created.length + r.forced.length + r.removed.length, review: r.newSidecar });
   },
   'run.stop': async (root, _args, ctx) => changed(ctx, { stopped: stopRuns(root) }),
+
+  // A task worked on in isolation, in its own git worktree (D79). Merge and pull request change the owner's
+  // branches or push: local only, absent from the relay.
+  'worktree.start': async (root, { id }, ctx) => gitOp(() => isolation.start(root, { id }, ctx.emit, { remote: !!ctx.remote })),
+  'worktree.feedback': async (root, { id, text: body }, ctx) => gitOp(() => {
+    const msg = text(body, 'Empty feedback.');
+    const file = findPlanFileForTask(root, id); if (!file) notFound(`Task ${id} not found.`);
+    store.addTaskComment(root, file, id, msg, 'me');
+    return isolation.start(root, { id, feedback: msg }, ctx.emit, { remote: !!ctx.remote });
+  }),
+  'worktree.diff': async (root, { id }, ctx) => gitOp(() => isolation.diff(root, { id }, { remote: !!ctx.remote })),
+  'worktree.stop': async (root, { id }, ctx) => changed(ctx, isolation.stop(root, { id })),
+  'worktree.discard': async (root, { id }, ctx) => changed(ctx, gitOp(() => isolation.discard(root, { id }))),
+  'worktree.merge': async (root, { id }, ctx) => { localOnly(ctx); return changed(ctx, gitOp(() => isolation.merge(root, { id }))); },
+  'worktree.pr': async (root, { id }, ctx) => { localOnly(ctx); return changed(ctx, gitOp(() => isolation.openPr(root, { id }))); },
   'chat.summarize': async (root, { agent }, ctx) => {
     const r = runSummarize(root, { agent }, ctx.emit);
     if (r.error) bad(r.error);
@@ -307,6 +342,26 @@ const ops = {
     return { autoAdd: globalConfig.set('brain.autoAdd', autoAdd) };
   }),
 
+  'memory.read': async (root) => storeOp(() => ({ ...projectMemory.read(projectMemory.fileFor(root)), path: projectMemory.REL })),
+  'memory.add': async (root, { category, text: body }, ctx) => memOp(root, ctx, (f) => projectMemory.add({ category, text: body, by: 'user' }, f)),
+  'memory.update': async (root, { id, patch }, ctx) => memOp(root, ctx, (f) => ({ entry: projectMemory.update(id, patch || {}, f) })),
+  'memory.remove': async (root, { id }, ctx) => memOp(root, ctx, (f) => projectMemory.remove(id, f)),
+  'memory.confirm': async (root, { id }, ctx) => memOp(root, ctx, (f) => ({ entry: projectMemory.confirm(id, f) })),
+  // The agent picked the wrong memory: move one entry to the other, under the category the user chose. Added
+  // to the target first, removed from the source after — a failure never loses the fact. Local only: one of
+  // the two files is always the user's personal brain.
+  'memory.move': async (root, { from, id, category }, ctx) => brainOp(ctx, () => {
+    if (from !== 'user' && from !== 'project') bad('from must be "user" or "project".');
+    const pf = projectMemory.fileFor(root);
+    const [src, srcFile, dst, dstFile] = from === 'user' ? [brain, undefined, projectMemory, pf] : [projectMemory, pf, brain, undefined];
+    const entry = src.get(id, srcFile);
+    if (!dst.CATEGORIES.includes(category)) bad(`Unknown category: ${category}.`);
+    const added = dst.add({ category, text: entry.text, by: entry.by }, dstFile);
+    src.remove(id, srcFile);
+    ctx.emit({ type: 'change' });
+    return added;
+  }),
+
   'attention.remove': async (root, { id }, ctx) => {
     const rt = store.readRuntime(root); rt.attention = (rt.attention || []).filter((x) => x.id !== id); store.writeRuntime(root, rt);
     return changed(ctx, { ok: true });

package/lib/dashboard/public/app.js

@@ -73,7 +73,7 @@ window.fetch=(url,opts)=>{
   return _fetch(url,opts);
 };
 // Served by the online relay? Its project.read always carries `online`; the local hub's never does.
-// Online, the Second brain tab is hidden: the brain is the machine owner's, never a project's.
+// Online, the Second brain tab shows only the project memory: the personal brain is the machine owner's.
 let REMOTE=false;
 function setOffline(p){
   REMOTE=typeof p.online==='boolean';
@@ -161,14 +161,14 @@ function applyNavTabs() {
   list.forEach((entry) => {
     const btn = nav.querySelector('.tab[data-tab="' + entry.id + '"]');
     if (!btn) return;
-    btn.hidden = !entry.enabled || (entry.id === 'brain' && REMOTE);
+    btn.hidden = !entry.enabled;
     nav.insertBefore(btn, anchor);
   });
   // If the currently active NATIVE tab just became disabled (e.g. the user disabled the tab they're
   // viewing, or another viewer did and this tab just reloaded), navigate to a sensible fallback
   // instead of leaving a hidden/disabled panel showing.
   const activeEntry = list.find((e) => e.id === activeTab);
-  if (activeEntry && (!activeEntry.enabled || (activeEntry.id === 'brain' && REMOTE))) {
+  if (activeEntry && !activeEntry.enabled) {
     const fallback = list.find((e) => e.id === 'board' && e.enabled) || list.find((e) => e.enabled);
     if (fallback) navigateTab(fallback.id);
   }
@@ -299,9 +299,10 @@ const runtimeTests=(id)=> (P.runtime&&P.runtime.tests&&P.runtime.tests[id])||nul
 async function load(){
   const r = await fetch(withProject('/api/project')); P = await r.json();
   syncSettingsFromServer();
-  REMOTE=typeof P.online==='boolean'; // known before the first paint: the brain tab is hidden online
+  REMOTE=typeof P.online==='boolean'; // known before the first paint: the personal brain is hidden online
   render(); setOffline(P); renderUpdateBar(); notifyOrchestration();
-  if(!REMOTE && !brainData) loadBrain();
+  if(!REMOTE && !MEMORIES.user.data) loadBrain();
+  loadMemory('project'); // .spectoflow/memory.md may be what just changed
   if(openTaskId) openDrawer(openTaskId,true);
 }
 // Coalesce bursts of SSE 'change'/'message' events into one reload so the board doesn't
@@ -315,6 +316,8 @@ function connect(){
     let m; try{ m=JSON.parse(ev.data); }catch{ return; }
     if(m.type==='change'||m.type==='message') return scheduleLoad(); // messages live from runtime.messages
     if(m.type==='brain') return loadBrain();                    // ~/.spectoflow/brain.md changed (page, MCP, run line)
+    if((m.type==='run-start'||m.type==='run-end') && m.task) return scheduleLoad(); // isolated work: the chat stays free
+    if(m.type==='run-line' && m.task) return;
     if(m.type==='run-start'||m.type==='run-end') { chatState.forEach(st=>{ st.rawBlock=null; }); sseBusy=(m.type==='run-start'); updateChatBusyUI(); if(m.type==='run-end') notify(t(m.code===0?'notify.done':'notify.failed',{project:P&&P.projectName||'spectoflow'}), ''); return; }
     if(m.type==='run-line') return appendRaw(m.chunk);          // raw output is ephemeral (not logged)
   };
@@ -981,6 +984,8 @@ function renderTask(t){
     c.append(tags);
   }
   const foot=el('div','task-foot');
+  const iso=isoState(t.id);
+  if(iso) foot.append(el('span','iso-chip is-'+iso.status,'⎇ '+window.t('iso.chip.'+iso.status))); // `t` is the task here
   if(t.owner) foot.append(el('span','owner','@'+t.owner));
   if(t.comments&&t.comments.length) foot.append(el('span','cmt-count','💬 '+t.comments.length));
   const tr=runtimeTests(t.id);
@@ -1581,7 +1586,7 @@ function navigateTab(tabId,push){
   // was scrolled to last (only on an actual switch INTO the tab — applyActiveTab() alone runs on
   // every SSE render tick too, and re-scrolling/re-focusing there would fight the user's typing).
   if(tabId==='chat') setTimeout(()=>{ scrollChat($('#chatTabLog')); $('#tabRunPrompt').focus(); },60);
-  if(tabId==='brain'){ renderBrain(); if(!brainData) loadBrain(); }
+  if(tabId==='brain'){ renderBrain(); if(!MEMORIES.user.data) loadBrain(); if(!MEMORIES.project.data) loadMemory('project'); }
   if(tabId==='files') renderFiles(); // the tree is fetched lazily — only load it on an actual switch in
 }
 function closeNav(){ document.body.classList.remove('nav-open'); const nt=$('#navToggle'); if(nt) nt.setAttribute('aria-expanded','false'); }
@@ -2159,60 +2164,79 @@ function notesSetStatus(state){
 }
 
 // ---- Second brain ------------------------------------------------------------------------------
-// What spectoflow has learned about the user: ~/.spectoflow/brain.md, shared by all their projects —
-// NOT this project's, so it is fetched on its own (/api/brain), never part of /api/project. The hub
-// pushes a 'brain' SSE event whenever the file changes, whoever wrote it (this page, an agent through
-// `spectoflow mcp`, or a `::spectoflow learn` run line).
-const BRAIN_CATEGORIES=['profile','preferences','workflow','avoid'];
+// Two memories on one page, one renderer. "user": what spectoflow has learned about the user —
+// ~/.spectoflow/brain.md, shared by all their projects, NOT this project's, so it is fetched on its own
+// (/api/brain) and hidden online; the hub pushes a 'brain' SSE event whenever that file changes, whoever
+// wrote it (this page, an agent through `spectoflow mcp`, a `::spectoflow learn` run line). "project":
+// facts about this project — .spectoflow/memory.md, committed; a write to it (page, agent, git) is an
+// ordinary 'change' event, and load() refetches it.
 const BRAIN_SOFT_LIMIT=60;
-let brainData=null, brainError=null, brainActionError=null;
-async function loadBrain(){
-  if(REMOTE) return;
+const MEMORIES={
+  user:{ api:'/api/brain', cats:['profile','preferences','workflow','avoid'], other:'project', empty:'brain.empty', dup:'brain.duplicate',
+    path:(d)=>t('brain.path',{path:d.path||'~/.spectoflow/brain.md'}),
+    setAuto:(v)=>memCall('POST','/api/brain/settings',{autoAdd:v}) },
+  project:{ api:'/api/memory', cats:['conventions','pitfalls','glossary','constraints'], other:'user', empty:'brain.projectEmpty', dup:'brain.projectDuplicate',
+    path:(d)=>t('brain.projectPath',{path:d.path||'.spectoflow/memory.md'}),
+    setAuto:(v)=>{ if(P&&P.config) P.config.memoryAutoAdd=v; return memCall('POST','/api/settings',{memoryAutoAdd:v}); } },
+};
+Object.values(MEMORIES).forEach(m=>{ m.data=null; m.error=null; m.actionError=null; });
+const memSection=(key)=>document.querySelector(`[data-memory="${key}"]`);
+const memUrl=(key,id,suffix)=>`${MEMORIES[key].api}/${encodeURIComponent(id)}${suffix||''}`;
+async function loadMemory(key){
+  const m=MEMORIES[key];
+  if(key==='user' && REMOTE) return;
   try{
-    const r=await fetch(withProject('/api/brain'));
+    const r=await fetch(withProject(m.api));
     const d=await r.json().catch(()=>({}));
     if(!r.ok) throw new Error(d.error||'error');
-    brainData=d; brainError=null;
-  }catch(err){ brainError=err.message||'error'; }
+    m.data=d; m.error=null;
+  }catch(err){ m.error=err.message||'error'; }
   renderBrain();
 }
-async function brainCall(method,url,body){
+function loadBrain(){ return loadMemory('user'); }
+async function memCall(method,url,body){
   flash();
   const r=await fetch(withProject(url),{method,headers:{'Content-Type':'application/json'},body:body===undefined?undefined:JSON.stringify(body)});
   const d=await r.json().catch(()=>({}));
   if(!r.ok) throw new Error(d.error||t('brain.error'));
   return d;
 }
-// A re-render (SSE tick, another tab's write) must never wipe what the user is typing.
+// A re-render (SSE tick, another tab's write) must never wipe what the user is typing or picking.
 function brainIsEditing(){
   const a=document.activeElement;
-  return !!(a && (a.tagName==='INPUT'||a.tagName==='TEXTAREA') && a.closest('#brainGrid, #brainPending'));
+  return !!(a && ['INPUT','TEXTAREA','SELECT'].includes(a.tagName) && a.closest('.mem-grid, .mem-pending'));
 }
 function renderBrain(){
   const badge=$('#brainBadge');
-  const pendingN=brainData ? brainData.pending.length : 0;
+  const pendingN=Object.entries(MEMORIES).reduce((n,[k,m])=> n+((m.data && !(k==='user'&&REMOTE)) ? m.data.pending.length : 0),0);
   if(badge){ badge.textContent=pendingN; badge.hidden=pendingN===0; }
   if(activeTab!=='brain' || brainIsEditing()) return;
-  const grid=$('#brainGrid'); if(!grid) return;
-  if(brainError && !brainData){ grid.innerHTML=''; grid.append(el('div','empty',t('brain.error'))); return; }
-  if(!brainData){ grid.innerHTML=''; grid.append(el('div','empty',t('drawer.loading'))); return; }
-  const d=brainData;
-  $('#brainCount').textContent=d.entries.length;
-  const auto=$('#brainAutoAdd'); auto.checked=!!d.autoAdd;
-  $('#brainAutoHint').textContent=d.autoAdd ? t('brain.autoAddOn') : t('brain.autoAddOff');
-  renderBrainAgents(d.agents||[]);
-  const notice=$('#brainNotice');
-  const noticeText=brainActionError || (d.entries.length>BRAIN_SOFT_LIMIT ? t('brain.tooMany',{n:d.entries.length}) : '');
+  Object.keys(MEMORIES).forEach(renderMemory);
+}
+function renderMemory(key){
+  const m=MEMORIES[key], sec=memSection(key); if(!sec) return;
+  sec.hidden = key==='user' && REMOTE;
+  if(sec.hidden) return;
+  const grid=sec.querySelector('.mem-grid');
+  if(m.error && !m.data){ grid.innerHTML=''; grid.append(el('div','empty',t('brain.error'))); return; }
+  if(!m.data){ grid.innerHTML=''; grid.append(el('div','empty',t('drawer.loading'))); return; }
+  const d=m.data;
+  sec.querySelector('.mem-count').textContent=d.entries.length;
+  sec.querySelector('.mem-auto').checked=!!d.autoAdd;
+  sec.querySelector('.mem-auto-hint').textContent=d.autoAdd ? t('brain.autoAddOn') : t('brain.autoAddOff');
+  const agents=sec.querySelector('.mem-agents'); if(agents) renderBrainAgents(agents, d.agents||[]);
+  const notice=sec.querySelector('.mem-notice');
+  const noticeText=m.actionError || (d.entries.length>BRAIN_SOFT_LIMIT ? t('brain.tooMany',{n:d.entries.length}) : '');
   notice.hidden=!noticeText; notice.textContent=noticeText;
-  notice.classList.toggle('is-error',!!brainActionError);
-  renderBrainPending(d.pending);
+  notice.classList.toggle('is-error',!!m.actionError);
+  renderMemoryPending(key, sec.querySelector('.mem-pending'), d.pending);
   grid.innerHTML='';
-  if(!d.entries.length && !d.pending.length) grid.append(el('div','brain-empty',t('brain.empty')));
-  BRAIN_CATEGORIES.forEach(cat=> grid.append(brainCard(cat, d.entries.filter(e=>e.category===cat))));
-  $('#brainPath').textContent=t('brain.path',{path:d.path||'~/.spectoflow/brain.md'});
+  if(!d.entries.length && !d.pending.length) grid.append(el('div','brain-empty',t(m.empty)));
+  m.cats.forEach(cat=> grid.append(memoryCard(key, cat, d.entries.filter(e=>e.category===cat))));
+  sec.querySelector('.mem-path').textContent=m.path(d);
 }
-function renderBrainAgents(agents){
-  const box=$('#brainAgents'); box.innerHTML='';
+function renderBrainAgents(box, agents){
+  box.innerHTML='';
   if(!agents.length){ box.append(el('span','brain-agents-none',t('brain.noAgents'))); return; }
   box.append(el('span','brain-agents-label',t('brain.agents')));
   agents.forEach(a=>{
@@ -2230,13 +2254,26 @@ function brainMeta(e){
   const who=e.by==='agent' ? t('brain.byAgent') : t('brain.byYou');
   return e.at ? `${who} · ${e.at}` : who;
 }
-function renderBrainPending(pending){
-  const box=$('#brainPending'); box.innerHTML='';
+// "Move to…": the agent picked the wrong memory. Lists the other memory's categories; local only (one of the
+// two files is the user's personal brain), so never offered online.
+function memoryMoveSelect(key, e){
+  if(REMOTE) return null;
+  const target=MEMORIES[key].other;
+  const sel=el('select','brain-move'); sel.title=t('brain.moveHint');
+  const ph=el('option',null,t('brain.moveTo')); ph.value=''; ph.selected=true; ph.disabled=true; sel.append(ph);
+  const group=document.createElement('optgroup'); group.label=t(target==='user'?'brain.you':'brain.project');
+  MEMORIES[target].cats.forEach(c=>{ const o=el('option',null,t('brain.cat.'+c)); o.value=c; group.append(o); });
+  sel.append(group);
+  sel.addEventListener('change',()=>{ const category=sel.value; sel.blur(); memAct(key,()=>memCall('POST','/api/memory/move',{from:key,id:e.id,category}),true); });
+  return sel;
+}
+function renderMemoryPending(key, box, pending){
+  box.innerHTML='';
   box.hidden=!pending.length; if(!pending.length) return;
   const head=el('div','brain-pending-head');
   head.append(el('h3','brain-pending-title',t('brain.toConfirm')));
   const all=el('button','btn primary',t('brain.confirmAll'));
-  all.addEventListener('click',async()=>{ all.disabled=true; try{ for(const e of pending) await brainCall('POST',`/api/brain/${encodeURIComponent(e.id)}/confirm`,{}); }catch(err){} loadBrain(); });
+  all.addEventListener('click',async()=>{ all.disabled=true; try{ for(const e of pending) await memCall('POST',memUrl(key,e.id,'/confirm'),{}); }catch(err){} loadMemory(key); });
   head.append(all); box.append(head);
   pending.forEach(e=>{
     const row=el('div','brain-row is-pending');
@@ -2244,14 +2281,17 @@ function renderBrainPending(pending){
     const txt=el('div','brain-text',e.text); row.append(txt);
     row.append(el('div','brain-meta',brainMeta(e)));
     const acts=el('div','brain-actions');
-    const ok=el('button','btn primary',t('brain.confirm')); ok.addEventListener('click',()=>brainAct(()=>brainCall('POST',`/api/brain/${encodeURIComponent(e.id)}/confirm`,{})));
-    const ed=el('button','btn',t('action.edit')); ed.addEventListener('click',()=>brainEdit(e,txt));
-    const no=el('button','btn danger',t('brain.reject')); no.addEventListener('click',()=>brainAct(()=>brainCall('DELETE',`/api/brain/${encodeURIComponent(e.id)}`)));
-    acts.append(ok,ed,no); row.append(acts);
+    const ok=el('button','btn primary',t('brain.confirm')); ok.addEventListener('click',()=>memAct(key,()=>memCall('POST',memUrl(key,e.id,'/confirm'),{})));
+    const ed=el('button','btn',t('action.edit')); ed.addEventListener('click',()=>memEdit(key,e,txt));
+    const no=el('button','btn danger',t('brain.reject')); no.addEventListener('click',()=>memAct(key,()=>memCall('DELETE',memUrl(key,e.id))));
+    acts.append(ok,ed,no);
+    const mv=memoryMoveSelect(key,e); if(mv) acts.append(mv);
+    row.append(acts);
     box.append(row);
   });
 }
-function brainCard(cat, entries){
+function memoryCard(key, cat, entries){
+  const m=MEMORIES[key];
   const card=el('div','brain-card');
   const head=el('div','brain-card-head');
   head.append(el('h3','brain-card-title',t('brain.cat.'+cat)), el('span','count',String(entries.length)));
@@ -2264,9 +2304,11 @@ function brainCard(cat, entries){
     const foot=el('div','brain-row-foot');
     foot.append(el('span','brain-meta',brainMeta(e)));
     const acts=el('span','brain-actions');
-    const ed=el('button','btn btn-xs',t('action.edit')); ed.addEventListener('click',()=>brainEdit(e,txt));
-    const del=el('button','btn btn-xs danger',t('action.delete')); del.addEventListener('click',()=>brainAct(()=>brainCall('DELETE',`/api/brain/${encodeURIComponent(e.id)}`)));
-    acts.append(ed,del); foot.append(acts); row.append(foot);
+    const ed=el('button','btn btn-xs',t('action.edit')); ed.addEventListener('click',()=>memEdit(key,e,txt));
+    const del=el('button','btn btn-xs danger',t('action.delete')); del.addEventListener('click',()=>memAct(key,()=>memCall('DELETE',memUrl(key,e.id))));
+    acts.append(ed,del);
+    const mv=memoryMoveSelect(key,e); if(mv) acts.append(mv);
+    foot.append(acts); row.append(foot);
     list.append(row);
   });
   card.append(list);
@@ -2280,28 +2322,28 @@ function brainCard(cat, entries){
     const text=input.value.trim(); if(!text){ input.focus(); return; }
     btn.disabled=true; err.hidden=true;
     try{
-      const r=await brainCall('POST','/api/brain',{category:cat,text});
+      const r=await memCall('POST',m.api,{category:cat,text});
       input.value=''; input.blur();
-      if(r.duplicate){ err.textContent=t('brain.duplicate'); err.hidden=false; }
+      if(r.duplicate){ err.textContent=t(m.dup); err.hidden=false; }
     }catch(e){ err.textContent=e.message; err.hidden=false; }
-    btn.disabled=false; loadBrain();
+    btn.disabled=false; loadMemory(key);
   });
   card.append(add);
   return card;
 }
-async function brainAct(fn){
-  try{ await fn(); brainActionError=null; }catch(err){ brainActionError=err.message; }
-  loadBrain();
+async function memAct(key, fn, both){
+  try{ await fn(); MEMORIES[key].actionError=null; }catch(err){ MEMORIES[key].actionError=err.message; }
+  loadMemory(key); if(both) loadMemory(MEMORIES[key].other);
 }
 // Inline edit, same interaction as the Attention tab: blur or Ctrl/Cmd+Enter saves, Escape cancels.
-function brainEdit(e, txtNode){
+function memEdit(key, e, txtNode){
   const ta=el('textarea','brain-edit'); ta.value=e.text; ta.maxLength=500; txtNode.replaceWith(ta); ta.focus();
   let done=false;
   const finish=async(save)=>{
     if(done) return; done=true;
     const v=ta.value.trim();
     ta.blur();
-    if(save && v && v!==e.text) await brainAct(()=>brainCall('PATCH',`/api/brain/${encodeURIComponent(e.id)}`,{text:v}));
+    if(save && v && v!==e.text) await memAct(key,()=>memCall('PATCH',memUrl(key,e.id),{text:v}));
     else renderBrain();
   };
   ta.addEventListener('blur',()=>finish(true));
@@ -2459,7 +2501,11 @@ function openDrawer(id,keep){
   const task=allTasks().find(x=>x.id===id); if(!task) return;
   openTaskId=id;
   if(!keep && taskFromPath()!==id) history.pushState(null,'',projectPath('/'+activeTab+'/'+encodeURIComponent(id)));
-  const b=$('#drawerBody'); const prev=keep?$('.drawer-panel').scrollTop:0; b.innerHTML='';
+  const b=$('#drawerBody'); const prev=keep?$('.drawer-panel').scrollTop:0;
+  // A re-render (any SSE tick) must not steal the feedback being typed: remember focus and caret.
+  const focused=document.activeElement&&document.activeElement.closest&&document.activeElement.closest('.iso-feedback') ? document.activeElement : null;
+  const caret=focused?[focused.selectionStart,focused.selectionEnd]:null;
+  b.innerHTML='';
   b.append(el('div','d-id',task.id+' · '+(task.level||'standard')+' · '+task.file));
   b.append(el('div','d-title',task.title));
   const sSec=el('div','d-section'); sSec.append(el('div','d-label',t('task.status')));
@@ -2471,6 +2517,7 @@ function openDrawer(id,keep){
     sr.append(btn);
   });
   sSec.append(sr); b.append(sSec);
+  renderIsolation(b,task);
 
   const tr=runtimeTests(id);
   if(tr){ const ts=el('div','d-section'); ts.append(el('div','d-label',t('task.tests')));
@@ -2491,6 +2538,129 @@ function openDrawer(id,keep){
   cSec.append(box); b.append(cSec);
   $('#drawer').setAttribute('aria-hidden','false');
   if(keep) $('.drawer-panel').scrollTop=prev;
+  if(caret){ const ta=b.querySelector('.iso-feedback textarea'); if(ta){ ta.focus(); ta.setSelectionRange(caret[0],caret[1]); } }
+}
+// ---- Isolated work (D79) -------------------------------------------------------------------------
+// A task worked on in its own git worktree: the agent's change stays off the user's working tree until
+// they review the diff and merge it, open a pull request, send feedback, or discard it. State comes from
+// runtime.worktrees (P.runtime); the diff is fetched on demand and kept until the run changes. Merge and pull
+// request are local only (the relay refuses them), so they aren't offered online.
+const isoDiffs={}, isoDraft={}, isoErrors={};
+let isoOpenPatch=null, isoArmed=null;
+const isoState=(id)=> (P&&P.runtime&&P.runtime.worktrees||{})[id]||null;
+const isoKey=(w)=> w ? `${w.runId}|${w.status}|${w.endedAt||''}` : '';
+async function isoCall(id,action,body,method){
+  flash();
+  const r=await fetch(withProject('/api/task/'+encodeURIComponent(id)+'/isolate'+(action?'/'+action:'')),{method:method||'POST',headers:{'Content-Type':'application/json'},body:method==='GET'?undefined:JSON.stringify(body||{})});
+  const d=await r.json().catch(()=>({}));
+  if(!r.ok) throw new Error(d.error||t('iso.error'));
+  return d;
+}
+// The outcome of an action shows after the next render: success arrives as a 'change' event; a refusal
+// (a merge conflict, gh missing…) is kept per task until the next action.
+function isoAct(id,btn,fn){
+  btn.disabled=true; delete isoErrors[id];
+  return fn().then(()=>{ delete isoDiffs[id]; },(err)=>{ isoErrors[id]=err.message; delete isoDiffs[id]; if(openTaskId===id) openDrawer(id,true); });
+}
+async function loadIsoDiff(id){
+  const w=isoState(id), key=isoKey(w);
+  try{ isoDiffs[id]={key, data:await isoCall(id,'diff',null,'GET')}; }
+  catch(err){ isoDiffs[id]={key, error:err.message}; }
+  if(openTaskId===id) openDrawer(id,true);
+}
+function renderIsoDiff(sec,id){
+  const cached=isoDiffs[id];
+  if(!cached){ sec.append(el('div','empty',t('drawer.loading'))); return null; }
+  if(cached.error){ sec.append(el('div','iso-error',cached.error)); return null; }
+  const d=cached.data;
+  if(!d.files.length){ sec.append(el('div','empty',t('iso.noChanges'))); return d; }
+  const files=el('div','iso-files');
+  d.files.forEach(f=>{
+    const row=el('div','iso-file');
+    row.append(el('span','iso-path',f.path));
+    const n=el('span','iso-count');
+    if(f.added===null) n.textContent=t('iso.binary');
+    else n.append(el('span','iso-plus','+'+f.added),' ',el('span','iso-minus','−'+f.removed));
+    row.append(n); files.append(row);
+  });
+  sec.append(files);
+  const open=isoOpenPatch===id;
+  const toggle=el('button','btn btn-xs',open?t('iso.hideDiff'):t('iso.showDiff'));
+  toggle.addEventListener('click',()=>{ isoOpenPatch=open?null:id; openDrawer(id,true); });
+  sec.append(toggle);
+  if(open){
+    const wrap=el('div','iso-patch'), pre=el('pre');
+    d.patch.split('\n').forEach(line=>{
+      const cls=/^(\+\+\+|---)/.test(line)?'iso-l-meta':line[0]==='+'?'iso-l-add':line[0]==='-'?'iso-l-del':/^@@/.test(line)?'iso-l-hunk':/^diff --git/.test(line)?'iso-l-file':'';
+      pre.append(el('span',cls,line+'\n'));
+    });
+    wrap.append(pre); sec.append(wrap);
+    if(d.truncated) sec.append(el('div','empty',t('iso.truncated')));
+  }
+  return d;
+}
+function renderIsolation(b,task){
+  if(!P.git) return;
+  const id=task.id, w=isoState(id);
+  const sec=el('div','d-section iso'); sec.append(el('div','d-label',t('iso.title')));
+  b.append(sec);
+  if(!w){
+    sec.append(el('p','iso-hint',t('iso.hint')));
+    if(isoErrors[id]) sec.append(el('div','iso-error',isoErrors[id]));
+    const go=el('button','btn primary',t('iso.start'));
+    go.addEventListener('click',()=>isoAct(id,go,()=>isoCall(id,'')));
+    sec.append(go);
+    return;
+  }
+  const head=el('div','iso-head');
+  head.append(el('span','iso-status is-'+w.status,t('iso.status.'+w.status)), el('code','iso-branch',w.branch));
+  sec.append(head);
+  if(w.status==='running'){
+    const recent=((P.runtime.messages)||[]).filter(m=>m.runId&&m.runId===w.runId&&m.kind!=='status').slice(-4);
+    if(recent.length){ const log=el('div','iso-log'); recent.forEach(m=>log.append(el('div','iso-log-line',m.text))); sec.append(log); }
+    if(isoErrors[id]) sec.append(el('div','iso-error',isoErrors[id]));
+    const stop=el('button','btn danger',t('chat.stop'));
+    stop.addEventListener('click',()=>isoAct(id,stop,()=>isoCall(id,'stop')));
+    sec.append(stop);
+    return;
+  }
+  if(w.uncommitted) sec.append(el('p','iso-hint',t('iso.uncommitted',{n:w.uncommitted})));
+  if(w.error) sec.append(el('div','iso-error',w.error));
+  if(w.output){ const said=el('div','iso-said'); said.append(el('div','iso-said-label',t('iso.said')), el('div','iso-said-text',w.output)); sec.append(said); }
+  if(w.prUrl){ const a=el('a','iso-pr',t('iso.prOpened')); a.href=w.prUrl; a.target='_blank'; a.rel='noopener noreferrer'; sec.append(a); }
+  if(!isoDiffs[id] || isoDiffs[id].key!==isoKey(w)){ if(!isoDiffs[id] || !isoDiffs[id].loading){ isoDiffs[id]={key:isoKey(w),loading:true}; loadIsoDiff(id); } }
+  const d=isoDiffs[id]&&!isoDiffs[id].loading ? renderIsoDiff(sec,id) : (sec.append(el('div','empty',t('drawer.loading'))), null);
+  const acts=el('div','iso-actions');
+  const hasChanges=!!(d&&d.files.length);
+  if(!REMOTE && hasChanges){
+    const merge=el('button','btn primary',t('iso.merge')); merge.title=t('iso.mergeHint');
+    merge.addEventListener('click',()=>isoAct(id,merge,()=>isoCall(id,'merge')));
+    acts.append(merge);
+    if(d.pr&&d.pr.ok&&w.status!=='pr'){
+      const pr=el('button','btn',t('iso.pr'));
+      pr.addEventListener('click',()=>isoAct(id,pr,()=>isoCall(id,'pr').then(r=>{ if(r.url) window.open(r.url,'_blank','noopener'); })));
+      acts.append(pr);
+    }
+  }
+  // Discard asks for a second click within 4s; the armed state outlives re-renders.
+  const armed=isoArmed&&isoArmed.id===id&&Date.now()<isoArmed.until;
+  const discard=el('button','btn danger',armed?t('iso.discardConfirm'):t('iso.discard')); discard.title=t('iso.discardHint');
+  discard.addEventListener('click',()=>{
+    if(isoArmed&&isoArmed.id===id&&Date.now()<isoArmed.until){ isoArmed=null; isoAct(id,discard,()=>isoCall(id,'discard')); return; }
+    isoArmed={id,until:Date.now()+4000}; discard.textContent=t('iso.discardConfirm');
+    setTimeout(()=>{ if(isoArmed&&isoArmed.id===id&&Date.now()>=isoArmed.until){ isoArmed=null; if(openTaskId===id) openDrawer(id,true); } },4100);
+  });
+  acts.append(discard);
+  sec.append(acts);
+  if(!REMOTE && hasChanges && d.pr && !d.pr.ok && w.status!=='pr') sec.append(el('p','iso-hint',t('iso.prUnavailable',{reason:d.pr.reason})));
+  if(isoErrors[id]) sec.append(el('div','iso-error',isoErrors[id]));
+  const fb=el('div','c-box iso-feedback');
+  const ta=el('textarea'); ta.placeholder=t('iso.feedbackPlaceholder'); ta.value=isoDraft[id]||'';
+  ta.addEventListener('input',()=>{ isoDraft[id]=ta.value; });
+  const send=el('button','btn',t('iso.feedback'));
+  send.addEventListener('click',()=>{ const v=ta.value.trim(); if(!v){ ta.focus(); return; } isoAct(id,send,()=>isoCall(id,'feedback',{text:v}).then(()=>{ delete isoDraft[id]; })); });
+  const row=el('div','c-actions'); row.append(send);
+  fb.append(ta,row); sec.append(fb);
 }
 function closeDrawer(){ if(taskFromPath()) history.pushState(null,'',projectPath('/'+activeTab)); openTaskId=null; $('#drawer').setAttribute('aria-hidden','true'); }
 const cssv=(v)=> getComputedStyle(document.documentElement).getPropertyValue(v).trim()||'#888';
@@ -2685,7 +2855,7 @@ $$('.chat-stop').forEach(b=>b.addEventListener('click',async()=>{ b.disabled=tru
 $('#wfAnalyzeBtn').addEventListener('click',analyzeWorkflow);
 $('#updateBtn').addEventListener('click',updateProject);
 $('#setWorkflowAuto').addEventListener('change',(e)=>{ if(P&&P.config) P.config.workflowAutoEnable=e.target.checked; saveSetting({workflowAutoEnable:e.target.checked}); });
-$('#brainAutoAdd').addEventListener('change',(e)=>brainAct(()=>brainCall('POST','/api/brain/settings',{autoAdd:e.target.checked})));
+$$('[data-memory]').forEach(sec=>{ const key=sec.dataset.memory; sec.querySelector('.mem-auto').addEventListener('change',(e)=>memAct(key,()=>MEMORIES[key].setAuto(e.target.checked))); });
 $('#attnAddBtn').addEventListener('click',()=>{ const t=$('#attnInput'); const v=t.value.trim(); if(v){ addAttn(v); t.value=''; } });
 $('#attnInput').addEventListener('keydown',e=>{ if((e.metaKey||e.ctrlKey)&&e.key==='Enter'){ const v=e.target.value.trim(); if(v){ addAttn(v); e.target.value=''; } } });
 $$('.attn-filters .fchip').forEach(b=> b.addEventListener('click',()=>{ attnFilter=b.dataset.attn; renderAttention(); }));