cohorte 2.7.0 → 2.8.0

package/dashboard/server/kanban.js

@@ -4,6 +4,7 @@
 // stays local + dependency-free. The kanban mirror is Obsidian-only by design.
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const { parse, parseProfileBlock } = require('./yaml');
@@ -37,9 +38,16 @@ function fetchPRs(repo) {
 }
 
 function readConfig(globalDir) {
-  // cohorte.config.yaml, then the pre-rename legacy names (read-only fallback).
-  for (const n of ['cohorte.config.yaml', 'thebidouille.config.yaml']) {
-    try { return parse(fs.readFileSync(path.join(globalDir, n), 'utf8')); } catch { /* try next */ }
+  // cohorte.config.yaml under the Claude global dir first, then `~/.cohorte/` — where the
+  // installer seeds it for every non-Claude runtime (the shipped scripts probe the same two,
+  // in the same order) — then the pre-rename legacy name (read-only fallback).
+  const candidates = [
+    path.join(globalDir, 'cohorte.config.yaml'),
+    path.join(os.homedir(), '.cohorte', 'cohorte.config.yaml'),
+    path.join(globalDir, 'thebidouille.config.yaml'),
+  ];
+  for (const p of candidates) {
+    try { return parse(fs.readFileSync(p, 'utf8')); } catch { /* try next */ }
   }
   return null;
 }
@@ -78,7 +86,10 @@ function parseBoard(md, repo) {
       const prs = [...src.matchAll(/#(\d+)\b/g)].map(m => ({
         num: m[1], url: repo ? `https://github.com/${repo}/pull/${m[1]}` : null,
       }));
-      const tags = [...src.matchAll(/#([A-Za-zÀ-ɏ][\wÀ-ɏ/-]*)/g)].map(m => m[1]);
+      // A tag is any #-word that is not a bare number (`#123` = PR ref) — feature ids
+      // may start with a digit (`#2fa-login`), which a letter-first pattern dropped
+      // from tags while the text-strip below still removed it: the card lost its join key.
+      const tags = [...src.matchAll(/#(?!\d+\b)([\wÀ-ɏ][\wÀ-ɏ/-]*)/g)].map(m => m[1]);
       const text = src
         .replace(/#[\wÀ-ɏ/-]+/g, '')   // strip tags + PR refs
         .replace(/\bPR\b/g, '')         // and the leftover "PR" label

package/dashboard/server/runtime.js

@@ -64,10 +64,29 @@ function layouts({ projectRoot, globalDir }) {
       seen.add(key);
       const rec = (registry && registry[id]) || {};
       const p = rec.paths || {};
+      // runtimes.json records ABSOLUTE install-time paths. For a bundled (committed)
+      // core, a clone or a moved checkout still carries the ORIGINAL machine's paths —
+      // taken verbatim, every doctor check goes red on a healthy install ("no rendered
+      // agent", "gate not registered"). Recover the install-time project root from the
+      // recorded core path (its tail must match this core's path relative to the
+      // current project root — '.claude', '.cohorte/<rt>') and re-root anything under
+      // it onto the current projectRoot. Global cores sit outside the project and are
+      // machine-local by definition — their absolute paths pass through untouched.
+      const rel = path.relative(projectRoot, dir);
+      let recordedRoot = null;
+      if (p.core && rel && !rel.startsWith('..') && !path.isAbsolute(rel)
+          && (p.core === rel || p.core.endsWith(path.sep + rel))) {
+        recordedRoot = p.core.slice(0, p.core.length - rel.length - 1) || null;
+      }
       const abs = (v, fallback) => {
         const raw = v || fallback;
         if (!raw) return null;
-        return path.isAbsolute(raw) ? raw : path.join(projectRoot, raw);
+        if (!path.isAbsolute(raw)) return path.join(projectRoot, raw);
+        if (recordedRoot && recordedRoot !== projectRoot
+            && (raw === recordedRoot || raw.startsWith(recordedRoot + path.sep))) {
+          return path.join(projectRoot, raw.slice(recordedRoot.length + 1) || '.');
+        }
+        return raw;
       };
       found.push({
         id,

package/install.ps1

@@ -33,50 +33,6 @@ if (-not $repoUrl) { $repoUrl = 'https://github.com/TheBidouilleAgency/cohorte'
 
 if (-not $Target) { $Target = (Get-Location).Path }
 
-# --- helpers -----------------------------------------------------------------
-
-# Write JSON as UTF-8 without BOM, un-escaping \uXXXX sequences that ConvertTo-Json
-# (notably on PowerShell 5.1) produces for non-ASCII and for < > & ' — so accented
-# characters survive a round-trip. Escapes for control chars, `"` and `\` are kept,
-# and \u preceded by an odd number of backslashes (a literal \u in a string) is untouched.
-function Write-JsonFile([string]$Path, $Data) {
-    $json = ConvertTo-Json -InputObject $Data -Depth 100
-    $json = [regex]::Replace($json, '(?<=(?:^|[^\\])(?:\\\\)*)\\u([0-9a-fA-F]{4})', {
-        param($m)
-        $code = [Convert]::ToInt32($m.Groups[1].Value, 16)
-        if ($code -lt 0x20 -or $code -eq 0x22 -or $code -eq 0x5C) { $m.Value }
-        else { [string][char]$code }
-    })
-    $full = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($Path)
-    [System.IO.File]::WriteAllText($full, $json + "`n", [System.Text.UTF8Encoding]::new($false))
-}
-
-function Read-JsonFile([string]$Path) {
-    if (-not (Test-Path -LiteralPath $Path)) { return $null }
-    try { return Get-Content -LiteralPath $Path -Raw -Encoding UTF8 | ConvertFrom-Json }
-    catch { return $null }
-}
-
-# cp -R src/. dest — deterministic merge/overwrite into an existing directory.
-function Copy-Tree([string]$From, [string]$To) {
-    New-Item -ItemType Directory -Force -Path $To | Out-Null
-    Copy-Item -Path (Join-Path $From '*') -Destination $To -Recurse -Force
-}
-
-# The gate hook runs `python <gate.py>` at tool-use time; find a working Python 3
-# launcher for the hook command (skipping the Microsoft Store alias stubs, which
-# exist on PATH but exit non-zero).
-function Find-Python {
-    foreach ($candidate in @('py', 'python', 'python3')) {
-        if (-not (Get-Command $candidate -ErrorAction SilentlyContinue)) { continue }
-        try {
-            $null = & $candidate --version 2>$null
-            if ($LASTEXITCODE -eq 0) { return $candidate }
-        } catch { }
-    }
-    return $null
-}
-
 # --- locate the source (this checkout, or clone if piped via irm|iex) --------
 $tmp = $null
 try {
@@ -112,10 +68,23 @@ try {
     # renderer, so hand the whole job to bin/cli.js, the documented route anyway.
     $node = Get-Command node -ErrorAction SilentlyContinue
     if ($node) {
+        # An old Node fails DEEP into cli.js (fs.cpSync needs >= 16.7) after some files
+        # are already on disk — a half-install that reports as a crash. Refuse up front.
+        $nodeMajor = 0
+        try { $nodeMajor = [int](& $node.Source -p 'process.versions.node.split(".")[0]') } catch { }
+        if ($nodeMajor -lt 18) {
+            Write-Error "cohorte needs Node >= 18 — found $(& $node.Source --version). Upgrade Node, then re-run."
+            if ($PSCommandPath) { exit 1 }
+            return
+        }
         $cliArgs = @((Join-Path $src 'bin\cli.js'), $(if ($Update) { 'update' } else { 'install' }))
         if ($Global) { $cliArgs += '--global' } else { $cliArgs += $Target }
         & $node.Source @cliArgs
-        exit $LASTEXITCODE
+        # `exit` under `irm … | iex` terminates the user's interactive PowerShell
+        # session (there is no script file to exit from) — closing the console that
+        # just ran the documented one-liner. Exit only when running as a file.
+        if ($PSCommandPath) { exit $LASTEXITCODE }
+        return
     }
     Write-Error @"
 cohorte needs Node >= 18 to install.
@@ -124,295 +93,9 @@ cohorte needs Node >= 18 to install.
   step, and a raw copy would install prompts this runtime cannot follow.
   Install Node, then:  npm i -g cohorte; cohorte install$(if ($Global) { ' --global' })
 "@
-    exit 1
-
-    # --- resolve the destination .claude dir ---------------------------------
-    if ($Global) {
-        $dest = $env:CLAUDE_CONFIG_DIR
-        if (-not $dest) { $dest = Join-Path $HOME '.claude' }
-    } else {
-        $dest = Join-Path $Target '.claude'
-    }
-    New-Item -ItemType Directory -Force -Path $dest | Out-Null
-
-    # version stamp so a per-repo pointer can record which core it expects:
-    # the package.json semver, with the git sha for traceability on from-main installs
-    $semver = ''
-    try {
-        $pkgPath = Join-Path $src 'package.json'
-        if (Test-Path $pkgPath) {
-            $pkgData = Get-Content -Raw $pkgPath | ConvertFrom-Json
-            if ($pkgData.version) { $semver = "$($pkgData.version)".Trim() }
-        }
-    } catch { }
-    $sha = ''
-    try {
-        $v = git -C $src rev-parse --short HEAD 2>$null
-        if ($LASTEXITCODE -eq 0 -and $v) { $sha = "$v".Trim() }
-    } catch { }
-    if ($semver -and $sha)  { $ver = "$semver ($sha)" }
-    elseif ($semver)        { $ver = $semver }
-    elseif ($sha)           { $ver = $sha }
-    else                    { $ver = 'unknown' }
+    if ($PSCommandPath) { exit 1 }
+    return
 
-    function Copy-Core {
-        Copy-Tree (Join-Path $src 'core\commands')  (Join-Path $dest 'commands')
-        Copy-Tree (Join-Path $src 'core\hooks')     (Join-Path $dest 'hooks')
-        Copy-Tree (Join-Path $src 'core\templates') (Join-Path $dest 'templates')
-        Copy-Tree (Join-Path $src 'core\workflows') (Join-Path $dest 'workflows')
-        # A Python bytecode cache appears in a source checkout the moment anyone compiles
-        # or imports gate.py (CI does) and Copy-Item carries it along — machine- and
-        # interpreter-specific, and copy-over would never delete it later.
-        Remove-Item -LiteralPath (Join-Path $dest 'hooks\__pycache__') -Recurse -Force -ErrorAction SilentlyContinue
-        # 0.1.19 renamed questionnaire-domain-brief.md -> research-brief.md; drop the stale copy.
-        Remove-Item -LiteralPath (Join-Path $dest 'templates\questionnaire-domain-brief.md') -Force -ErrorAction SilentlyContinue
-        New-Item -ItemType Directory -Force -Path (Join-Path $dest 'pipeline\scripts') | Out-Null
-        Copy-Item (Join-Path $src 'profile\PIPELINE.template.md') (Join-Path $dest 'pipeline') -Force
-        Copy-Item (Join-Path $src 'profile\SCHEMA.md')            (Join-Path $dest 'pipeline') -Force
-        Copy-Item (Join-Path $src 'profile\cohorte.config.template.yaml') (Join-Path $dest 'pipeline') -Force
-        Copy-Item (Join-Path $src 'scripts\*.template')           (Join-Path $dest 'pipeline\scripts') -Force
-        Copy-Item (Join-Path $src 'scripts\kanban-move.sh')       (Join-Path $dest 'pipeline\scripts') -Force
-        Copy-Item (Join-Path $src 'scripts\preflight.sh')         (Join-Path $dest 'pipeline\scripts') -Force
-        # 2.3.0 removed telemetry; copy-over never deletes, so scrub the sender from existing
-        # installs. The dead `telemetry:` config block is deleted by /cohorte-update-pipeline.
-        Remove-Item (Join-Path $dest 'pipeline\scripts\telemetry-send.sh') -Force -ErrorAction SilentlyContinue
-        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))
-        Clear-TddGate
-    }
-
-    # The TDD gate was removed in 0.1.6. Older installs have hooks\tdd_gate.py on disk and
-    # possibly registered in settings.json (by the sh/npm installers) — copy-over never deletes,
-    # and a registered hook whose file is gone errors on every Write/Edit, so scrub both.
-    function Clear-TddGate {
-        Remove-Item -LiteralPath (Join-Path $dest 'hooks\tdd_gate.py') -Force -ErrorAction SilentlyContinue
-        $settingsPath = Join-Path $dest 'settings.json'
-        $data = Read-JsonFile $settingsPath
-        if ($data -is [pscustomobject] -and $data.PSObject.Properties['hooks'] -and
-            $data.hooks.PSObject.Properties['PreToolUse']) {
-            $kept = @()
-            $dropped = $false
-            foreach ($entry in @($data.hooks.PreToolUse)) {
-                $isTdd = $false
-                foreach ($h in @($entry.hooks)) {
-                    if ($h -and $h.command -and "$($h.command)".Trim().TrimEnd('"').EndsWith('tdd_gate.py')) { $isTdd = $true }
-                }
-                if ($isTdd) { $dropped = $true } else { $kept += $entry }
-            }
-            if ($dropped) {
-                $data.hooks.PreToolUse = $kept
-                Write-JsonFile $settingsPath $data
-                Write-Host "  - removed the retired tdd_gate.py hook (file + settings registration)"
-            }
-        }
-    }
-
-    # the fixed (non-rendered) agents: the dev review/release pipeline agents
-    function Copy-FixedAgents {
-        New-Item -ItemType Directory -Force -Path (Join-Path $dest 'agents') | Out-Null
-        Copy-Item (Join-Path $src 'core\agents\review.md'),
-                  (Join-Path $src 'core\agents\release.md'),
-                  (Join-Path $src 'core\agents\profile-reader.md') (Join-Path $dest 'agents') -Force
-        # 1.5.0 removed the /smoke phase; copy-over never deletes, so scrub the orphan agent.
-        Remove-Item -LiteralPath (Join-Path $dest 'agents\smoke.md') -Force -ErrorAction SilentlyContinue
-        Remove-Item -LiteralPath (Join-Path $dest 'commands\smoke.md') -Force -ErrorAction SilentlyContinue
-        # 1.4.0 removed /cycle and its workflow — and no installer ever scrubbed them, so every
-        # install since has kept offering a command that dispatches a workflow whose phases were
-        # later deleted. A dead command is worse than a missing one: the model can still fire it.
-        Remove-Item -LiteralPath (Join-Path $dest 'commands\cycle.md') -Force -ErrorAction SilentlyContinue
-        Remove-Item -LiteralPath (Join-Path $dest 'workflows\cycle.js') -Force -ErrorAction SilentlyContinue
-        # 1.6.0 renamed /loop → /drive: Claude Code's own built-in /loop shadowed ours, so a leftover
-        # commands\loop.md is a command the user can never reach — scrub it rather than leave a decoy.
-        Remove-Item -LiteralPath (Join-Path $dest 'commands\loop.md') -Force -ErrorAction SilentlyContinue
-        # 2.0.0 prefixed every command with `cohorte-`, which ends the shadowing problem for good.
-        # Copy-Item never deletes, so all 13 bare names would survive an upgrade as decoys — and a
-        # stale /build is the worst kind: it still dispatches implementers, from a 1.x command file
-        # that knows nothing of this core's contract. /drive goes too (it became /cohorte-loop).
-        foreach ($c in @('align-ds','audit','brainstorm','build','doctor','drive','fix',
-                         'init-pipeline','refactor','review','ship','spec','update-pipeline')) {
-            Remove-Item -LiteralPath (Join-Path $dest "commands\$c.md") -Force -ErrorAction SilentlyContinue
-        }
-        # 0.1.19 split the bi-mode questionnaire-researcher into research-agent + questionnaire-architect;
-        # copy-over never deletes, so scrub the retired agent lest a dead subagent_type linger.
-        Remove-Item -LiteralPath (Join-Path $dest 'agents\questionnaire-researcher.md') -Force -ErrorAction SilentlyContinue
-        Clear-ResearchQuestionnaire
-    }
-
-    # The research + questionnaire capability was removed. Older installs have its agents, commands,
-    # templates and template-step dirs on disk; copy-over never deletes, so scrub every orphan.
-    function Clear-ResearchQuestionnaire {
-        foreach ($f in @('agents\research-agent.md', 'agents\questionnaire-architect.md',
-                         'agents\questionnaire-writer.md', 'agents\questionnaire-validator.md',
-                         'commands\research.md', 'commands\questionnaire.md',
-                         'templates\research-brief.md', 'templates\questionnaire-blueprint.md',
-                         'templates\questionnaire-declaration.md', 'templates\questionnaire-verdict.md')) {
-            Remove-Item -LiteralPath (Join-Path $dest $f) -Force -ErrorAction SilentlyContinue
-        }
-        foreach ($d in @('templates\steps\research', 'templates\steps\questionnaire')) {
-            Remove-Item -LiteralPath (Join-Path $dest $d) -Recurse -Force -ErrorAction SilentlyContinue
-        }
-    }
-
-    # pipeline capability config is USER-level (vault, Notion DB, kanban boards) — it lives in
-    # the user's .claude regardless of install scope. Seed only if neither the consolidated nor
-    # the legacy copy exists. Non-interactive here: seeds disabled defaults; /cohorte-init-pipeline +
-    # /cohorte-update-pipeline wire it (the npm CLI's installer offers a quick interview instead).
-    function Initialize-Config {
-        $userClaude = if ($env:CLAUDE_CONFIG_DIR) { $env:CLAUDE_CONFIG_DIR } else { Join-Path $HOME '.claude' }
-        $cfg = Join-Path $userClaude 'cohorte.config.yaml'
-        $legacy = @('thebidouille.config.yaml') |
-            ForEach-Object { Join-Path $userClaude $_ } |
-            Where-Object { Test-Path -LiteralPath $_ } |
-            Select-Object -First 1
-        if (Test-Path -LiteralPath $cfg) {
-            Write-Host "  - kept your existing $cfg"
-        } elseif ($legacy) {
-            Write-Host "  - found legacy $legacy — kept as-is (read as a fallback)."
-            Write-Host "    Run /cohorte-update-pipeline to migrate it into cohorte.config.yaml + wire the kanban."
-        } else {
-            New-Item -ItemType Directory -Force -Path $userClaude | Out-Null
-            Copy-Item (Join-Path $src 'profile\cohorte.config.template.yaml') $cfg
-            Write-Host "  - seeded $cfg (disabled defaults — enable via /cohorte-init-pipeline or /cohorte-update-pipeline)"
-        }
-    }
-
-    # Register the profile-driven gate hook in the GLOBAL settings.json. Idempotent:
-    # the hook reads each repo's own .claude/gate-config.json (and no-ops where absent),
-    # so one registration serves every project.
-    function Register-GlobalHook {
-        $settingsPath = Join-Path $dest 'settings.json'
-        $gate = Join-Path $dest 'hooks\gate.py'
-        $python = Find-Python
-        if (-not $python) {
-            return 'skipped — no Python 3 found on PATH; install it and re-run .\install.ps1 -Global'
-        }
-        $cmd = '{0} "{1}"' -f $python, $gate
-
-        $data = Read-JsonFile $settingsPath
-        if ($null -eq $data -or $data -isnot [pscustomobject]) { $data = [pscustomobject]@{} }
-        if (-not $data.PSObject.Properties['hooks']) {
-            $data | Add-Member -NotePropertyName hooks -NotePropertyValue ([pscustomobject]@{})
-        }
-        if (-not $data.hooks.PSObject.Properties['PreToolUse']) {
-            $data.hooks | Add-Member -NotePropertyName PreToolUse -NotePropertyValue @()
-        }
-
-        # Reconcile rather than append-if-absent: drop every existing gate.py
-        # registration, then add exactly one. Idempotent, collapses duplicates older
-        # installers left behind, and upgrades a stale "Bash"-only matcher in place —
-        # an append-if-absent would find the stale entry and skip, pinning the bug.
-        $kept = @()
-        foreach ($entry in @($data.hooks.PreToolUse)) {
-            $isGate = $false
-            foreach ($h in @($entry.hooks)) {
-                if ($h -and $h.command -and "$($h.command)".Trim().TrimEnd('"').EndsWith('gate.py')) {
-                    $isGate = $true
-                }
-            }
-            if (-not $isGate) { $kept += $entry }
-        }
-        # The matcher MUST cover Task as well as Bash: gate.py's preflight phase gate
-        # keys off tool_name == "Task" (the `preflight` block in a repo's
-        # gate-config.json). A Bash-only matcher never delivers a Task dispatch to the
-        # hook, so that gate silently never fires. Keep in lockstep with install.sh
-        # and bin/cli.js.
-        $data.hooks.PreToolUse = @($kept) + [pscustomobject]@{
-            matcher = 'Bash|Task'
-            hooks   = @([pscustomobject]@{ type = 'command'; command = $cmd })
-        }
-        Write-JsonFile $settingsPath $data
-        return 'ok'
-    }
-
-    # Bump only the core_version in a repo's committed .claude/pipeline.json (bundled mode).
-    # Leaves every other field intact; no-ops if the pointer is absent or has no core_version.
-    function Update-PointerVersion([string]$Ptr, [string]$NewVer) {
-        $data = Read-JsonFile $Ptr
-        if ($data -is [pscustomobject] -and $data.PSObject.Properties['core_version']) {
-            $data.core_version = $NewVer
-            Write-JsonFile $Ptr $data
-        }
-    }
-
-    if ($Global) {
-        if (-not $Update) {
-            Write-Host "-> installing pipeline core GLOBALLY into $dest"
-        } else {
-            Write-Host "-> updating pipeline core GLOBALLY in $dest (keeping global settings.json)"
-        }
-        Copy-FixedAgents
-        Copy-Core
-        $hookState = Register-GlobalHook
-        Initialize-Config
-        Write-Host @"
-
-OK pipeline core installed globally into $dest  (version $ver)
-  gate hook: $hookState  (reads each repo's .claude/gate-config.json; silent where absent)
-
-The commands (/cohorte-init-pipeline, /cohorte-brainstorm, /cohorte-build ...) and the review/release agents are now
-available in EVERY project on this machine — nothing is copied per repo.
-
-Per repo:
-  1. Open the project in Claude Code.
-  2. Run  /cohorte-init-pipeline  — it generates PIPELINE.md, renders the surface agents, writes
-     .claude/gate-config.json, and drops a committed .claude/pipeline.json pointer so
-     teammates know to install the global core ($repoUrl).
-  3. Commit PIPELINE.md + .claude/, then  /cohorte-brainstorm  to start a feature.
-
-Code retrieval (Serena — the default provider /cohorte-init-pipeline wires per repo):
-  uv tool install -p 3.13 serena-agent   # once per machine
-  Make sure the uv tools dir is on PATH (uv tool update-shell) — otherwise the
-  registered MCP server silently fails to start.
-
-Global kanban config, user-scoped — optional:
-  · One consolidated file: ~/.claude/cohorte.config.yaml (don't hand-edit it).
-  · /cohorte-init-pipeline (new project) and /cohorte-update-pipeline (existing) wire it for you: creating +
-    syncing an Obsidian kanban board of the pipeline in your shared vault.
-"@
-        return
-    }
-
-    if (-not $Update) {
-        Write-Host "-> installing pipeline core into $dest"
-        Copy-FixedAgents
-        Copy-Core
-        Initialize-Config
-        New-Item -ItemType Directory -Force -Path (Join-Path $Target 'specs') | Out-Null
-        if (-not (Test-Path -LiteralPath (Join-Path $Target 'specs\_template.md'))) {
-            Copy-Item (Join-Path $src 'core\templates\spec.template.md') (Join-Path $Target 'specs\_template.md')
-        }
-        Write-Host @"
-
-OK pipeline core installed into $dest  (version $ver)
-
-Next:
-  1. Open the project in Claude Code.
-  2. Run  /cohorte-init-pipeline   — it detects your stack, asks the gaps, and generates
-     PIPELINE.md + renders one implementer agent per surface.
-  3. Commit PIPELINE.md, then  /cohorte-brainstorm  to start a feature.
-
-Code retrieval (Serena — the default provider /cohorte-init-pipeline wires per repo):
-  uv tool install -p 3.13 serena-agent   # once per machine
-  Make sure the uv tools dir is on PATH (uv tool update-shell) — otherwise the
-  registered MCP server silently fails to start.
-
-Prefer one shared core across all your repos?  Re-run with  -Global.
-"@
-    } else {
-        Write-Host "-> updating pipeline core in $dest (keeping your PIPELINE.md + rendered agents)"
-        Copy-Core
-        if (Test-Path -LiteralPath (Join-Path $dest 'agents')) {
-            Copy-FixedAgents
-        }
-        Initialize-Config
-        Update-PointerVersion (Join-Path $dest 'pipeline.json') $ver
-        Write-Host @"
-
-OK core refreshed to $ver. Your PIPELINE.md, rendered surface agents, gate-config.json and
-  settings.json were left as-is. Re-run /cohorte-init-pipeline if your stack changed.
-"@
-    }
 } finally {
     if ($tmp -and (Test-Path -LiteralPath $tmp)) {
         Remove-Item -LiteralPath $tmp -Recurse -Force -ErrorAction SilentlyContinue