dojocho 1.0.0

package/dist/index.js

@@ -0,0 +1,1464 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import {
+  CLI,
+  DOJOS_DIR,
+  ManifestValidationError,
+  validateManifest,
+  parseManifest,
+  defineConfig,
+  resolveConfig,
+  loadConfig,
+  validateDojoRc,
+  findProjectRoot,
+  readDojoRc,
+  writeDojoRc,
+  readCatalog,
+  dojoDir,
+  readDojoMd,
+  katasPath,
+  resolveKata,
+  resolveAllKatas,
+  listDojos
+} from "@dojocho/config";
+
+// src/commands/root.ts
+import { existsSync as existsSync2, writeFileSync } from "fs";
+import { resolve, relative } from "path";
+
+// src/state.ts
+import { existsSync } from "fs";
+function kataState(kata2, progress) {
+  if (progress?.completed.includes(kata2.name)) return "completed";
+  return existsSync(kata2.workspacePath) ? "ongoing" : "not-started";
+}
+function findCurrentKata(katas, current) {
+  if (current) {
+    const found = katas.find((k) => k.name === current);
+    if (found && existsSync(found.workspacePath)) return found;
+  }
+  return katas.find((k) => existsSync(k.workspacePath)) ?? null;
+}
+function findNextKata(katas, progress) {
+  return katas.find((k) => {
+    if (progress?.completed.includes(k.name)) return false;
+    return !existsSync(k.workspacePath);
+  }) ?? null;
+}
+function completedCount(katas, progress) {
+  if (progress) {
+    return katas.filter((k) => progress.completed.includes(k.name)).length;
+  }
+  return 0;
+}
+function findKataByIdOrName(katas, query) {
+  const byName = katas.find((k) => k.name === query);
+  if (byName) return byName;
+  const padded = query.padStart(3, "0");
+  return katas.find((k) => k.name.startsWith(padded + "-")) ?? null;
+}
+
+// src/agent.ts
+var RUNTIMES = [
+  { envVar: "CLAUDECODE", runtime: { name: "claude", askTool: "AskUserQuestion" } },
+  { envVar: "OPENCODE", runtime: { name: "opencode", askTool: "question" } },
+  { envVar: "GEMINI_CLI", runtime: { name: "gemini", askTool: "ask_user" } }
+];
+var FALLBACK = { name: "unknown", askTool: "AskUserQuestion or similar tool" };
+function detectRuntime() {
+  for (const { envVar, runtime } of RUNTIMES) {
+    if (process.env[envVar]) return runtime;
+  }
+  return FALLBACK;
+}
+function askTool() {
+  return detectRuntime().askTool;
+}
+
+// src/format.ts
+function invokeAsk(variant) {
+  const tool = askTool();
+  const formatted = tool.includes(" ") ? tool : `\`${tool}\``;
+  return variant ? `Invoke ${formatted} (${variant})` : `Invoke ${formatted}`;
+}
+function status(fields) {
+  const body = Object.entries(fields).map(([k, v]) => `${k}: ${v}`).join("\n");
+  return `<dojo:status>
+${body}
+</dojo:status>`;
+}
+function sensei(content) {
+  return `<dojo:sensei>
+${content}
+</dojo:sensei>`;
+}
+function prompt(content) {
+  return `<dojo:prompt>
+${content}
+</dojo:prompt>`;
+}
+function learnings(content) {
+  return `<dojo:learnings>
+${content}
+</dojo:learnings>`;
+}
+
+// src/commands/root.ts
+var USAGE = `Usage: ${CLI} <command> [flags]
+
+Commands:
+  (none)              Project-level actions (use flags below)
+  kata                Kata-level actions (sensei, check, scaffold)
+  intro               Show the active dojo's introduction
+  status              Show current dojo/kata state
+  setup [--agent]     Set up a new dojo project and configure agents
+  add <source>        Add a dojo (training pack)
+  remove <name>       Remove a dojo
+
+Flags:
+  --test/--check      Show overall progress
+  --list              List installed dojos
+  --open              Print the active DOJO.md
+  --change <dojo>     Switch active dojo`;
+function root(rootDir, args2) {
+  const flag = args2.find((a) => a.startsWith("--"));
+  if (!flag) {
+    console.log(USAGE);
+    return;
+  }
+  switch (flag) {
+    case "--check":
+    case "--test":
+      check(rootDir);
+      break;
+    case "--list":
+      list(rootDir);
+      break;
+    case "--open":
+      open(rootDir);
+      break;
+    case "--change": {
+      const name = args2[args2.indexOf("--change") + 1];
+      if (!name) throw new Error("Usage: dojo --change <dojo>");
+      change(rootDir, name);
+      break;
+    }
+    case "--help":
+    case "-h":
+      console.log(USAGE);
+      break;
+    default:
+      throw new Error(`Unknown flag: ${flag}
+
+${USAGE}`);
+  }
+}
+function check(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const progress = rc.progress?.[rc.currentDojo];
+  const current = findCurrentKata(katas, rc.currentKata);
+  const completed = completedCount(katas, progress);
+  const total = katas.length;
+  if (!current) {
+    const next = findNextKata(katas, progress);
+    if (next) {
+      console.log(`${completed}/${total} katas complete. No kata in progress.`);
+      console.log(prompt(`${invokeAsk()} to ask the student:
+- "Start next kata" (Begin the next kata in sequence) \u2192 run: ${CLI} kata --start
+- "Pick a kata" (Browse and choose a specific kata) \u2192 run: ${CLI} kata --list`));
+    } else {
+      console.log(`All ${total} katas complete. The dojo is finished.`);
+    }
+    return;
+  }
+  const workspaceRel = relative(root2, current.workspacePath);
+  console.log(`Kata: ${current.name} (in progress)
+${completed}/${total} complete | Workspace: ${workspaceRel}`);
+  console.log(prompt(`${invokeAsk()} to ask the student:
+- "Check progress" \u2192 run: ${CLI} kata --check
+- "Keep working" \u2192 encourage them
+- "Switch kata" \u2192 run: ${CLI} kata --list`));
+}
+function list(root2) {
+  const rc = readDojoRc(root2);
+  const dojos = listDojos(root2);
+  if (dojos.length === 0) {
+    console.log(`No dojos installed. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  console.log("Dojos:\n");
+  for (const name of dojos) {
+    const marker = name === rc.currentDojo ? "[*]" : "[ ]";
+    console.log(`  ${marker} ${name}`);
+  }
+}
+function open(root2) {
+  const rc = readDojoRc(root2);
+  const md = readDojoMd(root2, rc.currentDojo);
+  if (md) {
+    console.log(md);
+  } else {
+    console.log("No DOJO.md found. Run `dojo setup` first.");
+  }
+}
+function change(root2, name) {
+  const dojos = listDojos(root2);
+  if (!dojos.includes(name)) {
+    throw new Error(`Dojo "${name}" not found. Available: ${dojos.join(", ") || "(none)"}`);
+  }
+  const rc = readDojoRc(root2);
+  rc.currentDojo = name;
+  rc.currentKata = null;
+  writeDojoRc(root2, rc);
+  const dojoTsconfigPath = resolve(root2, DOJOS_DIR, name, "tsconfig.json");
+  if (existsSync2(dojoTsconfigPath)) {
+    const config = loadConfig(root2);
+    const katasInclude = `${relative(root2, config.katasPath)}/**/*.ts`;
+    const tsconfigPath = resolve(root2, "tsconfig.json");
+    const extendsPath = `./${relative(root2, dojoTsconfigPath)}`;
+    writeFileSync(
+      tsconfigPath,
+      JSON.stringify(
+        {
+          extends: extendsPath,
+          compilerOptions: { noEmit: true },
+          include: [katasInclude]
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+  console.log(`Switched to dojo "${name}".`);
+}
+
+// src/commands/kata.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, mkdirSync as mkdirSync2, copyFileSync } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { dirname as dirname2, resolve as resolve3, relative as relative3 } from "path";
+
+// src/runner.ts
+import { execSync } from "child_process";
+import { relative as relative2 } from "path";
+function parseVitestJson(raw) {
+  const json = JSON.parse(raw);
+  const tests = [];
+  for (const suite of json.testResults) {
+    for (const t of suite.assertionResults) {
+      tests.push({
+        title: t.title,
+        status: t.status === "passed" ? "passed" : "failed",
+        failureMessages: t.failureMessages
+      });
+    }
+  }
+  return {
+    total: json.numTotalTests,
+    passed: json.numPassedTests,
+    failed: json.numFailedTests,
+    tests,
+    error: null
+  };
+}
+var vitestAdapter = {
+  prepareCommand(cmd) {
+    return `${cmd} --reporter=json`;
+  },
+  parseOutput(stdout, _stderr, exitCode) {
+    try {
+      return parseVitestJson(stdout);
+    } catch {
+      if (exitCode !== 0) {
+        return {
+          total: 0,
+          passed: 0,
+          failed: 0,
+          tests: [],
+          error: _stderr || "Test execution failed"
+        };
+      }
+      return { total: 0, passed: 0, failed: 0, tests: [], error: "Failed to parse vitest output" };
+    }
+  }
+};
+var exitCodeAdapter = {
+  prepareCommand(cmd) {
+    return cmd;
+  },
+  parseOutput(stdout, stderr, exitCode) {
+    if (exitCode === 0) {
+      return {
+        total: 1,
+        passed: 1,
+        failed: 0,
+        tests: [{ title: "all tests", status: "passed", failureMessages: [] }],
+        error: null
+      };
+    }
+    return {
+      total: 1,
+      passed: 0,
+      failed: 1,
+      tests: [{ title: "all tests", status: "failed", failureMessages: [stderr || stdout || "Tests failed"] }],
+      error: null
+    };
+  }
+};
+function getAdapter(manifest) {
+  const adapterName = manifest.runner?.adapter ?? "vitest";
+  return adapterName === "exit-code" ? exitCodeAdapter : vitestAdapter;
+}
+function runTests(kata2, catalog, dojoDir2) {
+  const adapter = getAdapter(catalog);
+  const testRelPath = relative2(dojoDir2, kata2.testPath);
+  const testTemplate = kata2.test ?? catalog.test;
+  const testCmd = testTemplate.replace("{template}", testRelPath);
+  const cmd = adapter.prepareCommand(testCmd);
+  try {
+    const output = execSync(cmd, {
+      cwd: dojoDir2,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 6e4
+    });
+    return adapter.parseOutput(output.toString(), "", 0);
+  } catch (err) {
+    const e = err;
+    const stdout = e.stdout?.toString() ?? "";
+    const stderr = e.stderr?.toString() ?? "";
+    const exitCode = e.status ?? 1;
+    const result = adapter.parseOutput(stdout, stderr, exitCode);
+    if (result.error === null && result.total === 0 && stdout === "" && stderr !== "") {
+      return { total: 0, passed: 0, failed: 0, tests: [], error: stderr || "Test execution failed" };
+    }
+    return result;
+  }
+}
+
+// src/journal.ts
+import { existsSync as existsSync3, readFileSync, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { resolve as resolve2, dirname } from "path";
+function journalPath(root2, dojo) {
+  return resolve2(dojoDir(root2, dojo), "JOURNAL.md");
+}
+function appendNote(root2, dojo, kata2, note2) {
+  const path = journalPath(root2, dojo);
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  let content;
+  if (existsSync3(path)) {
+    content = readFileSync(path, "utf8");
+  } else {
+    mkdirSync(dirname(path), { recursive: true });
+    content = "# Learning Journal\n";
+  }
+  const heading = `## ${kata2}`;
+  if (content.includes(heading)) {
+    const headingIdx = content.indexOf(heading);
+    const nextHeading = content.indexOf("\n## ", headingIdx + heading.length);
+    const insertIdx = nextHeading === -1 ? content.length : nextHeading;
+    const before = content.slice(0, insertIdx).trimEnd();
+    const after = content.slice(insertIdx);
+    content = before + `
+- ${note2}
+` + after;
+  } else {
+    content += `
+${heading}
+_${date}_
+
+- ${note2}
+`;
+  }
+  writeFileSync2(path, content);
+}
+function readLearnings(root2, dojo) {
+  const path = journalPath(root2, dojo);
+  if (!existsSync3(path)) return "";
+  return readFileSync(path, "utf8");
+}
+
+// src/commands/kata.ts
+function getProgress(rc) {
+  return rc.progress?.[rc.currentDojo];
+}
+function recordKataIntro(rc, kataName) {
+  rc.progress ??= {};
+  rc.progress[rc.currentDojo] ??= { completed: [], lastActive: null };
+  const progress = rc.progress[rc.currentDojo];
+  progress.kataIntros ??= [];
+  if (!progress.kataIntros.includes(kataName)) {
+    progress.kataIntros.push(kataName);
+  }
+}
+var USAGE2 = `Usage: ${CLI} kata [flags]
+
+Flags:
+  (none)              Show SENSEI.md for current kata (smart fallback)
+  intro               Show current kata's SENSEI.md briefing
+  --start             Scaffold next kata
+  --test/--check      Run tests for current kata
+  --list              List all katas with state
+  --change <name>     Switch to a specific kata + scaffold
+  --open              Open kata in editor
+  --note "text"       Record a learning observation`;
+function recordCompletion(rc, kataName) {
+  rc.progress ??= {};
+  rc.progress[rc.currentDojo] ??= { completed: [], lastActive: null };
+  const progress = rc.progress[rc.currentDojo];
+  if (!progress.completed.includes(kataName)) {
+    progress.completed.push(kataName);
+  }
+  progress.lastActive = kataName;
+}
+function kata(root2, args2) {
+  const sub = args2.find((a) => !a.startsWith("--"));
+  if (sub === "intro") {
+    kataIntro(root2, args2);
+    return;
+  }
+  const flag = args2.find((a) => a.startsWith("--"));
+  if (!flag) {
+    smart(root2, args2);
+    return;
+  }
+  switch (flag) {
+    case "--start":
+      start(root2);
+      break;
+    case "--check":
+    case "--test":
+      check2(root2, args2);
+      break;
+    case "--list":
+      list2(root2);
+      break;
+    case "--change": {
+      const name = args2[args2.indexOf("--change") + 1];
+      if (!name) throw new Error("Usage: dojo kata --change <name>");
+      change2(root2, name);
+      break;
+    }
+    case "--note": {
+      const text = args2[args2.indexOf("--note") + 1];
+      if (!text) throw new Error('Usage: dojo kata --note "observation text"');
+      note(root2, text);
+      break;
+    }
+    case "--open":
+      open2(root2);
+      break;
+    case "--help":
+    case "-h":
+      console.log(USAGE2);
+      break;
+    default:
+      throw new Error(`Unknown flag: ${flag}
+
+${USAGE2}`);
+  }
+}
+function note(root2, text) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) throw new Error("No dojo active.");
+  if (!rc.currentKata) throw new Error("No kata in progress.");
+  appendNote(root2, rc.currentDojo, rc.currentKata, text);
+  console.log(`Noted for ${rc.currentKata}.`);
+}
+function emitLearnings(root2, dojo) {
+  const content = readLearnings(root2, dojo);
+  if (content) {
+    console.log(learnings(content));
+  }
+}
+function kataIntro(root2, args2) {
+  if (args2.includes("--done")) {
+    kataIntroDone(root2);
+    return;
+  }
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  if (!rc.currentKata) {
+    console.log(`No kata in progress.
+
+run: ${CLI} kata --start`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const target = findCurrentKata(katas, rc.currentKata);
+  if (!target) {
+    console.log(`Kata "${rc.currentKata}" not found.`);
+    return;
+  }
+  if (existsSync4(target.senseiPath)) {
+    console.log(sensei(readFileSync2(target.senseiPath, "utf8")));
+  } else {
+    console.log(`No SENSEI.md found for ${target.name}.`);
+  }
+  emitLearnings(root2, rc.currentDojo);
+  console.log(prompt(`Present the kata briefing to the student using the <dojo:sensei> content above.
+Explain the goal, what they'll practice, and any key concepts \u2014 in your own words, do NOT paste sensei content verbatim.
+
+Then ${invokeAsk()} to ask the student:
+- "Let's code" (Ready to start) \u2192 run: ${CLI} kata intro --done
+- "Tell me more" (Ask questions first) \u2192 answer using the sensei content, then ask again`));
+}
+function kataIntroDone(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo || !rc.currentKata) {
+    console.log("No kata in progress.");
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const target = findCurrentKata(katas, rc.currentKata);
+  recordKataIntro(rc, rc.currentKata);
+  writeDojoRc(root2, rc);
+  console.log(`Kata "${rc.currentKata}" introduction complete.`);
+  if (target) {
+    const workspaceRel = relative3(root2, target.workspacePath);
+    console.log(prompt(`run: ${CLI} kata --open
+
+Do NOT read ${workspaceRel} until the student runs /kata again \u2014 let them write the code first.`));
+  }
+}
+function smart(root2, args2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    const md = readDojoMd(root2, "");
+    if (md) {
+      console.log(md);
+    } else {
+      console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    }
+    return;
+  }
+  let catalog;
+  try {
+    catalog = readCatalog(root2, rc.currentDojo);
+  } catch {
+    const md = readDojoMd(root2, rc.currentDojo);
+    if (md) {
+      console.log(md);
+    } else {
+      console.log(`Dojo "${rc.currentDojo}" has no dojo.json or DOJO.md.`);
+    }
+    return;
+  }
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const progress = getProgress(rc);
+  const query = args2.find((a) => !a.startsWith("--"));
+  const target = query ? findKataByIdOrName(katas, query) : findCurrentKata(katas, rc.currentKata);
+  if (target) {
+    if (existsSync4(target.senseiPath)) {
+      console.log(sensei(readFileSync2(target.senseiPath, "utf8")));
+    } else {
+      console.log(`No SENSEI.md found for ${target.name}.`);
+    }
+    emitLearnings(root2, rc.currentDojo);
+    return;
+  }
+  const next = findNextKata(katas, progress);
+  if (next) {
+    console.log("No kata in progress.");
+    console.log(prompt(`${invokeAsk()} to ask the student:
+- "Start next kata" (Begin the next kata in sequence) \u2192 run: ${CLI} kata --start
+- "Pick a kata" (Browse and choose a specific kata) \u2192 run: ${CLI} kata --list`));
+  } else {
+    const md = readDojoMd(root2, rc.currentDojo);
+    if (md) console.log(md);
+    else console.log("All katas complete. The dojo is finished.");
+  }
+}
+function start(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const dojoPath = dojoDir(root2, rc.currentDojo);
+  const progress = getProgress(rc);
+  const target = findNextKata(katas, progress);
+  if (!target) {
+    console.log("All katas are scaffolded. The dojo is complete.");
+    return;
+  }
+  scaffold(root2, rc, dojoPath, target);
+}
+function check2(root2, args2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const dojoPath = dojoDir(root2, rc.currentDojo);
+  const progress = getProgress(rc);
+  const query = args2.find((a) => !a.startsWith("--"));
+  const target = query ? findKataByIdOrName(katas, query) : findCurrentKata(katas, rc.currentKata);
+  if (!target) {
+    const next = findNextKata(katas, progress);
+    if (next) {
+      console.log("No kata in progress.");
+      console.log(prompt(`${invokeAsk()} to ask the student:
+- "Start next kata" (Begin the next kata in sequence) \u2192 run: ${CLI} kata --start
+- "Pick a kata" (Browse and choose a specific kata) \u2192 run: ${CLI} kata --list`));
+    } else {
+      console.log(`All ${katas.length} katas complete. The dojo is finished.`);
+    }
+    return;
+  }
+  const result = runTests(target, catalog, dojoPath);
+  const workspaceRel = relative3(root2, target.workspacePath);
+  if (result.error) {
+    throw new Error(`${target.name}: error
+
+${result.error}`);
+  }
+  const lines = result.tests.map(
+    (t) => `  [${t.status === "passed" ? "x" : " "}] ${t.title}`
+  );
+  if (result.passed === result.total && result.total > 0) {
+    recordCompletion(rc, target.name);
+    writeDojoRc(root2, rc);
+    console.log(`${target.name}: ${result.total}/${result.total} \u2014 complete!
+
+${lines.join("\n")}`);
+    console.log(prompt(`Congratulate the student! All tests are passing. Celebrate their achievement before presenting options.
+
+Then ${invokeAsk()} to ask the student:
+- "Review" (Get feedback on idiomatic patterns and potential improvements) \u2192 read ${workspaceRel} and run: ${CLI} kata, suggest improvements (Socratic only)
+- "Move on" (Wrap up with key insight, then start next kata) \u2192 run: ${CLI} kata, follow On Completion (insight + bridge), then run: ${CLI} kata --start
+- "Pause" (Take a break, come back anytime) \u2192 give a friendly sign-off and remind them to run /kata when ready to continue`));
+    return;
+  }
+  console.log(`${target.name}: ${result.passed}/${result.total} passing
+
+${lines.join("\n")}`);
+  console.log(prompt(`${invokeAsk()} to ask the student:
+- "Help me" (Get hints based on failing tests) \u2192 run: ${CLI} kata, use the Test Map
+- "Keep working" (Continue on your own) \u2192 encourage them
+- "Pause" (Take a break, come back anytime) \u2192 give a friendly sign-off and remind them to run /kata when ready to continue`));
+}
+function list2(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const progress = getProgress(rc);
+  const completed = completedCount(katas, progress);
+  console.log(`Katas (${completed}/${katas.length} complete):
+`);
+  for (const k of katas) {
+    const state = kataState(k, progress);
+    const marker = state === "completed" ? "[x]" : state === "ongoing" ? "[~]" : "[ ]";
+    const current = k.name === rc.currentKata ? "    (current)" : "";
+    console.log(`  ${marker} ${k.name}${current}`);
+  }
+}
+function change2(root2, name) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const dojoPath = dojoDir(root2, rc.currentDojo);
+  const target = findKataByIdOrName(katas, name);
+  if (!target) throw new Error(`Kata not found: ${name}`);
+  if (existsSync4(target.workspacePath)) {
+    rc.currentKata = target.name;
+    writeDojoRc(root2, rc);
+    const workspaceRel = relative3(root2, target.workspacePath);
+    console.log(`Switched to ${target.name}.
+Workspace: ${workspaceRel}`);
+    console.log(prompt(`${invokeAsk()} to ask the student:
+- "Check progress" \u2192 run: ${CLI} kata --check
+- "Keep working" \u2192 encourage them`));
+    return;
+  }
+  scaffold(root2, rc, dojoPath, target);
+}
+function open2(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentKata || !rc.currentDojo) {
+    console.log("No kata in progress.");
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const target = findCurrentKata(katas, rc.currentKata);
+  if (!target) {
+    console.log("No kata in progress.");
+    return;
+  }
+  const editor = rc.editor ?? "code";
+  const absPath = target.workspacePath;
+  console.log(`Opening ${target.name}...`);
+  try {
+    execSync2(`${editor} ${absPath}`, { stdio: "inherit" });
+  } catch {
+    console.log(`Could not open with "${editor}". File: ${absPath}`);
+  }
+}
+function scaffold(root2, rc, dojoPath, target) {
+  const templateSrc = resolve3(dojoPath, target.template);
+  if (!existsSync4(templateSrc)) {
+    throw new Error(`Template not found: ${target.template}`);
+  }
+  mkdirSync2(dirname2(target.workspacePath), { recursive: true });
+  copyFileSync(templateSrc, target.workspacePath);
+  rc.currentKata = target.name;
+  writeDojoRc(root2, rc);
+  const workspaceRel = relative3(root2, target.workspacePath);
+  const absPath = target.workspacePath;
+  let plain = `Kata ${target.name} scaffolded.
+Workspace: ${workspaceRel}`;
+  if (rc.editor) {
+    plain += `
+Open command: ${rc.editor} ${absPath}`;
+  }
+  console.log(plain);
+  console.log(prompt(`run: ${CLI} kata intro
+Present the kata briefing, then follow the instructions from that command.`));
+}
+
+// src/commands/intro.ts
+function intro(root2, args2) {
+  if (args2.includes("--done")) {
+    markDone(root2);
+    return;
+  }
+  present(root2);
+}
+function present(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    const md2 = readDojoMd(root2, "");
+    if (md2) console.log(sensei(md2));
+    else console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const md = readDojoMd(root2, rc.currentDojo);
+  if (md) console.log(sensei(md));
+  else console.log(`Dojo "${rc.currentDojo}" has no DOJO.md.`);
+  const dojos = listDojos(root2);
+  const others = dojos.filter((d) => d !== rc.currentDojo);
+  const switchOptions = others.length > 0 ? "\n" + others.map((d) => `- "${d}" (Switch to this dojo) \u2192 run: ${CLI} --change ${d}`).join("\n") : "";
+  console.log(prompt(`Introduce the dojo to the student using the <dojo:sensei> content above.
+Explain what they'll be learning, how katas work (short exercises with tests to guide them), and what to expect.
+Do NOT paste the sensei content verbatim \u2014 summarize and present it in your own words.
+
+Then ${invokeAsk()} to ask the student:
+- "Let's begin" (Start the first kata) \u2192 run: ${CLI} intro --done
+- "Tell me more" (Ask questions about the dojo before starting) \u2192 answer using the sensei content, then ask again${switchOptions}`));
+}
+function markDone(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active.`);
+    return;
+  }
+  rc.progress ??= {};
+  rc.progress[rc.currentDojo] ??= { completed: [], lastActive: null };
+  rc.progress[rc.currentDojo].introduced = true;
+  writeDojoRc(root2, rc);
+  console.log(`Dojo "${rc.currentDojo}" introduction complete.`);
+}
+
+// src/commands/setup.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, lstatSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { execSync as execSync3 } from "child_process";
+import { resolve as resolve5 } from "path";
+
+// src/pm.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve4 } from "path";
+function detectAt(dir) {
+  const pkgPath = resolve4(dir, "package.json");
+  if (existsSync5(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+      if (typeof pkg.packageManager === "string") {
+        const name = pkg.packageManager.split("@")[0];
+        if (name === "pnpm" || name === "yarn" || name === "bun" || name === "npm") {
+          return name;
+        }
+      }
+    } catch {
+    }
+  }
+  if (existsSync5(resolve4(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync5(resolve4(dir, "yarn.lock"))) return "yarn";
+  if (existsSync5(resolve4(dir, "bun.lockb")) || existsSync5(resolve4(dir, "bun.lock"))) return "bun";
+  if (existsSync5(resolve4(dir, "package-lock.json"))) return "npm";
+  return null;
+}
+function detectPackageManager(root2) {
+  let dir = resolve4(root2);
+  const fsRoot = dirname3(dir) === dir ? dir : void 0;
+  while (true) {
+    const found = detectAt(dir);
+    if (found) return found;
+    const parent = dirname3(dir);
+    if (parent === dir || parent === fsRoot) break;
+    dir = parent;
+  }
+  return "npm";
+}
+function pmCommands(root2) {
+  const pm = detectPackageManager(root2);
+  switch (pm) {
+    case "pnpm":
+      return {
+        name: pm,
+        installSilent: "pnpm install --ignore-workspace --silent",
+        add: (pkg) => `pnpm add ${pkg}`
+      };
+    case "yarn":
+      return {
+        name: pm,
+        installSilent: "yarn install --silent",
+        add: (pkg) => `yarn add ${pkg}`
+      };
+    case "bun":
+      return {
+        name: pm,
+        installSilent: "bun install --silent",
+        add: (pkg) => `bun add ${pkg}`
+      };
+    case "npm":
+    default:
+      return {
+        name: pm,
+        installSilent: "npm install --silent",
+        add: (pkg) => `npm install ${pkg}`
+      };
+  }
+}
+
+// src/commands/setup.ts
+var AGENTS = {
+  claude: { dir: ".claude", hasSettings: true },
+  opencode: { dir: ".opencode", hasSettings: false },
+  codex: { dir: ".codex", hasSettings: false },
+  gemini: { dir: ".gemini", hasSettings: false }
+};
+var CLAUDE_SETTINGS = {
+  permissions: {
+    allow: [
+      "Bash(dojo *)",
+      "Bash(dojo)"
+    ],
+    deny: [
+      "Read(.dojos/**)",
+      "Glob(.dojos/**)",
+      "Grep(.dojos/**)"
+    ]
+  }
+};
+var DEFAULT_DOJO_MD = `!\`dojo $ARGUMENTS\`
+
+Follow any \`<dojo:prompt>\` instructions in the output.
+`;
+var DEFAULT_KATA_MD = `!\`dojo status\`
+
+## Protocol
+
+CLI output uses XML tags to separate directives from student content:
+
+- \`<dojo:status>\` \u2014 Machine state. Parse the \`run:\` line and execute it.
+- \`<dojo:prompt>\` \u2014 Interaction spec. Follow the instructions inside.
+- \`<dojo:sensei>\` \u2014 Teaching material. Internalize but never show verbatim.
+- \`<dojo:learnings>\` \u2014 Prior student observations. Use to personalize teaching.
+- **Unwrapped text** \u2014 Student-facing. Display as-is.
+
+## Flow
+
+1. Parse \`<dojo:status>\` above.
+2. If state is \`complete\`, congratulate the student.
+3. If state is \`no-dojo\`, tell them to run \`dojo add <source>\`.
+4. Otherwise, execute the \`run:\` command.
+5. After running, follow any \`<dojo:prompt>\` instructions.
+6. Use \`<dojo:sensei>\` content to guide teaching \u2014 never paste it to the student.
+7. If \`<dojo:learnings>\` is present, use it to personalize teaching based on prior observations.
+`;
+var DEFAULT_KATA_MD_CLAUDE = `!\`dojo status\`
+
+## Identity
+
+You are a kata sensei. Teach through Socratic dialogue \u2014 questions, hints, nudges \u2014 never give solutions directly.
+
+## Protocol
+
+CLI output uses XML tags to separate directives from student content:
+
+- \`<dojo:status>\` \u2014 Machine state. Parse the \`run:\` line and execute it.
+- \`<dojo:prompt>\` \u2014 Interaction spec. Follow the instructions inside.
+- \`<dojo:sensei>\` \u2014 Teaching material. Internalize but **never** show verbatim to the student.
+- \`<dojo:learnings>\` \u2014 Prior student observations. Use to personalize teaching.
+- **Unwrapped text** \u2014 Student-facing. Display as-is.
+
+## Flow
+
+1. Parse \`<dojo:status>\` above.
+2. If state is \`complete\`, congratulate the student.
+3. If state is \`no-dojo\`, tell them to run \`dojo add <source>\`.
+4. Otherwise, execute the \`run:\` command via Bash.
+5. Parse the output. Display any unwrapped student-facing text.
+6. Internalize \`<dojo:sensei>\` as your teaching material \u2014 teach exclusively from it, do NOT rely on outside knowledge.
+7. If \`<dojo:learnings>\` is present, personalize: build on what the student knows, skip mastered concepts, address past struggles.
+8. Follow \`<dojo:prompt>\` instructions. If there is no \`<dojo:prompt>\`, present the content and ask what the student would like to do.
+9. **Use AskUserQuestion** for ALL student interactions \u2014 present choices, ask questions, gather responses. Never list numbered options as plain text.
+10. When the task or student responses require CLI commands (\`dojo kata --check\`, \`dojo kata intro --done\`, \`dojo kata --open\`, etc.), run them via Bash.
+11. If the teaching material contains Reference URLs, surface them to the student.
+12. Before finishing, record 1\u20133 key observations about the student by running \`dojo kata --note "observation"\` for each.
+13. Drive the full session: AskUserQuestion \u2192 process response \u2192 run commands if needed \u2192 AskUserQuestion again. Do not stop after one exchange.
+`;
+var ROOT_DOJO_MD = `# Welcome to Dojocho
+
+Your dojo is set up and ready. You just need a dojo (training pack) to start practicing.
+
+## Add a dojo
+
+\`\`\`bash
+dojo add <source>
+\`\`\`
+
+Source can be:
+- A local path: \`dojo add ./path/to/dojo\`
+- A git repo: \`dojo add org/repo\`
+- Official dojos: \`dojo add effect-ts\`
+
+## Start practicing
+
+Once a dojo is added, use \`/kata\` in your coding agent to begin.
+`;
+var DOJO_CONFIG = `import { defineConfig } from "@dojocho/config"
+
+export default defineConfig()
+`;
+var DEFAULT_RC = {
+  currentDojo: "",
+  currentKata: null,
+  editor: "code",
+  progress: {}
+};
+function setup(root2, args2) {
+  const explicit = Object.keys(AGENTS).filter(
+    (a) => args2.includes(`--${a}`)
+  );
+  if (explicit.length === 0) {
+    promptAgents();
+    return;
+  }
+  scaffold2(root2);
+  setupAgents(root2, explicit);
+  const kataCmd = explicit.length === 1 ? `${explicit[0]} "/kata"` : "/kata in your agent prompt";
+  console.log(`Dojo ready.
+
+  Add a dojo with: ${CLI} add <source>
+  Then use:        ${kataCmd}`);
+}
+function promptAgents() {
+  const options = [
+    `- "Claude Code" \u2192 --claude`,
+    `- "OpenCode" \u2192 --opencode`,
+    `- "Codex" \u2192 --codex`,
+    `- "Gemini CLI" \u2192 --gemini`
+  ].join("\n");
+  console.log(prompt(`${invokeAsk("multiSelect")} to ask the student:
+Which coding agents do you use?
+${options}
+
+Then run: ${CLI} setup --<agent1> --<agent2> ...`));
+}
+function scaffold2(root2) {
+  const rcPath = resolve5(root2, ".dojorc");
+  if (!existsSync6(rcPath)) {
+    writeDojoRc(root2, DEFAULT_RC);
+  }
+  mkdirSync3(resolve5(root2, DOJOS_DIR), { recursive: true });
+  const dojoMdPath = resolve5(root2, DOJOS_DIR, "DOJO.md");
+  if (!existsSync6(dojoMdPath)) {
+    writeFileSync3(dojoMdPath, ROOT_DOJO_MD);
+  }
+  const configPath = resolve5(root2, "dojo.config.ts");
+  if (!existsSync6(configPath)) {
+    writeFileSync3(configPath, DOJO_CONFIG);
+  }
+  const tsconfigPath = resolve5(root2, "tsconfig.json");
+  if (!existsSync6(tsconfigPath)) {
+    writeFileSync3(
+      tsconfigPath,
+      JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ES2022",
+            module: "ES2022",
+            moduleResolution: "bundler",
+            strict: true,
+            noEmit: true
+          },
+          include: ["katas/**/*.ts"]
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+  const pkgPath = resolve5(root2, "package.json");
+  if (!existsSync6(pkgPath)) {
+    writeFileSync3(
+      pkgPath,
+      JSON.stringify({ type: "module", private: true }, null, 2) + "\n"
+    );
+  }
+  const pm = pmCommands(root2);
+  console.log("Installing @dojocho/config...");
+  execSync3(pm.add("@dojocho/config"), { cwd: root2, stdio: "pipe" });
+}
+function setupAgents(root2, agents) {
+  for (const agent of agents) {
+    const dir = AGENTS[agent].dir;
+    mkdirSync3(resolve5(root2, dir, "commands"), { recursive: true });
+    mkdirSync3(resolve5(root2, dir, "skills"), { recursive: true });
+    const dojoMd = resolve5(root2, dir, "commands", "dojo.md");
+    try {
+      if (lstatSync(dojoMd).isSymbolicLink()) unlinkSync(dojoMd);
+    } catch {
+    }
+    if (!existsSync6(dojoMd)) {
+      writeFileSync3(dojoMd, DEFAULT_DOJO_MD);
+    }
+    const kataMdContent = agent === "claude" ? DEFAULT_KATA_MD_CLAUDE : DEFAULT_KATA_MD;
+    const kataMd = resolve5(root2, dir, "commands", "kata.md");
+    try {
+      if (lstatSync(kataMd).isSymbolicLink()) unlinkSync(kataMd);
+    } catch {
+    }
+    if (!existsSync6(kataMd)) {
+      writeFileSync3(kataMd, kataMdContent);
+    }
+    if (AGENTS[agent].hasSettings) {
+      const settingsPath = resolve5(root2, dir, "settings.json");
+      writeFileSync3(settingsPath, JSON.stringify(CLAUDE_SETTINGS, null, 2) + "\n");
+    }
+  }
+}
+function configuredAgents(root2) {
+  return Object.keys(AGENTS).filter(
+    (a) => existsSync6(resolve5(root2, AGENTS[a].dir))
+  );
+}
+
+// src/commands/add.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, cpSync, renameSync, unlinkSync as unlinkSync3, symlinkSync, readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync4, rmSync as rmSync2 } from "fs";
+import { execSync as execSync4, execFileSync } from "child_process";
+import { resolve as resolve7, relative as relative4 } from "path";
+import { tmpdir } from "os";
+
+// src/commands/remove.ts
+import { existsSync as existsSync7, rmSync, readdirSync, lstatSync as lstatSync2, readlinkSync, unlinkSync as unlinkSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+function remove(root2, args2) {
+  const name = args2.find((a) => !a.startsWith("--"));
+  if (!name) throw new Error("Usage: dojo remove <name>");
+  const dojoPath = resolve6(root2, DOJOS_DIR, name);
+  if (!existsSync7(dojoPath)) {
+    throw new Error(`Dojo "${name}" not found at ${DOJOS_DIR}/${name}`);
+  }
+  runLifecycleScript(root2, dojoPath, "teardown.sh");
+  rmSync(dojoPath, { recursive: true, force: true });
+  for (const agent of configuredAgents(root2)) {
+    const dir = AGENTS[agent].dir;
+    for (const sub of ["commands", "skills"]) {
+      const subDir = resolve6(root2, dir, sub);
+      if (!existsSync7(subDir)) continue;
+      for (const entry of readdirSync(subDir)) {
+        const link = resolve6(subDir, entry);
+        try {
+          if (!lstatSync2(link).isSymbolicLink()) continue;
+          const target = readlinkSync(link);
+          if (target.includes(`${DOJOS_DIR}/${name}/`) || target.includes(`${DOJOS_DIR}/${name}\\`)) {
+            unlinkSync2(link);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  try {
+    const rc = readDojoRc(root2);
+    if (rc.currentDojo === name) {
+      rc.currentDojo = "";
+      rc.currentKata = null;
+      writeDojoRc(root2, rc);
+    }
+  } catch {
+  }
+  console.log(`Dojo "${name}" removed.`);
+}
+
+// src/commands/add.ts
+async function add(root2, args2) {
+  const source = args2.find((a) => !a.startsWith("--"));
+  const force = args2.includes("--force");
+  if (!source) {
+    throw new Error(`Usage: dojo add <source>
+
+Source can be:
+  Local path:   dojo add ./path/to/dojo
+  npm package:  dojo add @dojocho/effect-ts
+  Registry:     dojo add effect-ts
+  URL:          dojo add https://example.com/dojo.tgz
+
+Flags:
+  --force       Overwrite existing dojo`);
+  }
+  const sourceType = classifySource(source);
+  switch (sourceType) {
+    case "local":
+      addLocal(root2, source, force);
+      break;
+    case "npm":
+      addNpm(root2, source, force);
+      break;
+    case "url":
+      addUrl(root2, source, force);
+      break;
+    case "registry":
+      await addFromRegistry(root2, source, force);
+      break;
+  }
+}
+function classifySource(source) {
+  if (source.startsWith(".") || source.startsWith("/")) return "local";
+  if (source.startsWith("https://") || source.startsWith("http://")) return "url";
+  if (source.startsWith("@") || source.includes("/")) return "npm";
+  return "registry";
+}
+function safeExtract(tarball, cwd) {
+  const listing = execFileSync("tar", ["-tzf", tarball], { cwd, encoding: "utf8" });
+  const unsafe = listing.split("\n").some((e) => e.startsWith("/") || e.includes(".."));
+  if (unsafe) {
+    throw new Error("Refusing to extract: tarball contains unsafe paths (absolute or ../)");
+  }
+  execFileSync("tar", ["xzf", tarball], { cwd, stdio: "pipe" });
+}
+function moveDir(src, dest) {
+  try {
+    renameSync(src, dest);
+  } catch {
+    cpSync(src, dest, { recursive: true });
+  }
+}
+function handleExisting(root2, name, force) {
+  const targetPath = dojoDir(root2, name);
+  if (!existsSync8(targetPath)) return;
+  if (!force) {
+    throw new Error(`Dojo "${name}" already exists at ${DOJOS_DIR}/${name}
+
+To update:  dojo add ${name} --force
+To remove:  dojo remove ${name}`);
+  }
+  remove(root2, [name]);
+}
+function addLocal(root2, source, force) {
+  const sourcePath = resolve7(source);
+  if (!existsSync8(sourcePath)) {
+    throw new Error(`Source not found: ${sourcePath}`);
+  }
+  const tmpDir = resolve7(tmpdir(), `dojocho-${Date.now()}`);
+  mkdirSync4(tmpDir, { recursive: true });
+  try {
+    const sourcePm = detectPackageManager(sourcePath);
+    execSync4(`${sourcePm} pack --pack-destination ${tmpDir}`, { cwd: sourcePath, stdio: "pipe" });
+    const tarballs = readdirSync2(tmpDir).filter((f) => f.endsWith(".tgz"));
+    if (tarballs.length === 0) throw new Error(`Failed to pack ${sourcePath}`);
+    safeExtract(tarballs[0], tmpDir);
+    installExtracted(root2, resolve7(tmpDir, "package"), source, force);
+  } finally {
+    rmSync2(tmpDir, { recursive: true, force: true });
+  }
+}
+function installExtracted(root2, extractedDir, source, force) {
+  const dojoJsonPath = resolve7(extractedDir, "dojo.json");
+  if (!existsSync8(dojoJsonPath)) {
+    throw new Error(`${source} is not a dojo \u2014 missing dojo.json`);
+  }
+  const manifest = parseManifest(readFileSync4(dojoJsonPath, "utf8"), dojoJsonPath);
+  const name = manifest.name.includes("/") ? manifest.name.split("/").pop() : manifest.name;
+  const pm = pmCommands(root2);
+  const pkgPath = resolve7(extractedDir, "package.json");
+  if (existsSync8(pkgPath)) {
+    console.log(`Installing ${name} dependencies...`);
+    execSync4(pm.installSilent, { cwd: extractedDir, stdio: "pipe" });
+  }
+  handleExisting(root2, name, force);
+  const targetPath = dojoDir(root2, name);
+  mkdirSync4(resolve7(root2, DOJOS_DIR), { recursive: true });
+  moveDir(extractedDir, targetPath);
+  finalize(root2, name, targetPath);
+}
+function addNpm(root2, source, force) {
+  const tmpDir = resolve7(tmpdir(), `dojocho-${Date.now()}`);
+  mkdirSync4(tmpDir, { recursive: true });
+  try {
+    console.log(`Fetching ${source}...`);
+    execSync4(`npm pack ${source} --pack-destination .`, { cwd: tmpDir, stdio: "pipe" });
+    const tarballs = readdirSync2(tmpDir).filter((f) => f.endsWith(".tgz"));
+    if (tarballs.length === 0) throw new Error(`Failed to download ${source}`);
+    safeExtract(tarballs[0], tmpDir);
+    installExtracted(root2, resolve7(tmpDir, "package"), source, force);
+  } finally {
+    rmSync2(tmpDir, { recursive: true, force: true });
+  }
+}
+function validateRegistryItem(data) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error("Invalid registry response: expected a JSON object");
+  }
+  const obj = data;
+  if (typeof obj.name !== "string" || typeof obj.version !== "string" || typeof obj.description !== "string") {
+    throw new Error("Invalid registry item: missing name, version, or description");
+  }
+  if (typeof obj.source !== "object" || obj.source === null) {
+    throw new Error("Invalid registry item: missing source");
+  }
+  const src = obj.source;
+  if (src.type === "npm" && typeof src.package === "string") {
+    return obj;
+  }
+  if (src.type === "tarball" && typeof src.url === "string") {
+    return obj;
+  }
+  throw new Error(`Invalid registry item: source must be npm or tarball`);
+}
+async function addFromRegistry(root2, name, force) {
+  const config = loadConfig(root2, { command: "add" });
+  for (const [registryName, urlTemplate] of Object.entries(config.registries)) {
+    const url = urlTemplate.replace("{name}", name);
+    try {
+      const res = await fetch(url);
+      if (!res.ok) continue;
+      const item = validateRegistryItem(await res.json());
+      if (item.source.type === "npm") {
+        return addNpm(root2, item.source.package, force);
+      }
+      return addUrl(root2, item.source.url, force);
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("Invalid registry")) throw err;
+      console.log(`Registry "${registryName}" unreachable: ${url}`);
+    }
+  }
+  throw new Error(`"${name}" not found in any registry.
+
+Try:
+  npm package:  dojo add @dojocho/${name}
+  Local path:   dojo add ./path/to/${name}`);
+}
+function addUrl(root2, url, force) {
+  const tmpDir = resolve7(tmpdir(), `dojocho-${Date.now()}`);
+  mkdirSync4(tmpDir, { recursive: true });
+  try {
+    console.log(`Fetching ${url}...`);
+    execFileSync("curl", ["-fsSL", "-o", "dojo.tgz", url], { cwd: tmpDir, stdio: "pipe" });
+    safeExtract("dojo.tgz", tmpDir);
+    const extractedDir = existsSync8(resolve7(tmpDir, "package", "dojo.json")) ? resolve7(tmpDir, "package") : tmpDir;
+    installExtracted(root2, extractedDir, url, force);
+  } finally {
+    rmSync2(tmpDir, { recursive: true, force: true });
+  }
+}
+function finalize(root2, name, targetPath) {
+  const rc = readDojoRc(root2);
+  rc.currentDojo = name;
+  writeDojoRc(root2, rc);
+  const dojoPkgPath = resolve7(targetPath, "package.json");
+  const dojoTsconfigPath = resolve7(targetPath, "tsconfig.json");
+  if (existsSync8(dojoPkgPath) && existsSync8(dojoTsconfigPath)) {
+    const dojoPkg = JSON.parse(readFileSync4(dojoPkgPath, "utf8"));
+    const dojoTsconfig = JSON.parse(readFileSync4(dojoTsconfigPath, "utf8"));
+    const deps = Object.keys(dojoPkg.dependencies ?? {});
+    if (deps.length > 0) {
+      dojoTsconfig.compilerOptions ??= {};
+      const paths = dojoTsconfig.compilerOptions.paths ?? {};
+      for (const dep of deps) {
+        paths[dep] = [`./node_modules/${dep}`];
+        paths[`${dep}/*`] = [`./node_modules/${dep}/*`];
+      }
+      dojoTsconfig.compilerOptions.paths = paths;
+      writeFileSync4(dojoTsconfigPath, JSON.stringify(dojoTsconfig, null, 2) + "\n");
+    }
+  }
+  const dojo = loadConfig(root2);
+  const katasInclude = `${relative4(root2, dojo.katasPath)}/**/*.ts`;
+  const tsconfigPath = resolve7(root2, "tsconfig.json");
+  const extendsPath = `./${relative4(root2, resolve7(targetPath, "tsconfig.json"))}`;
+  writeFileSync4(
+    tsconfigPath,
+    JSON.stringify(
+      {
+        extends: extendsPath,
+        compilerOptions: { noEmit: true },
+        include: [katasInclude]
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  symlinkDojo(root2, targetPath);
+  const agents = configuredAgents(root2);
+  const kataCmd = agents.length === 1 ? `${agents[0]} "/kata"` : "/kata";
+  console.log(`Dojo "${name}" added.
+
+  Location:  ${DOJOS_DIR}/${name}
+  Active:    ${name}
+  Command:   ${kataCmd}`);
+  runLifecycleScript(root2, targetPath, "prepare.sh");
+}
+function symlinkDir(sourceDir, targetDir, filter) {
+  if (!existsSync8(sourceDir)) return;
+  mkdirSync4(targetDir, { recursive: true });
+  for (const entry of readdirSync2(sourceDir, { withFileTypes: true })) {
+    if (!filter(entry)) continue;
+    const link = resolve7(targetDir, entry.name);
+    if (existsSync8(link)) unlinkSync3(link);
+    symlinkSync(relative4(targetDir, resolve7(sourceDir, entry.name)), link);
+  }
+}
+function runLifecycleScript(root2, dojoPath, script) {
+  const scriptPath = resolve7(dojoPath, script);
+  if (!existsSync8(scriptPath)) return;
+  try {
+    execSync4(`bash ${scriptPath}`, {
+      cwd: dojoPath,
+      stdio: "inherit",
+      env: { ...process.env, PROJECT_ROOT: root2 }
+    });
+  } catch {
+    console.log(`Warning: ${script} exited with errors.`);
+  }
+}
+function symlinkDojo(root2, dojoPath) {
+  for (const agent of configuredAgents(root2)) {
+    const dir = AGENTS[agent].dir;
+    symlinkDir(resolve7(dojoPath, "commands"), resolve7(root2, dir, "commands"), (e) => e.name.endsWith(".md"));
+    symlinkDir(resolve7(dojoPath, "skills"), resolve7(root2, dir, "skills"), (e) => e.isDirectory());
+  }
+}
+
+// src/commands/status.ts
+function status2(root2, _args) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(status({ state: "no-dojo" }));
+    return;
+  }
+  const progress = rc.progress?.[rc.currentDojo];
+  if (!progress?.introduced) {
+    const fields = {
+      state: "intro",
+      dojo: rc.currentDojo,
+      run: `${CLI} intro`
+    };
+    const dojos = listDojos(root2);
+    if (dojos.length > 1) {
+      fields.dojos = dojos.join(", ");
+    }
+    console.log(status(fields));
+    return;
+  }
+  let catalog;
+  try {
+    catalog = readCatalog(root2, rc.currentDojo);
+  } catch {
+    console.log(status({
+      state: "intro",
+      dojo: rc.currentDojo,
+      run: `${CLI} intro`
+    }));
+    return;
+  }
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const completed = completedCount(katas, progress);
+  const total = katas.length;
+  const current = findCurrentKata(katas, rc.currentKata);
+  if (!current) {
+    const next = findNextKata(katas, progress);
+    if (!next) {
+      console.log(status({
+        state: "complete",
+        dojo: rc.currentDojo,
+        progress: `${completed}/${total}`
+      }));
+    } else {
+      console.log(status({
+        state: "no-kata",
+        dojo: rc.currentDojo,
+        progress: `${completed}/${total}`,
+        run: `${CLI} kata --start`
+      }));
+    }
+    return;
+  }
+  const briefed = progress?.kataIntros?.includes(current.name) === true;
+  console.log(status({
+    state: briefed ? "practicing" : "kata-intro",
+    dojo: rc.currentDojo,
+    kata: current.name,
+    progress: `${completed}/${total}`,
+    run: `${CLI} kata ${briefed ? "--check" : "intro"}`
+  }));
+}
+
+// src/index.ts
+var [command, ...args] = process.argv.slice(2);
+async function main() {
+  if (command === "kata") {
+    kata(findProjectRoot(), args);
+  } else if (command === "intro") {
+    intro(findProjectRoot(), args);
+  } else if (command === "setup") {
+    setup(process.cwd(), args);
+  } else if (command === "add") {
+    await add(process.cwd(), args);
+  } else if (command === "remove") {
+    remove(findProjectRoot(), args);
+  } else if (command === "status") {
+    status2(findProjectRoot(), args);
+  } else {
+    root(process.cwd(), [command, ...args].filter(Boolean));
+  }
+}
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(message);
+  process.exit(1);
+});