cc-workspace 4.0.0

package/bin/cli.js

@@ -0,0 +1,735 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+// ─── Package info ───────────────────────────────────────────
+const PKG = require("../package.json");
+const PACKAGE_DIR = path.resolve(__dirname, "..");
+const SKILLS_DIR = path.join(PACKAGE_DIR, "global-skills");
+
+// ─── Claude global dirs ─────────────────────────────────────
+const HOME = process.env.HOME || process.env.USERPROFILE;
+const CLAUDE_DIR = path.join(HOME, ".claude");
+const VERSION_FILE = path.join(CLAUDE_DIR, ".orchestrator-version");
+const GLOBAL_SKILLS = path.join(CLAUDE_DIR, "skills");
+const GLOBAL_RULES = path.join(CLAUDE_DIR, "rules");
+const GLOBAL_AGENTS = path.join(CLAUDE_DIR, "agents");
+
+// ─── ANSI Colors (zero deps) ────────────────────────────────
+const isColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const c = {
+  reset:   isColor ? "\x1b[0m"  : "",
+  bold:    isColor ? "\x1b[1m"  : "",
+  dim:     isColor ? "\x1b[2m"  : "",
+  green:   isColor ? "\x1b[32m" : "",
+  yellow:  isColor ? "\x1b[33m" : "",
+  red:     isColor ? "\x1b[31m" : "",
+  cyan:    isColor ? "\x1b[36m" : "",
+  blue:    isColor ? "\x1b[34m" : "",
+  magenta: isColor ? "\x1b[35m" : "",
+  gray:    isColor ? "\x1b[90m" : "",
+  white:   isColor ? "\x1b[37m" : "",
+  bgGreen: isColor ? "\x1b[42m\x1b[30m" : "",
+  bgRed:   isColor ? "\x1b[41m\x1b[37m" : "",
+};
+
+// ─── Banner ─────────────────────────────────────────────────
+const BANNER = `
+${c.cyan}${c.bold}   ██████╗ ██████╗   ██╗    ██╗███████╗${c.reset}
+${c.cyan}  ██╔════╝██╔════╝   ██║    ██║██╔════╝${c.reset}
+${c.cyan}  ██║     ██║        ██║ █╗ ██║███████╗${c.reset}
+${c.cyan}  ██║     ██║        ██║███╗██║╚════██║${c.reset}
+${c.cyan}  ╚██████╗╚██████╗   ╚███╔███╔╝███████║${c.reset}
+${c.cyan}   ╚═════╝ ╚═════╝    ╚══╝╚══╝ ╚══════╝${c.reset}
+${c.dim}   Claude Code Workspace Orchestrator${c.reset} ${c.bold}v${PKG.version}${c.reset}
+`;
+
+const BANNER_SMALL = `${c.cyan}${c.bold}cc-workspace${c.reset} ${c.dim}v${PKG.version}${c.reset}`;
+
+// ─── Output helpers ─────────────────────────────────────────
+function log(msg = "") { console.log(msg); }
+function ok(msg)       { console.log(`  ${c.green}✓${c.reset} ${msg}`); }
+function warn(msg)     { console.log(`  ${c.yellow}⚠${c.reset} ${c.yellow}${msg}${c.reset}`); }
+function fail(msg)     { console.error(`  ${c.red}✗${c.reset} ${c.red}${msg}${c.reset}`); }
+function info(msg)     { console.log(`  ${c.blue}▸${c.reset} ${msg}`); }
+function step(msg)     { console.log(`\n${c.bold}${c.white}  ${msg}${c.reset}`); }
+function hr()          { console.log(`${c.dim}  ${"─".repeat(50)}${c.reset}`); }
+
+// ─── FS helpers ─────────────────────────────────────────────
+function mkdirp(dir) { fs.mkdirSync(dir, { recursive: true }); }
+
+function copyFile(src, dest) { fs.copyFileSync(src, dest); }
+
+function copyDir(src, dest) {
+  mkdirp(dest);
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    entry.isDirectory() ? copyDir(srcPath, destPath) : copyFile(srcPath, destPath);
+  }
+}
+
+// ─── Version helpers ────────────────────────────────────────
+function readVersion() {
+  try { return fs.readFileSync(VERSION_FILE, "utf8").trim(); }
+  catch { return null; }
+}
+
+function writeVersion(v) {
+  mkdirp(CLAUDE_DIR);
+  fs.writeFileSync(VERSION_FILE, v + "\n");
+}
+
+function semverCompare(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+function needsUpdate(force) {
+  if (force) return true;
+  const installed = readVersion();
+  if (!installed) return true;
+  return semverCompare(PKG.version, installed) > 0;
+}
+
+// ─── Detect project type ────────────────────────────────────
+function detectProjectType(dir) {
+  const has = (f) => fs.existsSync(path.join(dir, f));
+  const pkgHas = (kw) => {
+    try { return fs.readFileSync(path.join(dir, "package.json"), "utf8").includes(kw); }
+    catch { return false; }
+  };
+  if (has("composer.json")) return "PHP/Laravel";
+  if (has("pom.xml")) return "Java/Spring";
+  if (has("build.gradle")) return "Java/Gradle";
+  if (has("requirements.txt") || has("pyproject.toml")) return "Python";
+  if (has("go.mod")) return "Go";
+  if (has("Cargo.toml")) return "Rust";
+  if (has("package.json")) {
+    if (pkgHas("quasar")) return "Vue/Quasar";
+    if (pkgHas("nuxt")) return "Vue/Nuxt";
+    if (pkgHas("next")) return "React/Next";
+    if (pkgHas('"vue"')) return "Vue";
+    if (pkgHas('"react"')) return "React";
+    return "Node.js";
+  }
+  return "unknown";
+}
+
+// ─── Type badge ─────────────────────────────────────────────
+function typeBadge(type) {
+  const badges = {
+    "PHP/Laravel": `${c.magenta}PHP/Laravel${c.reset}`,
+    "Java/Spring": `${c.red}Java/Spring${c.reset}`,
+    "Java/Gradle": `${c.red}Java/Gradle${c.reset}`,
+    "Python":      `${c.yellow}Python${c.reset}`,
+    "Go":          `${c.cyan}Go${c.reset}`,
+    "Rust":        `${c.red}Rust${c.reset}`,
+    "Vue/Quasar":  `${c.green}Vue/Quasar${c.reset}`,
+    "Vue/Nuxt":    `${c.green}Vue/Nuxt${c.reset}`,
+    "Vue":         `${c.green}Vue${c.reset}`,
+    "React/Next":  `${c.blue}React/Next${c.reset}`,
+    "React":       `${c.blue}React${c.reset}`,
+    "Node.js":     `${c.green}Node.js${c.reset}`,
+  };
+  return badges[type] || `${c.dim}${type}${c.reset}`;
+}
+
+// ─── Install global components ──────────────────────────────
+function installGlobals(force) {
+  const installed = readVersion();
+  const shouldUpdate = needsUpdate(force);
+
+  if (!shouldUpdate) {
+    ok(`Global components up to date ${c.dim}(v${installed})${c.reset}`);
+    return false;
+  }
+
+  step(installed
+    ? `Updating globals: ${c.dim}v${installed}${c.reset} → ${c.green}v${PKG.version}${c.reset}`
+    : `Installing global components`
+  );
+
+  mkdirp(GLOBAL_SKILLS);
+  mkdirp(GLOBAL_RULES);
+  mkdirp(GLOBAL_AGENTS);
+
+  // Skills
+  const skipDirs = new Set(["rules", "agents", "hooks", "templates"]);
+  let skillCount = 0;
+  for (const entry of fs.readdirSync(SKILLS_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory() || skipDirs.has(entry.name)) continue;
+    copyDir(path.join(SKILLS_DIR, entry.name), path.join(GLOBAL_SKILLS, entry.name));
+    skillCount++;
+  }
+  ok(`${skillCount} skills`);
+
+  // Rules
+  const rulesDir = path.join(SKILLS_DIR, "rules");
+  if (fs.existsSync(rulesDir)) {
+    let n = 0;
+    for (const f of fs.readdirSync(rulesDir)) {
+      if (f.endsWith(".md")) { copyFile(path.join(rulesDir, f), path.join(GLOBAL_RULES, f)); n++; }
+    }
+    ok(`${n} rules`);
+  }
+
+  // Agents
+  const agentsDir = path.join(SKILLS_DIR, "agents");
+  if (fs.existsSync(agentsDir)) {
+    let n = 0;
+    for (const f of fs.readdirSync(agentsDir)) {
+      if (f.endsWith(".md")) { copyFile(path.join(agentsDir, f), path.join(GLOBAL_AGENTS, f)); n++; }
+    }
+    ok(`${n} agents`);
+  }
+
+  // Constitution (FR)
+  const constitutionFr = path.join(SKILLS_DIR, "constitution.md");
+  if (fs.existsSync(constitutionFr)) {
+    copyFile(constitutionFr, path.join(CLAUDE_DIR, "constitution.md"));
+    ok("constitution ${c.dim}(FR)${c.reset}");
+  }
+
+  writeVersion(PKG.version);
+  return true;
+}
+
+// ─── Generate settings.json with hooks ──────────────────────
+function generateSettings(orchDir) {
+  const hp = ".claude/hooks";
+  const settings = {
+    env: {
+      CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1",
+      CLAUDE_CODE_SUBAGENT_MODEL: "sonnet"
+    },
+    hooks: {
+      PreToolUse: [
+        { matcher: "Write|Edit|MultiEdit", command: `bash ${hp}/block-orchestrator-writes.sh`, timeout: 5 },
+        { matcher: "Teammate", command: `bash ${hp}/validate-spawn-prompt.sh`, timeout: 5 }
+      ],
+      SessionStart: [
+        { command: `bash ${hp}/session-start-context.sh`, timeout: 10 }
+      ],
+      UserPromptSubmit: [
+        { command: `bash ${hp}/user-prompt-guard.sh`, timeout: 3 }
+      ],
+      SubagentStart: [
+        { command: `bash ${hp}/subagent-start-context.sh`, timeout: 5 }
+      ],
+      PermissionRequest: [
+        { command: `bash ${hp}/permission-auto-approve.sh`, timeout: 3 }
+      ],
+      PostToolUse: [
+        { matcher: "Write|Edit|MultiEdit", command: `bash ${hp}/track-file-modifications.sh`, timeout: 3 }
+      ],
+      TeammateIdle: [
+        { command: `bash ${hp}/teammate-idle-check.sh`, timeout: 5 }
+      ],
+      TaskCompleted: [
+        { command: `bash ${hp}/task-completed-check.sh`, timeout: 3 }
+      ],
+      WorktreeCreate: [
+        { command: `bash ${hp}/worktree-create-context.sh`, timeout: 3 }
+      ],
+      Notification: [
+        { command: `bash ${hp}/notify-user.sh`, timeout: 5 }
+      ]
+    }
+  };
+  fs.writeFileSync(path.join(orchDir, ".claude", "settings.json"), JSON.stringify(settings, null, 2) + "\n");
+}
+
+// ─── Block hook (inline, always regenerated) ────────────────
+function generateBlockHook(hooksDir) {
+  const blockHook = `#!/usr/bin/env bash
+# block-orchestrator-writes.sh v${PKG.version}
+# PreToolUse hook: blocks writes to sibling repos. Allows writes within orchestrator/.
+set -euo pipefail
+
+INPUT=$(cat)
+
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_input.path // empty' 2>/dev/null) || FILE_PATH=""
+
+if [ -z "$FILE_PATH" ]; then
+    cat << 'EOF'
+{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"Cannot determine target path. Delegate to a teammate."}}
+EOF
+    exit 0
+fi
+
+ORCH_DIR="\${CLAUDE_PROJECT_DIR:-.}"
+ORCH_ABS="$(cd "$ORCH_DIR" 2>/dev/null && pwd)" || ORCH_ABS=""
+
+if [ -d "$(dirname "$FILE_PATH")" ]; then
+    TARGET_ABS="$(cd "$(dirname "$FILE_PATH")" 2>/dev/null && pwd)/$(basename "$FILE_PATH")"
+else
+    TARGET_ABS="$FILE_PATH"
+fi
+
+if [ -n "$ORCH_ABS" ]; then
+    case "$TARGET_ABS" in
+        "$ORCH_ABS"/*)
+            exit 0
+            ;;
+    esac
+fi
+
+PARENT_DIR="$(dirname "$ORCH_ABS" 2>/dev/null)" || PARENT_DIR=""
+if [ -n "$PARENT_DIR" ]; then
+    for repo_dir in "$PARENT_DIR"/*/; do
+        [ -d "$repo_dir/.git" ] || continue
+        REPO_ABS="$(cd "$repo_dir" 2>/dev/null && pwd)"
+        case "$TARGET_ABS" in
+            "$REPO_ABS"/*)
+                REPO_NAME=$(basename "$REPO_ABS")
+                cat << EOF
+{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"BLOCKED: Cannot write in repo $REPO_NAME/. Delegate to a teammate via Agent Teams."}}
+EOF
+                exit 0
+                ;;
+        esac
+    done
+fi
+
+cat << 'EOF'
+{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"BLOCKED: Write target is outside orchestrator/. Delegate to a teammate."}}
+EOF
+exit 0
+`;
+  fs.writeFileSync(path.join(hooksDir, "block-orchestrator-writes.sh"), blockHook, { mode: 0o755 });
+}
+
+// ─── CLAUDE.md content ──────────────────────────────────────
+function claudeMdContent() {
+  return `# Orchestrateur v${PKG.version}
+
+Tu es le lead technique. Tu ne codes jamais dans les repos — tu peux écrire dans orchestrator/.
+Tu clarifies, planifies, délègues, traces.
+
+## Sécurité
+- \`disallowedTools: Bash\` — pas de shell direct
+- \`allowed-tools\` : Read, Write, Edit, Glob, Grep, Task, Teammate, SendMessage
+- Hook \`PreToolUse\` path-aware : autorise orchestrator/, bloque les repos frères
+
+> settings.json contient env vars + hooks registration.
+
+## Lancement
+\`\`\`
+cd orchestrator/
+claude --agent workspace-init   # première fois : diagnostic + config
+claude --agent team-lead         # sessions de travail
+\`\`\`
+
+## Initialisation (workspace-init)
+L'agent \`workspace-init\` vérifie la structure, scanne les repos frères (type, CLAUDE.md,
+.claude/, tests), et configure interactivement workspace.md et constitution.md.
+Se lance une seule fois. Idempotent — peut être relancé pour re-diagnostiquer.
+
+## 4 modes de session
+| Mode | Description |
+|------|-------------|
+| **A — Complet** | Clarify → Plan → Validate → Dispatch en waves → QA |
+| **B — Plan rapide** | Specs → Plan → Dispatch |
+| **C — Go direct** | Dispatch immédiat |
+| **D — Single-service** | 1 repo, pas de waves |
+
+## Config
+- Contexte projet : \`./workspace.md\`
+- Constitution projet : \`./constitution.md\`
+- Templates : \`./templates/\`
+- Profils services : \`./plans/service-profiles.md\`
+- Plans actifs : \`./plans/*.md\`
+
+## Skills (9)
+- **dispatch-feature** : 4 modes, clarify → plan → waves → collect → verify
+- **qa-ruthless** : QA adversarial, min 3 findings par service
+- **cross-service-check** : cohérence inter-repos
+- **incident-debug** : diagnostic multi-couche
+- **plan-review** : sanity check du plan (haiku)
+- **merge-prep** : pré-merge, conflits, PR summaries
+- **cycle-retrospective** : capitalisation post-cycle (haiku)
+- **refresh-profiles** : relit les CLAUDE.md des repos (haiku)
+- **bootstrap-repo** : génère un CLAUDE.md pour un repo (haiku)
+
+## Règles
+1. Pas de code dans les repos — délègue aux teammates
+2. Peut écrire dans orchestrator/ (plans, workspace.md, constitution.md)
+3. Clarifie les ambiguïtés AVANT de planifier (sauf mode C)
+4. Tout plan en markdown dans \`./plans/\`
+5. Dispatch via Agent Teams (Teammate tool) en waves
+6. Constitution complète (12 principes + règles projet) dans chaque spawn prompt
+7. Standards UX injectés aux teammates frontend
+8. Chaque teammate détecte le code mort
+9. Escalade des choix archi non couverts par le plan
+10. QA impitoyable — violations UX = bloquant
+11. Compact après chaque cycle
+12. Hooks en warning uniquement — jamais bloquants
+13. Cycle rétrospective après chaque feature terminée
+`;
+}
+
+// ─── Plan template content ──────────────────────────────────
+function planTemplateContent() {
+  return `# Plan: [NOM]
+> Cree le : [DATE]
+> Statut : En cours
+
+## Contexte
+[Pourquoi cette feature]
+
+## Clarifications
+[Reponses clarify]
+
+## Services impactes
+| Service | Impacte | Branche | Teammate | Statut |
+|---------|---------|---------|----------|--------|
+| | oui/non | | | ⏳ |
+
+## Waves
+- Wave 1: [producteurs]
+- Wave 2: [consommateurs]
+- Wave 3: [infra]
+
+## Contrat API
+[Shapes exactes]
+
+## Taches
+
+### [service]
+- ⏳ [tache]
+
+## QA
+- ⏳ Cross-service check
+- ⏳ QA ruthless
+- ⏳ Merge prep
+
+## Session log
+- [DATE HH:MM] : Plan cree
+`;
+}
+
+// ─── Setup workspace ────────────────────────────────────────
+function setupWorkspace(workspacePath, projectName) {
+  const wsAbs = path.resolve(workspacePath);
+  const orchDir = path.join(wsAbs, "orchestrator");
+
+  // ── Structure ──
+  step("Creating orchestrator/");
+  mkdirp(path.join(orchDir, ".claude", "hooks"));
+  mkdirp(path.join(orchDir, "plans"));
+  mkdirp(path.join(orchDir, "templates"));
+  ok("Structure created");
+
+  // ── Templates ──
+  const templatesDir = path.join(SKILLS_DIR, "templates");
+  if (fs.existsSync(templatesDir)) {
+    for (const f of fs.readdirSync(templatesDir)) {
+      if (f.endsWith(".md")) copyFile(path.join(templatesDir, f), path.join(orchDir, "templates", f));
+    }
+    ok("Templates");
+  }
+
+  // ── workspace.md ──
+  const wsMd = path.join(orchDir, "workspace.md");
+  if (!fs.existsSync(wsMd)) {
+    const tpl = path.join(orchDir, "templates", "workspace.template.md");
+    if (fs.existsSync(tpl)) copyFile(tpl, wsMd);
+    else fs.writeFileSync(wsMd, `# Workspace: ${projectName}\n\n## Projet\n[UNCONFIGURED]\n`);
+    ok(`workspace.md ${c.dim}[UNCONFIGURED]${c.reset}`);
+  } else {
+    warn("workspace.md exists — skipped");
+  }
+
+  // ── constitution.md ──
+  const constMd = path.join(orchDir, "constitution.md");
+  if (!fs.existsSync(constMd)) {
+    const tpl = path.join(orchDir, "templates", "constitution.template.md");
+    if (fs.existsSync(tpl)) copyFile(tpl, constMd);
+    else fs.writeFileSync(constMd, [
+      `# Constitution — ${projectName}`, "",
+      "> The 12 universal principles apply automatically.",
+      "> Add project-specific rules starting at 13.", "",
+      "## Project-specific rules", "",
+      '13. **[Rule name].** [Description]', ""
+    ].join("\n"));
+    ok(`constitution.md ${c.dim}(template)${c.reset}`);
+  } else {
+    warn("constitution.md exists — skipped");
+  }
+
+  // ── Hooks ──
+  step("Installing hooks");
+  const hooksDir = path.join(orchDir, ".claude", "hooks");
+  generateBlockHook(hooksDir);
+  const hooksSrc = path.join(SKILLS_DIR, "hooks");
+  let hookCount = 1;
+  if (fs.existsSync(hooksSrc)) {
+    for (const f of fs.readdirSync(hooksSrc)) {
+      if (!f.endsWith(".sh") || f === "verify-cycle-complete.sh") continue;
+      copyFile(path.join(hooksSrc, f), path.join(hooksDir, f));
+      fs.chmodSync(path.join(hooksDir, f), 0o755);
+      hookCount++;
+    }
+  }
+  ok(`${hookCount} hooks ${c.dim}(all warning-only)${c.reset}`);
+
+  // ── Settings ──
+  generateSettings(orchDir);
+  ok(`settings.json ${c.dim}(env + hooks)${c.reset}`);
+
+  // ── CLAUDE.md ──
+  const claudeMd = path.join(orchDir, "CLAUDE.md");
+  if (!fs.existsSync(claudeMd)) {
+    fs.writeFileSync(claudeMd, claudeMdContent());
+    ok("CLAUDE.md");
+  } else {
+    warn("CLAUDE.md exists — skipped");
+  }
+
+  // ── Plan template ──
+  const planTpl = path.join(orchDir, "plans", "_TEMPLATE.md");
+  if (!fs.existsSync(planTpl)) {
+    fs.writeFileSync(planTpl, planTemplateContent());
+    ok("Plan template");
+  }
+
+  // ── .gitignore ──
+  const gi = path.join(orchDir, ".gitignore");
+  if (!fs.existsSync(gi)) {
+    fs.writeFileSync(gi, [
+      ".claude/bash-commands.log", ".claude/worktrees/", ".claude/modified-files.log",
+      "plans/*.md", "!plans/_TEMPLATE.md", "!plans/service-profiles.md", ""
+    ].join("\n"));
+    ok(".gitignore");
+  }
+
+  // ── Scan repos ──
+  step("Scanning sibling repos");
+  const repos = [];
+  const reposWithoutClaude = [];
+
+  for (const entry of fs.readdirSync(wsAbs, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name === "orchestrator") continue;
+    const repoDir = path.join(wsAbs, entry.name);
+    if (!fs.existsSync(path.join(repoDir, ".git"))) continue;
+    const type = detectProjectType(repoDir);
+    const hasClaude = fs.existsSync(path.join(repoDir, "CLAUDE.md"));
+    repos.push({ name: entry.name, type, hasClaude });
+    if (!hasClaude) reposWithoutClaude.push(entry.name);
+  }
+
+  if (repos.length === 0) {
+    info(`${c.dim}No sibling repos found${c.reset}`);
+  } else {
+    // Tree-view output
+    repos.forEach((r, i) => {
+      const isLast = i === repos.length - 1;
+      const branch = isLast ? "└──" : "├──";
+      const claudeIcon = r.hasClaude
+        ? `${c.green}CLAUDE.md ✓${c.reset}`
+        : `${c.red}CLAUDE.md ✗${c.reset}`;
+      const name = r.name.padEnd(22);
+      console.log(`    ${c.dim}${branch}${c.reset} ${c.bold}${name}${c.reset} ${typeBadge(r.type).padEnd(25)} ${claudeIcon}`);
+    });
+  }
+
+  // ── Service profiles ──
+  const profileLines = [
+    `# Service Profiles — ${projectName}`,
+    `> Generated: ${new Date().toISOString().slice(0, 10)}`,
+    "> Regenerate with `/refresh-profiles`", ""
+  ];
+  for (const r of repos) {
+    profileLines.push(`## ${r.name} (../${r.name}/)`);
+    profileLines.push(`- **Type** : ${r.type}`);
+    profileLines.push(`- **CLAUDE.md** : ${r.hasClaude ? "present" : "ABSENT — /bootstrap-repo"}`);
+    profileLines.push("");
+  }
+  fs.writeFileSync(path.join(orchDir, "plans", "service-profiles.md"), profileLines.join("\n"));
+
+  // ── Final summary ──
+  log("");
+  log(`${c.green}${c.bold}  ══════════════════════════════════════════════════${c.reset}`);
+  log(`${c.green}${c.bold}   Ready!${c.reset} ${c.dim}Orchestrator v${PKG.version}${c.reset}`);
+  log(`${c.green}${c.bold}  ══════════════════════════════════════════════════${c.reset}`);
+  log("");
+  log(`  ${c.dim}Directory${c.reset}  ${orchDir}`);
+  log(`  ${c.dim}Repos${c.reset}      ${repos.length} detected`);
+  log(`  ${c.dim}Hooks${c.reset}      ${hookCount} scripts`);
+  log(`  ${c.dim}Skills${c.reset}     9 ${c.dim}(~/.claude/skills/)${c.reset}`);
+  log("");
+  log(`  ${c.bold}Next steps:${c.reset}`);
+  log(`    ${c.cyan}cd orchestrator/${c.reset}`);
+  log(`    ${c.cyan}claude --agent workspace-init${c.reset}   ${c.dim}# first time: diagnostic + config${c.reset}`);
+  log(`    ${c.cyan}claude --agent team-lead${c.reset}        ${c.dim}# orchestration sessions${c.reset}`);
+  if (reposWithoutClaude.length > 0) {
+    log("");
+    warn(`${reposWithoutClaude.length} repo(s) without CLAUDE.md: ${c.bold}${reposWithoutClaude.join(", ")}${c.reset}`);
+    info(`workspace-init can generate them`);
+  }
+  log("");
+}
+
+// ─── Doctor ─────────────────────────────────────────────────
+function doctor() {
+  log(BANNER_SMALL);
+  step("Diagnostic");
+
+  const checks = [];
+  function check(name, isOk, detail) {
+    checks.push({ name, ok: isOk, detail });
+    isOk ? ok(name) : fail(`${name} — ${detail}`);
+  }
+
+  // Version
+  const installed = readVersion();
+  check("Installed version",
+    installed === PKG.version,
+    installed ? `v${installed} (package is v${PKG.version})` : "not installed — run: npx cc-workspace update"
+  );
+
+  // Global dirs
+  check("~/.claude/skills/", fs.existsSync(GLOBAL_SKILLS), "missing");
+  check("~/.claude/rules/", fs.existsSync(GLOBAL_RULES), "missing");
+  check("~/.claude/agents/", fs.existsSync(GLOBAL_AGENTS), "missing");
+
+  // Skills count
+  if (fs.existsSync(GLOBAL_SKILLS)) {
+    const skills = fs.readdirSync(GLOBAL_SKILLS, { withFileTypes: true }).filter(e => e.isDirectory());
+    check(`Skills (${skills.length}/9)`, skills.length >= 9, `only ${skills.length} found`);
+  }
+
+  // Rules
+  for (const r of ["constitution-en.md", "context-hygiene.md", "model-routing.md"]) {
+    check(`Rule: ${r}`, fs.existsSync(path.join(GLOBAL_RULES, r)), "missing");
+  }
+
+  // Agents
+  for (const a of ["team-lead.md", "implementer.md", "workspace-init.md"]) {
+    check(`Agent: ${a}`, fs.existsSync(path.join(GLOBAL_AGENTS, a)), "missing");
+  }
+
+  // jq
+  let jqOk = false;
+  try { execSync("jq --version", { stdio: "pipe" }); jqOk = true; } catch {}
+  check("jq installed", jqOk, "required for hooks — brew install jq");
+
+  // Local orchestrator/ check
+  const cwd = process.cwd();
+  const orchDir = path.join(cwd, "orchestrator");
+  const inOrch = fs.existsSync(path.join(cwd, "workspace.md"));
+  const hasOrch = fs.existsSync(orchDir);
+
+  if (inOrch) {
+    step("Local workspace (inside orchestrator/)");
+    check("workspace.md", true, "");
+    check("constitution.md", fs.existsSync(path.join(cwd, "constitution.md")), "missing");
+    check("plans/", fs.existsSync(path.join(cwd, "plans")), "missing");
+    check("templates/", fs.existsSync(path.join(cwd, "templates")), "missing");
+    check(".claude/hooks/", fs.existsSync(path.join(cwd, ".claude", "hooks")), "missing");
+    const configured = !fs.readFileSync(path.join(cwd, "workspace.md"), "utf8").includes("[UNCONFIGURED]");
+    check("workspace.md configured", configured, "[UNCONFIGURED] — run: claude --agent workspace-init");
+  } else if (hasOrch) {
+    step("Local workspace (orchestrator/ found)");
+    check("orchestrator/workspace.md", fs.existsSync(path.join(orchDir, "workspace.md")), "missing — run init");
+  } else {
+    log(`\n  ${c.dim}No orchestrator/ found in cwd.${c.reset}`);
+  }
+
+  // Summary
+  const failed = checks.filter(x => !x.ok);
+  log("");
+  hr();
+  if (failed.length === 0) {
+    log(`  ${c.bgGreen} ALL CHECKS PASSED ${c.reset}`);
+  } else {
+    log(`  ${c.bgRed} ${failed.length} ISSUE(S) FOUND ${c.reset}`);
+  }
+  log("");
+}
+
+// ─── CLI ────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+const command = args[0];
+
+switch (command) {
+  case "init": {
+    const workspace = args[1] || ".";
+    const name = args[2] || "Mon Projet";
+    log(BANNER);
+    installGlobals(false);
+    setupWorkspace(workspace, name);
+    break;
+  }
+
+  case "update": {
+    const force = args.includes("--force");
+    log(BANNER);
+    const updated = installGlobals(force);
+    if (!updated) {
+      log(`\n  ${c.dim}Already up to date. Use --force to reinstall.${c.reset}\n`);
+    } else {
+      log(`\n  ${c.green}${c.bold}Update complete.${c.reset}\n`);
+    }
+    break;
+  }
+
+  case "doctor": {
+    doctor();
+    break;
+  }
+
+  case "version":
+  case "--version":
+  case "-v": {
+    const installed = readVersion();
+    log(`${c.cyan}${c.bold}cc-workspace${c.reset} v${PKG.version}`);
+    if (installed && installed !== PKG.version) {
+      log(`  ${c.dim}installed globals: v${installed}${c.reset}`);
+    }
+    break;
+  }
+
+  case "help":
+  case "--help":
+  case "-h":
+  case undefined: {
+    log(BANNER);
+    log(`  ${c.bold}Usage:${c.reset}`);
+    log("");
+    log(`    ${c.cyan}npx cc-workspace init${c.reset} ${c.dim}[path] ["Project Name"]${c.reset}`);
+    log(`      Setup orchestrator/ in the target workspace.`);
+    log(`      Installs global skills/rules/agents if version is newer.`);
+    log("");
+    log(`    ${c.cyan}npx cc-workspace update${c.reset} ${c.dim}[--force]${c.reset}`);
+    log(`      Update global components to this package version.`);
+    log("");
+    log(`    ${c.cyan}npx cc-workspace doctor${c.reset}`);
+    log(`      Check all components are installed and consistent.`);
+    log("");
+    log(`    ${c.cyan}npx cc-workspace version${c.reset}`);
+    log(`      Show package and installed versions.`);
+    log("");
+    hr();
+    log(`  ${c.bold}After init:${c.reset}`);
+    log(`    ${c.cyan}cd orchestrator/${c.reset}`);
+    log(`    ${c.cyan}claude --agent workspace-init${c.reset}   ${c.dim}# first time${c.reset}`);
+    log(`    ${c.cyan}claude --agent team-lead${c.reset}        ${c.dim}# work sessions${c.reset}`);
+    log("");
+    break;
+  }
+
+  default: {
+    fail(`Unknown command: ${command}`);
+    log(`  Run: ${c.cyan}npx cc-workspace --help${c.reset}`);
+    process.exit(1);
+  }
+}