cohorte 2.0.2 → 2.2.0

package/dashboard/server/doctor.js

@@ -6,6 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { layouts, primary, stateDirs } = require('./runtime.js');
 const { parseProfileBlock } = require('./yaml');
 const { versions } = require('./versions');
 
@@ -19,9 +20,9 @@ const FIXED_AGENTS = new Set([
   'implementer.template',
 ]);
 
-// The spec lifecycle (SCHEMA.md §Spec status). `in-progress` and `blocked` are written by
-// the /cohorte-loop driver — they are what makes an interrupted autonomous loop resumable, so a
-// dashboard that flagged them as invalid would report the pipeline's own state as a defect.
+// The spec lifecycle (SCHEMA.md §Spec status). `in-progress` and `blocked` stay valid after
+// /cohorte-loop was retired in 2.2.0: specs in existing repos carry them, and an external driver
+// still needs somewhere to record "a round is under way" / "a round gave up".
 const VALID_STATUS = ['draft', 'frozen', 'in-progress', 'in-review', 'shipped', 'blocked'];
 
 // Artifacts the pipeline itself writes into specs/ that are NOT feature specs and have no
@@ -42,6 +43,12 @@ const sameSet = (a, b) => {
   return true;
 };
 
+// Paths are reported to a human looking at a repo: show them relative to it.
+const rel = (projectRoot) => (p) => {
+  const r = path.relative(projectRoot, p);
+  return r && !r.startsWith('..') ? r : p;
+};
+
 function mk(id, label, status, detail, fix) {
   return fix ? { id, label, status, detail, fix } : { id, label, status, detail };
 }
@@ -84,11 +91,14 @@ function checkProfile(profile, hasPipelineMd) {
     n ? undefined : 'add at least one surface to §surfaces');
 }
 
-function checkAgents(profile, projectRoot) {
+function checkAgents(profile, projectRoot, layout) {
   if (!profile || !(profile.surfaces || []).length) {
     return mk('agents', 'Surfaces ↔ agents', 'skip', 'no surfaces to reconcile');
   }
-  const agentsDir = path.join(projectRoot, '.claude', 'agents');
+  if (!layout) {
+    return mk('agents', 'Surfaces ↔ agents', 'skip', 'no core installed — nothing renders agents yet');
+  }
+  const agentsDir = layout.agents;
   const surfaceAgents = profile.surfaces.map(s => s.agent).filter(Boolean);
 
   const missing = surfaceAgents.filter(a => !exists(path.join(agentsDir, `${a}.md`)));
@@ -109,17 +119,21 @@ function checkAgents(profile, projectRoot) {
       'remove the stale agent file, or add its surface to PIPELINE.md');
   }
   return mk('agents', 'Surfaces ↔ agents', 'ok',
-    `${surfaceAgents.length} surface agent(s) all rendered, no orphans`);
+    `${surfaceAgents.length} surface agent(s) all rendered, no orphans (${layout.label})`);
 }
 
