spectoflow 0.30.0 → 0.31.1

package/README.md

@@ -101,6 +101,7 @@ spectoflow list                                agents, skills and the workflow a
 spectoflow agents                              list the team personas
 spectoflow skills                              list the procedures
 spectoflow workflow                            show the enabled pipeline steps
+spectoflow workflow suggest [--apply]          which steps fit the project now (code yet? tests? E2E? infra/data?)
 
 spectoflow --version   (-v)                    print the version
 spectoflow --help      (-h)                    show help   (append -h to any command for its help)
@@ -204,6 +205,11 @@ that another website sent — a malicious page, a DNS-rebinding trick, or a tunn
 machine can't drive it. Clicking a link to it from another site still opens it. To reach your projects from
 another device, use the online dashboard ([below](#going-online-optional-local-hub-vs-relay-server)).
 
+**A custom agent command needs your OK.** `config.json → runners` sets the command that launches each agent,
+and that file is committed — it can come from a cloned repository or a teammate's change. A command other than
+the agent's default only runs once you allow it on this machine: Personalize → *Agent & automation* → **Allow
+on this machine**, or `spectoflow runners allow <agent>`. Change the command and it asks again.
+
 ### One hub, every project
 
 There is only ever **one dashboard process on your machine**, no matter how many projects you have.
@@ -280,6 +286,8 @@ off by default):
   noted yourself — edit / resolve / delete, or **validate → task**.
 - **Backlog** — a flat sortable/filterable, paginated table of every task, defaulting to open work.
 - **Workflow** — the pipeline as step cards; click one to enable/disable it, which edits `workflow.md`.
+  **Analyze the project** proposes the steps that fit it now, each with its reason — you apply the ones you
+  tick (see [A workflow that fits the project](#a-workflow-that-fits-the-project)).
 - **Agents & Skills** — enriched cards that open a full-body markdown drawer.
 - **Files** — a project file tree with read / write / create, syntax-highlighted (self-hosted Prism.js).
 - **Bloc note** *(off by default)* — a per-project post-it Markdown scratchpad.
@@ -398,6 +406,26 @@ agents then read and grow your second brain through that server: nothing is copi
   A run started from either of those can't write into it, and a learned fact never goes into a project's chat
   log.
 
+## A workflow that fits the project
+
+The workflow (`.spectoflow/workflow.md`) isn't one-size-fits-all anymore.
+
+- **At `init`**, spectoflow looks at the files: is there code yet, tests, an end-to-end setup (Playwright,
+  Cypress), infrastructure (Terraform, Helm) or data (dbt, notebooks)? A project still in design gets
+  Brainstorm, Analysis, Spec and Plan — and *Develop*, *Unit tests* and *Review* stay off until there is code.
+  Integration and end-to-end tests are switched on only if the project already has them. `init` tells you
+  what it switched off and why. An existing `workflow.md` is never touched.
+- **At the first session**, your agent reviews it with you: a file scan can't tell a prototype from a
+  product, the agent can, from your docs, specs and plans.
+- **As the project moves on**, when a request needs a step that is off (asked to write code while *Develop*
+  is off…), the agent asks you first — or, with Personalize → *Let the agent enable workflow steps when
+  needed* (`workflowAutoEnable` in `config.json`), it enables the step itself and tells you. It never
+  disables a step on its own.
+- **For a project initialized before this**, run `spectoflow workflow suggest` (add `--apply` to apply), or
+  use Workflow → **Analyze the project** in the dashboard and tick the changes you want.
+
+You can still switch any step on or off by hand, anytime.
+
 ## Agents vs skills
 
 Agents (`.spectoflow/agents/`) are **stable team personas** (Product Manager, Developer, QA Engineer…).

package/bin/spectoflow.js

@@ -374,6 +374,50 @@ function configCmd() {
   } catch (e) { console.log(`${c.y('!')} ${e.message}`); process.exitCode = 1; }
 }
 
+// ---- workflow: show it, or suggest the steps that fit the project now (D75) ----
+function workflowCmd() {
+  if (argv[1] !== 'suggest') { console.log(wordmark()); printWorkflow(false); return; }
+  const root = process.cwd();
+  if (!fs.existsSync(path.join(root, '.spectoflow', 'workflow.md'))) { console.log('No spectoflow project here. Run: spectoflow init'); process.exitCode = 1; return; }
+  const wd = require('../lib/workflow-detect');
+  const cfg = store.readConfig(root);
+  const s = wd.suggest(root, { projectType: cfg.projectType });
+  const apply = argv.includes('--apply');
+  console.log(wordmark());
+  console.log(`  ${c.bold('spectoflow workflow suggest')}${apply ? c.dim('   (apply)') : ''}`);
+  console.log(`  ${c.dim('detected:')} ${s.projectType} project · ${s.phase === 'design' ? 'design phase (no code yet)' : 'has code'}${s.truncated ? c.dim('  (large project: scan stopped early)') : ''}\n`);
+  if (!s.changes.length) { console.log(`  ${c.g('✓')} The workflow already matches the project.\n`); return; }
+  const w = Math.max(...s.changes.map((ch) => ch.name.length));
+  for (const ch of s.changes) console.log(`  ${ch.to ? c.g('●') : c.dim('○')} ${ch.name.padEnd(w)}  ${ch.from ? 'on' : 'off'} ${c.amber('→')} ${ch.to ? c.g('on ') : c.y('off')}  ${c.dim(wd.REASONS[ch.reason])}`);
+  if (!apply) { console.log(`\n  ${c.dim('apply them:')} ${c.g('spectoflow workflow suggest --apply')}   ${c.dim('— or pick in the dashboard: Workflow → Analyze the project')}\n`); return; }
+  const changed = wd.applySteps(root, Object.fromEntries(s.changes.map((ch) => [ch.name, ch.to])));
+  console.log(`\n  ${c.g('✓')} ${changed.length} step(s) updated in .spectoflow/workflow.md\n`);
+}
+
+// ---- runners: the commands that launch agents, and which custom ones are allowed on this machine (D76) ----
+function runnersCmd() {
+  const root = process.cwd();
+  if (!fs.existsSync(path.join(root, '.spectoflow', 'config.json'))) { console.log('No spectoflow project here. Run: spectoflow init'); process.exitCode = 1; return; }
+  const trust = require('../lib/runner-trust');
+  const runners = store.readConfig(root).runners || {};
+  if (argv[1] === 'allow') {
+    const which = argv[2];
+    if (!which || typeof runners[which] !== 'string') { console.log(`${c.y('!')} Usage: spectoflow runners allow <agent>   ${c.dim('— one of: ' + (Object.keys(runners).join(', ') || 'none'))}`); process.exitCode = 1; return; }
+    if (trust.isDefault(which, runners[which])) { console.log(`${c.dim('·')} ${which} uses the default command — nothing to allow.`); return; }
+    trust.trust(root, which, runners[which]);
+    console.log(`${c.g('✓')} allowed on this machine for this project: ${c.bold(which)} → ${runners[which]}`);
+    return;
+  }
+  console.log(wordmark());
+  const w = Math.max(4, ...Object.keys(runners).map((k) => k.length));
+  for (const [which, cmd] of Object.entries(runners)) {
+    const state = trust.isDefault(which, cmd) ? c.dim('default') : trust.isTrusted(root, which, cmd) ? c.g('allowed') : c.y('needs your OK');
+    console.log(`  ${which.padEnd(w)}  ${state.padEnd(24)}  ${cmd}`);
+  }
+  if (!Object.keys(runners).length) console.log(c.dim('  (no runners in config.json)'));
+  if (trust.untrusted(root, { runners }).length) console.log(`\n  ${c.dim('a custom command only runs once allowed:')} ${c.g('spectoflow runners allow <agent>')}\n`);
+}
+
 // ---- brain: the user's second brain (~/.spectoflow/brain.md), shared by every project ----
 function brainCmd() {
   const brain = require('../lib/brain');
@@ -699,7 +743,7 @@ const HELP = {
   (or the bundled kit when run outside a project) at a glance.`,
   agents: `${c.bold('spectoflow agents')}\n  List the stable team personas (name · capability · role).`,
   skills: `${c.bold('spectoflow skills')}\n  List the evolving procedures (name · capability · what it does).`,
-  workflow: `${c.bold('spectoflow workflow')}\n  Show the pipeline steps, marking which are enabled (●) or disabled (○).`,
+  workflow: `${c.bold('spectoflow workflow')} ${c.dim('[suggest [--apply]]')}\n  Show the pipeline steps, marking which are enabled (●) or disabled (○).\n    ${c.g('suggest')}          look at the project (is there code yet? tests? an E2E setup? infra or data?) and\n                     list the steps worth switching on or off, with the reason — nothing is written\n    ${c.g('suggest --apply')}  apply them (only those lines of .spectoflow/workflow.md change)`,
   brain: `${c.bold('spectoflow brain')} ${c.dim('[setup [--dry-run]]')}\n
   Your second brain — what spectoflow has learned about you (profile, preferences, working style,
   things to avoid), in ${c.dim('~/.spectoflow/brain.md')}, shared by all your projects and editable in the
@@ -708,6 +752,7 @@ const HELP = {
     ${c.g('brain setup')}    register the MCP server in each installed agent's USER-level config (once
                    per machine; never touches an existing entry; Goose gets a snippet to paste)
   Learned facts are added directly by default: ${c.g('spectoflow config set brain.autoAdd false')} to confirm them first.`,
+  runners: `${c.bold('spectoflow runners')} ${c.dim('[allow <agent>]')}\n\n  The commands that launch each agent (${c.dim('.spectoflow/config.json → runners')}). A command other than the\n  agent's default only runs once you allow it on this machine — config.json is committed, so it can come\n  from a cloned repository, a teammate, or an agent's edit.\n    ${c.g('runners')}                list them: default · allowed · needs your OK\n    ${c.g('runners allow <agent>')}  allow that agent's current command, for this project, on this machine`,
   stop: `${c.bold('spectoflow stop')}\n  Stop the running dashboard (alias for ${c.g('spectoflow dashboard stop')}).`,
   config: `${c.bold('spectoflow config')} ${c.dim('[get <key> | set <key> <value>]')}\n
   Global settings that apply to every project on this machine, stored in ${c.dim('~/.spectoflow/config.json')}:
@@ -725,9 +770,10 @@ const fns = {
   config: configCmd,
   mcp: () => require('../lib/mcp-server').serve({ version: VERSION }),
   brain: brainCmd,
+  runners: runnersCmd,
   agents: () => { console.log(wordmark()); printAgents(false); },
   skills: () => { console.log(wordmark()); printSkills(false); },
-  workflow: () => { console.log(wordmark()); printWorkflow(false); },
+  workflow: workflowCmd,
   skill: () => runCustomize('skill'),
   agent: () => runCustomize('agent'),
 };

package/lib/adapters.js

@@ -30,6 +30,10 @@ learn one (a stated preference, a correction of how you work, their role), recor
 \`::spectoflow learn category=<profile|preferences|workflow|avoid> msg=<fact>\` if that tool is unavailable. Never
 secrets or sensitive data.
 
+**Workflow.** If a request needs a step that is disabled in \`.spectoflow/workflow.md\` (e.g. writing code while
+*Develop* is off): enable it yourself and say so when \`.spectoflow/config.json\` → \`workflowAutoEnable\` is \`true\`;
+otherwise ask first. Never disable a step without the user.
+
 - Command: \`/spectoflow\` (\`init\` / \`status\` / or just a request).
 - Dashboard: \`spectoflow dashboard\` → http://localhost:4319
 - Artifacts are markdown in \`specs/\` and \`plans/\`; volatile state in \`.spectoflow/runtime.json\`.
@@ -48,6 +52,10 @@ is clear — then execute. See the Clarify reflex in \`.spectoflow/SPECTOFLOW.md
 learn one (a stated preference, a correction of how you work, their role), record it with \`brain_learn\`, or print
 \`::spectoflow learn category=<profile|preferences|workflow|avoid> msg=<fact>\` if that tool is unavailable. Never
 secrets or sensitive data.
+
+**Workflow.** If a request needs a step that is disabled in \`.spectoflow/workflow.md\` (e.g. writing code while
+*Develop* is off): enable it yourself and say so when \`.spectoflow/config.json\` → \`workflowAutoEnable\` is \`true\`;
+otherwise ask first. Never disable a step without the user.
 `;
 
 const GEMINI_MD = `# GEMINI.md — spectoflow
@@ -64,6 +72,10 @@ is clear — then execute. See the Clarify reflex in \`.spectoflow/SPECTOFLOW.md
 learn one (a stated preference, a correction of how you work, their role), record it with \`brain_learn\`, or print
 \`::spectoflow learn category=<profile|preferences|workflow|avoid> msg=<fact>\` if that tool is unavailable. Never
 secrets or sensitive data.
+
+**Workflow.** If a request needs a step that is disabled in \`.spectoflow/workflow.md\` (e.g. writing code while
+*Develop* is off): enable it yourself and say so when \`.spectoflow/config.json\` → \`workflowAutoEnable\` is \`true\`;
+otherwise ask first. Never disable a step without the user.
 `;
 
 const SLASH_CMD = `---

package/lib/dashboard/files.js

@@ -38,6 +38,15 @@ function realUnderRoot(root, abs) {
   return real;
 }
 
+// Files that make tools run commands on their own — the agent launcher (config.json runners), hooks,
+// MCP server definitions, editor tasks. Someone editing through the online dashboard must never be able
+// to change them: that would turn a project write into running anything on the owner's machine (D76).
+const EXEC_CONFIG = ['.git', '.spectoflow/config.json', '.spectoflow/hooks', '.spectoflow/lib', '.claude', '.mcp.json', '.cursor', '.codex', '.gemini', '.kiro', '.vscode', '.idea', '.husky'];
+function isExecConfig(rel) {
+  const n = String(rel || '').replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '').toLowerCase();
+  return EXEC_CONFIG.some((p) => n === p || n.startsWith(p + '/'));
+}
+
 function isUnderGit(rel) {
   const n = String(rel || '').replace(/\\/g, '/').replace(/^\/+/, '');
   return n === '.git' || n.startsWith('.git/');
@@ -83,9 +92,10 @@ function readFile(root, rel) {
   return { content: buf.toString('utf8') };
 }
 
-function writeFile(root, rel, content) {
+function writeFile(root, rel, content, { remote = false } = {}) {
   if (typeof content !== 'string') return { error: 'Missing content.' };
   if (isUnderGit(rel)) return { error: 'Writes under .git are blocked.' };
+  if (remote && isExecConfig(rel)) return { error: 'This file controls commands run on the owner\'s machine: it can only be edited locally.' };
   const abs = safePath(root, rel);
   if (!abs) return { error: 'Invalid path.' };
   const parentDir = path.dirname(abs);
@@ -95,8 +105,9 @@ function writeFile(root, rel, content) {
   return { ok: true };
 }
 
-function mkdir(root, rel) {
+function mkdir(root, rel, { remote = false } = {}) {
   if (isUnderGit(rel)) return { error: 'Cannot create folders under .git.' };
+  if (remote && isExecConfig(rel)) return { error: 'This folder controls commands run on the owner\'s machine: it can only be changed locally.' };
   const abs = safePath(root, rel);
   if (!abs) return { error: 'Invalid path.' };
   const parentDir = path.dirname(abs);
@@ -105,4 +116,4 @@ function mkdir(root, rel) {
   return { ok: true };
 }
 
-module.exports = { tree, readFile, writeFile, mkdir };
+module.exports = { tree, readFile, writeFile, mkdir, isExecConfig };

package/lib/dashboard/meeting.js

@@ -11,6 +11,7 @@ const { spawn } = require('child_process');
 const store = require('../store');
 const files = require('./files');
 const { resolveRunnerCommand } = require('./runner');
+const runnerTrust = require('../runner-trust');
 const { formatLog } = require('./summarize'); // reused as-is rather than reimplemented — see report
 
 const TASK_LIMIT = 20; // mirrors summarize.js's own DEFAULT_LIMIT philosophy (cap, most-recent-last)
@@ -82,6 +83,8 @@ function runMeetingGenerate(root, { agent, date } = {}, emit) {
   const which = agent || cfg.agent || 'claude';
   const cmdStr = resolveRunnerCommand(root, cfg, which);
   if (!cmdStr) return { error: `No runner configured for "${which}".` };
+  const blocked = runnerTrust.blockedMessage(root, which, cmdStr);
+  if (blocked) return { error: blocked, untrustedRunner: { agent: which, command: cmdStr } };
 
   const day = date || todayLocal();
   if (!isValidDate(day)) return { error: 'Invalid date.' };

package/lib/dashboard/ops.js

@@ -20,6 +20,8 @@ const detect = require('../detect');
 const brain = require('../brain');
 const brainSetup = require('../brain-setup');
 const globalConfig = require('../global-config');
+const workflowDetect = require('../workflow-detect');
+const runnerTrust = require('../runner-trust');
 
 const PKG_VERSION = require('../../package.json').version;
 
@@ -71,6 +73,7 @@ function writeConfig(root, patch, detectOpts) {
   if (Array.isArray(patch.expandedPhases)) cfg.expandedPhases = patch.expandedPhases.filter((v) => typeof v === 'string');
   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;
   // 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.
@@ -161,14 +164,25 @@ const ops = {
     // todayLocal() header comment for why this, not the browser's date, is the one source of truth
     // for which .spectoflow/meetings/<date>.md "today" resolves to.
     p.todayDate = todayLocal();
+    p.untrustedRunners = runnerTrust.untrusted(root, p.config);
     return p;
   },
   'agentfile.read': async (root, { path: rel }) => readAgentFile(root, rel),
 
   'files.tree': async (root) => ({ tree: files.tree(root) }),
   'files.read': async (root, { path: rel }) => filesResult(files.readFile(root, rel || '')),
-  'files.write': async (root, { path: rel, content }, ctx) => changed(ctx, filesResult(files.writeFile(root, rel, content))),
-  'files.mkdir': async (root, { path: rel }, ctx) => changed(ctx, filesResult(files.mkdir(root, rel))),
+  'files.write': async (root, { path: rel, content }, ctx) => changed(ctx, filesResult(files.writeFile(root, rel, content, { remote: !!ctx.remote }))),
+  'files.mkdir': async (root, { path: rel }, ctx) => changed(ctx, filesResult(files.mkdir(root, rel, { remote: !!ctx.remote }))),
+
+  // Allow, on this machine, the custom command config.json sets for one agent (D76). Local only: the relay
+  // doesn't list this op, and ctx.remote is refused here too.
+  'runners.trust': async (root, { agent }, ctx) => {
+    if (ctx && ctx.remote) throw new OpError(404, 'Unknown operation.');
+    const cmd = ((store.readConfig(root).runners) || {})[agent];
+    if (typeof cmd !== 'string' || !cmd.trim()) notFound(`No custom command set for "${agent}".`);
+    runnerTrust.trust(root, agent, cmd);
+    return changed(ctx, { ok: true, agent, command: cmd });
+  },
 
   'task.add': async (root, { title, phase, file, owner, level }, ctx) => {
     const t = store.addTask(root, { title: text(title, 'A title is required.'), phase, file, owner, level });
@@ -200,6 +214,20 @@ const ops = {
     return changed(ctx, { ok: true });
   },
 
+  // Re-analysis (D75): what would fit the project now, and applying the steps the user picked. Apply
+  // recomputes the suggestion server-side and writes only those of the listed names it still contains.
+  'workflow.suggest': async (root) => {
+    const s = workflowDetect.suggest(root, { projectType: store.readConfig(root).projectType });
+    return { ...s, reasons: workflowDetect.REASONS };
+  },
+  'workflow.apply': async (root, { names }, ctx) => {
+    if (!Array.isArray(names) || !names.every((n) => typeof n === 'string')) bad('names must be a list of step names.');
+    const s = workflowDetect.suggest(root);
+    const picked = s.changes.filter((c) => names.includes(c.name));
+    const written = workflowDetect.applySteps(root, Object.fromEntries(picked.map((c) => [c.name, c.to])));
+    return written.length ? changed(ctx, { changed: written }) : { changed: written };
+  },
+
   'run.start': async (root, { prompt, agent, display }, ctx) => {
     text(prompt, 'Empty request.');
     const r = startRun(root, { prompt, agent, display, learn: !ctx.remote }, ctx.emit);

package/lib/dashboard/orchestrator.js

@@ -90,7 +90,7 @@ function defaultRunStep({ root, step, agent, skill, request, learn = true }, emi
     // logPrompt:false — the orchestrator already posts a clean "→ step (agent)" line; the raw
     // priming prompt would otherwise show as a noisy user bubble.
     const r = startRun(root, { prompt, agent: tool, logPrompt: false, learn }, (e) => { emit(e); if (e.type === 'run-end') resolve(e.code); });
-    if (r.error) { emit({ type: 'message', message: { role: 'orchestrator', kind: 'status', text: r.error } }); resolve(1); }
+    if (r.error) { post(root, 'orchestrator', 'status', r.error, emit); resolve(1); }
   });
 }
 

package/lib/dashboard/public/app.js

@@ -376,6 +376,21 @@ function renderApproval(container){
   const acts=el('div','c-actions'); acts.append(a,c); row.append(acts);
   container.append(row); scrollChat(container);
 }
+// A launch refused before any agent ran (no runner, a custom command not allowed yet…) has no run-start/
+// run-end to show for it: say so in the chat, without persisting anything.
+function showChatError(message){
+  chatContainers().forEach(container=>{
+    clearIdle(container);
+    const st=stateFor(container); st.rawBlock=null;
+    container.append(el('div','msg chat-error',message));
+    scrollChat(container);
+  });
+}
+async function postRunRequest(url,body){
+  const r=await fetch(withProject(url),{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
+  if(!r.ok){ const d=await r.json().catch(()=>({})); showChatError(d.error||t('files.saveError')); if(/needs your OK/.test(d.error||'')) scheduleLoad(); }
+  return r.ok;
+}
 function appendRaw(chunk){
   chatContainers().forEach(container=>{
     const st=stateFor(container);
@@ -413,7 +428,7 @@ async function doRun(promptEl,agentEl){
   const agent=agentEl.value;
   const ex=expandForSend(raw);
   const body=ex ? {prompt:ex.prompt, display:ex.display, agent} : {prompt:raw, agent};
-  await fetch(withProject('/api/run'),{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
+  if(!(await postRunRequest('/api/run',body))) return;
   promptEl.value=''; hideCmdMenu(); // the prompt renders as a bubble from the message log
 }
 async function doOrchestrate(promptEl){
@@ -421,7 +436,7 @@ async function doOrchestrate(promptEl){
   promptEl=promptEl||$('#runPrompt');
   const raw=promptEl.value.trim(); if(!raw) return;
   const ex=expandForSend(raw);
-  await fetch(withProject('/api/orchestrate'),{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({request: ex?ex.prompt:raw})});
+  if(!(await postRunRequest('/api/orchestrate',{request: ex?ex.prompt:raw}))) return;
   promptEl.value=''; hideCmdMenu();
 }
 // ---- slash-command autocomplete: a single reused #cmdMenu popover, anchored above whichever chat
@@ -488,7 +503,7 @@ async function summarizeChat(agentEl){
   if(isChatBusy()) return;
   const agent=(agentEl||$('#tabRunAgent'))?.value;
   flash();
-  await fetch(withProject('/api/chat/summarize'),{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({agent})});
+  await postRunRequest('/api/chat/summarize',{agent});
 }
 async function clearChat(){
   flash();
@@ -1009,6 +1024,72 @@ function renderWorkflow(){
   box.append(pipe);
   if(wfPopStep) renderWfPop(); // re-anchor / refresh an open popover after a live re-render
 }
+// ---- Workflow → Analyze the project (D75): what the file analysis would switch on or off now. Nothing is
+// written until the user applies the ticked changes. Lives outside #wfDiagram so SSE re-renders keep it open.
+let wfSuggestion=null, wfSuggestPicked=null, wfSuggestNote='';
+async function analyzeWorkflow(){
+  const box=$('#wfSuggest'); if(!box) return;
+  box.hidden=false; box.innerHTML=''; box.append(el('div','empty',t('drawer.loading')));
+  try{
+    const r=await fetch(withProject('/api/workflow/suggest'));
+    const d=await r.json().catch(()=>({}));
+    if(!r.ok) throw new Error(d.error||'error');
+    wfSuggestion=d; wfSuggestPicked=new Set(d.changes.map(c=>c.name)); wfSuggestNote='';
+  }catch(err){ wfSuggestion=null; wfSuggestNote=t('workflow.analyzeError'); }
+  renderWfSuggest();
+}
+function closeWfSuggest(){ wfSuggestion=null; wfSuggestNote=''; const box=$('#wfSuggest'); if(box){ box.hidden=true; box.innerHTML=''; } }
+function renderWfSuggest(){
+  const box=$('#wfSuggest'); if(!box) return;
+  box.innerHTML='';
+  if(!wfSuggestion){ if(wfSuggestNote){ box.hidden=false; box.append(el('div','wf-suggest-note',wfSuggestNote)); } return; }
+  const d=wfSuggestion; box.hidden=false;
+  const head=el('div','wf-suggest-head');
+  head.append(el('span','wf-suggest-detected',t('workflow.detected',{type:t('workflow.type.'+d.projectType),phase:t('workflow.phase.'+d.phase)})));
+  const x=el('button','wf-suggest-close','×'); x.type='button'; x.title=t('workflow.dismiss'); x.setAttribute('aria-label',t('workflow.dismiss')); x.addEventListener('click',closeWfSuggest);
+  head.append(x); box.append(head);
+  if(wfSuggestNote) box.append(el('div','wf-suggest-note',wfSuggestNote));
+  if(!d.changes.length){ box.append(el('div','wf-suggest-ok',t('workflow.matches'))); return; }
+  const list=el('div','wf-suggest-list');
+  d.changes.forEach(c=>{
+    const row=el('label','wf-suggest-row');
+    const cb=el('input'); cb.type='checkbox'; cb.checked=wfSuggestPicked.has(c.name);
+    cb.addEventListener('change',()=>{ if(cb.checked) wfSuggestPicked.add(c.name); else wfSuggestPicked.delete(c.name); applyBtn.disabled=!wfSuggestPicked.size; });
+    const change=el('span','wf-suggest-change '+(c.to?'is-on':'is-off'),`${c.from?t('workflow.on'):t('workflow.off')} → ${c.to?t('workflow.on'):t('workflow.off')}`);
+    row.append(cb, el('span','wf-suggest-name',c.name), change, el('span','wf-suggest-reason',t('workflow.reason.'+c.reason)));
+    list.append(row);
+  });
+  box.append(list);
+  const acts=el('div','wf-suggest-actions');
+  const applyBtn=el('button','btn primary',t('workflow.apply')); applyBtn.type='button'; applyBtn.disabled=!wfSuggestPicked.size;
+  applyBtn.addEventListener('click',async()=>{
+    applyBtn.disabled=true; flash();
+    try{
+      const r=await fetch(withProject('/api/workflow/apply'),{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({names:[...wfSuggestPicked]})});
+      const res=await r.json().catch(()=>({}));
+      if(!r.ok) throw new Error(res.error||'error');
+      wfSuggestion=null; wfSuggestNote=t('workflow.applied',{n:(res.changed||[]).length});
+    }catch(err){ wfSuggestNote=t('workflow.analyzeError'); }
+    renderWfSuggest(); scheduleLoad();
+  });
+  const cancel=el('button','btn',t('workflow.dismiss')); cancel.type='button'; cancel.addEventListener('click',closeWfSuggest);
+  acts.append(applyBtn,cancel); box.append(acts);
+}
+// Personalize → a custom agent command set by config.json, not yet allowed on this machine (D76).
+function renderUntrustedRunners(){
+  const box=$('#setRunnersTrust'); if(!box) return;
+  const list=(!REMOTE && P && P.untrustedRunners) || [];
+  box.innerHTML=''; box.hidden=!list.length;
+  if(!list.length) return;
+  box.append(el('div','runner-trust-title',t('runners.title')), el('div','runner-trust-hint',t('runners.hint')));
+  list.forEach(r=>{
+    const row=el('div','runner-trust-row');
+    row.append(el('span','runner-trust-agent',r.agent), el('code','runner-trust-cmd',r.command));
+    const b=el('button','btn',t('runners.allow')); b.type='button';
+    b.addEventListener('click',async()=>{ b.disabled=true; flash(); await fetch(withProject('/api/runners/trust'),{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({agent:r.agent})}); scheduleLoad(); });
+    row.append(b); box.append(row);
+  });
+}
 function wfDetailRow(k,v){ const r=el('div','wf-detail-row'); r.append(el('span','wf-detail-k',k), el('span','wf-detail-v',v)); return r; }
 function wfPopFill(pop, s, idx){
   const skill=(P.skills||[]).find(x=>x.name===s.skill);
@@ -1229,6 +1310,8 @@ function renderSettings(){
   setModeSelects(c.mode||'semi');
   setLangSelect(c.language||'en');
   setAgentSelects();
+  const wfAuto=$('#setWorkflowAuto'); if(wfAuto) wfAuto.checked=!!c.workflowAutoEnable;
+  renderUntrustedRunners();
   // design switcher — options from the DESIGNS registry (designs.js)
   const dsel=$('#setDesign');
   if(dsel){
@@ -1423,7 +1506,7 @@ function renderCustomize(){
 async function czSubmit(kind,description,agent){
   const cfg=CZ_KINDS.find((c)=>c.kind===kind);
   const prompt=description?cfg.promptAdd(description):cfg.promptAuto;
-  await fetch(withProject('/api/run'),{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({prompt,agent})});
+  await postRunRequest('/api/run',{prompt,agent});
   const root=$('#czRoot'); if(root) root.dataset.open='';
   navigateTab('chat');
 }
@@ -2558,6 +2641,8 @@ $('#blAddCancel').addEventListener('click', closeBacklogAddForm);
 $('#blAddSubmit').addEventListener('click', submitBacklogAdd);
 $('#blAddTitle').addEventListener('keydown', e=>{ if(e.key==='Enter') submitBacklogAdd(); });
 // attention tab: add a note + filter chips
+$('#wfAnalyzeBtn').addEventListener('click',analyzeWorkflow);
+$('#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})));
 $('#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=''; } } });

package/lib/dashboard/public/i18n.js

@@ -90,6 +90,8 @@ en: {
   'drawer.agent':'Agent','drawer.skill':'Skill','drawer.file':'File · {rel}',
   'drawer.loading':'Loading…','drawer.loadError':'Could not load this file.','files.title':'Files','files.sub':'Browse the project\'s files — view Markdown & HTML, edit any text file, create new ones.','files.newFile':'+ File','files.newFolder':'+ Folder','files.pickFile':'Select a file to view it.','files.empty':'No files yet.','files.edit':'Edit','files.preview':'Preview','files.save':'Save','files.saved':'✓ saved','files.saveError':'Could not save this file.','files.loadError':'Could not load this file.','files.binary':'This file can\'t be previewed here (not text).','files.discardConfirm':'Discard unsaved changes?','files.newFilePrompt':'New file name (e.g. todo.md):','files.newFolderPrompt':'New folder name:','files.projectRoot':'project root','files.creatingIn':'Creating in: {path}','files.refresh':'Refresh','files.discard':'Discard','files.create':'Create',
   'notes.sub':'A freeform scratchpad for this project — Markdown, autosaved as you type. Only you (and whoever else opens this dashboard) can see it.','notes.saving':'Saving…',
+  'runners.title':'A custom command needs your OK','runners.hint':'This project’s config.json launches an agent with a command other than its default. It only runs once you allow it on this machine.','runners.allow':'Allow on this machine',
+  'workflow.analyze':'Analyze the project','workflow.analyzeTitle':'Look at the project and suggest which steps fit it now','workflow.detected':'Detected: {type} · {phase}','workflow.type.app':'application','workflow.type.infra':'infrastructure','workflow.type.data':'data','workflow.phase.design':'design phase, no code yet','workflow.phase.build':'has code','workflow.matches':'Your workflow already matches the project.','workflow.apply':'Apply','workflow.dismiss':'Close','workflow.applied':'{n} step(s) updated.','workflow.analyzeError':'Could not analyze the project.','workflow.on':'on','workflow.off':'off','workflow.reason.always':'always useful','workflow.reason.design-no-code':'no code yet','workflow.reason.has-code':'the project has code','workflow.reason.has-tests':'the project has tests','workflow.reason.infra-no-tests':'infrastructure project with no tests','workflow.reason.data-quality':'data project — data quality tests','workflow.reason.has-integration-tests':'integration tests exist','workflow.reason.no-integration-tests':'no integration tests yet','workflow.reason.has-e2e-setup':'an end-to-end test setup exists','workflow.reason.no-e2e-setup':'no end-to-end test setup','settings.workflowAuto':'Let the agent enable workflow steps when needed','settings.workflowAutoHint':'Off: it asks you first. It never disables a step on its own.',
   'brain.sub':'What spectoflow has learned about you, shared by all your projects and given to your agent in every session. Add or fix anything.','brain.autoAdd':'Add what the agent learns directly','brain.autoAddOn':'New facts are added right away — you can fix or delete them here.','brain.autoAddOff':'New facts wait in “To confirm” until you accept them.','brain.agents':'Reachable by:','brain.agentWired':'Connected: this agent reads and grows your second brain','brain.agentNotWired':'Not connected yet','brain.setupHint':'Run {cmd} to connect the others.','brain.noAgents':'No coding agent found on this machine.','brain.tooMany':'{n} entries — all of it is given to your agent in every session. Consider removing what is no longer true.','brain.empty':'Nothing yet. As you work, your agent notes durable things about you here — your role, your preferences, how you like to work, what to avoid. You can also add them yourself below.','brain.toConfirm':'To confirm','brain.confirm':'Confirm','brain.confirmAll':'Confirm all','brain.reject':'Reject','brain.cat.profile':'Profile','brain.cat.preferences':'Preferences','brain.cat.workflow':'Working style','brain.cat.avoid':'Avoid','brain.catHint.profile':'Who you are: role, skills, context.','brain.catHint.preferences':'Tools, languages, code style, formats you prefer.','brain.catHint.workflow':'How you like the agent to work with you.','brain.catHint.avoid':'What the agent should never do.','brain.catEmpty':'Nothing here yet.','brain.addPlaceholder':'Add a fact…','brain.duplicate':'Already in your second brain.','brain.byAgent':'learned by the agent','brain.byYou':'added by you','brain.path':'Stored in {path} — never inside a project.','brain.error':'Could not reach your second brain.',
   'meeting.sub':'One dated note per day for this project — write it yourself, or have the active agent draft it from recent tasks and chat activity.','meeting.history':'History','meeting.today':'today','meeting.generate':'Generate','meeting.generateTitle':'Generate today\'s note from recent activity','meeting.overwriteWarn':'This will overwrite today\'s note.','meeting.generateAnyway':'Generate anyway',
   'chat.widgetTitle':'Run an agent','chat.widgetSub':'Quick access · full view in the Chat tab',
@@ -210,6 +212,8 @@ fr: {
   'drawer.agent':'Agent','drawer.skill':'Compétence','drawer.file':'Fichier · {rel}',
   'drawer.loading':'Chargement…','drawer.loadError':'Impossible de charger ce fichier.','files.title':'Fichiers','files.sub':'Parcourez les fichiers du projet — visualisez Markdown et HTML, modifiez tout fichier texte, créez-en de nouveaux.','files.newFile':'+ Fichier','files.newFolder':'+ Dossier','files.pickFile':'Sélectionnez un fichier pour l’afficher.','files.empty':'Aucun fichier pour l’instant.','files.edit':'Modifier','files.preview':'Aperçu','files.save':'Enregistrer','files.saved':'✓ enregistré','files.saveError':'Impossible d’enregistrer ce fichier.','files.loadError':'Impossible de charger ce fichier.','files.binary':'Ce fichier ne peut pas être prévisualisé ici (non textuel).','files.discardConfirm':'Abandonner les modifications non enregistrées ?','files.newFilePrompt':'Nom du nouveau fichier (ex. todo.md) :','files.newFolderPrompt':'Nom du nouveau dossier :','files.projectRoot':'racine du projet','files.creatingIn':'Création dans : {path}','files.refresh':'Actualiser','files.discard':'Annuler','files.create':'Créer',
   'notes.sub':'Un bloc-note libre pour ce projet — Markdown, enregistré automatiquement au fil de la frappe. Visible uniquement par vous (et quiconque ouvre ce tableau de bord).','notes.saving':'Enregistrement…',
+  'runners.title':'Une commande personnalisée attend votre accord','runners.hint':'Le config.json de ce projet lance un agent avec une commande différente de celle par défaut. Elle ne s’exécute qu’une fois autorisée sur cette machine.','runners.allow':'Autoriser sur cette machine',
+  'workflow.analyze':'Analyser le projet','workflow.analyzeTitle':'Examiner le projet et proposer les étapes qui lui conviennent maintenant','workflow.detected':'Détecté : {type} · {phase}','workflow.type.app':'application','workflow.type.infra':'infrastructure','workflow.type.data':'données','workflow.phase.design':'phase de conception, pas encore de code','workflow.phase.build':'contient du code','workflow.matches':'Votre workflow correspond déjà au projet.','workflow.apply':'Appliquer','workflow.dismiss':'Fermer','workflow.applied':'{n} étape(s) mise(s) à jour.','workflow.analyzeError':'Impossible d’analyser le projet.','workflow.on':'activée','workflow.off':'désactivée','workflow.reason.always':'toujours utile','workflow.reason.design-no-code':'pas encore de code','workflow.reason.has-code':'le projet contient du code','workflow.reason.has-tests':'le projet a des tests','workflow.reason.infra-no-tests':'projet d’infrastructure sans tests','workflow.reason.data-quality':'projet de données — tests de qualité des données','workflow.reason.has-integration-tests':'des tests d’intégration existent','workflow.reason.no-integration-tests':'pas encore de tests d’intégration','workflow.reason.has-e2e-setup':'une configuration de tests de bout en bout existe','workflow.reason.no-e2e-setup':'pas de configuration de tests de bout en bout','settings.workflowAuto':'Laisser l’agent activer les étapes du workflow quand il faut','settings.workflowAutoHint':'Désactivé : il vous demande d’abord. Il ne désactive jamais une étape de lui-même.',
   'brain.sub':'Ce que spectoflow a appris sur vous, partagé par tous vos projets et donné à votre agent à chaque session. Ajoutez ou corrigez ce que vous voulez.','brain.autoAdd':'Ajouter directement ce que l’agent apprend','brain.autoAddOn':'Les nouveaux faits sont ajoutés tout de suite — vous pouvez les corriger ou les supprimer ici.','brain.autoAddOff':'Les nouveaux faits attendent dans « À confirmer » jusqu’à votre validation.','brain.agents':'Accessible par :','brain.agentWired':'Connecté : cet agent lit et enrichit votre second cerveau','brain.agentNotWired':'Pas encore connecté','brain.setupHint':'Lancez {cmd} pour connecter les autres.','brain.noAgents':'Aucun agent de code trouvé sur cette machine.','brain.tooMany':'{n} entrées — tout est donné à votre agent à chaque session. Pensez à retirer ce qui n’est plus vrai.','brain.empty':'Rien pour l’instant. Au fil de votre travail, votre agent note ici des choses durables sur vous — votre rôle, vos préférences, votre façon de travailler, ce qu’il faut éviter. Vous pouvez aussi les ajouter vous-même ci-dessous.','brain.toConfirm':'À confirmer','brain.confirm':'Confirmer','brain.confirmAll':'Tout confirmer','brain.reject':'Rejeter','brain.cat.profile':'Profil','brain.cat.preferences':'Préférences','brain.cat.workflow':'Façon de travailler','brain.cat.avoid':'À éviter','brain.catHint.profile':'Qui vous êtes : rôle, compétences, contexte.','brain.catHint.preferences':'Outils, langues, style de code, formats que vous préférez.','brain.catHint.workflow':'Comment vous aimez que l’agent travaille avec vous.','brain.catHint.avoid':'Ce que l’agent ne doit jamais faire.','brain.catEmpty':'Rien ici pour l’instant.','brain.addPlaceholder':'Ajouter un fait…','brain.duplicate':'Déjà dans votre second cerveau.','brain.byAgent':'appris par l’agent','brain.byYou':'ajouté par vous','brain.path':'Stocké dans {path} — jamais dans un projet.','brain.error':'Impossible d’accéder à votre second cerveau.',
   'meeting.sub':'Une note datée par jour pour ce projet — rédigez-la vous-même, ou laissez l’agent actif la rédiger à partir des tâches récentes et du chat.','meeting.history':'Historique','meeting.today':'aujourd’hui','meeting.generate':'Générer','meeting.generateTitle':'Générer la note du jour à partir de l’activité récente','meeting.overwriteWarn':'Cela va écraser la note d’aujourd’hui.','meeting.generateAnyway':'Générer quand même',
   'chat.widgetTitle':'Lancer un agent','chat.widgetSub':'Accès rapide · vue complète dans l’onglet Chat',
@@ -330,6 +334,8 @@ es: {
   'drawer.agent':'Agente','drawer.skill':'Habilidad','drawer.file':'Archivo · {rel}',
   'drawer.loading':'Cargando…','drawer.loadError':'No se pudo cargar este archivo.','files.title':'Archivos','files.sub':'Explora los archivos del proyecto — visualiza Markdown y HTML, edita cualquier archivo de texto, crea otros nuevos.','files.newFile':'+ Archivo','files.newFolder':'+ Carpeta','files.pickFile':'Selecciona un archivo para verlo.','files.empty':'Aún no hay archivos.','files.edit':'Editar','files.preview':'Vista previa','files.save':'Guardar','files.saved':'✓ guardado','files.saveError':'No se pudo guardar este archivo.','files.loadError':'No se pudo cargar este archivo.','files.binary':'Este archivo no se puede previsualizar aquí (no es texto).','files.discardConfirm':'¿Descartar los cambios sin guardar?','files.newFilePrompt':'Nombre del nuevo archivo (p. ej. todo.md):','files.newFolderPrompt':'Nombre de la nueva carpeta:','files.projectRoot':'raíz del proyecto','files.creatingIn':'Creando en: {path}','files.refresh':'Actualizar','files.discard':'Descartar','files.create':'Crear',
   'notes.sub':'Un bloc de notas libre para este proyecto — Markdown, guardado automáticamente mientras escribes. Solo tú (y quien más abra este panel) puedes verlo.','notes.saving':'Guardando…',
+  'runners.title':'Un comando personalizado espera tu aprobación','runners.hint':'El config.json de este proyecto lanza un agente con un comando distinto del predeterminado. Solo se ejecuta cuando lo autorizas en esta máquina.','runners.allow':'Autorizar en esta máquina',
+  'workflow.analyze':'Analizar el proyecto','workflow.analyzeTitle':'Examinar el proyecto y proponer los pasos que le convienen ahora','workflow.detected':'Detectado: {type} · {phase}','workflow.type.app':'aplicación','workflow.type.infra':'infraestructura','workflow.type.data':'datos','workflow.phase.design':'fase de diseño, aún sin código','workflow.phase.build':'tiene código','workflow.matches':'Tu workflow ya corresponde al proyecto.','workflow.apply':'Aplicar','workflow.dismiss':'Cerrar','workflow.applied':'{n} paso(s) actualizado(s).','workflow.analyzeError':'No se pudo analizar el proyecto.','workflow.on':'activado','workflow.off':'desactivado','workflow.reason.always':'siempre útil','workflow.reason.design-no-code':'aún no hay código','workflow.reason.has-code':'el proyecto tiene código','workflow.reason.has-tests':'el proyecto tiene tests','workflow.reason.infra-no-tests':'proyecto de infraestructura sin tests','workflow.reason.data-quality':'proyecto de datos — tests de calidad de datos','workflow.reason.has-integration-tests':'existen tests de integración','workflow.reason.no-integration-tests':'aún no hay tests de integración','workflow.reason.has-e2e-setup':'existe una configuración de tests end-to-end','workflow.reason.no-e2e-setup':'no hay configuración de tests end-to-end','settings.workflowAuto':'Dejar que el agente active pasos del workflow cuando haga falta','settings.workflowAutoHint':'Desactivado: te pregunta antes. Nunca desactiva un paso por su cuenta.',
   'brain.sub':'Lo que spectoflow ha aprendido sobre ti, compartido por todos tus proyectos y dado a tu agente en cada sesión. Añade o corrige lo que quieras.','brain.autoAdd':'Añadir directamente lo que aprende el agente','brain.autoAddOn':'Los nuevos datos se añaden al instante — puedes corregirlos o borrarlos aquí.','brain.autoAddOff':'Los nuevos datos esperan en «Por confirmar» hasta que los aceptes.','brain.agents':'Accesible por:','brain.agentWired':'Conectado: este agente lee y amplía tu segundo cerebro','brain.agentNotWired':'Aún no conectado','brain.setupHint':'Ejecuta {cmd} para conectar los demás.','brain.noAgents':'No se encontró ningún agente de código en esta máquina.','brain.tooMany':'{n} entradas — todo se da a tu agente en cada sesión. Plantéate quitar lo que ya no sea cierto.','brain.empty':'Nada todavía. Mientras trabajas, tu agente anota aquí cosas duraderas sobre ti — tu rol, tus preferencias, cómo te gusta trabajar, qué evitar. También puedes añadirlas tú abajo.','brain.toConfirm':'Por confirmar','brain.confirm':'Confirmar','brain.confirmAll':'Confirmar todo','brain.reject':'Rechazar','brain.cat.profile':'Perfil','brain.cat.preferences':'Preferencias','brain.cat.workflow':'Forma de trabajar','brain.cat.avoid':'Evitar','brain.catHint.profile':'Quién eres: rol, habilidades, contexto.','brain.catHint.preferences':'Herramientas, idiomas, estilo de código, formatos que prefieres.','brain.catHint.workflow':'Cómo te gusta que el agente trabaje contigo.','brain.catHint.avoid':'Lo que el agente nunca debe hacer.','brain.catEmpty':'Nada aquí todavía.','brain.addPlaceholder':'Añadir un dato…','brain.duplicate':'Ya está en tu segundo cerebro.','brain.byAgent':'aprendido por el agente','brain.byYou':'añadido por ti','brain.path':'Guardado en {path} — nunca dentro de un proyecto.','brain.error':'No se pudo acceder a tu segundo cerebro.',
   'meeting.sub':'Una nota fechada por día para este proyecto — escríbela tú mismo, o deja que el agente activo la redacte a partir de las tareas y el chat recientes.','meeting.history':'Historial','meeting.today':'hoy','meeting.generate':'Generar','meeting.generateTitle':'Generar la nota de hoy a partir de la actividad reciente','meeting.overwriteWarn':'Esto sobrescribirá la nota de hoy.','meeting.generateAnyway':'Generar de todos modos',
   'chat.widgetTitle':'Ejecutar un agente','chat.widgetSub':'Acceso rápido · vista completa en la pestaña Chat',
@@ -450,6 +456,8 @@ de: {
   'drawer.agent':'Agent','drawer.skill':'Skill','drawer.file':'Datei · {rel}',
   'drawer.loading':'Lädt…','drawer.loadError':'Diese Datei konnte nicht geladen werden.','files.title':'Dateien','files.sub':'Durchsuche die Projektdateien — Markdown & HTML ansehen, jede Textdatei bearbeiten, neue erstellen.','files.newFile':'+ Datei','files.newFolder':'+ Ordner','files.pickFile':'Wähle eine Datei aus, um sie anzuzeigen.','files.empty':'Noch keine Dateien.','files.edit':'Bearbeiten','files.preview':'Vorschau','files.save':'Speichern','files.saved':'✓ gespeichert','files.saveError':'Diese Datei konnte nicht gespeichert werden.','files.loadError':'Diese Datei konnte nicht geladen werden.','files.binary':'Diese Datei kann hier nicht angezeigt werden (kein Text).','files.discardConfirm':'Nicht gespeicherte Änderungen verwerfen?','files.newFilePrompt':'Name der neuen Datei (z. B. todo.md):','files.newFolderPrompt':'Name des neuen Ordners:','files.projectRoot':'Projektstamm','files.creatingIn':'Erstellen in: {path}','files.refresh':'Aktualisieren','files.discard':'Verwerfen','files.create':'Erstellen',
   'notes.sub':'Ein freier Notizblock für dieses Projekt — Markdown, automatisch gespeichert während der Eingabe. Nur du (und wer sonst dieses Dashboard öffnet) siehst ihn.','notes.saving':'Speichert…',
+  'runners.title':'Ein eigener Befehl braucht deine Zustimmung','runners.hint':'Die config.json dieses Projekts startet einen Agenten mit einem anderen als dem Standardbefehl. Er läuft erst, wenn du ihn auf diesem Rechner erlaubst.','runners.allow':'Auf diesem Rechner erlauben',
+  'workflow.analyze':'Projekt analysieren','workflow.analyzeTitle':'Das Projekt ansehen und vorschlagen, welche Schritte jetzt passen','workflow.detected':'Erkannt: {type} · {phase}','workflow.type.app':'Anwendung','workflow.type.infra':'Infrastruktur','workflow.type.data':'Daten','workflow.phase.design':'Entwurfsphase, noch kein Code','workflow.phase.build':'enthält Code','workflow.matches':'Dein Workflow passt bereits zum Projekt.','workflow.apply':'Anwenden','workflow.dismiss':'Schließen','workflow.applied':'{n} Schritt(e) aktualisiert.','workflow.analyzeError':'Das Projekt konnte nicht analysiert werden.','workflow.on':'an','workflow.off':'aus','workflow.reason.always':'immer nützlich','workflow.reason.design-no-code':'noch kein Code','workflow.reason.has-code':'das Projekt enthält Code','workflow.reason.has-tests':'das Projekt hat Tests','workflow.reason.infra-no-tests':'Infrastrukturprojekt ohne Tests','workflow.reason.data-quality':'Datenprojekt — Datenqualitätstests','workflow.reason.has-integration-tests':'Integrationstests vorhanden','workflow.reason.no-integration-tests':'noch keine Integrationstests','workflow.reason.has-e2e-setup':'ein End-to-End-Test-Setup ist vorhanden','workflow.reason.no-e2e-setup':'kein End-to-End-Test-Setup','settings.workflowAuto':'Den Agenten Workflow-Schritte bei Bedarf aktivieren lassen','settings.workflowAutoHint':'Aus: er fragt dich vorher. Er deaktiviert nie selbst einen Schritt.',
   'brain.sub':'Was spectoflow über dich gelernt hat — geteilt von all deinen Projekten und deinem Agenten in jeder Sitzung mitgegeben. Ergänze oder korrigiere, was du willst.','brain.autoAdd':'Was der Agent lernt, direkt hinzufügen','brain.autoAddOn':'Neue Fakten werden sofort hinzugefügt — du kannst sie hier korrigieren oder löschen.','brain.autoAddOff':'Neue Fakten warten unter „Zu bestätigen“, bis du sie annimmst.','brain.agents':'Erreichbar für:','brain.agentWired':'Verbunden: dieser Agent liest und erweitert dein zweites Gehirn','brain.agentNotWired':'Noch nicht verbunden','brain.setupHint':'Führe {cmd} aus, um die anderen zu verbinden.','brain.noAgents':'Kein Coding-Agent auf diesem Rechner gefunden.','brain.tooMany':'{n} Einträge — alles wird deinem Agenten in jeder Sitzung mitgegeben. Entferne, was nicht mehr stimmt.','brain.empty':'Noch nichts. Während du arbeitest, notiert dein Agent hier Dauerhaftes über dich — deine Rolle, deine Vorlieben, wie du gern arbeitest, was zu vermeiden ist. Du kannst sie auch unten selbst hinzufügen.','brain.toConfirm':'Zu bestätigen','brain.confirm':'Bestätigen','brain.confirmAll':'Alle bestätigen','brain.reject':'Ablehnen','brain.cat.profile':'Profil','brain.cat.preferences':'Vorlieben','brain.cat.workflow':'Arbeitsweise','brain.cat.avoid':'Vermeiden','brain.catHint.profile':'Wer du bist: Rolle, Fähigkeiten, Kontext.','brain.catHint.preferences':'Werkzeuge, Sprachen, Code-Stil, Formate, die du bevorzugst.','brain.catHint.workflow':'Wie der Agent mit dir arbeiten soll.','brain.catHint.avoid':'Was der Agent nie tun soll.','brain.catEmpty':'Hier ist noch nichts.','brain.addPlaceholder':'Fakt hinzufügen…','brain.duplicate':'Schon in deinem zweiten Gehirn.','brain.byAgent':'vom Agenten gelernt','brain.byYou':'von dir hinzugefügt','brain.path':'Gespeichert in {path} — nie in einem Projekt.','brain.error':'Dein zweites Gehirn ist nicht erreichbar.',
   'meeting.sub':'Eine datierte Notiz pro Tag für dieses Projekt — schreibe sie selbst, oder lass sie vom aktiven Agenten aus den letzten Aufgaben und dem Chat entwerfen.','meeting.history':'Verlauf','meeting.today':'heute','meeting.generate':'Generieren','meeting.generateTitle':'Die heutige Notiz aus der letzten Aktivität generieren','meeting.overwriteWarn':'Dies überschreibt die heutige Notiz.','meeting.generateAnyway':'Trotzdem generieren',
   'chat.widgetTitle':'Agenten ausführen','chat.widgetSub':'Schnellzugriff · vollständige Ansicht im Chat-Tab',
@@ -570,6 +578,8 @@ pt: {
   'drawer.agent':'Agente','drawer.skill':'Habilidade','drawer.file':'Ficheiro · {rel}',
   'drawer.loading':'A carregar…','drawer.loadError':'Não foi possível carregar este ficheiro.','files.title':'Ficheiros','files.sub':'Percorra os ficheiros do projeto — veja Markdown e HTML, edite qualquer ficheiro de texto, crie novos.','files.newFile':'+ Ficheiro','files.newFolder':'+ Pasta','files.pickFile':'Selecione um ficheiro para o ver.','files.empty':'Ainda não há ficheiros.','files.edit':'Editar','files.preview':'Pré-visualizar','files.save':'Guardar','files.saved':'✓ guardado','files.saveError':'Não foi possível guardar este ficheiro.','files.loadError':'Não foi possível carregar este ficheiro.','files.binary':'Este ficheiro não pode ser pré-visualizado aqui (não é texto).','files.discardConfirm':'Descartar alterações não guardadas?','files.newFilePrompt':'Nome do novo ficheiro (ex. todo.md):','files.newFolderPrompt':'Nome da nova pasta:','files.projectRoot':'raiz do projeto','files.creatingIn':'A criar em: {path}','files.refresh':'Atualizar','files.discard':'Descartar','files.create':'Criar',
   'notes.sub':'Um bloco de notas livre para este projeto — Markdown, guardado automaticamente enquanto escreve. Só você (e quem mais abrir este painel) o vê.','notes.saving':'A guardar…',
+  'runners.title':'Um comando personalizado aguarda a sua aprovação','runners.hint':'O config.json deste projeto inicia um agente com um comando diferente do predefinido. Só é executado depois de o autorizar nesta máquina.','runners.allow':'Autorizar nesta máquina',
+  'workflow.analyze':'Analisar o projeto','workflow.analyzeTitle':'Examinar o projeto e propor os passos que lhe convêm agora','workflow.detected':'Detetado: {type} · {phase}','workflow.type.app':'aplicação','workflow.type.infra':'infraestrutura','workflow.type.data':'dados','workflow.phase.design':'fase de conceção, ainda sem código','workflow.phase.build':'tem código','workflow.matches':'O seu workflow já corresponde ao projeto.','workflow.apply':'Aplicar','workflow.dismiss':'Fechar','workflow.applied':'{n} passo(s) atualizado(s).','workflow.analyzeError':'Não foi possível analisar o projeto.','workflow.on':'ativado','workflow.off':'desativado','workflow.reason.always':'sempre útil','workflow.reason.design-no-code':'ainda sem código','workflow.reason.has-code':'o projeto tem código','workflow.reason.has-tests':'o projeto tem testes','workflow.reason.infra-no-tests':'projeto de infraestrutura sem testes','workflow.reason.data-quality':'projeto de dados — testes de qualidade de dados','workflow.reason.has-integration-tests':'existem testes de integração','workflow.reason.no-integration-tests':'ainda sem testes de integração','workflow.reason.has-e2e-setup':'existe uma configuração de testes ponta a ponta','workflow.reason.no-e2e-setup':'sem configuração de testes ponta a ponta','settings.workflowAuto':'Deixar o agente ativar passos do workflow quando necessário','settings.workflowAutoHint':'Desativado: pergunta-lhe primeiro. Nunca desativa um passo por conta própria.',
   'brain.sub':'O que o spectoflow aprendeu sobre si, partilhado por todos os seus projetos e dado ao seu agente em cada sessão. Acrescente ou corrija o que quiser.','brain.autoAdd':'Adicionar diretamente o que o agente aprende','brain.autoAddOn':'Os novos factos são adicionados de imediato — pode corrigi-los ou apagá-los aqui.','brain.autoAddOff':'Os novos factos esperam em «A confirmar» até os aceitar.','brain.agents':'Acessível por:','brain.agentWired':'Ligado: este agente lê e enriquece o seu segundo cérebro','brain.agentNotWired':'Ainda não ligado','brain.setupHint':'Execute {cmd} para ligar os outros.','brain.noAgents':'Nenhum agente de código encontrado nesta máquina.','brain.tooMany':'{n} entradas — tudo é dado ao seu agente em cada sessão. Pense em retirar o que já não é verdade.','brain.empty':'Ainda nada. À medida que trabalha, o seu agente anota aqui coisas duradouras sobre si — o seu papel, as suas preferências, como gosta de trabalhar, o que evitar. Também as pode adicionar abaixo.','brain.toConfirm':'A confirmar','brain.confirm':'Confirmar','brain.confirmAll':'Confirmar tudo','brain.reject':'Rejeitar','brain.cat.profile':'Perfil','brain.cat.preferences':'Preferências','brain.cat.workflow':'Forma de trabalhar','brain.cat.avoid':'A evitar','brain.catHint.profile':'Quem é: papel, competências, contexto.','brain.catHint.preferences':'Ferramentas, línguas, estilo de código, formatos que prefere.','brain.catHint.workflow':'Como gosta que o agente trabalhe consigo.','brain.catHint.avoid':'O que o agente nunca deve fazer.','brain.catEmpty':'Ainda nada aqui.','brain.addPlaceholder':'Adicionar um facto…','brain.duplicate':'Já está no seu segundo cérebro.','brain.byAgent':'aprendido pelo agente','brain.byYou':'adicionado por si','brain.path':'Guardado em {path} — nunca dentro de um projeto.','brain.error':'Não foi possível aceder ao seu segundo cérebro.',
   'meeting.sub':'Uma nota datada por dia para este projeto — escreva-a você mesmo, ou deixe o agente ativo redigi-la a partir das tarefas e do chat recentes.','meeting.history':'Histórico','meeting.today':'hoje','meeting.generate':'Gerar','meeting.generateTitle':'Gerar a nota de hoje a partir da atividade recente','meeting.overwriteWarn':'Isto vai substituir a nota de hoje.','meeting.generateAnyway':'Gerar mesmo assim',
   'chat.widgetTitle':'Executar um agente','chat.widgetSub':'Acesso rápido · vista completa no separador Chat',
@@ -690,6 +700,8 @@ it: {
   'drawer.agent':'Agente','drawer.skill':'Skill','drawer.file':'File · {rel}',
   'drawer.loading':'Caricamento…','drawer.loadError':'Impossibile caricare questo file.','files.title':'File','files.sub':'Sfoglia i file del progetto — visualizza Markdown e HTML, modifica qualsiasi file di testo, creane di nuovi.','files.newFile':'+ File','files.newFolder':'+ Cartella','files.pickFile':'Seleziona un file per visualizzarlo.','files.empty':'Nessun file ancora.','files.edit':'Modifica','files.preview':'Anteprima','files.save':'Salva','files.saved':'✓ salvato','files.saveError':'Impossibile salvare questo file.','files.loadError':'Impossibile caricare questo file.','files.binary':'Questo file non può essere visualizzato qui (non è testo).','files.discardConfirm':'Scartare le modifiche non salvate?','files.newFilePrompt':'Nome del nuovo file (es. todo.md):','files.newFolderPrompt':'Nome della nuova cartella:','files.projectRoot':'radice del progetto','files.creatingIn':'Creazione in: {path}','files.refresh':'Aggiorna','files.discard':'Scarta','files.create':'Crea',
   'notes.sub':'Un blocco note libero per questo progetto — Markdown, salvato automaticamente mentre scrivi. Solo tu (e chiunque altro apra questa dashboard) puoi vederlo.','notes.saving':'Salvataggio…',
+  'runners.title':'Un comando personalizzato attende la tua approvazione','runners.hint':'Il config.json di questo progetto avvia un agente con un comando diverso da quello predefinito. Viene eseguito solo dopo che lo autorizzi su questa macchina.','runners.allow':'Autorizza su questa macchina',
+  'workflow.analyze':'Analizza il progetto','workflow.analyzeTitle':'Esaminare il progetto e proporre i passi adatti ora','workflow.detected':'Rilevato: {type} · {phase}','workflow.type.app':'applicazione','workflow.type.infra':'infrastruttura','workflow.type.data':'dati','workflow.phase.design':'fase di progettazione, ancora nessun codice','workflow.phase.build':'contiene codice','workflow.matches':'Il tuo workflow corrisponde già al progetto.','workflow.apply':'Applica','workflow.dismiss':'Chiudi','workflow.applied':'{n} passo/i aggiornato/i.','workflow.analyzeError':'Impossibile analizzare il progetto.','workflow.on':'attivo','workflow.off':'disattivo','workflow.reason.always':'sempre utile','workflow.reason.design-no-code':'ancora nessun codice','workflow.reason.has-code':'il progetto contiene codice','workflow.reason.has-tests':'il progetto ha dei test','workflow.reason.infra-no-tests':'progetto di infrastruttura senza test','workflow.reason.data-quality':'progetto di dati — test di qualità dei dati','workflow.reason.has-integration-tests':'esistono test di integrazione','workflow.reason.no-integration-tests':'ancora nessun test di integrazione','workflow.reason.has-e2e-setup':'esiste una configurazione di test end-to-end','workflow.reason.no-e2e-setup':'nessuna configurazione di test end-to-end','settings.workflowAuto':'Lascia che l’agente attivi i passi del workflow quando serve','settings.workflowAutoHint':'Disattivato: ti chiede prima. Non disattiva mai un passo da solo.',
   'brain.sub':'Ciò che spectoflow ha imparato su di te, condiviso da tutti i tuoi progetti e dato al tuo agente in ogni sessione. Aggiungi o correggi ciò che vuoi.','brain.autoAdd':'Aggiungi direttamente ciò che l’agente impara','brain.autoAddOn':'I nuovi fatti vengono aggiunti subito — puoi correggerli o eliminarli qui.','brain.autoAddOff':'I nuovi fatti attendono in «Da confermare» finché non li accetti.','brain.agents':'Raggiungibile da:','brain.agentWired':'Collegato: questo agente legge e arricchisce il tuo secondo cervello','brain.agentNotWired':'Non ancora collegato','brain.setupHint':'Esegui {cmd} per collegare gli altri.','brain.noAgents':'Nessun agente di programmazione trovato su questa macchina.','brain.tooMany':'{n} voci — tutto viene dato al tuo agente in ogni sessione. Valuta di rimuovere ciò che non è più vero.','brain.empty':'Ancora niente. Mentre lavori, il tuo agente annota qui cose durature su di te — il tuo ruolo, le tue preferenze, come ti piace lavorare, cosa evitare. Puoi anche aggiungerle tu qui sotto.','brain.toConfirm':'Da confermare','brain.confirm':'Conferma','brain.confirmAll':'Conferma tutto','brain.reject':'Rifiuta','brain.cat.profile':'Profilo','brain.cat.preferences':'Preferenze','brain.cat.workflow':'Modo di lavorare','brain.cat.avoid':'Da evitare','brain.catHint.profile':'Chi sei: ruolo, competenze, contesto.','brain.catHint.preferences':'Strumenti, lingue, stile di codice, formati che preferisci.','brain.catHint.workflow':'Come ti piace che l’agente lavori con te.','brain.catHint.avoid':'Ciò che l’agente non deve mai fare.','brain.catEmpty':'Ancora niente qui.','brain.addPlaceholder':'Aggiungi un fatto…','brain.duplicate':'Già nel tuo secondo cervello.','brain.byAgent':'imparato dall’agente','brain.byYou':'aggiunto da te','brain.path':'Salvato in {path} — mai dentro un progetto.','brain.error':'Impossibile raggiungere il tuo secondo cervello.',
   'meeting.sub':'Una nota datata al giorno per questo progetto — scrivila tu stesso, oppure lascia che l’agente attivo la scriva a partire dalle attività e dalla chat recenti.','meeting.history':'Cronologia','meeting.today':'oggi','meeting.generate':'Genera','meeting.generateTitle':'Genera la nota di oggi dall’attività recente','meeting.overwriteWarn':'Questo sovrascriverà la nota di oggi.','meeting.generateAnyway':'Genera comunque',
   'chat.widgetTitle':'Avvia un agente','chat.widgetSub':'Accesso rapido · vista completa nella scheda Chat',

package/lib/dashboard/public/index.html

@@ -217,6 +217,10 @@
       <div class="wf-wrap">
         <h2 class="panel-title" data-i18n="workflow.title">Active workflow</h2>
         <p class="panel-sub" data-i18n-html="workflow.sub">The pipeline your requests flow through — from idea to shipped, spec-driven. <strong>Click a step</strong> to see what it does and turn it on or off (this edits <code>.spectoflow/workflow.md</code>). Enabled steps run in order; the orchestrator gates each one by your <em>mode</em> and <em>policy</em>. Optional steps stay off until you switch them on.</p>
+        <div class="wf-analyze">
+          <button class="btn" id="wfAnalyzeBtn" type="button" data-i18n="workflow.analyze" data-i18n-title="workflow.analyzeTitle" title="Look at the project and suggest which steps fit it now">Analyze the project</button>
+          <div class="wf-suggest" id="wfSuggest" hidden></div>
+        </div>
         <div class="wf-diagram" id="wfDiagram"></div>
       </div>
     </section>
@@ -389,6 +393,7 @@
               <select id="setAgent" class="settings-select"></select>
               <span class="settings-field-hint is-empty" id="setAgentHint" data-i18n="topbar.agent.none" hidden>No agent found</span>
             </label>
+            <div class="runner-trust" id="setRunnersTrust" hidden></div>
             <label class="settings-field">
               <span class="settings-field-label" data-i18n="field.mode">Autonomy mode</span>
               <select id="setMode" class="settings-select">
@@ -397,6 +402,13 @@
                 <option value="manual" data-i18n="mode.manual.desc">manual — approve every step</option>
               </select>
             </label>
+            <label class="settings-check">
+              <input type="checkbox" id="setWorkflowAuto">
+              <span class="settings-check-text">
+                <span class="settings-check-label" data-i18n="settings.workflowAuto">Let the agent enable workflow steps when needed</span>
+                <span class="settings-check-hint" data-i18n="settings.workflowAutoHint">Off: it asks you first. It never disables a step on its own.</span>
+              </span>
+            </label>
           </div>
           <div class="settings-card">
             <h3 class="settings-card-title" data-i18n="settings.group.appearance">Appearance &amp; language</h3>

package/lib/dashboard/public/styles.css

@@ -659,6 +659,41 @@ body.booting .ring-svg circle:last-of-type { transform-origin:center; animation:
 .attn-edit { width:100%; min-height:64px; font-family:inherit; font-size:14px; padding:8px; border:1px solid var(--cool); border-radius:8px; background:var(--surface-2); color:var(--ink); box-sizing:border-box; }
 .attn-actions { display:flex; flex-wrap:wrap; gap:8px; margin-top:11px; }
 
+/* ---- Custom agent commands awaiting the user's OK (D76) ---- */
+.runner-trust { border:1px solid color-mix(in srgb,var(--s-blocked) 45%,var(--line)); border-radius:var(--radius); padding:10px 12px; display:flex; flex-direction:column; gap:8px; }
+.runner-trust[hidden] { display:none; }
+.runner-trust-title { font-size:13px; font-weight:600; color:var(--s-blocked); }
+.runner-trust-hint { font-size:12px; color:var(--muted); }
+.runner-trust-row { display:flex; flex-wrap:wrap; align-items:center; gap:6px 10px; }
+.runner-trust-agent { font-weight:600; font-size:13px; }
+.runner-trust-cmd { font-family:var(--mono); font-size:11.5px; background:var(--surface-2); border:1px solid var(--line); border-radius:5px; padding:2px 6px; overflow-wrap:anywhere; flex:1 1 180px; }
+.msg.chat-error { color:var(--s-blocked); border:1px solid color-mix(in srgb,var(--s-blocked) 40%,var(--line)); border-radius:8px; padding:8px 10px; font-size:12.5px; white-space:pre-wrap; }
+
+/* ---- Workflow → Analyze the project ---- */
+.wf-analyze { display:flex; flex-direction:column; align-items:flex-start; gap:10px; margin:2px 0 16px; }
+.wf-suggest { align-self:stretch; border:1px solid var(--line); border-left:3px solid var(--signal); border-radius:var(--radius); background:var(--surface); padding:12px 14px; display:flex; flex-direction:column; gap:10px; max-width:820px; }
+.wf-suggest[hidden] { display:none; }
+.wf-suggest-head { display:flex; align-items:center; justify-content:space-between; gap:10px; }
+.wf-suggest-detected { font-size:13px; font-weight:600; }
+.wf-suggest-close { border:none; background:none; color:var(--muted); font-size:18px; line-height:1; cursor:pointer; padding:0 4px; }
+.wf-suggest-close:hover { color:var(--ink); }
+.wf-suggest-ok, .wf-suggest-note { font-size:13px; color:var(--muted); }
+.wf-suggest-list { display:flex; flex-direction:column; gap:6px; }
+.wf-suggest-row { display:grid; grid-template-columns:auto minmax(110px,max-content) auto 1fr; align-items:center; gap:6px 12px; font-size:13px; cursor:pointer; padding:6px 8px; border-radius:8px; background:var(--surface-2); }
+.wf-suggest-row input { accent-color:var(--signal); margin:0; }
+.wf-suggest-name { font-weight:600; }
+.wf-suggest-change { font-family:var(--mono); font-size:11px; border:1px solid var(--line); border-radius:999px; padding:1px 8px; white-space:nowrap; }
+.wf-suggest-change.is-on { color:var(--s-done); border-color:color-mix(in srgb,var(--s-done) 45%,var(--line)); }
+.wf-suggest-change.is-off { color:var(--muted); }
+.wf-suggest-reason { color:var(--muted); font-size:12.5px; }
+.wf-suggest-actions { display:flex; gap:8px; }
+@media (max-width:620px){ .wf-suggest-row { grid-template-columns:auto 1fr; } .wf-suggest-change, .wf-suggest-reason { grid-column:2; } }
+.settings-check { display:flex; align-items:flex-start; gap:9px; cursor:pointer; }
+.settings-check input { accent-color:var(--signal); width:15px; height:15px; margin:2px 0 0; flex:none; }
+.settings-check-text { display:flex; flex-direction:column; gap:3px; }
+.settings-check-label { font-size:13px; font-weight:600; }
+.settings-check-hint { font-size:12px; color:var(--muted); }
+
 /* ---- Second brain ---- */
 .brain-wrap { max-width:1080px; margin:0 auto; padding:20px 22px 32px; }
 .brain-bar { display:flex; flex-wrap:wrap; align-items:center; gap:6px 14px; margin:4px 0 10px; }

package/lib/dashboard/routes.js

@@ -20,6 +20,8 @@ const ROUTES = [
   ['PATCH', /^\/api\/task\/[^/]+$/, 'task.update', (_u, b, p) => ({ id: seg(p, 3), patch: b })],
   ['POST', /^\/api\/task\/[^/]+\/comment$/, 'task.comment', (_u, b, p) => ({ id: seg(p, 3), text: b.text, action: b.action })],
   ['POST', '/api/workflow/toggle', 'workflow.toggle', (_u, b) => b],
+  ['GET', '/api/workflow/suggest', 'workflow.suggest', () => ({})],
+  ['POST', '/api/workflow/apply', 'workflow.apply', (_u, b) => b],
   ['POST', '/api/run', 'run.start', (_u, b) => b],
   ['POST', '/api/chat/summarize', 'chat.summarize', (_u, b) => b],
   ['POST', '/api/meeting/generate', 'meeting.generate', (_u, b) => b],
@@ -27,6 +29,8 @@ const ROUTES = [
   ['POST', '/api/orchestrate', 'orchestrate.start', (_u, b) => b],
   ['POST', '/api/orchestrate/approve', 'orchestrate.approve', (_u, b) => b],
   ['POST', '/api/settings', 'settings.save', (_u, b) => b],
+  // Local only — deliberately absent from server/src/relay.js's OP_PERMISSIONS (D76).
+  ['POST', '/api/runners/trust', 'runners.trust', (_u, b) => b],
   ['POST', '/api/attention', 'attention.add', (_u, b) => b],
   ['POST', /^\/api\/attention\/[^/]+\/promote$/, 'attention.promote', (_u, _b, p) => ({ id: seg(p, 3) })],
   ['PATCH', /^\/api\/attention\/[^/]+$/, 'attention.update', (_u, b, p) => ({ id: seg(p, 3), patch: b })],

package/lib/dashboard/runner.js

@@ -12,6 +12,7 @@ const store = require('../store');
 const adapters = require('../adapters');
 const detect = require('../detect');
 const brain = require('../brain');
+const runnerTrust = require('../runner-trust');
 
 // The command to run `which`: config.json's own runners map first (an explicit user choice always
 // wins), falling back to the registry's default for a known, headless-capable, genuinely-installed
@@ -80,6 +81,8 @@ function startRun(root, { prompt, agent, logPrompt = true, display, learn = true
   const which = agent || cfg.agent || 'claude';
   const cmdStr = resolveRunnerCommand(root, cfg, which);
   if (!cmdStr) return { error: `No runner configured for "${which}".` };
+  const blocked = runnerTrust.blockedMessage(root, which, cmdStr);
+  if (blocked) return { error: blocked, untrustedRunner: { agent: which, command: cmdStr } };
   const parts = cmdStr.split(/\s+/).filter(Boolean);
   const runId = 'r' + Date.now().toString(36);
   const p = String(prompt).trim();

package/lib/dashboard/summarize.js

@@ -9,6 +9,7 @@
 const { spawn } = require('child_process');
 const store = require('../store');
 const { resolveRunnerCommand } = require('./runner');
+const runnerTrust = require('../runner-trust');
 
 const DEFAULT_LIMIT = 40;
 
@@ -26,6 +27,8 @@ function runSummarize(root, { agent } = {}, emit) {
   const which = agent || cfg.agent || 'claude';
   const cmdStr = resolveRunnerCommand(root, cfg, which);
   if (!cmdStr) return { error: `No runner configured for "${which}".` };
+  const blocked = runnerTrust.blockedMessage(root, which, cmdStr);
+  if (blocked) return { error: blocked, untrustedRunner: { agent: which, command: cmdStr } };
 
   const rt = store.readRuntime(root);
   const messages = (rt.messages || []).filter((m) => m.kind !== 'summary');

package/lib/init.js

@@ -14,6 +14,7 @@ const manifest = require('./manifest');
 const mcp = require('./mcp');
 const store = require('./store');
 const globalConfig = require('./global-config');
+const workflowDetect = require('./workflow-detect');
 
 function copyDir(src, dst) {
   fs.mkdirSync(dst, { recursive: true });
@@ -70,6 +71,7 @@ function runInit({ target, templatesDir, version, agentsArg, defaults }) {
   }
 
   const spectoflowDir = path.join(target, '.spectoflow');
+  const workflowExisted = fs.existsSync(path.join(spectoflowDir, 'workflow.md'));
   copyDir(templatesDir, spectoflowDir);
 
   const frameworkFiles = ownership.listFrameworkFiles(templatesDir);
@@ -87,6 +89,15 @@ function runInit({ target, templatesDir, version, agentsArg, defaults }) {
   cfg.agent = agentsArg ? agents[0] : ((detected.includes(d.agent) || !detected.length) ? d.agent : detected[0]);
   if (!agents.includes(cfg.agent)) agents.unshift(cfg.agent);
   cfg.runners = { ...cfg.runners, ...adapters.defaultRunners(agents) };
+  // Fit the freshly copied workflow to the project (D75). An existing workflow.md is the user's: never touched.
+  let workflowFit = null;
+  if (!workflowExisted) {
+    const fit = workflowDetect.detect(target);
+    const changed = workflowDetect.applySteps(target, Object.fromEntries(Object.entries(fit.steps).map(([k, v]) => [k, v.enabled])));
+    cfg.projectType = fit.projectType;
+    cfg.workflowReview = 'pending';
+    workflowFit = { ...fit, changed };
+  }
   fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n');
 
   const plansDirName = store.resolvePlansDir(target, cfg);
@@ -118,6 +129,18 @@ function runInit({ target, templatesDir, version, agentsArg, defaults }) {
     if (!giText.includes(line)) fs.appendFileSync(gi, ((fs.existsSync(gi) && fs.readFileSync(gi, 'utf8').length) ? '\n' : '') + line + '\n');
   }
 
+  if (workflowFit) {
+    // One clause per (on/off, reason): "off: Develop, Unit tests, Review (no code yet)".
+    const groups = new Map();
+    for (const n of workflowFit.changed) {
+      const s = workflowFit.steps[n], key = `${s.enabled ? 'on' : 'off'}|${s.reason}`;
+      groups.set(key, [...(groups.get(key) || []), n]);
+    }
+    const clauses = [...groups].map(([key, names]) => { const [state, reason] = key.split('|'); return `${state}: ${names.join(', ')} (${workflowDetect.REASONS[reason]})`; });
+    const phase = workflowFit.phase === 'design' ? 'design phase' : `${workflowFit.projectType} project with code`;
+    notes.push(`Workflow fitted to the project (${phase})${clauses.length ? ' — ' + clauses.join('; ') : ' — the default steps fit'}. Your agent will review it with you; change it anytime in the dashboard's Workflow tab.`);
+  }
+
   const unwired = require('./brain-setup').status().filter((a) => !a.wired);
   if (unwired.length) notes.push(`Your second brain isn't connected to ${unwired.map((a) => a.label).join(', ')} yet — run: spectoflow brain setup (once per machine).`);
 

package/lib/runner-trust.js

@@ -0,0 +1,48 @@
+'use strict';
+/*
+ * A project's config.json can set the command that launches an agent (`runners`). That file is committed
+ * and can be written by others — a cloned repository, a teammate's change, a member of the online
+ * dashboard, or an agent run told to edit it — so a command that isn't the registry's default for that
+ * agent only runs once the user has allowed it on THIS machine. Trust lives outside every project
+ * (~/.spectoflow/trusted-runners.json) and is bound to the exact command: change it, and it must be
+ * allowed again. Default commands never ask. (D76)
+ */
+const fs = require('fs');
+const path = require('path');
+const globalConfig = require('./global-config');
+const adapters = require('./adapters');
+
+function storePath() { return path.join(globalConfig.homeDir(), 'trusted-runners.json'); }
+function readStore() { try { return JSON.parse(fs.readFileSync(storePath(), 'utf8')) || {}; } catch { return {}; } }
+function projectKey(root) { try { return fs.realpathSync(root); } catch { return path.resolve(root); } }
+
+const defaultRunner = (which) => { const a = adapters.knownAgents().find((x) => x.id === which); return a ? a.runner : null; };
+const isDefault = (which, cmd) => !!cmd && cmd === defaultRunner(which);
+
+function isTrusted(root, which, cmd) {
+  if (!cmd || isDefault(which, cmd)) return true;
+  const allowed = readStore()[projectKey(root)];
+  return !!(allowed && allowed[which] === cmd);
+}
+
+function trust(root, which, cmd) {
+  const store = readStore(), key = projectKey(root);
+  store[key] = { ...(store[key] || {}), [which]: cmd };
+  fs.mkdirSync(path.dirname(storePath()), { recursive: true });
+  fs.writeFileSync(storePath(), JSON.stringify(store, null, 2) + '\n', { mode: 0o600 });
+}
+
+// The project's runners that would be refused right now → [{ agent, command }].
+function untrusted(root, cfg) {
+  return Object.entries((cfg && cfg.runners) || {})
+    .filter(([which, cmd]) => typeof cmd === 'string' && !isTrusted(root, which, cmd))
+    .map(([agent, command]) => ({ agent, command }));
+}
+
+// null when `cmd` may run; otherwise the message explaining why not and how to allow it.
+function blockedMessage(root, which, cmd) {
+  if (isTrusted(root, which, cmd)) return null;
+  return `For your safety, this project's custom command for "${which}" needs your OK once on this machine before it runs: ${cmd} — allow it in Personalize → Agent & automation, or run: spectoflow runners allow ${which}`;
+}
+
+module.exports = { isTrusted, isDefault, trust, untrusted, blockedMessage, storePath };

package/lib/workflow-detect.js

@@ -0,0 +1,152 @@
+'use strict';
+/*
+ * Fits the workflow to the project (docs/workflow-autoconfig-design.md, DECISIONS D75). A deterministic,
+ * zero-dependency look at the files: is there code yet (phase: design or build), what kind of project it is
+ * (app / infra / data), and which test setups already exist. From that, which of the kit's workflow steps
+ * make sense now — each decision with a reason code. `init` applies it to a freshly copied workflow.md;
+ * `spectoflow workflow suggest` and the dashboard's Workflow tab offer it for an existing project. Steps
+ * the user added themselves are never touched. The agent refines this with the user (it can tell a
+ * prototype from a product; a file scan can't).
+ */
+const fs = require('fs');
+const path = require('path');
+
+const SKIP_DIRS = new Set(['.git', 'node_modules', '.spectoflow', 'vendor', 'dist', 'build', 'target', '.venv', 'venv', '__pycache__', 'coverage', '.next', '.nuxt', 'out']);
+const CODE_EXT = new Set(['.js', '.ts', '.tsx', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs', '.java', '.kt', '.cs', '.rb', '.php', '.swift', '.c', '.cpp', '.h', '.vue', '.svelte', '.dart', '.scala', '.ex', '.exs']);
+const MANIFESTS = new Set(['pyproject.toml', 'setup.py', 'requirements.txt', 'go.mod', 'Cargo.toml', 'pom.xml', 'build.gradle', 'build.gradle.kts', 'Gemfile', 'composer.json', 'pubspec.yaml', 'mix.exs']);
+const INFRA_FILES = new Set(['Pulumi.yaml', 'Chart.yaml', 'kustomization.yaml', 'ansible.cfg']);
+const TEST_DIRS = new Set(['test', 'tests', '__tests__']);
+const E2E_DEPS = ['@playwright/test', 'playwright', 'cypress', 'puppeteer'];
+const LIMITS = { depth: 4, entries: 5000 };
+
+const isTestFile = (name) => /\.(test|spec)\.[cm]?[jt]sx?$/.test(name) || /_test\.(go|py)$/.test(name) || /^test_.*\.py$/.test(name) || /Tests?\.(java|kt|cs)$/.test(name) || /_spec\.rb$/.test(name);
+
+function readPackageJson(fp, s) {
+  let pkg;
+  try { pkg = JSON.parse(fs.readFileSync(fp, 'utf8')); } catch { return; }
+  const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+  const scripts = pkg.scripts || {};
+  const realScripts = Object.entries(scripts).filter(([k, v]) => !(k === 'test' && /no test specified/.test(String(v))));
+  if (Object.keys(deps).length || realScripts.length) s.manifests.push(fp);
+  if (scripts.test && !/no test specified/.test(String(scripts.test))) s.unitTests = true;
+  if (E2E_DEPS.some((d) => deps[d])) s.e2e = true;
+}
+
+// → { sourceFiles, manifests, unitTests, e2e, integration, infra, data, truncated }
+function scan(root, limits = LIMITS) {
+  const s = { sourceFiles: 0, manifests: [], unitTests: false, e2e: false, integration: false, infra: false, data: false, truncated: false };
+  let seen = 0;
+  const walk = (dir, depth, dirs) => {
+    if (s.truncated) return;
+    let list;
+    try { list = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of list) {
+      if (++seen > limits.entries) { s.truncated = true; return; }
+      const fp = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name) || e.name.startsWith('.') || depth >= limits.depth) continue;
+        walk(fp, depth + 1, [...dirs, e.name]);
+        continue;
+      }
+      if (!e.isFile()) continue;
+      const name = e.name, ext = path.extname(name).toLowerCase();
+      if (name === 'package.json') readPackageJson(fp, s);
+      else if (MANIFESTS.has(name) || ext === '.csproj') s.manifests.push(fp);
+      if (/^(playwright|cypress)\.config\.[cm]?[jt]s$/.test(name) || name === 'cypress.json') s.e2e = true;
+      if (ext === '.tf' || INFRA_FILES.has(name)) s.infra = true;
+      if (name === 'dbt_project.yml' || ext === '.ipynb' || (ext === '.py' && dirs.includes('dags'))) s.data = true;
+      if (!CODE_EXT.has(ext)) continue;
+      const underTests = dirs.some((d) => TEST_DIRS.has(d));
+      if (dirs.includes('e2e') || dirs.includes('cypress')) { s.e2e = true; continue; }
+      if (underTests && dirs.includes('integration')) { s.integration = true; continue; }
+      if (underTests || isTestFile(name)) { s.unitTests = true; continue; }
+      s.sourceFiles++;
+    }
+  };
+  walk(root, 0, []);
+  return s;
+}
+
+const STEPS = ['Brainstorm', 'Analysis', 'Spec', 'Plan', 'Develop', 'Unit tests', 'Integration tests', 'End-to-end tests', 'Review'];
+
+// → { projectType, phase, signals, steps: { <name>: { enabled, reason } } }
+function detect(root, limits) {
+  const signals = scan(root, limits);
+  const hasCode = signals.sourceFiles > 0 || signals.manifests.length > 0 || signals.unitTests || signals.infra || signals.data;
+  const projectType = signals.infra && signals.sourceFiles < 10 ? 'infra' : signals.data ? 'data' : 'app';
+  const phase = hasCode ? 'build' : 'design';
+  const on = (reason) => ({ enabled: true, reason }), off = (reason) => ({ enabled: false, reason });
+  const steps = { Brainstorm: on('always'), Analysis: on('always'), Spec: on('always'), Plan: on('always') };
+  if (phase === 'design') {
+    for (const n of ['Develop', 'Unit tests', 'Integration tests', 'End-to-end tests', 'Review']) steps[n] = off('design-no-code');
+  } else {
+    steps.Develop = on('has-code');
+    steps.Review = on('has-code');
+    steps['Unit tests'] = projectType === 'infra' ? (signals.unitTests ? on('has-tests') : off('infra-no-tests'))
+      : projectType === 'data' ? on('data-quality') : on('has-code');
+    steps['Integration tests'] = signals.integration ? on('has-integration-tests') : off('no-integration-tests');
+    steps['End-to-end tests'] = projectType === 'app' && signals.e2e ? on('has-e2e-setup') : off('no-e2e-setup');
+  }
+  return { projectType, phase, signals, steps };
+}
+
+// The step's name as store.readWorkflow() reports it: annotation stripped first, then "(optional)".
+function stepName(rest) {
+  const ann = rest.match(/\{([^}]*)\}\s*$/);
+  if (ann) rest = rest.slice(0, ann.index).trim();
+  return rest.replace(/\s*\(optional\)\s*$/i, '').trim();
+}
+const LINE_RE = /^(\s*- \[)( |x|X)(\]\s+)(.*?)(\r?)$/;
+
+function workflowPath(root) { return path.join(root, '.spectoflow', 'workflow.md'); }
+
+// Current state of the steps detection knows about → [{ name, enabled }] in file order.
+function currentSteps(root) {
+  let text;
+  try { text = fs.readFileSync(workflowPath(root), 'utf8'); } catch { return []; }
+  return text.split('\n').map((l) => l.match(LINE_RE)).filter(Boolean).map((m) => ({ name: stepName(m[4]), enabled: m[2].trim() !== '' }));
+}
+
+// What re-analysis would change → { projectType, phase, currentType, changes: [{ name, from, to, reason }] }
+function suggest(root, { projectType: currentType, limits } = {}) {
+  const d = detect(root, limits);
+  const changes = currentSteps(root)
+    .filter((s) => d.steps[s.name] && d.steps[s.name].enabled !== s.enabled)
+    .map((s) => ({ name: s.name, from: s.enabled, to: d.steps[s.name].enabled, reason: d.steps[s.name].reason }));
+  return { projectType: d.projectType, phase: d.phase, currentType: currentType || null, changes, truncated: d.signals.truncated };
+}
+
+// Set the checkbox of each named step to `target[name]` (true/false). Only those lines change, byte for
+// byte otherwise. → names actually changed.
+function applySteps(root, target) {
+  const fp = workflowPath(root);
+  const lines = fs.readFileSync(fp, 'utf8').split('\n');
+  const changed = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(LINE_RE);
+    if (!m) continue;
+    const name = stepName(m[4]);
+    if (!Object.prototype.hasOwnProperty.call(target, name)) continue;
+    const want = target[name] ? 'x' : ' ';
+    if ((m[2].trim() ? 'x' : ' ') === want) continue;
+    lines[i] = m[1] + want + m[3] + m[4] + m[5];
+    if (!changed.includes(name)) changed.push(name);
+  }
+  if (changed.length) fs.writeFileSync(fp, lines.join('\n'));
+  return changed;
+}
+
+const REASONS = {
+  always: 'always useful',
+  'design-no-code': 'no code yet',
+  'has-code': 'the project has code',
+  'has-tests': 'the project has tests',
+  'infra-no-tests': 'infrastructure project with no tests',
+  'data-quality': 'data project — data quality tests',
+  'has-integration-tests': 'integration tests exist',
+  'no-integration-tests': 'no integration tests yet',
+  'has-e2e-setup': 'an end-to-end test setup exists',
+  'no-e2e-setup': 'no end-to-end test setup',
+};
+
+module.exports = { scan, detect, suggest, applySteps, currentSteps, STEPS, REASONS, LIMITS };

