@fernado03/zoo-flow 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zoo Flow contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,326 @@
+# Zoo Flow
+
+> **Smoke-tested workflow control plane for Zoo Code.**
+
+Zoo Flow is a small, opinionated template that turns [Zoo Code](https://docs.zoocode.dev/)
+into a predictable mode + command + skill orchestrator. It defines three
+modes, a fixed routing matrix, a command protocol, and path-safety rules.
+Drop it into a workspace and your AI assistant stops freelancing.
+
+## Why this exists
+
+Out of the box, AI coding assistants tend to skip planning when you want
+planning, plan when you want a tweak, and quietly invent file paths that do
+not exist. Adding a pile of skills makes it worse.
+
+Zoo Flow takes a different bet:
+
+- A **router mode** chooses the workflow.
+- An **architect mode** plans, diagnoses, and triages — and cannot edit
+  source code.
+- A **tweaker mode** implements, runs tests, prototypes, and commits — only
+  when explicitly approved.
+- A small set of **slash commands** acts as the public API between you and
+  the modes.
+- A few **always-on rules** keep the path layout honest and stop skill paths
+  from drifting under `.roo/rules/`.
+
+Everything else is optional. The skills bundled in the template are a
+sensible starting point, not the point of the project.
+
+## Why are the folders still named `.roo/`?
+
+Zoo Code keeps compatibility with Roo-style workspace paths. Project
+modes still live in `.roomodes`, project slash commands still live in
+`.roo/commands/`, and mode-specific rules still live in
+`.roo/rules-{mode-slug}/`.
+
+Zoo Flow uses Zoo Code as the primary target, but keeps those `.roo/`
+paths because they are the official Zoo Code configuration paths. See
+[the Zoo Code docs](https://docs.zoocode.dev/) for the canonical
+reference.
+
+Zoo Flow keeps skill discovery in [`docs/skills-index.md`](docs/skills-index.md),
+not `.roo/rules/`, so the always-loaded rule set stays small. Zoo Code
+loads everything in `.roo/rules/` on every turn, so that folder only
+contains rules needed every turn: path safety, the command protocol,
+and the manual-reply protocol.
+
+## Core workflow
+
+```mermaid
+flowchart TD
+    User([User])
+    Orchestrator[🪃 custom-orchestrator<br/>router only]
+    Architect[🏗️ system-architect<br/>plan / diagnose / triage<br/>Markdown edits only]
+    Tweaker[⚡ code-tweaker<br/>implement / test / prototype / commit]
+
+    User -- "free-form request" --> Orchestrator
+    Orchestrator -- "proposes /command, waits" --> User
+    User -- "/tweak, /tdd, /update-docs,<br/>/commit-and-document, /prototype" --> Orchestrator
+    User -- "/fix, /feature, /refactor,<br/>/explore, /triage" --> Orchestrator
+
+    Orchestrator -- "new_task" --> Tweaker
+    Orchestrator -- "new_task" --> Architect
+
+    Architect -- "switch_mode (same window)" --> Tweaker
+    Tweaker -- "switch_mode (same window)" --> Architect
+
+    Tweaker -- "attempt_completion" --> Orchestrator
+    Architect -- "attempt_completion" --> Orchestrator
+    Orchestrator -- "summarize, HALT" --> User
+```
+
+## Modes
+
+| Slug                  | Name                  | Role                                                       | Edits allowed                                  | Delegation                                  |
+| --------------------- | --------------------- | ---------------------------------------------------------- | ---------------------------------------------- | ------------------------------------------- |
+| `custom-orchestrator` | 🪃 Custom Orchestrator | Router. Picks workflow, delegates, waits for the user.     | None                                           | `new_task` to architect or tweaker          |
+| `system-architect`    | 🏗️ System Architect   | Planning, diagnosis, refactor design, exploration, triage. | Markdown, `.scratch/`, `docs/`                 | `switch_mode` to tweaker in same window     |
+| `code-tweaker`        | ⚡ Code Tweaker        | Implementation, TDD, docs updates, prototypes, commits.    | Full repo edits within the assigned command    | `switch_mode` to architect in same window   |
+
+Modes are defined in [`templates/full/.roomodes`](templates/full/.roomodes).
+The file is intentionally minimal — each mode's `customInstructions`
+points at the matching `.roo/rules-{modeSlug}/` folder, where the actual
+behavior lives. See [`docs/mode-rules.md`](docs/mode-rules.md) for the
+layout and the rationale.
+
+> Zoo Flow uses the preferred `.roo/rules-{modeSlug}/` directory form
+> only. Legacy single-file fallbacks such as `.roorules-{modeSlug}` and
+> `.clinerules-{modeSlug}` are not used by this template.
+
+## Commands
+
+The orchestrator's routing matrix only routes the **core workflow
+commands**. Helper commands are still part of the template — you can run
+them directly in `system-architect` or `code-tweaker` when you need
+them. They are intentionally outside the routing matrix so the
+orchestrator stays focused on the workflows that benefit from
+delegation.
+
+### Core commands (routed by the orchestrator)
+
+| Command                  | Routes to            | What it does                                                |
+| ------------------------ | -------------------- | ----------------------------------------------------------- |
+| `/tweak`                 | `code-tweaker`       | Direct implementation of small, known changes.              |
+| `/tdd`                   | `code-tweaker`       | Test-first implementation loop.                             |
+| `/prototype`             | `code-tweaker`       | Throwaway prototype to settle a design uncertainty.         |
+| `/update-docs`           | `code-tweaker`       | Reconcile docs with code reality.                           |
+| `/commit-and-document`   | `code-tweaker`       | Stage, message, commit, journal — pauses for approval.      |
+| `/fix`                   | `system-architect`   | Diagnose → implement → post-mortem chain.                   |
+| `/feature`               | `system-architect`   | Sharpen → optional prototype → PRD → issues → TDD chain.    |
+| `/refactor`              | `system-architect`   | Plan and stage architecture changes.                        |
+| `/explore`               | `system-architect`   | Map unfamiliar code before touching it.                     |
+| `/triage`                | `system-architect`   | Clean and prioritize an issue queue.                        |
+
+### Helper commands (run directly when needed)
+
+| Command                          | Best run in          | What it does                                                |
+| -------------------------------- | -------------------- | ----------------------------------------------------------- |
+| `/diagnose`                      | `system-architect`   | Standalone diagnosis loop with HITL checkpoints.            |
+| `/grill-with-docs`               | `system-architect`   | Sharpen a feature spec via QA against current docs.         |
+| `/improve-codebase-architecture` | `system-architect`   | Generate a deep architecture review report.                 |
+| `/to-prd`                        | `system-architect`   | Turn sharpened context into a PRD.                          |
+| `/to-issues`                     | `system-architect`   | Slice a PRD into issues.                                    |
+| `/zoom-out`                      | `system-architect`   | Pull back to architectural altitude.                        |
+| `/handoff`                       | either               | Produce a clean handoff package for another agent or human. |
+| `/grill-me`                      | either               | Adversarial Q&A to sharpen an idea.                         |
+| `/caveman`                       | either               | Ultra-compressed communication mode.                        |
+| `/write-a-skill`                 | `code-tweaker`       | Author a new skill following the bucket layout.             |
+| `/setup-matt-pocock-skills`      | `code-tweaker`       | One-shot setup helper for the bundled skill set.            |
+
+The full routing matrix lives in the orchestrator's `customInstructions`
+inside [`templates/full/.roomodes`](templates/full/.roomodes). The command
+files themselves live in
+[`templates/full/.roo/commands/`](templates/full/.roo/commands).
+
+## Install
+
+Run this from the root of the project where you use Zoo Code:
+
+```bash
+npx @fernado03/zoo-flow@latest init
+```
+
+If the project already has `.roomodes` or `.roo/`, Zoo Flow will stop
+instead of overwriting.
+
+To back up and overwrite existing config:
+
+```bash
+npx @fernado03/zoo-flow@latest init --force
+```
+
+Zoo Flow installs only the runtime template:
+
+- `.roomodes`
+- `.roo/`
+
+It does not copy this repository's `docs/` folder into your project.
+
+> Zoo Flow overwrites `.roomodes` and `.roo/` only when you pass
+> `--force` or run `update`. It always creates a backup in
+> `.zoo-flow-backup/<timestamp>/`.
+
+After install, reload VS Code:
+
+> Command Palette → **Developer: Reload Window**
+
+Then open Zoo Code, switch to `custom-orchestrator`, and run the smoke
+test:
+
+> change a harmless comment in `README`
+
+When choices appear, manually type the number, e.g. `1`. Do not click
+suggestions that contain slash commands or mode names. See
+[`docs/troubleshooting.md`](docs/troubleshooting.md#clickable-suggestions-can-route-incorrectly).
+
+## Quick start
+
+```bash
+npx @fernado03/zoo-flow@latest init
+```
+
+Then reload VS Code and run this in `custom-orchestrator`:
+
+> change a harmless comment in `README`
+
+When choices appear, type the number manually, for example `1`.
+
+## Manual install
+
+If you would rather copy the template by hand:
+
+### macOS / Linux
+
+```sh
+git clone https://github.com/Fernado03/zoo-flow.git /tmp/zoo-flow
+cp /tmp/zoo-flow/templates/full/.roomodes .
+cp -R /tmp/zoo-flow/templates/full/.roo .
+```
+
+### Windows (PowerShell)
+
+```powershell
+git clone https://github.com/Fernado03/zoo-flow.git C:\Temp\zoo-flow
+Copy-Item C:\Temp\zoo-flow\templates\full\.roomodes .
+Copy-Item -Recurse C:\Temp\zoo-flow\templates\full\.roo .
+```
+
+After copying:
+
+1. Open the project in an editor running Zoo Code.
+2. Confirm the three custom modes appear: `🪃 Custom Orchestrator`,
+   `🏗️ System Architect`, `⚡ Code Tweaker`.
+3. Switch to `custom-orchestrator` and start a new task.
+
+If a slash command does not run, see
+[`docs/troubleshooting.md`](docs/troubleshooting.md).
+
+## Update Zoo Flow
+
+Run this from your project root:
+
+```bash
+npx @fernado03/zoo-flow@latest update
+```
+
+Zoo Flow backs up your current runtime config before replacing it:
+
+- `.roomodes`
+- `.roo/`
+
+Backups are stored in:
+
+```text
+.zoo-flow-backup/<timestamp>/
+```
+
+Preview without changing files:
+
+```bash
+npx @fernado03/zoo-flow@latest update --dry-run
+```
+
+Zoo Flow does not copy this repository's `docs/` folder into your
+project.
+
+## Smoke tests
+
+The repo ships a fixed set of smoke tests in
+[`docs/smoke-tests.md`](docs/smoke-tests.md). They are short scripts you can
+run by hand inside Zoo Code to verify routing, mode boundaries,
+and skill loading. The first one — README tweak with no slash command —
+takes about a minute.
+
+When the orchestrator asks which workflow to use, **type the number
+manually**, for example `1`. Do not click suggestions that contain slash
+commands or mode names — clicking them can route incorrectly. See
+[`docs/troubleshooting.md`](docs/troubleshooting.md#clickable-suggestions-can-route-incorrectly).
+
+Example choice list:
+
+```text
+1. /tweak — small known implementation change
+2. /update-docs — documentation-focused change
+3. Hold — I will specify more detail
+
+Reply by typing only the number, e.g. 1.
+```
+
+Worked examples for the most common flows live in
+[`examples/`](examples/):
+
+- [`tweak-smoke-test.md`](examples/tweak-smoke-test.md)
+- [`fix-flow.md`](examples/fix-flow.md)
+- [`feature-flow.md`](examples/feature-flow.md)
+
+## Screenshots
+
+Screenshots and short clips of the orchestrator routing, the architect
+hand-off, and the tweaker running a slash command will land in
+[`assets/`](assets/) before the first tagged release.
+
+## Roadmap
+
+- `templates/minimal/` — a stripped-down template with only the three modes,
+  the path-safety rules, and `/tweak` + `/fix`.
+- Optional CI workflow that runs the smoke-test JSON validation on every
+  PR.
+- A short demo video in `assets/`.
+- ADRs covering the three-mode split, the routing matrix, and the
+  path-safety choice.
+- Guidance on integrating Zoo Flow alongside other workflow tools.
+
+## How this is different
+
+Zoo Flow is not a methodology and it is not a giant skills pack. It is a
+**Zoo-native control plane**: a thin layer that turns three modes,
+a routing matrix, and a path-safety contract into a predictable workflow.
+
+For a longer comparison with adjacent projects, see
+[`docs/comparison.md`](docs/comparison.md).
+
+## Migration note
+
+Zoo Flow started as a Roo Flow template and was renamed for Zoo Code.
+The `.roo/` folder names are intentionally preserved because Zoo Code
+still uses those paths for project modes, commands, rules, and skills.
+If you are migrating from a Roo Code workspace, copying the same
+`.roo/` directory and `.roomodes` file into a Zoo Code workspace is
+expected to keep working.
+
+## Inspiration
+
+This project was inspired by Matt Pocock's agent-skills workflow ideas
+and his emphasis on small, composable, task-focused skills for coding
+agents.
+
+Zoo Flow is not affiliated with, endorsed by, or maintained by Matt
+Pocock. It is an independent Zoo Code workflow-control template
+focused on custom modes, delegation, command routing, and smoke-tested
+agent workflows.
+
+## License
+
+[MIT](LICENSE).

package/bin/zoo-flow.js

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, "..");
+const templateRoot = path.join(packageRoot, "templates", "full");
+
+const command = process.argv[2];
+
+const HELP = `
+Zoo Flow
+
+Usage:
+  npx @fernado03/zoo-flow@latest init
+  npx @fernado03/zoo-flow@latest init --force
+  npx @fernado03/zoo-flow@latest update
+  npx @fernado03/zoo-flow@latest update --dry-run
+  npx @fernado03/zoo-flow@latest update --force
+  npx @fernado03/zoo-flow@latest doctor --template-only
+
+Commands:
+  init              Install Zoo Flow into the current project
+  update            Back up current config and copy the latest template
+  doctor            Validate the bundled template
+
+Options:
+  --force           Overwrite existing .roomodes and .roo after backup
+  --dry-run         Print what update would do without changing files
+  --template-only   Validate this package's template instead of current project
+`;
+
+function exitWithError(message) {
+  console.error(`\nError: ${message}\n`);
+  process.exit(1);
+}
+
+function pathExists(targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+function copyRecursive(src, dest) {
+  if (!pathExists(src)) {
+    throw new Error(`Missing source: ${src}`);
+  }
+
+  const stat = fs.statSync(src);
+
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+
+    for (const entry of fs.readdirSync(src)) {
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function removeRecursive(targetPath) {
+  if (!pathExists(targetPath)) return;
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+
+function backupIfExists(projectRoot, backupDir, relativePath) {
+  const src = path.join(projectRoot, relativePath);
+
+  if (!pathExists(src)) {
+    return false;
+  }
+
+  const dest = path.join(backupDir, relativePath);
+  copyRecursive(src, dest);
+  return true;
+}
+
+function makeTimestamp() {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw new Error(`Invalid JSON: ${filePath}\n${error.message}`);
+  }
+}
+
+function walkFiles(rootDir) {
+  const files = [];
+
+  function walk(current) {
+    if (!pathExists(current)) return;
+
+    const stat = fs.statSync(current);
+
+    if (stat.isDirectory()) {
+      for (const entry of fs.readdirSync(current)) {
+        if (entry === ".git" || entry === "node_modules") continue;
+        walk(path.join(current, entry));
+      }
+      return;
+    }
+
+    files.push(current);
+  }
+
+  walk(rootDir);
+  return files;
+}
+
+function validateTemplate(rootDir) {
+  const roomodesPath = path.join(rootDir, ".roomodes");
+  const rooDir = path.join(rootDir, ".roo");
+  const commandsDir = path.join(rooDir, "commands");
+  const skillsDir = path.join(rooDir, "skills");
+  const rulesDir = path.join(rooDir, "rules");
+
+  const failures = [];
+
+  if (!pathExists(roomodesPath)) failures.push("Missing .roomodes");
+  if (!pathExists(rooDir)) failures.push("Missing .roo/");
+  if (!pathExists(commandsDir)) failures.push("Missing .roo/commands/");
+  if (!pathExists(skillsDir)) failures.push("Missing .roo/skills/");
+  if (!pathExists(rulesDir)) failures.push("Missing .roo/rules/");
+
+  if (pathExists(roomodesPath)) {
+    try {
+      const parsed = readJson(roomodesPath);
+      if (!Array.isArray(parsed.customModes)) {
+        failures.push(".roomodes must contain customModes array");
+      }
+    } catch (error) {
+      failures.push(error.message);
+    }
+  }
+
+  const allFiles = walkFiles(rootDir);
+  const textFileExtensions = new Set([".md", ".json", ".txt", ".yaml", ".yml"]);
+
+  for (const file of allFiles) {
+    const ext = path.extname(file);
+    if (!textFileExtensions.has(ext)) continue;
+
+    const text = fs.readFileSync(file, "utf8");
+
+    const badPatterns = [
+      ".roo/skills///SKILL.md",
+      ".roo/commands/.md",
+      "your-org/roo-flow",
+      ".zoo/"
+    ];
+
+    for (const pattern of badPatterns) {
+      if (text.includes(pattern)) {
+        failures.push(`Bad pattern "${pattern}" in ${path.relative(rootDir, file)}`);
+      }
+    }
+  }
+
+  const requiredRules = [
+    ".roo/rules/00-paths.md",
+    ".roo/rules/01-command-protocol.md",
+    ".roo/rules/03-manual-reply-protocol.md"
+  ];
+
+  for (const rule of requiredRules) {
+    if (!pathExists(path.join(rootDir, rule))) {
+      failures.push(`Missing required global rule: ${rule}`);
+    }
+  }
+
+  const requiredModeRules = [
+    ".roo/rules-code-tweaker",
+    ".roo/rules-system-architect",
+    ".roo/rules-custom-orchestrator"
+  ];
+
+  for (const ruleDir of requiredModeRules) {
+    if (!pathExists(path.join(rootDir, ruleDir))) {
+      failures.push(`Missing mode rule folder: ${ruleDir}`);
+    }
+  }
+
+  return failures;
+}
+
+function install() {
+  const args = new Set(process.argv.slice(3));
+  const force = args.has("--force");
+  const projectRoot = process.cwd();
+
+  const sourceRoomodes = path.join(templateRoot, ".roomodes");
+  const sourceRoo = path.join(templateRoot, ".roo");
+
+  if (!pathExists(sourceRoomodes) || !pathExists(sourceRoo)) {
+    exitWithError("Bundled template is missing templates/full/.roomodes or templates/full/.roo/");
+  }
+
+  const targetRoomodes = path.join(projectRoot, ".roomodes");
+  const targetRoo = path.join(projectRoot, ".roo");
+  const hasExistingConfig = pathExists(targetRoomodes) || pathExists(targetRoo);
+
+  if (hasExistingConfig && !force) {
+    console.log(`
+Zoo Flow found existing config in this project.
+
+Existing:
+${pathExists(targetRoomodes) ? "  - .roomodes\n" : ""}${pathExists(targetRoo) ? "  - .roo/\n" : ""}
+Run again with --force to back up and overwrite:
+
+  npx @fernado03/zoo-flow@latest init --force
+`);
+    process.exit(0);
+  }
+
+  const backupDir = path.join(projectRoot, ".zoo-flow-backup", makeTimestamp());
+  let didBackup = false;
+
+  if (hasExistingConfig) {
+    fs.mkdirSync(backupDir, { recursive: true });
+    didBackup = backupIfExists(projectRoot, backupDir, ".roomodes") || didBackup;
+    didBackup = backupIfExists(projectRoot, backupDir, ".roo") || didBackup;
+
+    removeRecursive(targetRoomodes);
+    removeRecursive(targetRoo);
+  }
+
+  copyRecursive(sourceRoomodes, targetRoomodes);
+  copyRecursive(sourceRoo, targetRoo);
+
+  console.log(`
+Zoo Flow installed.
+
+Copied:
+  - .roomodes
+  - .roo/
+
+${didBackup ? `Backup:\n  ${backupDir}\n` : ""}Next:
+  1. Reload VS Code
+  2. Open Zoo Code
+  3. Switch to custom-orchestrator
+  4. Smoke test:
+       change a harmless comment in README
+
+When workflow choices appear, type the number manually, e.g. 1.
+`);
+}
+
+function doctor() {
+  const args = new Set(process.argv.slice(3));
+  const rootToCheck = args.has("--template-only") ? templateRoot : process.cwd();
+  const failures = validateTemplate(rootToCheck);
+
+  if (failures.length > 0) {
+    console.error("\nZoo Flow doctor found problems:\n");
+    for (const failure of failures) {
+      console.error(`- ${failure}`);
+    }
+    console.error("");
+    process.exit(1);
+  }
+
+  console.log(`Zoo Flow doctor passed: ${rootToCheck}`);
+}
+
+function update() {
+  const args = new Set(process.argv.slice(3));
+  const dryRun = args.has("--dry-run");
+  const projectRoot = process.cwd();
+
+  const sourceRoomodes = path.join(templateRoot, ".roomodes");
+  const sourceRoo = path.join(templateRoot, ".roo");
+
+  if (!pathExists(sourceRoomodes) || !pathExists(sourceRoo)) {
+    exitWithError("Bundled template is missing templates/full/.roomodes or templates/full/.roo/");
+  }
+
+  const targetRoomodes = path.join(projectRoot, ".roomodes");
+  const targetRoo = path.join(projectRoot, ".roo");
+  const hasRoomodes = pathExists(targetRoomodes);
+  const hasRoo = pathExists(targetRoo);
+
+  if (!hasRoomodes && !hasRoo) {
+    console.log(`
+Zoo Flow is not installed in this project yet.
+
+Run:
+  npx @fernado03/zoo-flow@latest init
+`);
+    process.exit(0);
+  }
+
+  if (dryRun) {
+    console.log(`
+Zoo Flow update dry run.
+
+Would back up:
+${hasRoomodes ? "  - .roomodes\n" : ""}${hasRoo ? "  - .roo/\n" : ""}
+Would replace with latest template:
+  - .roomodes
+  - .roo/
+
+Run this to update:
+  npx @fernado03/zoo-flow@latest update
+`);
+    process.exit(0);
+  }
+
+  const backupDir = path.join(projectRoot, ".zoo-flow-backup", makeTimestamp());
+  fs.mkdirSync(backupDir, { recursive: true });
+
+  let didBackup = false;
+  didBackup = backupIfExists(projectRoot, backupDir, ".roomodes") || didBackup;
+  didBackup = backupIfExists(projectRoot, backupDir, ".roo") || didBackup;
+
+  removeRecursive(targetRoomodes);
+  removeRecursive(targetRoo);
+
+  copyRecursive(sourceRoomodes, targetRoomodes);
+  copyRecursive(sourceRoo, targetRoo);
+
+  console.log(`
+Zoo Flow updated.
+
+Replaced:
+  - .roomodes
+  - .roo/
+
+${didBackup ? `Backup:\n  ${backupDir}\n\nTo restore the previous config:\n  rm -rf .roomodes .roo\n  cp -R ${backupDir}/. .\n` : ""}
+Next:
+  1. Reload VS Code
+  2. Open Zoo Code
+  3. Confirm the three custom modes still appear
+`);
+}
+
+if (!command || command === "--help" || command === "-h") {
+  console.log(HELP);
+  process.exit(0);
+}
+
+if (command === "init") {
+  install();
+} else if (command === "update") {
+  update();
+} else if (command === "doctor") {
+  doctor();
+} else {
+  console.log(HELP);
+  process.exit(1);
+}