-function checkGate(profile, projectRoot) {
+function checkGate(profile, projectRoot, stateDirs) {
   const gate = profile && profile.gate;
   if (!gate || (!gate.deny && !gate.ask && !gate.ask_on_default_branch && !gate.preflight)) {
     return mk('gate', 'Gate config', 'skip', 'no gate block in the profile');
   }
-  const cfg = readJson(path.join(projectRoot, '.claude', 'gate-config.json'));
+  // One gate config per PROJECT, wherever the installed runtime keeps it. A repo driven from
+  // two agents shares it deliberately — they must not disagree about what is gated.
+  const cfgPath = stateDirs.map(d => path.join(d, 'gate-config.json')).find(exists);
+  const cfg = cfgPath ? readJson(cfgPath) : null;
   if (!cfg) {
-    return mk('gate', 'Gate config', 'bad', '.claude/gate-config.json missing or unreadable',
+    return mk('gate', 'Gate config', 'bad',
+      `gate-config.json missing or unreadable (looked in ${stateDirs.map(rel(projectRoot)).join(', ')})`,
       '/cohorte-init-pipeline   (regenerate gate-config.json from the gate block)');
   }
   const drifted = [];
@@ -139,7 +153,7 @@ function checkGate(profile, projectRoot) {
   if (drifted.length) {
     return mk('gate', 'Gate config', 'warn',
       `gate-config.json drifted from PIPELINE.md gate block (${drifted.join(', ')})`,
-      'regenerate .claude/gate-config.json to mirror the gate block');
+      `regenerate ${rel(projectRoot)(cfgPath)} to mirror the gate block`);
   }
   const branchGated = (gate.ask_on_default_branch || []).length;
   return mk('gate', 'Gate config', 'ok',
@@ -147,15 +161,24 @@ function checkGate(profile, projectRoot) {
     (branchGated ? `, ${branchGated} gated on ${gate.default_branch || 'main'}` : '') + ')');
 }
 
-// Local-only pipeline artifacts. `.claude/preflight.ok` is the one that BREAKS things when
-// versioned rather than merely being noise: the stamp names the tree it verified, committing
-// it moves HEAD past that, and the committed copy then rides into every fresh clone and
-// worktree — the phase gate either blocks a clean tree or greens one it never checked.
-const LOCAL_ARTIFACTS = [
-  { path: '.claude/preflight.ok', why: 'the phase-gate stamp — a versioned one breaks the gate in every clone and worktree' },
-  { path: '.claude/pipeline-metrics.jsonl', why: 'the per-dispatch metrics sink (local, append-only)' },
-  { path: 'specs/reports/', why: 'the /cohorte-review report buffer (derived, regenerated each run)' },
-];
+// Local-only pipeline artifacts, named relative to whichever `<state>` dir the installed
+// runtime uses (`.claude` on a Claude install, `.cohorte` on the others). `preflight.ok` is the
+// one that BREAKS things when versioned rather than merely being noise: the stamp names the tree
+// it verified, committing it moves HEAD past that, and the committed copy then rides into every
+// fresh clone and worktree — the phase gate either blocks a clean tree or greens one it never
+// checked.
+function localArtifacts(stateRels) {
+  const out = [];
+  for (const d of stateRels) {
+    out.push({ path: `${d}/preflight.ok`, stamp: true,
+      why: 'the phase-gate stamp — a versioned one breaks the gate in every clone and worktree' });
+    out.push({ path: `${d}/pipeline-metrics.jsonl`,
+      why: 'the per-dispatch metrics sink (local, append-only)' });
+  }
+  out.push({ path: 'specs/reports/',
+    why: 'the /cohorte-review report buffer (derived, regenerated each run)' });
+  return out;
+}
 
 // Does any .gitignore in play cover `rel`? Deliberately literal — it recognizes the exact
 // path, its basename, a trailing-slash dir prefix and a `*.<ext>` glob, which is every form
@@ -183,60 +206,110 @@ function ignoreCovers(projectRoot, rel) {
   return false;
 }
 
-function checkLocalArtifacts(projectRoot) {
-  const unignored = LOCAL_ARTIFACTS.filter(a => !ignoreCovers(projectRoot, a.path));
+function checkLocalArtifacts(projectRoot, stateRels) {
+  const artifacts = localArtifacts(stateRels);
+  const unignored = artifacts.filter(a => !ignoreCovers(projectRoot, a.path));
   if (!unignored.length) {
     return mk('artifacts', 'Local artifacts', 'ok',
-      `${LOCAL_ARTIFACTS.length} local-only artifact path(s) all gitignored`);
+      `${artifacts.length} local-only artifact path(s) all gitignored`);
   }
-  const stamp = unignored.find(a => a.path === '.claude/preflight.ok');
+  const stamp = unignored.find(a => a.stamp);
   return mk('artifacts', 'Local artifacts', stamp ? 'bad' : 'warn',
     `not gitignored: ${unignored.map(a => a.path).join(', ')} — ${unignored[0].why}`,
     `add ${unignored.map(a => a.path).join(' + ')} to .gitignore`
-    + (stamp ? ', then `git rm --cached --ignore-unmatch .claude/preflight.ok`' : ''));
+    + (stamp ? `, then \`git rm --cached --ignore-unmatch ${stamp.path}\`` : ''));
 }
 
-function gateRegs(settingsPath) {
+// Gate registrations in one config file. Three shapes across the runtimes that host the hook:
+// Claude Code and Codex use the matcher-group form under `PreToolUse`, Gemini the same shape
+// under `BeforeTool`, Cursor a flat `[{command}]` under `beforeShellExecution`. A registration
+// read with the wrong shape looks absent, which is how a healthy install gets reported broken.
+function gateRegs(settingsPath, event) {
   const data = readJson(settingsPath);
-  const pre = data && data.hooks && Array.isArray(data.hooks.PreToolUse) ? data.hooks.PreToolUse : [];
+  const list = data && data.hooks && Array.isArray(data.hooks[event]) ? data.hooks[event] : [];
   // Trailing-quote tolerant, like the installers since 1.3.2: the Windows form is
   // `py "C:\…\gate.py"` — a bare .endsWith() reports every healthy Windows install
   // as "not registered".
-  return pre.filter(e => (e.hooks || []).some(
-    h => typeof h.command === 'string' && h.command.trim().replace(/"+$/, '').endsWith('gate.py')));
+  // Strip the trailing `--runtime <id>` BEFORE the quotes: the registered command is
+  // `python3 "/path/gate.py" --runtime cursor`, so taking the quotes off first leaves
+  // `…gate.py"` and the match fails — a healthy registration read as missing.
+  const isOurs = (c) => typeof c === 'string'
+    && c.trim().replace(/\s+--runtime[= ]\S+$/, '').replace(/"+$/, '').endsWith('gate.py');
+  return list.filter(e => isOurs(e && e.command)
+    || ((e && e.hooks) || []).some(h => isOurs(h && h.command)));
 }
 
-function checkHooks(projectRoot, globalDir, installMode) {
-  // A registration in EITHER scope serves the project: bundled repos get it from
-  // /cohorte-init-pipeline in project settings, but on a machine with the global core the
-  // hook usually lives (correctly, exactly once) in global settings — warning
-  // there would prescribe a re-registration that double-prompts.
-  const scopes = [
-    { label: 'project', path: path.join(projectRoot, '.claude', 'settings.json') },
-    { label: 'global', path: path.join(globalDir, 'settings.json') },
-  ];
-  if (installMode === 'global') scopes.reverse();
-  const found = scopes.map(s => ({ ...s, regs: gateRegs(s.path) })).filter(s => s.regs.length);
-
-  if (!found.length) {
-    return mk('hooks', 'Gate hook', 'warn', 'gate.py not registered in project or global settings.json',
-      installMode === 'global'
-        ? 'npx cohorte install --global   (re-registers the hook)'
-        : '/cohorte-init-pipeline   (register the PreToolUse gate hook)');
+function checkHooks(projectRoot, globalDir, installMode, all) {
+  // A registration can exist without a discoverable core — a repo whose core lives in a global
+  // dir the dashboard was not pointed at, or one predating `runtimes.json`. Falling through to
+  // "no runtime installed" there would hide a real double-registration, so assume the Claude
+  // layout: before the adapter it was the only one, and it is the only one whose hook can be
+  // registered outside its own core dir.
+  const known = all.length ? all : [{
+    id: 'claude', label: 'Claude Code', scope: installMode === 'bundled' ? 'project' : 'global',
+    core: path.join(projectRoot, '.claude'),
+    hooksConfig: path.join(projectRoot, '.claude', 'settings.json'),
+    capabilities: { subagents: true, hooks: true, workflows: true },
+  }];
+  const hosts = known.filter(l => l.capabilities && l.capabilities.hooks && l.hooksConfig);
+  const advisory = known.filter(l => !(l.capabilities && l.capabilities.hooks));
+
+  if (!hosts.length) {
+    if (advisory.length) {
+      // OpenCode extends via plugins, not a blocking hook. The gate still runs — the rendered
+      // commands call `gate.py --check` — but it is advisory, and saying ✅ here would claim an
+      // enforcement property that genuinely is not there.
+      return mk('hooks', 'Gate hook', 'warn',
+        `${advisory.map(l => l.label).join(', ')} has no blocking hook — the gate runs as an explicit --check the agent must call`,
+        'nothing to fix; run /cohorte-doctor inside that runtime for the full picture');
+    }
+    return mk('hooks', 'Gate hook', 'warn', 'no runtime installed to register the gate hook against',
+      'npx cohorte install   (or --global)');
   }
-  const total = found.reduce((n, s) => n + s.regs.length, 0);
-  if (total > 1) {
-    return mk('hooks', 'Gate hook', 'warn',
-      `gate.py registered ${total}× (${found.map(s => `${s.regs.length} in ${s.label}`).join(', ')}) — it will double-prompt`,
-      'keep exactly one PreToolUse entry (drop the project-level one when the global core is installed)');
+
+  const problems = [];
+  const okLines = [];
+  for (const l of hosts) {
+    const event = (l.id === 'cursor') ? 'beforeShellExecution'
+      : (l.id === 'gemini') ? 'BeforeTool' : 'PreToolUse';
+    // A Claude registration serves the project from EITHER scope: bundled repos get it from
+    // /cohorte-init-pipeline in project settings, but on a machine with the global core it
+    // usually lives (correctly, exactly once) in global settings — warning there would
+    // prescribe a re-registration that double-prompts.
+    const paths = l.id === 'claude'
+      ? (installMode === 'global'
+        ? [path.join(globalDir, 'settings.json'), path.join(projectRoot, '.claude', 'settings.json')]
+        : [path.join(projectRoot, '.claude', 'settings.json'), path.join(globalDir, 'settings.json')])
+      : [l.hooksConfig];
+    const found = paths.map(p2 => ({ path: p2, regs: gateRegs(p2, event) })).filter(f => f.regs.length);
+    if (!found.length) {
+      problems.push(`${l.label}: not registered (${event})`);
+      continue;
+    }
+    const total = found.reduce((n, f) => n + f.regs.length, 0);
+    if (total > 1) {
+      problems.push(`${l.label}: registered ${total}× — it will double-prompt`);
+      continue;
+    }
+    // Only the matcher-group runtimes carry one, and only Claude dispatches subagents through
+    // a `Task` tool — a Bash-only matcher there leaves the preflight phase gate dead.
+    const matcher = String(found[0].regs[0].matcher || '');
+    if (l.id === 'claude' && (!/\bTask\b/.test(matcher) || !/\bBash\b/.test(matcher))) {
+      problems.push(`${l.label}: matcher "${matcher}" must cover both Bash and Task`);
+      continue;
+    }
+    okLines.push(`${l.label} (${event}${matcher ? `, ${matcher}` : ''})`);
   }
-  const matcher = String(found[0].regs[0].matcher || '');
-  if (!/\bTask\b/.test(matcher) || !/\bBash\b/.test(matcher)) {
-    return mk('hooks', 'Gate hook', 'warn',
-      `registered with matcher "${matcher}" — it must cover both Bash (command gating) and Task (preflight phase gate)`,
-      'npx cohorte@latest update --global   (reconciles the matcher to Bash|Task)');
+
+  if (problems.length) {
+    // Name the healthy ones too. With several runtimes installed, "Claude Code: not registered"
+    // alone reads as if the gate were off everywhere, when four of five may be fine.
+    const tail = okLines.length ? ` (ok: ${okLines.join(', ')})` : '';
+    return mk('hooks', 'Gate hook', 'warn', problems.join(' · ') + tail,
+      'npx cohorte@latest update   (re-registers the gate hook for every installed runtime)');
   }
-  return mk('hooks', 'Gate hook', 'ok', `registered once, matcher ${matcher} (${found[0].label} settings.json)`);
+  const tail = advisory.length ? ` · ${advisory.map(l => l.label).join(', ')}: advisory --check only` : '';
+  return mk('hooks', 'Gate hook', 'ok', `registered once for ${okLines.join(', ')}${tail}`);
 }
 
 function checkRetrieval(profile, projectRoot) {
@@ -292,14 +365,17 @@ function checkIsolation(profile, projectRoot) {
 // the conversational commands stay the default path, so nothing here is ever 'bad'.
 // Whether the session has workflows ENABLED needs a live Claude session — /cohorte-doctor
 // in-session checks that; here we only check what's on disk.
-function checkWorkflows(projectRoot, globalDir, installMode) {
+function checkWorkflows(projectRoot, globalDir, installMode, all) {
   if (installMode === 'none') return mk('workflows', 'Workflows', 'skip', 'no core installed');
-  const dir = installMode === 'bundled'
-    ? path.join(projectRoot, '.claude', 'workflows')
-    : path.join(globalDir, 'workflows');
-  const agentsDir = installMode === 'bundled'
-    ? path.join(projectRoot, '.claude', 'agents')
-    : path.join(globalDir, 'agents');
+  // The Workflow engine is Claude Code's; the other runtimes are not shipped the scripts at
+  // all, and reporting them as "missing" would flag a deliberate omission as a defect.
+  const cc = all.find(l => l.id === 'claude');
+  if (!cc) {
+    return mk('workflows', 'Workflows', 'skip',
+      `not available on ${all.map(l => l.label).join(', ') || 'this runtime'} — conversational commands only`);
+  }
+  const dir = path.join(cc.core, 'workflows');
+  const agentsDir = cc.agents;
   const scripts = ['review.js', 'audit.js', 'refactor.js'];
   const missing = scripts.filter(s => !exists(path.join(dir, s)));
   if (missing.length === scripts.length) {
@@ -333,7 +409,8 @@ function scanSpecs(projectRoot) {
     const body = fm ? fm[1] : '';
     const get = k => { const m = body.match(new RegExp(`^${k}:\\s*(.*)$`, 'm')); return m ? m[1].trim() : null; };
     const status = get('status');
-    // The loop driver's resume state, when a /cohorte-loop is (or was) running on this spec.
+    // Legacy resume state from the retired /cohorte-loop driver. Nothing writes it any more;
+    // it is still read so a spec left mid-flight by an older core still shows why on the board.
     const pass = parseInt(get('loop_pass'), 10);
     const phase = get('loop_phase');
     specs.push({
@@ -371,17 +448,25 @@ async function state({ projectRoot, globalDir, cliVersion }) {
   const profile = pipelineMd ? parseProfileBlock(pipelineMd) : null;
   const specs = scanSpecs(projectRoot);
 
+  // Which coding agent(s) this repo is wired for. Every path-dependent check below reads from
+  // this rather than assuming `.claude/` — on a Cursor-only repo that assumption reported the
+  // core, the agents, the artifacts and the hook as all broken, and every one of them was fine.
+  const all = layouts({ projectRoot, globalDir });
+  const main = primary(all);
+  const stateAbs = stateDirs(all, projectRoot);
+  const stateRels = stateAbs.map(rel(projectRoot));
+
   const checks = [
     checkCore(v),
     checkProfile(profile, pipelineMd != null),
-    checkAgents(profile, projectRoot),
-    checkGate(profile, projectRoot),
-    checkLocalArtifacts(projectRoot),
-    checkHooks(projectRoot, globalDir, v.installMode),
+    checkAgents(profile, projectRoot, main),
+    checkGate(profile, projectRoot, stateAbs),
+    checkLocalArtifacts(projectRoot, stateRels),
+    checkHooks(projectRoot, globalDir, v.installMode, all),
     checkRetrieval(profile, projectRoot),
     checkDesign(profile, projectRoot),
     checkIsolation(profile, projectRoot),
-    checkWorkflows(projectRoot, globalDir, v.installMode),
+    checkWorkflows(projectRoot, globalDir, v.installMode, all),
     checkSpecs(specs),
   ];
 
@@ -390,6 +475,8 @@ async function state({ projectRoot, globalDir, cliVersion }) {
 
   return {
     project: projectRoot,
+    runtimes: all.map(l => ({ id: l.id, label: l.label, scope: l.scope,
+      capabilities: l.capabilities, legacy: !!l.legacy })),
     versions: v,
     profile: profile ? {
       name: profile.name,

package/dashboard/server/index.js

@@ -171,7 +171,7 @@ function runClaude(req, res, body) {
   req.on('close', () => { try { child.kill(); } catch { /* already gone */ } });
 }
 
-// Full project reset: back up the project's pipeline footprint (.claude/, PIPELINE.md, and
+// Full project reset: back up the project's pipeline footprint (every runtime's dir, PIPELINE.md, and
 // optionally specs/) to .claude.bak-<ts>, remove it, then reinstall a fresh BUNDLED core (or,
 // for global-mode projects, leave the shared ~/.claude core untouched). Never touches ~/.claude.
 // Streams progress; ends with __EXIT__ <code>. The profile is regenerated by /cohorte-init-pipeline after.
@@ -217,6 +217,16 @@ function runReset(req, res, body, { pkgRoot, globalDir }) {
 
     let moved = 0;
     if (fs.existsSync(claudeDir)) { fs.renameSync(claudeDir, path.join(backup, '.claude')); log('  · moved .claude/'); moved++; }
+    // A repo installed for another coding agent keeps its footprint elsewhere. Leaving these
+    // behind would make a "full reset" silently partial: the old rendered commands survive and
+    // the fresh install lands next to them.
+    for (const d of ['.cohorte', '.agents', '.cursor', '.gemini', '.opencode', '.codex']) {
+      const from = path.join(project, d);
+      if (!fs.existsSync(from)) continue;
+      fs.renameSync(from, path.join(backup, d));
+      log(`  · moved ${d}/`);
+      moved++;
+    }
     if (fs.existsSync(pipelineMd)) { fs.renameSync(pipelineMd, path.join(backup, 'PIPELINE.md')); log('  · moved PIPELINE.md'); moved++; }
     if (purgeSpecs && fs.existsSync(specsDir)) { fs.renameSync(specsDir, path.join(backup, 'specs')); log('  · moved specs/'); moved++; }
     if (!moved) log('  · nothing to move (no .claude/ or PIPELINE.md found)');
@@ -320,7 +330,7 @@ function start({ projectRoot, globalDir, port, host, openBrowser, pkgRoot, versi
       if (url === '/api/metrics') {
         const q = new URL(req.url, 'http://localhost').searchParams.get('project');
         const root = q ? path.resolve(q) : projectRoot;
-        return sendJson(res, 200, metrics({ projectRoot: root }));
+        return sendJson(res, 200, metrics({ projectRoot: root, globalDir }));
       }
       if (url === '/api/usage') {
         const q = new URL(req.url, 'http://localhost');

package/dashboard/server/metrics.js

@@ -1,5 +1,5 @@
 'use strict';
-// Read a project's `.claude/pipeline-metrics.jsonl` (one line per phase batch, appended by
+// Read a project's `pipeline-metrics.jsonl` (one line per phase batch, appended by
 // /cohorte-build, /cohorte-review and /cohorte-fix) and aggregate it per feature: wall-clock per phase, fix
 // rounds, and per-surface results. Dependency-free; a missing file is simply "no data yet".
 //
@@ -10,6 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { layouts, stateDirs } = require('./runtime.js');
 
 // `smoke` and `cycle` are RETIRED phases, kept so metrics files written before their removal
 // still render. Without them in this list their per-surface results parse fine but land in no
@@ -93,11 +94,17 @@ function aggregate(batches) {
   return [...byFeature.values()].sort((a, b) => (b.lastTs || '').localeCompare(a.lastTs || ''));
 }
 
-function metrics({ projectRoot }) {
-  const file = path.join(projectRoot, '.claude', 'pipeline-metrics.jsonl');
-  let raw;
-  try { raw = fs.readFileSync(file, 'utf8'); }
-  catch { return { present: false, phases: PHASES, features: [], batches: 0 }; }
+function metrics({ projectRoot, globalDir }) {
+  // The sink lives in `<state>`, which is `.claude` on a Claude install and `.cohorte` on the
+  // others. A repo driven from both has two, and the phases genuinely split across them — read
+  // every one rather than silently reporting half the spend.
+  const dirs = stateDirs(layouts({ projectRoot, globalDir }), projectRoot);
+  let raw = '';
+  for (const d of dirs) {
+    try { raw += fs.readFileSync(path.join(d, 'pipeline-metrics.jsonl'), 'utf8'); }
+    catch { /* absent in this layout */ }
+  }
+  if (!raw) return { present: false, phases: PHASES, features: [], batches: 0 };
 
   const batches = parseBatches(raw);
   return { present: true, phases: PHASES, features: aggregate(batches), batches: batches.length };

package/dashboard/server/runtime.js

@@ -0,0 +1,115 @@
+'use strict';
+// Which coding agent(s) this project is wired for, and where each one keeps its files.
+//
+// Before 2.2.0 every path in the dashboard was `.claude/…`. That is now one layout of five:
+// a repo driven from Cursor keeps its core in `.cohorte/cursor/`, its agents in
+// `.cursor/agents/` and its gate registration in `.cursor/hooks.json`. Checking the Claude
+// paths there reports a perfectly healthy install as broken — "no core", "no rendered agent",
+// "gate not registered" — which is worse than not checking at all: it sends a human fixing
+// something that is not wrong.
+//
+// The installer writes `<core>/pipeline/runtimes.json` (a map of every runtime installed
+// against that core), so discovery is a directory probe rather than a guess.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+// `<state>` — where the pipeline writes what it generates FOR THIS PROJECT (gate config,
+// preflight stamp, metrics). Shared by every non-Claude runtime on purpose: it describes the
+// project, not the agent driving it.
+function stateDirFor(id) {
+  return id === 'claude' ? '.claude' : '.cohorte';
+}
+
+// Candidate core directories, project scope first — a bundled core wins over a global one,
+// same precedence the commands themselves use.
+function candidateCores(projectRoot, globalDir) {
+  const home = os.homedir();
+  const out = [
+    { dir: path.join(projectRoot, '.claude'), scope: 'project' },
+    { dir: globalDir || path.join(home, '.claude'), scope: 'global' },
+  ];
+  for (const [root, scope] of [[path.join(projectRoot, '.cohorte'), 'project'],
+                               [path.join(home, '.cohorte'), 'global']]) {
+    let entries = [];
+    try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { /* absent */ }
+    for (const e of entries) {
+      if (e.isDirectory()) out.push({ dir: path.join(root, e.name), scope });
+    }
+  }
+  return out;
+}
+
+/**
+ * Every runtime installed against this project, most-authoritative first.
+ * Each layout resolves the paths a check needs, absolute where they are absolute.
+ * Returns [] when nothing is installed — callers report that as the missing core it is.
+ */
+function layouts({ projectRoot, globalDir }) {
+  const found = [];
+  const seen = new Set();
+  for (const { dir, scope } of candidateCores(projectRoot, globalDir)) {
+    const registry = readJson(path.join(dir, 'pipeline', 'runtimes.json'));
+    // A core with no registry predates the adapter ⇒ it can only be a Claude install.
+    const ids = registry ? Object.keys(registry) : (
+      fs.existsSync(path.join(dir, 'pipeline', 'VERSION')) ? ['claude'] : []);
+    for (const id of ids) {
+      const key = `${id}@${dir}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const rec = (registry && registry[id]) || {};
+      const p = rec.paths || {};
+      const abs = (v, fallback) => {
+        const raw = v || fallback;
+        if (!raw) return null;
+        return path.isAbsolute(raw) ? raw : path.join(projectRoot, raw);
+      };
+      found.push({
+        id,
+        label: rec.label || id,
+        scope: rec.scope || scope,
+        core: dir,
+        agents: abs(p.agents, path.join(dir, 'agents')),
+        commands: abs(p.commands, path.join(dir, 'commands')),
+        state: abs(null, p.state || stateDirFor(id)),
+        // Pre-2.2.0 cores carry no registry, so nothing records where the hook is registered.
+        // Claude's is `<core>/settings.json` and always has been — without this fallback a
+        // legacy install reports its perfectly good registration as missing.
+        hooksConfig: (rec.paths && rec.paths.hooks_config)
+          ? abs(rec.paths.hooks_config)
+          : (id === 'claude' ? path.join(dir, 'settings.json') : null),
+        capabilities: rec.capabilities || {
+          subagents: true, hooks: id === 'claude', workflows: id === 'claude',
+        },
+        legacy: !registry,
+      });
+    }
+  }
+  return found;
+}
+
+/**
+ * The layout the project-level checks should use. Claude first when present — it is the
+ * reference implementation and the layout every pre-2.2.0 repo has — else whatever is
+ * installed. Null when nothing is.
+ */
+function primary(all) {
+  if (!all.length) return null;
+  return all.find((l) => l.id === 'claude') || all[0];
+}
+
+// The state dirs actually in play. A repo driven from Claude AND Cursor has both `.claude`
+// and `.cohorte`; a check that looked at only one would miss a stamp or a metrics file.
+function stateDirs(all, projectRoot) {
+  const dirs = [];
+  for (const l of all) if (!dirs.includes(l.state)) dirs.push(l.state);
+  if (!dirs.length) dirs.push(path.join(projectRoot, '.claude'));
+  return dirs;
+}
+
+module.exports = { layouts, primary, stateDirs, stateDirFor };

package/dashboard/server/versions.js

@@ -5,6 +5,7 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { layouts } = require('./runtime.js');
 
 function readTrimmed(file) {
   try { return fs.readFileSync(file, 'utf8').trim(); } catch { return null; }
@@ -106,10 +107,20 @@ function cmpSemver(a, b) {
 
 async function versions({ projectRoot, globalDir, cliVersion }) {
   const global = coreAt(globalDir);
-  const bundled = coreAt(path.join(projectRoot, '.claude'));
+  let bundled = coreAt(path.join(projectRoot, '.claude'));
   const pointer = pointerAt(projectRoot);
   const latest = await latestNpm();
 
+  // A non-Claude runtime keeps its core in `.cohorte/<id>/`, not `.claude/`. Probing only the
+  // Claude path reported a perfectly installed Cursor/Codex/Gemini/OpenCode repo as having no
+  // core at all — and every downstream check keys off `installMode`, so one wrong probe turned
+  // the whole report red.
+  if (!bundled.present) {
+    const projectCore = layouts({ projectRoot, globalDir })
+      .find(l => l.scope === 'project' && l.core.startsWith(projectRoot));
+    if (projectCore) bundled = coreAt(projectCore.core);
+  }
+
   // The core that actually serves this project: bundled wins if present, else global.
   const effective = bundled.present ? bundled : global.present ? global : null;
   const installedVersion = effective ? effective.version : null;

package/install.ps1

@@ -103,6 +103,29 @@ try {
         throw "pipeline source not found (no core/ in $src)"
     }
 
+    # --- delegate to the Node CLI --------------------------------------------
+    # Since 2.2.0 the commands in core/ are runtime-NEUTRAL sources: they carry capability
+    # conditionals (`<!-- cohorte:if subagents -->`) and path tokens (`<core>`, `<state>`)
+    # that the adapter resolves per coding agent. Copying them verbatim, as this script used
+    # to, would install prompts full of unresolved markers — an install that looks successful
+    # and instructs the model with text meant for a different runtime. There is no PowerShell
+    # renderer, so hand the whole job to bin/cli.js, the documented route anyway.
+    $node = Get-Command node -ErrorAction SilentlyContinue
+    if ($node) {
+        $cliArgs = @((Join-Path $src 'bin\cli.js'), $(if ($Update) { 'update' } else { 'install' }))
+        if ($Global) { $cliArgs += '--global' } else { $cliArgs += $Target }
+        & $node.Source @cliArgs
+        exit $LASTEXITCODE
+    }
+    Write-Error @"
+cohorte needs Node >= 18 to install.
+  The pipeline's commands are rendered per coding agent (Claude Code, Codex, Cursor,
+  Gemini CLI, OpenCode) at install time; there is no PowerShell equivalent of that
+  step, and a raw copy would install prompts this runtime cannot follow.
+  Install Node, then:  npx cohorte install$(if ($Global) { ' --global' })
+"@
+    exit 1
+
     # --- resolve the destination .claude dir ---------------------------------
     if ($Global) {
         $dest = $env:CLAUDE_CONFIG_DIR
@@ -151,8 +174,6 @@ try {
         Copy-Item (Join-Path $src 'scripts\kanban-move.sh')       (Join-Path $dest 'pipeline\scripts') -Force
         Copy-Item (Join-Path $src 'scripts\telemetry-send.sh')    (Join-Path $dest 'pipeline\scripts') -Force
         Copy-Item (Join-Path $src 'scripts\preflight.sh')         (Join-Path $dest 'pipeline\scripts') -Force
-        Copy-Item (Join-Path $src 'scripts\loop.sh')              (Join-Path $dest 'pipeline\scripts') -Force
-        Copy-Item (Join-Path $src 'scripts\loop-detach.sh')       (Join-Path $dest 'pipeline\scripts') -Force
         Copy-Item (Join-Path $src 'core\agents\implementer.template.md') (Join-Path $dest 'pipeline') -Force
         if (Test-Path (Join-Path $src 'CHANGELOG.md')) { Copy-Item (Join-Path $src 'CHANGELOG.md') (Join-Path $dest 'pipeline') -Force }
         [System.IO.File]::WriteAllText((Join-Path $dest 'pipeline\VERSION'), "$ver`n", [System.Text.UTF8Encoding]::new($false))