package/package.json

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

package/templates/SPECTOFLOW.md

@@ -85,7 +85,9 @@ whole file. This lets the dashboard and you co-edit without clobbering. Reflect
 4. **Gate** — by `mode` (`.spectoflow/config.json`): **autopilot** proceeds · **semi** (default)
    confirms if ambiguous/borderline/risky **and always for a Major** · **manual** confirms each step.
 5. **Load** — read the enabled steps from `.spectoflow/workflow.md` (single source of truth), plus the
-   `.spectoflow/skills/` needed for those steps. Load only what this task needs.
+   `.spectoflow/skills/` needed for those steps. Load only what this task needs. **If the request needs a
+   step that is disabled** (asked to implement while *Develop* is off, writing code while *Unit tests* is
+   off…), see *Keep the workflow in step with the project* below — never silently skip it.
 6. **Run** — execute. A **policy gate** (`.spectoflow/policy.md`) can interrupt at any point, any mode.
 
 ## New / empty project → Intake
@@ -127,6 +129,25 @@ clarifying question there.
 
 - The **active workflow** is `.spectoflow/workflow.md` — a checklist of enabled steps, editable (also
   from the dashboard). It is the single source; do not restate workflows elsewhere.
+
+### Keep the workflow in step with the project
+
+`init` fitted `workflow.md` to what the files showed (is there code yet, tests, an E2E setup, infra or data).
+A file scan can't tell a prototype from a product, or a project still in design from one being built — you
+can, from the docs, specs and plans. Enable or disable a step by changing only its checkbox line.
+
+- **First review** — when `.spectoflow/config.json` → `workflowReview` is `"pending"`: early in the session,
+  compare the enabled steps with what you understand of the project (phase, type, what the user is doing
+  now). Propose the changes that fit, one line of reason each; apply what the user accepts; then set
+  `workflowReview` to `"done"`. If nothing needs changing, just say it looks right and set it to `"done"`.
+- **As the project moves on** — when a request needs a step that is disabled:
+  - `workflowAutoEnable` is `false` (default): tell the user which step and why, and ask before doing that
+    part of the work;
+  - `workflowAutoEnable` is `true`: enable that step yourself and tell the user you did.
+- You may **enable** a step on your own only under `workflowAutoEnable: true`. **Disabling** a step always
+  goes through the user, whatever the setting.
+- `spectoflow workflow suggest` (and the dashboard's Workflow → *Analyze the project*) re-runs the file
+  analysis; point the user to it when the project changed a lot.
 - **Capabilities** (`.spectoflow/capabilities.md`) are a palette; the project type selects the active ones.
 - **Agents** (`.spectoflow/agents/`) are stable team personas (Developer, QA Engineer, …). **Skills**
   (`.spectoflow/skills/`) are the evolving procedures. A workflow step → a capability → its agent →

package/templates/config.json

@@ -3,6 +3,7 @@
   "language": "en",
   "agent": "claude",
   "projectType": "app",
+  "workflowAutoEnable": false,
   "plansDir": null,
   "specsDir": null,
   "dashboard": { "autostart": true },