spectoflow 0.33.0 → 0.34.0

package/README.md

@@ -340,6 +340,34 @@ drawer is served by the one read-only endpoint, `GET /api/agentfile?path=` (scop
 `.spectoflow/agents/**` + `.spectoflow/skills/**`, path-traversal-safe) — the framework's only other
 server surface is unchanged.
 
+### Isolated work on a task
+
+In a git project, open a task and click **Work on it in isolation**. The agent works in its own copy of the
+repository — a git worktree on the branch `spectoflow/<task>` — so your working tree stays untouched, and several
+tasks can run at once without stepping on each other or blocking the chat.
+
+```
+  task T-012 ── Work on it in isolation ──►  its own copy, branch spectoflow/T-012   (task: in progress)
+                                                    │  the agent finishes
+                                                    ▼
+                                   task drawer: what changed + the diff             (task: to validate)
+                                   ├─ Merge          into your current branch, copy removed    → done
+                                   ├─ Open a PR      push + gh pr create                        → link on the task
+                                   ├─ Send feedback  the agent works again on the same copy
+                                   └─ Discard        copy and branch removed — the rollback     → to do
+```
+
+- **Nothing to learn:** no command, no setting. Chat runs and orchestration keep working as before.
+- **The agent's last message** shows in the drawer, so a run that changed nothing still says why.
+- **Merge never half-happens:** on a conflict it is aborted, nothing changes, and the drawer shows git's reason —
+  send feedback to the agent, or resolve it yourself.
+- **Open a PR** appears when `gh` is installed and signed in and the repository has a remote.
+- The copies live in `~/.spectoflow/worktrees/`, outside your project (no tool sees a second copy of the code) and
+  outside `.git` (agents refuse to write there). Uncommitted changes in your working tree aren't in the copy; the
+  drawer tells you how many.
+- **Online:** members with write access can start, review, send feedback and discard; merging and opening a pull
+  request stay on the owner's machine.
+
 ### Slash commands
 
 Type `/` in either chat surface to open an autocomplete of reusable **prompt macros** — pick one,

package/lib/dashboard/handlers.js

@@ -69,6 +69,7 @@ function createHandlers(root) {
     // so the 409 guard in orchestrate.start can't wedge forever. Not a resume — just un-wedging.
     try { orchestrator.reconcileOnBoot(root); } catch (_) {}
     try { require('./runner').reconcileRunsOnBoot(root); } catch (_) {}
+    try { require('./isolation').reconcileOnBoot(root); } catch (_) {}
   }
   return {
     handleApi,

package/lib/dashboard/isolation.js

@@ -0,0 +1,177 @@
+'use strict';
+/*
+ * The delivery loop (D79, docs/delivery-loop-design.md): a task worked on in isolation. One path, riding on the
+ * task's existing status:
+ *
+ *   start     → git worktree + branch spectoflow/<id>, the agent runs there         task: in progress
+ *   run ends  → what it left uncommitted is committed on the branch                 task: to validate
+ *   diff      → files and patch, for review in the task drawer
+ *   feedback  → the comment is added to the task, the agent runs again, same worktree
+ *   merge     → merged into the working tree's branch, worktree and branch removed  task: done
+ *   pr        → branch pushed, pull request opened with gh, worktree removed         (link added to the task)
+ *   discard   → worktree and branch removed — the rollback                          task: to do
+ *
+ * State lives in runtime.json → worktrees[<id>] = { branch, base, status, runId, startedAt, endedAt,
+ * uncommitted, prUrl }; git itself stays the source of truth (boot drops an entry whose branch is gone).
+ */
+const store = require('../store');
+const worktree = require('../worktree');
+const { startRun, stopRuns, isRunning } = require('./runner');
+
+const group = (id) => `task:${id}`;
+const OUTPUT_TAIL = 4000;
+// What the agent said last (its plain output, sentinel lines left out) — shown in the drawer, so a run that
+// changed nothing still says why (a question, a refusal, an error).
+function tailOutput(child) {
+  let text = '';
+  const keep = (d) => { text = (text + d.toString()).slice(-OUTPUT_TAIL * 2); };
+  if (child.stdout) child.stdout.on('data', keep);
+  return () => text.split('\n').filter((l) => !/^::spectoflow\s/.test(l.trim())).join('\n').trim().slice(-OUTPUT_TAIL);
+}
+const fail = (status, message) => { throw new worktree.GitError(status, message); };
+
+function findTask(root, id) {
+  for (const pl of store.readPlans(root)) for (const ph of pl.phases) {
+    const task = ph.tasks.find((t) => t.id === id);
+    if (task) return { task, file: pl.file };
+  }
+  return fail(404, `Task ${id} not found.`);
+}
+function readState(root) { return store.readRuntime(root).worktrees || {}; }
+function setState(root, id, patch) {
+  const rt = store.readRuntime(root);
+  rt.worktrees = rt.worktrees || {};
+  if (patch === null) delete rt.worktrees[id];
+  else rt.worktrees[id] = { ...(rt.worktrees[id] || {}), ...patch };
+  store.writeRuntime(root, rt);
+  return rt.worktrees[id] || null;
+}
+const setStatus = (root, file, id, status) => { try { store.updateTaskLine(root, file, id, { status }); } catch (_) {} };
+
+function promptFor(id, task, file, branch, feedback) {
+  const lines = [
+    `Work on task ${id}: ${task.title} (from plans/${file}).`,
+    `You are in an isolated git worktree of this project, on branch ${branch}. The user reviews the diff before anything reaches their own working tree.`,
+    "Don't edit this task's line or its status in plans/ — the dashboard tracks it. Don't push, don't switch or create branches.",
+    'The user started this work from the dashboard: that is their go-ahead to do this task now. If it needs a workflow step that is disabled, enable it in .spectoflow/workflow.md and say so — the change shows in the diff they review.',
+  ];
+  const notes = (task.comments || []).filter((c) => !/^PR: /.test(c));
+  if (notes.length) lines.push(`Notes on the task:\n${notes.map((c) => `- ${c}`).join('\n')}`);
+  if (feedback) lines.push(`Review feedback on your previous change — address it:\n${feedback}`);
+  lines.push('When done, summarize what you changed.');
+  return lines.join('\n\n');
+}
+
+// Start (or restart, with feedback) the agent on a task in its worktree.
+function start(root, { id, feedback }, emit, { remote } = {}) {
+  const { task, file } = findTask(root, id);
+  if (isRunning(root, group(id))) fail(409, `An agent is already working on ${id}.`);
+  const made = worktree.create(root, id);
+  const prev = readState(root)[id] || null;
+  const was = prev || {};
+  // Marked running before the agent starts: startRun's own events must never show the previous run's result.
+  setState(root, id, {
+    branch: made.branch, base: was.base || made.base, status: 'running', runId: null,
+    startedAt: new Date().toISOString(), endedAt: null, error: null, output: null, prUrl: was.prUrl || null,
+    uncommitted: made.created ? worktree.uncommitted(root, [store.resolvePlansDir(root, store.readConfig(root))]).length : (was.uncommitted || 0),
+  });
+  const run = startRun(root, {
+    prompt: promptFor(id, task, file, made.branch, feedback),
+    display: `⎇ ${id} — ${feedback ? 'feedback: ' + feedback : task.title}`,
+    task: id, cwd: made.cwd, learn: !remote,
+  }, emit);
+  if (run.error) {
+    setState(root, id, prev);
+    if (made.created) { try { worktree.discard(root, id); } catch (_) {} }
+    fail(400, run.error);
+  }
+  setState(root, id, { runId: run.runId });
+  setStatus(root, file, id, 'in_progress');
+  const output = run.child ? tailOutput(run.child) : () => '';
+  const finish = (code, signal) => {
+    let error = null;
+    try { worktree.commitAll(made.path, `${id}: ${task.title}`); } catch (e) { error = e.message; }
+    const status = signal ? 'stopped' : code === 0 && !error ? 'ready' : 'failed';
+    setState(root, id, { status, endedAt: new Date().toISOString(), error, output: output() || null });
+    setStatus(root, file, id, 'to_validate');
+    emit({ type: 'change' });
+  };
+  if (run.child) run.child.on('close', finish); else finish(1, null);
+  emit({ type: 'change' });
+  return { runId: run.runId, branch: made.branch, uncommitted: readState(root)[id].uncommitted };
+}
+
+function requireIdle(root, id) {
+  if (isRunning(root, group(id))) fail(409, `An agent is still working on ${id}: stop it first.`);
+}
+// Anything left uncommitted in the worktree (a stopped run, a crash, a hand edit) is part of the change.
+function commitLeftovers(root, id, title) {
+  const wt = worktree.list(root)[id];
+  if (wt) worktree.commitAll(wt, `${id}: ${title}`);
+}
+
+function diff(root, { id }, { remote } = {}) {
+  const { task } = findTask(root, id);
+  const state = readState(root)[id] || {};
+  if (!isRunning(root, group(id))) commitLeftovers(root, id, task.title);
+  const d = worktree.diff(root, id, state.base);
+  return { ...d, running: isRunning(root, group(id)), pr: remote ? { ok: false, reason: 'local dashboard only' } : prReadyCached(root) };
+}
+
+function merge(root, { id }) {
+  const { task, file } = findTask(root, id);
+  requireIdle(root, id);
+  commitLeftovers(root, id, task.title);
+  const r = worktree.merge(root, id, `Merge ${worktree.branchOf(id)}: ${id} ${task.title}`);
+  setState(root, id, null);
+  setStatus(root, file, id, 'done');
+  return r;
+}
+
+function openPr(root, { id }) {
+  const { task, file } = findTask(root, id);
+  requireIdle(root, id);
+  commitLeftovers(root, id, task.title);
+  const r = worktree.openPr(root, id, { title: `${id}: ${task.title}`, body: `Task ${id} from \`plans/${file}\`, worked on with spectoflow.` });
+  setState(root, id, { status: 'pr', prUrl: r.url });
+  try { store.addTaskComment(root, file, id, `PR: ${r.url}`); } catch (_) {}
+  return r;
+}
+
+function discard(root, { id }) {
+  const { file } = findTask(root, id);
+  requireIdle(root, id);
+  const r = worktree.discard(root, id);
+  setState(root, id, null);
+  setStatus(root, file, id, 'todo');
+  return r;
+}
+
+const stop = (root, { id }) => ({ stopped: stopRuns(root, group(id)) });
+
+// After a restart nothing runs: a 'running' entry was interrupted; an entry whose branch is gone is dropped.
+function reconcileOnBoot(root) {
+  const state = readState(root);
+  const ids = Object.keys(state);
+  if (!ids.length) return;
+  const rt = store.readRuntime(root);
+  for (const id of ids) {
+    const exists = worktree.isRepo(root) && worktree.list(root)[id] !== undefined;
+    const branchKept = exists || state[id].status === 'pr';
+    if (!branchKept) { delete rt.worktrees[id]; continue; }
+    if (state[id].status === 'running') rt.worktrees[id] = { ...state[id], status: 'stopped', endedAt: new Date().toISOString() };
+  }
+  store.writeRuntime(root, rt);
+}
+
+// `gh auth status` is slow-ish: remember the answer for a minute per project.
+const prCache = new Map();
+function prReadyCached(root) {
+  const hit = prCache.get(root);
+  if (hit && Date.now() - hit.at < 60000) return hit.value;
+  const value = worktree.prReady(root);
+  prCache.set(root, { at: Date.now(), value });
+  return value;
+}
+
+module.exports = { start, diff, merge, openPr, discard, stop, reconcileOnBoot, promptFor };

package/lib/dashboard/ops.js

@@ -23,6 +23,8 @@ 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;
 
@@ -143,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; };
 
@@ -172,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),
@@ -249,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);

package/lib/dashboard/public/app.js

@@ -316,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)
   };
@@ -982,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);
@@ -2497,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')));
@@ -2509,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')));
@@ -2529,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';

package/lib/dashboard/public/i18n.js

@@ -118,7 +118,7 @@ en: {
   'settings.saved':'✓ saved','settings.group.execution':'Agent & automation','settings.group.appearance':'Appearance & language','settings.group.navTabs':'Navigation tabs','settings.navTabs.locked':'Always on — this is where you manage this setting','settings.navTabs.moveUp':'Move up','settings.navTabs.moveDown':'Move down','field.plansFolder':'Plans folder','field.specsFolder':'Specs folder',
   'settings.commands.title':'Commands','settings.commands.note':'Slash commands you can type in the chat. Use {{input}} in the instruction to place your text where you want it.','settings.commands.add':'+ Add command','settings.commands.restore':'Restore defaults','settings.commands.ph.trigger':'Trigger (e.g. rapport_jour)','settings.commands.ph.desc':'Short description (shown in the menu)','settings.commands.ph.instruction':'Instruction sent to the agent (use {{input}} for your text)','settings.commands.err.invalidTrigger':'Invalid trigger: lowercase letters, digits, - and _ only (max 40).','settings.commands.err.duplicateTrigger':'A command with this trigger already exists.','settings.commands.err.emptyInstruction':'The instruction cannot be empty.',
   'field.frameworkVersion':'Framework version',
-  'task.status':'Status','task.tests':'Tests','task.failing':'{n} failing','task.passing':'{n} passing',
+  'task.status':'Status','task.tests':'Tests','task.failing':'{n} failing','task.passing':'{n} passing','iso.title':'Isolated work','iso.hint':'The agent works on this task in its own copy of the repository (a git worktree): your working tree stays untouched until you review the change and merge it.','iso.start':'Work on it in isolation','iso.error':'Something went wrong.','iso.status.running':'Agent working…','iso.status.ready':'Ready for review','iso.status.stopped':'Stopped — review what was done','iso.status.failed':'The agent ended with an error — review what was done','iso.status.pr':'Pull request opened','iso.chip.running':'working','iso.chip.ready':'to review','iso.chip.stopped':'stopped','iso.chip.failed':'failed','iso.chip.pr':'PR','iso.noChanges':'No change yet.','iso.binary':'binary','iso.showDiff':'Show the changes','iso.hideDiff':'Hide the changes','iso.truncated':'The diff is too long to show in full.','iso.uncommitted':'{n} uncommitted change(s) in your working tree are not in this copy.','iso.prOpened':'Open the pull request ↗','iso.merge':'Merge','iso.mergeHint':'Merge into your current branch, then remove the isolated copy','iso.pr':'Open a pull request','iso.prUnavailable':'Pull request unavailable: {reason}.','iso.discard':'Discard','iso.discardHint':'Delete the isolated copy and its branch','iso.discardConfirm':'Click again to discard','iso.feedback':'Send feedback to the agent','iso.feedbackPlaceholder':'What should the agent change?','iso.said':'The agent\'s last words',
   'task.failingPassing':'{f} failing, {p} passing','task.comments':'Comments','task.noComments':'No comments.',
   'task.addCommentPlaceholder':'Add a comment, a remark, feedback…',
   'task.toAnalyzeHint':'"To analyze" moves the task back so the agent picks it up next round.',
@@ -243,7 +243,7 @@ fr: {
   'settings.saved':'✓ enregistré','settings.group.execution':'Agent et automatisation','settings.group.appearance':'Apparence et langue','settings.group.navTabs':'Onglets de navigation','settings.navTabs.locked':'Toujours activé — c’est ici que vous gérez ce réglage','settings.navTabs.moveUp':'Monter','settings.navTabs.moveDown':'Descendre','field.plansFolder':'Dossier des plans','field.specsFolder':'Dossier des specs',
   'settings.commands.title':'Commandes','settings.commands.note':'Des commandes slash à taper dans le chat. Utilisez {{input}} dans l\'instruction pour placer votre texte où vous voulez.','settings.commands.add':'+ Ajouter une commande','settings.commands.restore':'Restaurer les commandes par défaut','settings.commands.ph.trigger':'Déclencheur (ex. rapport_jour)','settings.commands.ph.desc':'Courte description (affichée dans le menu)','settings.commands.ph.instruction':'Instruction envoyée à l\'agent (utilisez {{input}} pour votre texte)','settings.commands.err.invalidTrigger':'Déclencheur invalide : minuscules, chiffres, - et _ uniquement (40 max).','settings.commands.err.duplicateTrigger':'Une commande avec ce déclencheur existe déjà.','settings.commands.err.emptyInstruction':'L\'instruction ne peut pas être vide.',
   'field.frameworkVersion':'Version du framework',
-  'task.status':'Statut','task.tests':'Tests','task.failing':'{n} en échec','task.passing':'{n} réussi(s)',
+  'task.status':'Statut','task.tests':'Tests','task.failing':'{n} en échec','task.passing':'{n} réussi(s)','iso.title':'Travail isolé','iso.hint':'L’agent travaille sur cette tâche dans sa propre copie du dépôt (un worktree git) : votre dossier de travail reste intact jusqu’à ce que vous relisiez le changement et le fusionniez.','iso.start':'Travailler en isolation','iso.error':'Une erreur est survenue.','iso.status.running':'L’agent travaille…','iso.status.ready':'Prêt à relire','iso.status.stopped':'Arrêté — relisez ce qui a été fait','iso.status.failed':'L’agent a terminé en erreur — relisez ce qui a été fait','iso.status.pr':'Pull request ouverte','iso.chip.running':'en cours','iso.chip.ready':'à relire','iso.chip.stopped':'arrêté','iso.chip.failed':'échec','iso.chip.pr':'PR','iso.noChanges':'Aucun changement pour l’instant.','iso.binary':'binaire','iso.showDiff':'Voir les changements','iso.hideDiff':'Masquer les changements','iso.truncated':'Le diff est trop long pour être affiché en entier.','iso.uncommitted':'{n} changement(s) non commité(s) de votre dossier de travail ne sont pas dans cette copie.','iso.prOpened':'Ouvrir la pull request ↗','iso.merge':'Fusionner','iso.mergeHint':'Fusionner dans votre branche actuelle, puis supprimer la copie isolée','iso.pr':'Ouvrir une pull request','iso.prUnavailable':'Pull request indisponible : {reason}.','iso.discard':'Abandonner','iso.discardHint':'Supprimer la copie isolée et sa branche','iso.discardConfirm':'Cliquez encore pour abandonner','iso.feedback':'Renvoyer un commentaire à l’agent','iso.feedbackPlaceholder':'Que doit changer l’agent ?','iso.said':'Dernier message de l’agent',
   'task.failingPassing':'{f} en échec, {p} réussi(s)','task.comments':'Commentaires','task.noComments':'Aucun commentaire.',
   'task.addCommentPlaceholder':'Ajouter un commentaire, une remarque, un retour…',
   'task.toAnalyzeHint':'« À analyser » renvoie la tâche pour que l’agent la reprenne au tour suivant.',
@@ -368,7 +368,7 @@ es: {
   'settings.saved':'✓ guardado','settings.group.execution':'Agente y automatización','settings.group.appearance':'Apariencia e idioma','settings.group.navTabs':'Pestañas de navegación','settings.navTabs.locked':'Siempre activo — aquí es donde gestionas este ajuste','settings.navTabs.moveUp':'Subir','settings.navTabs.moveDown':'Bajar','field.plansFolder':'Carpeta de planes','field.specsFolder':'Carpeta de specs',
   'settings.commands.title':'Comandos','settings.commands.note':'Comandos slash que puedes escribir en el chat. Usa {{input}} en la instrucción para colocar tu texto donde quieras.','settings.commands.add':'+ Añadir comando','settings.commands.restore':'Restaurar valores predeterminados','settings.commands.ph.trigger':'Activador (p. ej. rapport_jour)','settings.commands.ph.desc':'Descripción breve (se muestra en el menú)','settings.commands.ph.instruction':'Instrucción enviada al agente (usa {{input}} para tu texto)','settings.commands.err.invalidTrigger':'Activador inválido: solo minúsculas, dígitos, - y _ (máx. 40).','settings.commands.err.duplicateTrigger':'Ya existe un comando con este activador.','settings.commands.err.emptyInstruction':'La instrucción no puede estar vacía.',
   'field.frameworkVersion':'Versión del framework',
-  'task.status':'Estado','task.tests':'Pruebas','task.failing':'{n} fallando','task.passing':'{n} superadas',
+  'task.status':'Estado','task.tests':'Pruebas','task.failing':'{n} fallando','task.passing':'{n} superadas','iso.title':'Trabajo aislado','iso.hint':'El agente trabaja en esta tarea en su propia copia del repositorio (un worktree de git): tu directorio de trabajo no se toca hasta que revises el cambio y lo fusiones.','iso.start':'Trabajar en aislamiento','iso.error':'Algo salió mal.','iso.status.running':'El agente está trabajando…','iso.status.ready':'Listo para revisar','iso.status.stopped':'Detenido — revisa lo hecho','iso.status.failed':'El agente terminó con un error — revisa lo hecho','iso.status.pr':'Pull request abierta','iso.chip.running':'en curso','iso.chip.ready':'a revisar','iso.chip.stopped':'detenido','iso.chip.failed':'error','iso.chip.pr':'PR','iso.noChanges':'Aún no hay cambios.','iso.binary':'binario','iso.showDiff':'Ver los cambios','iso.hideDiff':'Ocultar los cambios','iso.truncated':'El diff es demasiado largo para mostrarlo entero.','iso.uncommitted':'{n} cambio(s) sin confirmar de tu directorio de trabajo no están en esta copia.','iso.prOpened':'Abrir la pull request ↗','iso.merge':'Fusionar','iso.mergeHint':'Fusionar en tu rama actual y luego eliminar la copia aislada','iso.pr':'Abrir una pull request','iso.prUnavailable':'Pull request no disponible: {reason}.','iso.discard':'Descartar','iso.discardHint':'Eliminar la copia aislada y su rama','iso.discardConfirm':'Haz clic otra vez para descartar','iso.feedback':'Enviar comentarios al agente','iso.feedbackPlaceholder':'¿Qué debe cambiar el agente?','iso.said':'Último mensaje del agente',
   'task.failingPassing':'{f} fallando, {p} superadas','task.comments':'Comentarios','task.noComments':'Sin comentarios.',
   'task.addCommentPlaceholder':'Añade un comentario, una observación, feedback…',
   'task.toAnalyzeHint':'«Por analizar» devuelve la tarea para que el agente la retome en la siguiente ronda.',
@@ -493,7 +493,7 @@ de: {
   'settings.saved':'✓ gespeichert','settings.group.execution':'Agent & Automatisierung','settings.group.appearance':'Erscheinungsbild & Sprache','settings.group.navTabs':'Navigations-Tabs','settings.navTabs.locked':'Immer aktiv — hier verwaltest du diese Einstellung','settings.navTabs.moveUp':'Nach oben','settings.navTabs.moveDown':'Nach unten','field.plansFolder':'Plan-Ordner','field.specsFolder':'Spec-Ordner',
   'settings.commands.title':'Befehle','settings.commands.note':'Slash-Befehle, die du im Chat eingeben kannst. Verwende {{input}} in der Anweisung, um deinen Text an der gewünschten Stelle einzufügen.','settings.commands.add':'+ Befehl hinzufügen','settings.commands.restore':'Standardwerte wiederherstellen','settings.commands.ph.trigger':'Auslöser (z. B. rapport_jour)','settings.commands.ph.desc':'Kurze Beschreibung (im Menü angezeigt)','settings.commands.ph.instruction':'An den Agenten gesendete Anweisung (verwende {{input}} für deinen Text)','settings.commands.err.invalidTrigger':'Ungültiger Auslöser: nur Kleinbuchstaben, Ziffern, - und _ (max. 40).','settings.commands.err.duplicateTrigger':'Ein Befehl mit diesem Auslöser existiert bereits.','settings.commands.err.emptyInstruction':'Die Anweisung darf nicht leer sein.',
   'field.frameworkVersion':'Framework-Version',
-  'task.status':'Status','task.tests':'Tests','task.failing':'{n} fehlgeschlagen','task.passing':'{n} bestanden',
+  'task.status':'Status','task.tests':'Tests','task.failing':'{n} fehlgeschlagen','task.passing':'{n} bestanden','iso.title':'Isolierte Arbeit','iso.hint':'Der Agent arbeitet an dieser Aufgabe in seiner eigenen Kopie des Repositorys (einem git-Worktree): Dein Arbeitsverzeichnis bleibt unberührt, bis du die Änderung prüfst und zusammenführst.','iso.start':'Isoliert daran arbeiten','iso.error':'Etwas ist schiefgelaufen.','iso.status.running':'Der Agent arbeitet…','iso.status.ready':'Bereit zur Prüfung','iso.status.stopped':'Gestoppt — prüfe, was gemacht wurde','iso.status.failed':'Der Agent endete mit einem Fehler — prüfe, was gemacht wurde','iso.status.pr':'Pull Request geöffnet','iso.chip.running':'läuft','iso.chip.ready':'zu prüfen','iso.chip.stopped':'gestoppt','iso.chip.failed':'Fehler','iso.chip.pr':'PR','iso.noChanges':'Noch keine Änderung.','iso.binary':'binär','iso.showDiff':'Änderungen anzeigen','iso.hideDiff':'Änderungen ausblenden','iso.truncated':'Der Diff ist zu lang, um ihn vollständig anzuzeigen.','iso.uncommitted':'{n} nicht committete Änderung(en) in deinem Arbeitsverzeichnis sind nicht in dieser Kopie.','iso.prOpened':'Pull Request öffnen ↗','iso.merge':'Zusammenführen','iso.mergeHint':'In deinen aktuellen Branch zusammenführen, dann die isolierte Kopie entfernen','iso.pr':'Pull Request öffnen','iso.prUnavailable':'Pull Request nicht verfügbar: {reason}.','iso.discard':'Verwerfen','iso.discardHint':'Die isolierte Kopie und ihren Branch löschen','iso.discardConfirm':'Zum Verwerfen erneut klicken','iso.feedback':'Feedback an den Agenten senden','iso.feedbackPlaceholder':'Was soll der Agent ändern?','iso.said':'Letzte Nachricht des Agenten',
   'task.failingPassing':'{f} fehlgeschlagen, {p} bestanden','task.comments':'Kommentare','task.noComments':'Keine Kommentare.',
   'task.addCommentPlaceholder':'Kommentar, Anmerkung oder Feedback hinzufügen…',
   'task.toAnalyzeHint':'„Zu analysieren“ gibt die Aufgabe zurück, damit der Agent sie in der nächsten Runde aufgreift.',
@@ -618,7 +618,7 @@ pt: {
   'settings.saved':'✓ guardado','settings.group.execution':'Agente e automação','settings.group.appearance':'Aparência e idioma','settings.group.navTabs':'Abas de navegação','settings.navTabs.locked':'Sempre ativo — é aqui que você gerencia esta configuração','settings.navTabs.moveUp':'Mover para cima','settings.navTabs.moveDown':'Mover para baixo','field.plansFolder':'Pasta de planos','field.specsFolder':'Pasta de specs',
   'settings.commands.title':'Comandos','settings.commands.note':'Comandos slash que você pode digitar no chat. Use {{input}} na instrução para posicionar seu texto onde quiser.','settings.commands.add':'+ Adicionar comando','settings.commands.restore':'Restaurar padrões','settings.commands.ph.trigger':'Gatilho (ex.: rapport_jour)','settings.commands.ph.desc':'Descrição curta (exibida no menu)','settings.commands.ph.instruction':'Instrução enviada ao agente (use {{input}} para o seu texto)','settings.commands.err.invalidTrigger':'Gatilho inválido: apenas minúsculas, dígitos, - e _ (máx. 40).','settings.commands.err.duplicateTrigger':'Já existe um comando com este gatilho.','settings.commands.err.emptyInstruction':'A instrução não pode ficar vazia.',
   'field.frameworkVersion':'Versão do framework',
-  'task.status':'Estado','task.tests':'Testes','task.failing':'{n} a falhar','task.passing':'{n} bem-sucedido(s)',
+  'task.status':'Estado','task.tests':'Testes','task.failing':'{n} a falhar','task.passing':'{n} bem-sucedido(s)','iso.title':'Trabalho isolado','iso.hint':'O agente trabalha nesta tarefa na sua própria cópia do repositório (um worktree git): a sua pasta de trabalho fica intacta até rever a alteração e a integrar.','iso.start':'Trabalhar em isolamento','iso.error':'Algo correu mal.','iso.status.running':'O agente está a trabalhar…','iso.status.ready':'Pronto para rever','iso.status.stopped':'Parado — reveja o que foi feito','iso.status.failed':'O agente terminou com um erro — reveja o que foi feito','iso.status.pr':'Pull request aberta','iso.chip.running':'em curso','iso.chip.ready':'a rever','iso.chip.stopped':'parado','iso.chip.failed':'erro','iso.chip.pr':'PR','iso.noChanges':'Ainda sem alterações.','iso.binary':'binário','iso.showDiff':'Ver as alterações','iso.hideDiff':'Ocultar as alterações','iso.truncated':'O diff é demasiado longo para mostrar por inteiro.','iso.uncommitted':'{n} alteração(ões) não confirmada(s) da sua pasta de trabalho não estão nesta cópia.','iso.prOpened':'Abrir a pull request ↗','iso.merge':'Integrar','iso.mergeHint':'Integrar no seu ramo atual e depois remover a cópia isolada','iso.pr':'Abrir uma pull request','iso.prUnavailable':'Pull request indisponível: {reason}.','iso.discard':'Descartar','iso.discardHint':'Apagar a cópia isolada e o seu ramo','iso.discardConfirm':'Clique outra vez para descartar','iso.feedback':'Enviar comentário ao agente','iso.feedbackPlaceholder':'O que deve o agente mudar?','iso.said':'Última mensagem do agente',
   'task.failingPassing':'{f} a falhar, {p} bem-sucedido(s)','task.comments':'Comentários','task.noComments':'Sem comentários.',
   'task.addCommentPlaceholder':'Adicione um comentário, uma observação, feedback…',
   'task.toAnalyzeHint':'«Por analisar» devolve a tarefa para o agente a retomar na ronda seguinte.',
@@ -743,7 +743,7 @@ it: {
   'settings.saved':'✓ salvato','settings.group.execution':'Agente e automazione','settings.group.appearance':'Aspetto e lingua','settings.group.navTabs':'Schede di navigazione','settings.navTabs.locked':'Sempre attivo — è qui che gestisci questa impostazione','settings.navTabs.moveUp':'Sposta su','settings.navTabs.moveDown':'Sposta giù','field.plansFolder':'Cartella dei piani','field.specsFolder':'Cartella delle specs',
   'settings.commands.title':'Comandi','settings.commands.note':'Comandi slash che puoi digitare in chat. Usa {{input}} nell\'istruzione per posizionare il tuo testo dove vuoi.','settings.commands.add':'+ Aggiungi comando','settings.commands.restore':'Ripristina predefiniti','settings.commands.ph.trigger':'Trigger (es. rapport_jour)','settings.commands.ph.desc':'Breve descrizione (mostrata nel menu)','settings.commands.ph.instruction':'Istruzione inviata all\'agente (usa {{input}} per il tuo testo)','settings.commands.err.invalidTrigger':'Trigger non valido: solo minuscole, cifre, - e _ (max 40).','settings.commands.err.duplicateTrigger':'Esiste già un comando con questo trigger.','settings.commands.err.emptyInstruction':'L\'istruzione non può essere vuota.',
   'field.frameworkVersion':'Versione del framework',
-  'task.status':'Stato','task.tests':'Test','task.failing':'{n} falliti','task.passing':'{n} superati',
+  'task.status':'Stato','task.tests':'Test','task.failing':'{n} falliti','task.passing':'{n} superati','iso.title':'Lavoro isolato','iso.hint':'L’agente lavora a questa attività nella propria copia del repository (un worktree git): la tua cartella di lavoro resta intatta finché non rivedi la modifica e la unisci.','iso.start':'Lavora in isolamento','iso.error':'Qualcosa è andato storto.','iso.status.running':'L’agente sta lavorando…','iso.status.ready':'Pronto da rivedere','iso.status.stopped':'Fermato — rivedi ciò che è stato fatto','iso.status.failed':'L’agente è terminato con un errore — rivedi ciò che è stato fatto','iso.status.pr':'Pull request aperta','iso.chip.running':'in corso','iso.chip.ready':'da rivedere','iso.chip.stopped':'fermato','iso.chip.failed':'errore','iso.chip.pr':'PR','iso.noChanges':'Ancora nessuna modifica.','iso.binary':'binario','iso.showDiff':'Mostra le modifiche','iso.hideDiff':'Nascondi le modifiche','iso.truncated':'Il diff è troppo lungo per essere mostrato per intero.','iso.uncommitted':'{n} modifica/e non committata/e della tua cartella di lavoro non sono in questa copia.','iso.prOpened':'Apri la pull request ↗','iso.merge':'Unisci','iso.mergeHint':'Unisci nel tuo branch attuale, poi rimuovi la copia isolata','iso.pr':'Apri una pull request','iso.prUnavailable':'Pull request non disponibile: {reason}.','iso.discard':'Scarta','iso.discardHint':'Elimina la copia isolata e il suo branch','iso.discardConfirm':'Clicca di nuovo per scartare','iso.feedback':'Invia un commento all’agente','iso.feedbackPlaceholder':'Cosa deve cambiare l’agente?','iso.said':'Ultimo messaggio dell’agente',
   'task.failingPassing':'{f} falliti, {p} superati','task.comments':'Commenti','task.noComments':'Nessun commento.',
   'task.addCommentPlaceholder':'Aggiungi un commento, un’osservazione, un feedback…',
   'task.toAnalyzeHint':'«Da analizzare» rimanda l’attività così l’agente la riprende al giro successivo.',

package/lib/dashboard/public/styles.css

@@ -698,6 +698,37 @@ body.booting .ring-svg circle:last-of-type { transform-origin:center; animation:
 .settings-check-label { font-size:13px; font-weight:600; }
 .settings-check-hint { font-size:12px; color:var(--muted); }
 
+/* ---- Isolated work (task drawer) ---- */
+.iso-hint { color:var(--muted); font-size:12.5px; line-height:1.5; margin:0 0 8px; }
+.iso-head { display:flex; flex-wrap:wrap; align-items:center; gap:6px 10px; margin-bottom:8px; }
+.iso-status { font-size:12.5px; font-weight:700; color:var(--ink); }
+.iso-status.is-running { color:var(--cool); } .iso-status.is-failed { color:var(--s-blocked); } .iso-status.is-ready, .iso-status.is-pr { color:var(--signal); }
+.iso-branch { font-family:var(--mono); font-size:11px; color:var(--muted); background:var(--surface-2); border:1px solid var(--line); border-radius:5px; padding:1px 6px; overflow-wrap:anywhere; }
+.iso-log { display:flex; flex-direction:column; gap:3px; margin:0 0 8px; }
+.iso-log-line { font-size:12.5px; color:var(--muted); border-left:2px solid var(--cool); padding-left:8px; overflow-wrap:anywhere; }
+.iso-files { display:flex; flex-direction:column; gap:3px; margin:0 0 8px; }
+.iso-file { display:flex; justify-content:space-between; gap:10px; font-family:var(--mono); font-size:11.5px; min-width:0; }
+.iso-path { overflow-wrap:anywhere; min-width:0; }
+.iso-count { white-space:nowrap; color:var(--faint); }
+.iso-plus { color:var(--s-done); } .iso-minus { color:var(--s-blocked); }
+.iso-patch { margin:8px 0 0; max-height:420px; overflow:auto; border:1px solid var(--line); border-radius:8px; background:var(--surface-2); }
+.iso-patch pre { margin:0; padding:8px 10px; font-family:var(--mono); font-size:11px; line-height:1.5; font-variant-ligatures:none; }
+.iso-patch pre span { display:block; white-space:pre; }
+.iso-l-add { color:var(--s-done); background:color-mix(in srgb,var(--s-done) 10%,transparent); }
+.iso-l-del { color:var(--s-blocked); background:color-mix(in srgb,var(--s-blocked) 10%,transparent); }
+.iso-l-hunk { color:var(--cool); } .iso-l-file, .iso-l-meta { color:var(--faint); font-weight:700; }
+.iso-said { border:1px solid var(--line); border-left:3px solid var(--cool); border-radius:8px; background:var(--surface-2); padding:8px 10px; margin:0 0 10px; max-height:260px; overflow:auto; }
+.iso-said-label { font-size:10.5px; text-transform:uppercase; letter-spacing:.08em; color:var(--faint); font-weight:700; margin-bottom:4px; }
+.iso-said-text { font-size:12.5px; line-height:1.5; white-space:pre-wrap; overflow-wrap:anywhere; }
+.iso-actions { display:flex; flex-wrap:wrap; gap:6px; margin:12px 0 4px; }
+.iso-error { white-space:pre-wrap; font-size:12px; color:var(--s-blocked); border:1px solid color-mix(in srgb,var(--s-blocked) 45%,var(--line)); border-radius:8px; padding:7px 10px; margin:8px 0; overflow-wrap:anywhere; }
+.iso-pr { display:inline-block; font-size:12.5px; color:var(--signal); margin:0 0 8px; }
+.iso-feedback { margin-top:10px; }
+.iso-chip { font-family:var(--mono); font-size:10.5px; color:var(--muted); border:1px solid var(--line); border-radius:999px; padding:1px 7px; }
+.iso-chip.is-running { color:var(--cool); border-color:color-mix(in srgb,var(--cool) 45%,var(--line)); }
+.iso-chip.is-ready, .iso-chip.is-pr { color:var(--signal); border-color:color-mix(in srgb,var(--signal) 45%,var(--line)); }
+.iso-chip.is-failed { color:var(--s-blocked); }
+
 /* ---- Second brain ---- */
 .brain-wrap { max-width:1080px; margin:0 auto; padding:20px 22px 32px; }
 .brain-section { margin-top:22px; }

package/lib/dashboard/routes.js

@@ -24,6 +24,14 @@ const ROUTES = [
   ['POST', '/api/workflow/apply', 'workflow.apply', (_u, b) => b],
   ['POST', '/api/run', 'run.start', (_u, b) => b],
   ['POST', '/api/run/stop', 'run.stop', () => ({})],
+  // A task worked on in isolation (D79). merge and pr are local only — absent from server/src/relay.js.
+  ['POST', /^\/api\/task\/[^/]+\/isolate$/, 'worktree.start', (_u, _b, p) => ({ id: seg(p, 3) })],
+  ['POST', /^\/api\/task\/[^/]+\/isolate\/feedback$/, 'worktree.feedback', (_u, b, p) => ({ id: seg(p, 3), text: b.text })],
+  ['GET', /^\/api\/task\/[^/]+\/isolate\/diff$/, 'worktree.diff', (_u, _b, p) => ({ id: seg(p, 3) })],
+  ['POST', /^\/api\/task\/[^/]+\/isolate\/stop$/, 'worktree.stop', (_u, _b, p) => ({ id: seg(p, 3) })],
+  ['POST', /^\/api\/task\/[^/]+\/isolate\/discard$/, 'worktree.discard', (_u, _b, p) => ({ id: seg(p, 3) })],
+  ['POST', /^\/api\/task\/[^/]+\/isolate\/merge$/, 'worktree.merge', (_u, _b, p) => ({ id: seg(p, 3) })],
+  ['POST', /^\/api\/task\/[^/]+\/isolate\/pr$/, 'worktree.pr', (_u, _b, p) => ({ id: seg(p, 3) })],
   ['POST', '/api/chat/summarize', 'chat.summarize', (_u, b) => b],
   ['POST', '/api/meeting/generate', 'meeting.generate', (_u, b) => b],
   ['POST', '/api/chat/clear', 'chat.clear', () => ({})],

package/lib/dashboard/runner.js

@@ -26,22 +26,25 @@ function resolveRunnerCommand(root, cfg, which, opts) {
   return null;
 }
 
-// Agent processes in flight, per project — so a stuck one can be stopped from the dashboard. Runs, summaries
-// and meeting notes all register here.
+// Agent processes in flight, per project and group — so a stuck one can be stopped from the dashboard. Runs,
+// summaries and meeting notes share the 'chat' group; a task worked on in isolation (D79) has its own,
+// 'task:<id>', so stopping the chat never stops it, and the other way round.
 const inFlight = new Map();
-function trackChild(root, child) {
-  const key = path.resolve(root);
+const flightKey = (root, group) => `${path.resolve(root)}\n${group || 'chat'}`;
+function trackChild(root, child, group) {
+  const key = flightKey(root, group);
   if (!inFlight.has(key)) inFlight.set(key, new Set());
   inFlight.get(key).add(child);
   child.on('close', () => { const set = inFlight.get(key); if (set) set.delete(child); });
 }
-// Stop every agent process running for this project → how many were signalled.
-function stopRuns(root) {
-  const set = inFlight.get(path.resolve(root));
+// Stop every agent process of this project's group → how many were signalled.
+function stopRuns(root, group) {
+  const set = inFlight.get(flightKey(root, group));
   if (!set || !set.size) return 0;
   for (const child of set) { try { child.kill(); } catch (_) {} }
   return set.size;
 }
+const isRunning = (root, group) => { const set = inFlight.get(flightKey(root, group)); return !!(set && set.size); };
 // After a crash or restart, runs recorded as running can't be: mark them interrupted.
 function reconcileRunsOnBoot(root) {
   const rt = store.readRuntime(root);
@@ -104,7 +107,9 @@ function parseLearnLine(line) {
 // logPrompt:false suppresses echoing the prompt as a user bubble — used by the orchestrator,
 // whose priming prompt ("You are the …") is machinery the user shouldn't have to read.
 // display: when a non-empty string, the chat bubble shows this while the child still receives prompt.
-function startRun(root, { prompt, agent, logPrompt = true, display, learn = true }, emit) {
+// task + cwd: a task worked on in isolation (D79) — the agent runs in the task's worktree, its run and events
+// carry the task id (the chat stays free), and it is stopped with its own group.
+function startRun(root, { prompt, agent, logPrompt = true, display, learn = true, task, cwd }, emit) {
   const cfg = store.readConfig(root);
   const which = agent || cfg.agent || 'claude';
   const cmdStr = resolveRunnerCommand(root, cfg, which);
@@ -124,24 +129,25 @@ function startRun(root, { prompt, agent, logPrompt = true, display, learn = true
     emit({ type: 'message', message: um });
   }
 
-  const run = { id: runId, tool: which, prompt: p, status: 'running', startedAt: new Date().toISOString() };
-  runStart(root, run); emit({ type: 'run-start', run }); emit({ type: 'change' });
+  const run = { id: runId, tool: which, prompt: p, status: 'running', startedAt: new Date().toISOString(), ...(task ? { task } : {}) };
+  const tag = task ? { task } : {};
+  runStart(root, run); emit({ type: 'run-start', run, ...tag }); emit({ type: 'change' });
 
   let child;
   // windowsHide: without it, spawning a .cmd-shimmed CLI (e.g. a global npm install of `claude` on
   // Windows) pops up a real, empty console window on top of the browser — jarring, and pointless
   // since stdout/stderr are already piped and captured below, never read from that window anyway.
-  try { child = spawn(parts[0], [...parts.slice(1), p], { cwd: root, env: process.env, windowsHide: true }); }
+  try { child = spawn(parts[0], [...parts.slice(1), p], { cwd: cwd || root, env: process.env, windowsHide: true }); }
   catch (e) {
     runEnd(root, runId, 1);
-    emit({ type: 'run-line', runId, chunk: 'spawn error: ' + e.message + '\n' });
-    emit({ type: 'run-end', runId, code: 1 }); emit({ type: 'change' });
-    return { runId };
+    emit({ type: 'run-line', runId, chunk: 'spawn error: ' + e.message + '\n', ...tag });
+    emit({ type: 'run-end', runId, code: 1, ...tag }); emit({ type: 'change' });
+    return { runId, spawnError: e.message };
   }
   // End the child's stdin immediately: a child that reads stdin (or a Windows pipe that
   // otherwise keeps 'close' from firing) can't stall the run waiting on input that never comes.
   try { child.stdin && child.stdin.end(); } catch {}
-  trackChild(root, child);
+  trackChild(root, child, task ? `task:${task}` : 'chat');
 
   const onLine = (line) => {
     // A learn line is swallowed either way. When recorded, it ALWAYS waits in "To confirm", whatever
@@ -158,20 +164,20 @@ function startRun(root, { prompt, agent, logPrompt = true, display, learn = true
     if (att) { pushAttention(root, att, which); emit({ type: 'change' }); return; }
     const m = store.parseAgentLine(line);
     if (m) { const full = store.appendMessage(root, { ...m, agent: which, runId }); emit({ type: 'message', message: full }); }
-    else emit({ type: 'run-line', runId, chunk: line + '\n' });
+    else emit({ type: 'run-line', runId, chunk: line + '\n', ...tag });
   };
   const out = makeFeeder(onLine), err = makeFeeder(onLine);
   child.stdout && child.stdout.on('data', (d) => out.feed(d));
   child.stderr && child.stderr.on('data', (d) => err.feed(d));
-  child.on('error', (e) => emit({ type: 'run-line', runId, chunk: 'error: ' + e.message + '\n' }));
+  child.on('error', (e) => emit({ type: 'run-line', runId, chunk: 'error: ' + e.message + '\n', ...tag }));
   child.on('close', (code, signal) => {
     out.flush(); err.flush();
     runEnd(root, runId, code, signal);
     const sm = store.appendMessage(root, { role: which, kind: 'status', text: signal ? 'stopped' : `finished (exit ${code})`, agent: which, runId });
     emit({ type: 'message', message: sm });
-    emit({ type: 'run-end', runId, code }); emit({ type: 'change' });
+    emit({ type: 'run-end', runId, code, ...tag }); emit({ type: 'change' });
   });
   return { runId, child };
 }
 
-module.exports = { startRun, resolveRunnerCommand, parseLearnLine, trackChild, stopRuns, reconcileRunsOnBoot };
+module.exports = { startRun, resolveRunnerCommand, parseLearnLine, trackChild, stopRuns, isRunning, reconcileRunsOnBoot };

package/lib/worktree.js

@@ -0,0 +1,193 @@
+'use strict';
+/*
+ * The delivery loop's git side (D79): one git worktree per task, so an agent works on a task without touching
+ * the user's working tree, then the change is reviewed as a diff and merged, turned into a pull request, sent
+ * back with feedback, or discarded. Zero dependency: `git` and `gh` are run with execFileSync — never a shell,
+ * so nothing in a task id, a title or a comment is ever interpreted.
+ *
+ *   worktree  ~/.spectoflow/worktrees/<repo>-<hash>/<task-id>   outside the project, so no watcher, search, test
+ *             runner or build sees a second copy of the code — and outside .git, where agents refuse to write
+ *             (Claude Code protects .git/ — found with a real run)
+ *   branch    spectoflow/<task-id>, created from the working tree's HEAD
+ *
+ * The project may sit in a sub-folder of the repository: the agent then works in the same sub-folder of the
+ * worktree.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execFileSync } = require('child_process');
+const globalConfig = require('./global-config');
+
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const MAX_PATCH = 400 * 1024;
+const BRANCH_PREFIX = 'spectoflow/';
+
+class GitError extends Error {
+  constructor(status, message) { super(message); this.status = status; }
+}
+
+function run(cmd, args, cwd, { input, allowFail } = {}) {
+  try {
+    return execFileSync(cmd, args, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], input, maxBuffer: 64 * 1024 * 1024, windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } });
+  } catch (e) {
+    if (allowFail) return null;
+    const msg = String((e.stderr || '') + (e.stdout || '')).trim() || e.message;
+    throw new GitError(409, msg.split('\n').slice(-6).join('\n'));
+  }
+}
+const git = (cwd, args, opts) => run('git', args, cwd, opts);
+const gitOk = (cwd, args) => git(cwd, args, { allowFail: true });
+
+const checkId = (id) => { if (!ID_RE.test(String(id || ''))) throw new GitError(400, `Invalid task id: ${id}`); return String(id); };
+const branchOf = (id) => BRANCH_PREFIX + checkId(id);
+
+// → { top, commonDir, rel } for a project inside a git work tree, else null.
+function repoInfo(root) {
+  const top = gitOk(root, ['rev-parse', '--show-toplevel']);
+  if (top === null) return null;
+  const common = git(root, ['rev-parse', '--git-common-dir']).trim();
+  const topDir = top.trim();
+  let rel = path.relative(fs.realpathSync(topDir), fs.realpathSync(root));
+  if (rel.startsWith('..')) rel = '';
+  return { top: topDir, commonDir: path.resolve(root, common), rel };
+}
+function requireRepo(root) {
+  const info = repoInfo(root);
+  if (!info) throw new GitError(400, 'This project is not a git repository: isolated work needs git.');
+  if (!gitOk(root, ['rev-parse', '--verify', 'HEAD'])) throw new GitError(400, 'This repository has no commit yet: make a first commit, then try again.');
+  return info;
+}
+const isRepo = (root) => !!repoInfo(root);
+
+// One folder per repository, named so a person can tell which is which, and unique per repository.
+function worktreePath(info, id) {
+  const key = crypto.createHash('sha1').update(fs.realpathSync(info.commonDir)).digest('hex').slice(0, 8);
+  const name = path.basename(info.top).replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 40) || 'repo';
+  return path.join(globalConfig.homeDir(), 'worktrees', `${name}-${key}`, checkId(id));
+}
+const branchExists = (root, branch) => gitOk(root, ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`]) !== null;
+
+// The worktrees git knows about for spectoflow branches → { <task-id>: path }.
+function list(root) {
+  const out = gitOk(root, ['worktree', 'list', '--porcelain']);
+  const found = {};
+  if (!out) return found;
+  let current = null;
+  for (const line of out.split('\n')) {
+    if (line.startsWith('worktree ')) current = line.slice(9);
+    else if (line.startsWith(`branch refs/heads/${BRANCH_PREFIX}`) && current) found[line.slice(`branch refs/heads/${BRANCH_PREFIX}`.length)] = current;
+  }
+  return found;
+}
+
+// Create the task's worktree (or reuse the one that exists) → { branch, path, cwd, base }.
+function create(root, id) {
+  const info = requireRepo(root);
+  const branch = branchOf(id);
+  const wt = worktreePath(info, id);
+  const existing = list(root)[id];
+  const base = git(root, ['rev-parse', 'HEAD']).trim();
+  if (existing) return { branch, path: existing, cwd: path.join(existing, info.rel), base: mergeBase(root, branch) || base, created: false };
+  fs.mkdirSync(path.dirname(wt), { recursive: true });
+  if (branchExists(root, branch)) git(root, ['worktree', 'add', wt, branch]);
+  else git(root, ['worktree', 'add', '-b', branch, wt, 'HEAD']);
+  return { branch, path: wt, cwd: path.join(wt, info.rel), base, created: true };
+}
+const mergeBase = (root, branch) => { const r = gitOk(root, ['merge-base', 'HEAD', branch]); return r && r.trim(); };
+
+// Uncommitted changes in the user's working tree (they are not in the worktree) → paths. Left out: what the
+// dashboard writes itself — preferences in config.json, task status lines in the plans folder (`ignore`, paths
+// relative to the project) — the agent is given its task in the prompt.
+function uncommitted(root, ignore = []) {
+  const out = gitOk(root, ['status', '--porcelain', '--untracked-files=normal', '--', '.']) || '';
+  const info = repoInfo(root);
+  const skip = ['.spectoflow/config.json', ...ignore].map((p) => path.posix.join(info && info.rel ? info.rel.split(path.sep).join('/') : '', p));
+  return out.split('\n').filter(Boolean).map((l) => l.slice(3).replace(/^"|"$/g, ''))
+    .filter((p) => !skip.some((s) => p === s || p.startsWith(s.replace(/\/?$/, '/'))));
+}
+
+// Commit whatever the agent left uncommitted in the worktree → true when a commit was made. No hooks: the
+// worktree has no installed dependencies for them to run with, and the change is reviewed before it lands.
+function commitAll(wtPath, message) {
+  git(wtPath, ['add', '-A']);
+  if (gitOk(wtPath, ['diff', '--cached', '--quiet']) !== null) return false;
+  const ident = gitOk(wtPath, ['config', 'user.email']) ? [] : ['-c', 'user.name=spectoflow', '-c', 'user.email=spectoflow@localhost'];
+  git(wtPath, [...ident, 'commit', '--no-verify', '-q', '-m', message]);
+  return true;
+}
+
+// What the branch changes compared to where it started → { files: [{ path, added, removed }], patch, truncated }.
+function diff(root, id, base) {
+  requireRepo(root);
+  const branch = branchOf(id);
+  if (!branchExists(root, branch)) throw new GitError(404, `No isolated work for ${id}.`);
+  const from = base || mergeBase(root, branch);
+  const range = [`${from}`, branch];
+  const files = git(root, ['diff', '--numstat', '--no-color', ...range]).split('\n').filter(Boolean).map((l) => {
+    const [a, r, ...p] = l.split('\t');
+    return { path: p.join('\t'), added: a === '-' ? null : Number(a), removed: r === '-' ? null : Number(r) };
+  });
+  let patch = git(root, ['diff', '--no-color', '--no-ext-diff', ...range]);
+  const truncated = patch.length > MAX_PATCH;
+  if (truncated) patch = patch.slice(0, MAX_PATCH);
+  return { branch, files, patch, truncated };
+}
+
+function removeWorktree(root, id) {
+  const wt = list(root)[id];
+  if (wt) git(root, ['worktree', 'remove', '--force', wt]);
+  gitOk(root, ['worktree', 'prune']);
+  if (wt) { try { fs.rmdirSync(path.dirname(wt)); } catch (_) {} } // the repository's folder, once empty
+}
+
+// Merge the branch into the working tree's current branch. On any failure (conflict, local changes git would
+// overwrite) the merge is aborted and nothing has changed → throws with git's own explanation.
+function merge(root, id, message) {
+  requireRepo(root);
+  const branch = branchOf(id);
+  if (!branchExists(root, branch)) throw new GitError(404, `No isolated work for ${id}.`);
+  const ident = gitOk(root, ['config', 'user.email']) ? [] : ['-c', 'user.name=spectoflow', '-c', 'user.email=spectoflow@localhost'];
+  try {
+    git(root, [...ident, 'merge', '--no-ff', '--no-verify', '-m', message || `Merge ${branch}`, branch]);
+  } catch (e) {
+    if (gitOk(root, ['rev-parse', '--verify', '--quiet', 'MERGE_HEAD']) !== null) gitOk(root, ['merge', '--abort']);
+    throw new GitError(409, `The merge could not be done, nothing was changed. Git said:\n${e.message}`);
+  }
+  removeWorktree(root, id);
+  gitOk(root, ['branch', '-D', branch]);
+  return { branch };
+}
+
+function discard(root, id) {
+  requireRepo(root);
+  const branch = branchOf(id);
+  removeWorktree(root, id);
+  gitOk(root, ['branch', '-D', branch]);
+  return { branch };
+}
+
+// Can a pull request be opened from here? → { ok, reason }. `gh` installed and signed in, and a remote.
+function prReady(root) {
+  if (!isRepo(root)) return { ok: false, reason: 'not a git repository' };
+  const remotes = (gitOk(root, ['remote']) || '').split('\n').filter(Boolean);
+  if (!remotes.length) return { ok: false, reason: 'no git remote' };
+  if (run('gh', ['--version'], root, { allowFail: true }) === null) return { ok: false, reason: 'gh is not installed' };
+  if (run('gh', ['auth', 'status'], root, { allowFail: true }) === null) return { ok: false, reason: 'gh is not signed in (run: gh auth login)' };
+  return { ok: true, remote: remotes.includes('origin') ? 'origin' : remotes[0] };
+}
+
+// Push the branch and open a pull request with `gh` → { url }. The branch stays; the worktree goes.
+function openPr(root, id, { title, body } = {}) {
+  const ready = prReady(root);
+  if (!ready.ok) throw new GitError(400, `Can't open a pull request: ${ready.reason}.`);
+  const branch = branchOf(id);
+  if (!branchExists(root, branch)) throw new GitError(404, `No isolated work for ${id}.`);
+  git(root, ['push', '-u', ready.remote, branch]);
+  const out = run('gh', ['pr', 'create', '--head', branch, '--title', title || branch, '--body', body || ''], root);
+  const url = (out.match(/https?:\/\/\S+/) || [])[0] || out.trim();
+  removeWorktree(root, id);
+  return { url, branch };
+}
+
+module.exports = { GitError, isRepo, repoInfo, list, create, uncommitted, commitAll, diff, merge, discard, prReady, openPr, branchOf, BRANCH_PREFIX };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectoflow",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "description": "Agent-agnostic spec-driven development framework + real-time local control plane. Markdown artifacts, intent router, workflow-by-scope.",
   "keywords": [
     "spec-driven-development",