syntaur 0.3.3 → 0.4.1

package/dist/index.js

@@ -4429,7 +4429,7 @@ function App({ projectsDir: projectsDir2, onLaunch }) {
     collapseNode,
     currentNode
   } = useTreeState(nodes, filteredIds);
-  useInput((input2, key) => {
+  useInput((input3, key) => {
     if (searchActive) {
       if (key.escape) {
         setSearchActive(false);
@@ -4442,19 +4442,19 @@ function App({ projectsDir: projectsDir2, onLaunch }) {
       }
       return;
     }
-    if (input2 === "q" || key.escape) {
+    if (input3 === "q" || key.escape) {
       exit();
       return;
     }
-    if (input2 === "/") {
+    if (input3 === "/") {
       setSearchActive(true);
       return;
     }
-    if (key.upArrow || input2 === "k") {
+    if (key.upArrow || input3 === "k") {
       moveUp();
       return;
     }
-    if (key.downArrow || input2 === "j") {
+    if (key.downArrow || input3 === "j") {
       moveDown();
       return;
     }
@@ -4546,8 +4546,8 @@ __export(launch_exports, {
   launchAgent: () => launchAgent
 });
 import { spawn as spawn2 } from "child_process";
-import { mkdir as mkdir2, writeFile as writeFile7 } from "fs/promises";
-import { resolve as resolve28 } from "path";
+import { mkdir as mkdir4, writeFile as writeFile9 } from "fs/promises";
+import { resolve as resolve31 } from "path";
 async function launchAgent(options) {
   const { projectsDir: projectsDir2, projectSlug, assignmentSlug, agent } = options;
   const command = AGENT_COMMANDS[agent];
@@ -4557,10 +4557,10 @@ async function launchAgent(options) {
     process.exit(1);
   }
   const workspaceDir = detail.workspace.worktreePath ?? (detail.workspace.repository?.startsWith("/") ? detail.workspace.repository : null) ?? process.cwd();
-  const projectDir = resolve28(projectsDir2, projectSlug);
-  const assignmentDir = resolve28(projectDir, "assignments", assignmentSlug);
-  const contextDir = resolve28(workspaceDir, ".syntaur");
-  await mkdir2(contextDir, { recursive: true });
+  const projectDir = resolve31(projectsDir2, projectSlug);
+  const assignmentDir = resolve31(projectDir, "assignments", assignmentSlug);
+  const contextDir = resolve31(workspaceDir, ".syntaur");
+  await mkdir4(contextDir, { recursive: true });
   const context = {
     projectSlug,
     assignmentSlug,
@@ -4571,8 +4571,8 @@ async function launchAgent(options) {
     branch: detail.workspace.branch ?? null,
     grabbedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile7(
-    resolve28(contextDir, "context.json"),
+  await writeFile9(
+    resolve31(contextDir, "context.json"),
     JSON.stringify(context, null, 2) + "\n"
   );
   return new Promise((resolvePromise, reject) => {
@@ -5909,8 +5909,8 @@ async function migrateFromMarkdown(projectsDir2) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile26 } = await import("fs/promises");
-  const raw = await readFile26(filePath, "utf-8");
+  const { readFile: readFile29 } = await import("fs/promises");
+  const raw = await readFile29(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -7637,8 +7637,8 @@ ${entry}`;
   });
   return router;
 }
-function slugifyLocal(input2) {
-  return input2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "untitled";
+function slugifyLocal(input3) {
+  return input3.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "untitled";
 }
 async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
   const commentsPath = resolve15(assignmentDir, "comments.md");
@@ -8218,8 +8218,8 @@ function createTodosRouter(todosDir2, broadcast) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve42 } = await import("path");
-      const { readFile: readFile26 } = await import("fs/promises");
+      const { resolve: resolve45 } = await import("path");
+      const { readFile: readFile29 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
       const checklist = await readChecklist(todosDir2, workspace);
@@ -8235,10 +8235,10 @@ function createTodosRouter(todosDir2, broadcast) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve42(todosDir2, "archive"));
+      await ensureDir(resolve45(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile26(archFile, "utf-8");
+        archContent = await readFile29(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -10489,6 +10489,165 @@ async function textPrompt(question, defaultValue) {
   }
 }
 
+// src/utils/install-skills.ts
+init_fs();
+import { readFile as readFile16, readdir as readdir11, mkdir as mkdir2, copyFile, rm as rm4 } from "fs/promises";
+import { dirname as dirname7, resolve as resolve25, relative as relative3, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { homedir as homedir3 } from "os";
+var REQUIRED_SKILLS = [
+  "syntaur-protocol",
+  "grab-assignment",
+  "plan-assignment",
+  "complete-assignment",
+  "create-assignment",
+  "create-project"
+];
+function getVendoredSkillsDir() {
+  const here = dirname7(fileURLToPath4(import.meta.url));
+  return resolve25(here, "..", "vendor", "syntaur-skills", "skills");
+}
+function defaultSkillTargetDir(target) {
+  if (target === "claude") return resolve25(homedir3(), ".claude", "skills");
+  return resolve25(homedir3(), ".codex", "skills");
+}
+async function walkFiles(root) {
+  const out = [];
+  async function walk(dir) {
+    const entries = await readdir11(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile()) {
+        out.push(full);
+      }
+    }
+  }
+  await walk(root);
+  return out.sort();
+}
+async function filesEqual(a, b) {
+  try {
+    const [ba, bb] = await Promise.all([readFile16(a), readFile16(b)]);
+    if (ba.length !== bb.length) return false;
+    return ba.equals(bb);
+  } catch {
+    return false;
+  }
+}
+async function copyDir(srcDir, destDir) {
+  await mkdir2(destDir, { recursive: true });
+  const entries = await readdir11(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const src = join3(srcDir, entry.name);
+    const dest = join3(destDir, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(src, dest);
+    } else if (entry.isFile()) {
+      await copyFile(src, dest);
+    }
+  }
+}
+async function skillMatches(srcDir, destDir) {
+  if (!await fileExists(destDir)) return false;
+  const srcFiles = await walkFiles(srcDir);
+  for (const srcFile of srcFiles) {
+    const rel = relative3(srcDir, srcFile);
+    const destFile = join3(destDir, rel);
+    if (!await filesEqual(srcFile, destFile)) return false;
+  }
+  const destFiles = await walkFiles(destDir);
+  if (destFiles.length !== srcFiles.length) return false;
+  return true;
+}
+async function installSkills(options) {
+  const source = options.sourceDir ?? getVendoredSkillsDir();
+  const targetRoot = options.targetDir ?? defaultSkillTargetDir(options.target);
+  const force = options.force ?? false;
+  if (!await fileExists(source)) {
+    throw new Error(
+      `Vendored skills not found at ${source}. Reinstall syntaur: npm install -g syntaur@latest`
+    );
+  }
+  const results = [];
+  await mkdir2(targetRoot, { recursive: true });
+  for (const skill of REQUIRED_SKILLS) {
+    const srcDir = join3(source, skill);
+    const destDir = join3(targetRoot, skill);
+    if (!await fileExists(srcDir)) continue;
+    if (!await fileExists(destDir)) {
+      await copyDir(srcDir, destDir);
+      results.push({
+        skill,
+        status: "installed",
+        targetPath: destDir
+      });
+      continue;
+    }
+    if (await skillMatches(srcDir, destDir)) {
+      results.push({
+        skill,
+        status: "already-current",
+        targetPath: destDir
+      });
+      continue;
+    }
+    if (force) {
+      await rm4(destDir, { recursive: true, force: true });
+      await copyDir(srcDir, destDir);
+      results.push({
+        skill,
+        status: "overwritten",
+        targetPath: destDir
+      });
+    } else {
+      results.push({
+        skill,
+        status: "differs-preserved",
+        targetPath: destDir
+      });
+    }
+  }
+  return results;
+}
+async function uninstallSkills(options) {
+  const targetRoot = options.targetDir ?? defaultSkillTargetDir(options.target);
+  if (!await fileExists(targetRoot)) return [];
+  const removed = [];
+  for (const skill of REQUIRED_SKILLS) {
+    const destDir = join3(targetRoot, skill);
+    if (!await fileExists(destDir)) continue;
+    const skillMd = join3(destDir, "SKILL.md");
+    if (!await fileExists(skillMd)) continue;
+    const content = await readFile16(skillMd, "utf-8").catch(() => "");
+    const match = content.match(/^name:\s*(\S+)\s*$/m);
+    if (!match || match[1] !== skill) continue;
+    await rm4(destDir, { recursive: true, force: true });
+    removed.push(destDir);
+  }
+  return removed;
+}
+function formatInstallReport(results, target) {
+  const lines = [];
+  lines.push(`Skill install (${target}):`);
+  for (const r of results) {
+    const marker = r.status === "installed" ? "+" : r.status === "overwritten" ? "!" : r.status === "differs-preserved" ? "?" : "=";
+    lines.push(`  ${marker} ${r.skill} (${r.status})`);
+  }
+  const diffs = results.filter((r) => r.status === "differs-preserved");
+  if (diffs.length > 0) {
+    lines.push("");
+    lines.push(
+      `  Note: ${diffs.length} skill(s) already exist with different content and were preserved.`
+    );
+    lines.push(
+      "  Run with --force-skills to overwrite with the vendored version."
+    );
+  }
+  return lines.join("\n");
+}
+
 // src/commands/install-plugin.ts
 async function promptForInstallPath(question, recommendedPath) {
   while (true) {
@@ -10571,10 +10730,474 @@ async function installPluginCommand(options) {
   if (currentMarketplace) {
     console.log(`  marketplace: ${currentMarketplace.manifestPath}`);
   }
+  if (!options.skipSkills) {
+    try {
+      const skillResults = await installSkills({
+        target: "claude",
+        force: options.forceSkills
+      });
+      console.log("");
+      console.log(formatInstallReport(skillResults, "claude"));
+    } catch (error) {
+      console.warn(
+        `Warning: skill install failed \u2014 ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   console.log("\nThe plugin is now available in Claude Code.");
-  console.log("  Skills: /grab-assignment, /plan-assignment, /complete-assignment");
-  console.log("  Background: syntaur-protocol (auto-invoked)");
-  console.log("  Hook: write boundary enforcement (PreToolUse)");
+  console.log("  Slash commands: /grab-assignment, /plan-assignment, /complete-assignment, /create-assignment, /create-project");
+  console.log("  Background: syntaur-protocol skill (auto-invoked)");
+  console.log("  Hook: write boundary enforcement (PreToolUse) + SessionStart/End");
+}
+
+// src/commands/install-statusline.ts
+init_paths();
+init_fs();
+import { readFile as readFile18, writeFile as writeFile8, copyFile as copyFile2, rm as rm5, stat as stat3, symlink as symlink2, unlink as unlink6, lstat as lstat2 } from "fs/promises";
+import { resolve as resolve27, dirname as dirname9 } from "path";
+import { homedir as homedir4 } from "os";
+import { fileURLToPath as fileURLToPath5 } from "url";
+
+// src/commands/configure-statusline.ts
+init_paths();
+init_fs();
+import { readFile as readFile17, writeFile as writeFile7 } from "fs/promises";
+import { resolve as resolve26, dirname as dirname8 } from "path";
+import { spawnSync } from "child_process";
+import { checkbox, input as input2, confirm } from "@inquirer/prompts";
+var AVAILABLE_SEGMENTS = [
+  { name: "git", preview: "syntaur:main* +2", description: "repo:branch (with dirty marker and ahead/behind)" },
+  { name: "assignment", preview: "my-proj/demo-assn \u2014 Demo Assignment", description: "active syntaur assignment (project/slug or standalone/uuid)" },
+  { name: "session", preview: "\u2026ccddeeff", description: "Claude Code session id \u2014 last 8 chars prefixed by \u2026" },
+  { name: "model", preview: "Opus 4.7", description: "Claude model display name" },
+  { name: "ctx", preview: "ctx:[####------] 42%", description: "context window fill bar" },
+  { name: "cwd", preview: "syntaur", description: "basename of current working directory" },
+  { name: "wrap", preview: "<output of an external script>", description: "compose another statusline script as a leading segment" }
+];
+var PRESETS = {
+  minimal: { segments: ["git", "session"], separator: " \xB7 " },
+  syntaur: { segments: ["git", "assignment", "session"], separator: " \xB7 " },
+  full: { segments: ["wrap", "git", "assignment", "model", "ctx", "session"], separator: " \xB7 " },
+  dev: { segments: ["git", "assignment", "ctx", "session"], separator: " \xB7 " }
+};
+function getConfigPath(installRoot) {
+  return resolve26(installRoot, "statusline.config.json");
+}
+async function readConfig2(path) {
+  if (!await fileExists(path)) return null;
+  try {
+    const raw = await readFile17(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    const segments = Array.isArray(parsed.segments) ? parsed.segments.filter(isSegmentName) : [];
+    const separator = typeof parsed.separator === "string" ? parsed.separator : " \xB7 ";
+    const wrap = typeof parsed.wrap === "string" ? parsed.wrap : void 0;
+    return { segments, separator, wrap };
+  } catch {
+    return null;
+  }
+}
+function isSegmentName(value) {
+  return typeof value === "string" && AVAILABLE_SEGMENTS.some((s) => s.name === value);
+}
+function parseSegmentsFlag(flag) {
+  const parts = flag.split(",").map((s) => s.trim()).filter(Boolean);
+  const invalid = parts.filter((p) => !AVAILABLE_SEGMENTS.some((s) => s.name === p));
+  if (invalid.length > 0) {
+    throw new Error(
+      `Unknown segment${invalid.length > 1 ? "s" : ""}: ${invalid.join(", ")}. Valid segments: ${AVAILABLE_SEGMENTS.map((s) => s.name).join(", ")}.`
+    );
+  }
+  return parts;
+}
+async function promptSegmentsInteractive(current) {
+  const canonicalOrder = ["wrap", "git", "assignment", "session", "model", "ctx", "cwd"];
+  const selectedSet = new Set(current?.segments ?? ["git", "assignment", "session"]);
+  const choices = canonicalOrder.map((name) => {
+    const def = AVAILABLE_SEGMENTS.find((s) => s.name === name);
+    return {
+      name: `${def.name.padEnd(11)} ${def.description}`,
+      value: name,
+      checked: selectedSet.has(name),
+      description: `preview: ${def.preview}`
+    };
+  });
+  const selected = await checkbox({
+    message: "Pick segments (space to toggle, enter to confirm):",
+    choices,
+    loop: false,
+    pageSize: choices.length,
+    required: true
+  });
+  const defaultReorderHint = selected.join(", ");
+  let orderedSegments = [...selected];
+  const wantReorder = await confirm({
+    message: `Order will be: ${defaultReorderHint}. Customize order?`,
+    default: false
+  });
+  if (wantReorder) {
+    const raw = await input2({
+      message: `Enter the segments in the order you want, comma-separated:`,
+      default: defaultReorderHint,
+      validate: (value) => {
+        const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
+        const invalid = parts.filter((p) => !canonicalOrder.includes(p));
+        if (invalid.length > 0) {
+          return `Unknown: ${invalid.join(", ")}. Valid: ${canonicalOrder.join(", ")}.`;
+        }
+        const missing = selected.filter((s) => !parts.includes(s));
+        if (missing.length > 0) {
+          return `Missing previously-selected segment(s): ${missing.join(", ")}. Include all of them or go back.`;
+        }
+        return true;
+      }
+    });
+    orderedSegments = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  const separator = await input2({
+    message: "Separator between segments:",
+    default: current?.separator ?? " \xB7 "
+  });
+  let wrap = current?.wrap;
+  if (orderedSegments.includes("wrap")) {
+    wrap = await input2({
+      message: "Path to external script to wrap (leave blank to skip):",
+      default: current?.wrap ?? ""
+    });
+    wrap = wrap.trim() ? wrap.trim() : void 0;
+  }
+  return { segments: orderedSegments, separator, wrap };
+}
+function renderPreview(config, statuslineScript, cwd) {
+  const payload = {
+    session_id: "preview-demo-0000000000abcdef12",
+    cwd,
+    model: { display_name: "Opus 4.7" },
+    context_window: { used_percentage: 42 }
+  };
+  const res = spawnSync("bash", [statuslineScript], {
+    input: JSON.stringify(payload),
+    encoding: "utf-8",
+    env: {
+      ...process.env,
+      // Force the child to pick up the freshly-written config from install root.
+      HOME: dirname8(dirname8(statuslineScript))
+    }
+  });
+  if (res.status !== 0) return null;
+  return res.stdout;
+}
+async function configureStatuslineCommand(options = {}) {
+  const installRoot = options.installRoot ?? syntaurRoot();
+  const configPath = getConfigPath(installRoot);
+  const current = await readConfig2(configPath);
+  let segments;
+  let separator;
+  let wrap;
+  if (options.preset) {
+    const preset = PRESETS[options.preset.toLowerCase()];
+    if (!preset) {
+      throw new Error(
+        `Unknown preset "${options.preset}". Presets: ${Object.keys(PRESETS).join(", ")}.`
+      );
+    }
+    segments = [...preset.segments];
+    separator = options.separator ?? preset.separator;
+    wrap = options.wrap ?? current?.wrap;
+  } else if (options.segments) {
+    segments = parseSegmentsFlag(options.segments);
+    separator = options.separator ?? current?.separator ?? " \xB7 ";
+    wrap = options.wrap ?? current?.wrap;
+  } else if (isInteractiveTerminal()) {
+    const answers = await promptSegmentsInteractive(current);
+    segments = answers.segments;
+    separator = answers.separator;
+    wrap = answers.wrap;
+  } else {
+    throw new Error(
+      "Non-interactive invocation requires --preset, --segments, or run in a TTY."
+    );
+  }
+  if (segments.includes("wrap") && !wrap) {
+    console.warn(
+      `Note: the "wrap" segment is selected but no wrap path is configured. Set one with --wrap <path> or edit ${configPath} afterwards.`
+    );
+  }
+  const config = { segments, separator, ...wrap ? { wrap } : {} };
+  if (options.preview) {
+    console.log("Segments:  " + config.segments.join(", "));
+    console.log("Separator: " + JSON.stringify(config.separator));
+    if (config.wrap) console.log("Wrap:      " + config.wrap);
+    console.log("");
+    console.log("(preview mode \u2014 config NOT written)");
+    return;
+  }
+  await ensureDir(dirname8(configPath));
+  await writeFile7(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  console.log("Wrote statusline config:");
+  console.log(`  path:      ${configPath}`);
+  console.log(`  segments:  ${config.segments.join(", ")}`);
+  console.log(`  separator: ${JSON.stringify(config.separator)}`);
+  if (config.wrap) console.log(`  wrap:      ${config.wrap}`);
+  const script = options.statuslineScript ?? resolve26(installRoot, "statusline.sh");
+  if (await fileExists(script)) {
+    console.log("");
+    console.log("Live preview:");
+    const out = renderPreview(config, script, process.cwd());
+    if (out) {
+      console.log("  " + out);
+    } else {
+      console.log("  (preview failed \u2014 run `syntaur install-statusline` if the script is missing)");
+    }
+  } else {
+    console.log("");
+    console.log(
+      "(statusline script not yet installed \u2014 run `syntaur install-statusline` to wire it up)"
+    );
+  }
+}
+async function writeDefaultConfigIfMissing(installRoot) {
+  const path = getConfigPath(installRoot);
+  if (await fileExists(path)) return;
+  await ensureDir(dirname8(path));
+  const defaultConfig = {
+    segments: ["git", "assignment", "session"],
+    separator: " \xB7 "
+  };
+  await writeFile7(path, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
+}
+
+// src/commands/install-statusline.ts
+function getPackageStatuslineSource() {
+  const here = dirname9(fileURLToPath5(import.meta.url));
+  return resolve27(here, "..", "statusline", "statusline.sh");
+}
+async function readSettingsJson(settingsPath) {
+  if (!await fileExists(settingsPath)) return {};
+  const raw = await readFile18(settingsPath, "utf-8");
+  if (raw.trim() === "") return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (error) {
+    throw new Error(
+      `Unable to parse ${settingsPath}: ${error.message}. Fix the JSON and re-run.`
+    );
+  }
+}
+async function writeSettingsJson(settingsPath, data) {
+  await ensureDir(dirname9(settingsPath));
+  await writeFile8(settingsPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+async function resolveMode(mode, existingCommand, ourCommand) {
+  if (mode !== "ask") return mode;
+  if (!existingCommand || existingCommand === ourCommand) return "replace";
+  if (!isInteractiveTerminal()) {
+    return "wrap";
+  }
+  console.log(
+    `A Claude Code statusLine is already configured:
+  ${existingCommand}
+`
+  );
+  const wantWrap = await confirmPrompt(
+    "Compose (wrap) your existing statusline with syntaur segments? [Y to wrap / n to replace]",
+    true
+  );
+  if (wantWrap) return "wrap";
+  const confirmReplace = await confirmPrompt(
+    "Replace your existing statusline with syntaur only?",
+    false
+  );
+  return confirmReplace ? "replace" : "skip";
+}
+function extractExistingCommand(settings) {
+  const sl = settings.statusLine;
+  if (!sl || typeof sl !== "object") return void 0;
+  const obj = sl;
+  return {
+    type: typeof obj.type === "string" ? obj.type : void 0,
+    command: typeof obj.command === "string" ? obj.command : void 0
+  };
+}
+async function backupSettings(settingsSnapshot, backupPath) {
+  await ensureDir(dirname9(backupPath));
+  await writeFile8(
+    backupPath,
+    JSON.stringify(
+      {
+        version: 1,
+        takenAt: (/* @__PURE__ */ new Date()).toISOString(),
+        settingsPath: settingsSnapshot.settingsPath,
+        previousStatusLine: settingsSnapshot.existingStatusLine ?? null
+      },
+      null,
+      2
+    ) + "\n",
+    "utf-8"
+  );
+}
+async function installScript(sourceScript, destScript, link) {
+  await ensureDir(dirname9(destScript));
+  try {
+    const s = await lstat2(destScript);
+    if (s.isSymbolicLink() || s.isFile()) {
+      await unlink6(destScript);
+    }
+  } catch {
+  }
+  if (link) {
+    await symlink2(sourceScript, destScript);
+  } else {
+    await copyFile2(sourceScript, destScript);
+  }
+}
+async function installStatuslineCommand(options = {}) {
+  const mode = options.mode ?? "ask";
+  const settingsPath = options.settingsPath ?? resolve27(homedir4(), ".claude", "settings.json");
+  const installRoot = options.installRoot ?? syntaurRoot();
+  const sourceScript = options.sourceScript ?? getPackageStatuslineSource();
+  const destScript = resolve27(installRoot, "statusline.sh");
+  const confPath = resolve27(installRoot, "statusline.conf");
+  const backupPath = resolve27(installRoot, "statusline.backup.json");
+  if (!await fileExists(sourceScript)) {
+    throw new Error(
+      `Statusline source script not found at ${sourceScript}. Try re-installing syntaur (npm install -g syntaur) or pass --source-script explicitly.`
+    );
+  }
+  await installScript(sourceScript, destScript, Boolean(options.link));
+  await writeDefaultConfigIfMissing(installRoot);
+  const settings = await readSettingsJson(settingsPath);
+  const existingStatusLine = extractExistingCommand(settings);
+  const existingCommand = existingStatusLine?.command;
+  const ourCommand = `bash ${destScript}`;
+  const resolvedMode = await resolveMode(mode, existingCommand, ourCommand);
+  if (resolvedMode === "skip") {
+    console.log("Installed statusline script only:");
+    console.log(`  script: ${destScript}`);
+    console.log(`  source: ${sourceScript}`);
+    console.log(
+      "  (settings.json left unchanged \u2014 run with --mode=replace or --mode=wrap to wire it up)"
+    );
+    return;
+  }
+  await backupSettings(
+    {
+      settingsPath,
+      existingStatusLine,
+      existingCommand
+    },
+    backupPath
+  );
+  let wrapTarget = "";
+  if (resolvedMode === "wrap" && existingCommand && existingCommand !== ourCommand) {
+    const parsed = parseWrapCommand(existingCommand);
+    if (parsed) {
+      wrapTarget = parsed;
+    } else {
+      const wrapperPath = resolve27(installRoot, "statusline-wrapped.sh");
+      const wrapperBody = `#!/usr/bin/env bash
+# Auto-generated by syntaur install-statusline.
+# Executes the previously configured statusLine command.
+exec ${existingCommand}
+`;
+      await writeFile8(wrapperPath, wrapperBody, "utf-8");
+      await chmodExec(wrapperPath);
+      wrapTarget = wrapperPath;
+    }
+  }
+  await ensureDir(dirname9(confPath));
+  await writeFile8(
+    confPath,
+    wrapTarget ? `# Wrap target \u2014 the command below is invoked with the same stdin; its
+# stdout becomes the leading segment of the statusline. Remove this
+# line or comment it out to disable wrapping.
+${wrapTarget}
+` : `# syntaur statusline config. Add a single path on a non-comment line to
+# wrap another statusline script with syntaur segments appended.
+`,
+    "utf-8"
+  );
+  settings.statusLine = {
+    type: "command",
+    command: ourCommand
+  };
+  await writeSettingsJson(settingsPath, settings);
+  console.log("Installed syntaur statusline:");
+  console.log(`  script:       ${destScript}`);
+  console.log(`  source:       ${sourceScript}`);
+  console.log(`  mode:         ${resolvedMode}`);
+  console.log(`  settings.json:${settingsPath}`);
+  console.log(`  backup:       ${backupPath}`);
+  if (wrapTarget) {
+    console.log(`  wrap target:  ${wrapTarget}`);
+    console.log(`  (edit ${confPath} to change or disable wrapping)`);
+  }
+}
+function parseWrapCommand(command) {
+  const trimmed = command.trim();
+  const bashMatch = trimmed.match(/^bash\s+(\S+)$/);
+  if (bashMatch) return bashMatch[1];
+  if (/^\S+\.(sh|bash)$/.test(trimmed)) return trimmed;
+  return null;
+}
+async function chmodExec(path) {
+  const fs = await import("fs/promises");
+  try {
+    const s = await stat3(path);
+    await fs.chmod(path, s.mode | 73);
+  } catch {
+  }
+}
+async function uninstallStatuslineCommand(options = {}) {
+  const settingsPath = options.settingsPath ?? resolve27(homedir4(), ".claude", "settings.json");
+  const installRoot = options.installRoot ?? syntaurRoot();
+  const destScript = resolve27(installRoot, "statusline.sh");
+  const confPath = resolve27(installRoot, "statusline.conf");
+  const backupPath = resolve27(installRoot, "statusline.backup.json");
+  const wrapperPath = resolve27(installRoot, "statusline-wrapped.sh");
+  const settings = await readSettingsJson(settingsPath);
+  const existing = extractExistingCommand(settings);
+  const ourCommand = `bash ${destScript}`;
+  let restored = null;
+  if (await fileExists(backupPath)) {
+    try {
+      const raw = await readFile18(backupPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const prev = parsed?.previousStatusLine;
+      if (prev && typeof prev === "object" && typeof prev.command === "string") {
+        restored = { command: prev.command };
+      }
+    } catch {
+    }
+  }
+  if (existing?.command === ourCommand) {
+    if (restored) {
+      settings.statusLine = {
+        type: "command",
+        command: restored.command
+      };
+    } else {
+      delete settings.statusLine;
+    }
+    await writeSettingsJson(settingsPath, settings);
+  }
+  if (!options.keepScript) {
+    const configPath = resolve27(installRoot, "statusline.config.json");
+    for (const path of [destScript, confPath, backupPath, wrapperPath, configPath]) {
+      try {
+        await rm5(path, { force: true });
+      } catch {
+      }
+    }
+  }
+  console.log("Uninstalled syntaur statusline.");
+  if (restored) {
+    console.log(`  Restored previous command: ${restored.command}`);
+  } else {
+    console.log("  Removed statusLine entry from settings.json.");
+  }
+  console.log(`  settings.json: ${settingsPath}`);
 }
 
 // src/commands/install-codex-plugin.ts
@@ -10656,14 +11279,61 @@ async function installCodexPluginCommand(options) {
   console.log(`  source: ${result.sourceDir}`);
   console.log(`  mode: ${result.mode}`);
   console.log(`  marketplace: ${marketplace.marketplacePath}`);
+  if (!options.skipSkills) {
+    try {
+      const skillResults = await installSkills({
+        target: "codex",
+        force: options.forceSkills
+      });
+      console.log("");
+      console.log(formatInstallReport(skillResults, "codex"));
+    } catch (error) {
+      console.warn(
+        `Warning: skill install failed \u2014 ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   console.log("\nThe plugin is now available to Codex.");
   console.log(
-    "  Skills: syntaur-protocol, create-project, create-assignment, grab-assignment, plan-assignment, complete-assignment, track-session"
+    "  Protocol skills: syntaur-protocol, create-project, create-assignment, grab-assignment, plan-assignment, complete-assignment"
   );
-  console.log("  Command: /track-session");
+  console.log("  Codex-specific: track-session skill (rollout path aware)");
   console.log("  Hooks: write boundary enforcement, session cleanup");
 }
 
+// src/commands/uninstall-skills.ts
+async function uninstallSkillsCommand(options) {
+  const runClaude = Boolean(options.claude || options.all);
+  const runCodex = Boolean(options.codex || options.all);
+  if (!runClaude && !runCodex) {
+    throw new Error(
+      "Specify --claude, --codex, or --all (use one or more)."
+    );
+  }
+  let totalRemoved = 0;
+  if (runClaude) {
+    const removed = await uninstallSkills({ target: "claude" });
+    totalRemoved += removed.length;
+    console.log(
+      `Removed ${removed.length} Syntaur protocol skill(s) from ~/.claude/skills:`
+    );
+    for (const p of removed) console.log(`  - ${p}`);
+  }
+  if (runCodex) {
+    const removed = await uninstallSkills({ target: "codex" });
+    totalRemoved += removed.length;
+    console.log(
+      `Removed ${removed.length} Syntaur protocol skill(s) from ~/.codex/skills:`
+    );
+    for (const p of removed) console.log(`  - ${p}`);
+  }
+  if (totalRemoved === 0) {
+    console.log(
+      "No Syntaur protocol skills found to remove. (User-authored skills with matching directory names are preserved.)"
+    );
+  }
+}
+
 // src/commands/setup.ts
 import { execSync } from "child_process";
 init_config2();
@@ -10768,7 +11438,7 @@ async function setupCommand(options) {
 }
 
 // src/commands/uninstall.ts
-import { resolve as resolve25 } from "path";
+import { resolve as resolve28 } from "path";
 init_paths();
 function expandTargets(options) {
   if (options.all) {
@@ -10848,7 +11518,7 @@ async function uninstallCommand(options) {
     const configuredProjectDir = await getConfiguredProjectDir();
     await removeSyntaurData();
     console.log(`Removed ${syntaurRoot()}`);
-    if (configuredProjectDir && resolve25(configuredProjectDir) !== resolve25(syntaurRoot(), "projects")) {
+    if (configuredProjectDir && resolve28(configuredProjectDir) !== resolve28(syntaurRoot(), "projects")) {
       console.warn(
         `Warning: config.md pointed to an external project directory (${configuredProjectDir}). That directory was not removed automatically.`
       );
@@ -10863,7 +11533,7 @@ async function uninstallCommand(options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve26 } from "path";
+import { resolve as resolve29 } from "path";
 var SUPPORTED_FRAMEWORKS = ["cursor", "codex", "opencode"];
 async function setupAdapterCommand(framework, options) {
   if (!SUPPORTED_FRAMEWORKS.includes(framework)) {
@@ -10889,19 +11559,19 @@ async function setupAdapterCommand(framework, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-  const projectDir = resolve26(baseDir, options.project);
-  const assignmentDir = resolve26(
+  const projectDir = resolve29(baseDir, options.project);
+  const assignmentDir = resolve29(
     projectDir,
     "assignments",
     options.assignment
   );
-  const projectMdPath = resolve26(projectDir, "project.md");
+  const projectMdPath = resolve29(projectDir, "project.md");
   if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
     throw new Error(
       `Project "${options.project}" not found at ${projectDir}.`
     );
   }
-  const assignmentMdPath = resolve26(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve29(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath)) {
     throw new Error(
       `Assignment "${options.assignment}" not found at ${assignmentDir}.`
@@ -10929,15 +11599,15 @@ async function setupAdapterCommand(framework, options) {
     }
   }
   if (framework === "cursor") {
-    const protocolPath = resolve26(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
-    const assignmentPath = resolve26(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
+    const protocolPath = resolve29(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
+    const assignmentPath = resolve29(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
     await writeAdapterFile(protocolPath, renderCursorProtocol());
     await writeAdapterFile(assignmentPath, renderCursorAssignment(rendererParams));
   } else if (framework === "codex" || framework === "opencode") {
-    const agentsPath = resolve26(cwd, "AGENTS.md");
+    const agentsPath = resolve29(cwd, "AGENTS.md");
     await writeAdapterFile(agentsPath, renderCodexAgents(rendererParams));
     if (framework === "opencode") {
-      const configPath = resolve26(cwd, "opencode.json");
+      const configPath = resolve29(cwd, "opencode.json");
       await writeAdapterFile(configPath, renderOpenCodeConfig({ projectDir }));
     }
   }
@@ -10962,7 +11632,7 @@ async function setupAdapterCommand(framework, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve27 } from "path";
+import { resolve as resolve30 } from "path";
 async function trackSessionCommand(options) {
   if (!options.agent) {
     throw new Error("--agent <name> is required.");
@@ -10975,7 +11645,7 @@ async function trackSessionCommand(options) {
   if (options.project) {
     const config = await readConfig();
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-    const projectDir = resolve27(baseDir, options.project);
+    const projectDir = resolve30(baseDir, options.project);
     if (!await fileExists(projectDir)) {
       throw new Error(
         `Project "${options.project}" not found at ${projectDir}.`
@@ -11030,7 +11700,7 @@ async function browseCommand(options) {
 }
 
 // src/commands/create-playbook.ts
-import { resolve as resolve29 } from "path";
+import { resolve as resolve32 } from "path";
 init_timestamp();
 init_paths();
 init_fs();
@@ -11046,7 +11716,7 @@ async function createPlaybookCommand(name, options) {
   }
   const dir = playbooksDir();
   await ensureDir(dir);
-  const filePath = resolve29(dir, `${slug}.md`);
+  const filePath = resolve32(dir, `${slug}.md`);
   if (await fileExists(filePath)) {
     throw new Error(
       `Playbook "${slug}" already exists at ${filePath}
@@ -11067,15 +11737,15 @@ Use --slug to specify a different slug.`
 init_paths();
 init_fs();
 init_parser();
-import { readdir as readdir11, readFile as readFile16 } from "fs/promises";
-import { resolve as resolve30 } from "path";
+import { readdir as readdir12, readFile as readFile19 } from "fs/promises";
+import { resolve as resolve33 } from "path";
 async function listPlaybooksCommand() {
   const dir = playbooksDir();
   if (!await fileExists(dir)) {
     console.log('No playbooks directory found. Run "syntaur init" first.');
     return;
   }
-  const entries = await readdir11(dir, { withFileTypes: true });
+  const entries = await readdir12(dir, { withFileTypes: true });
   const mdFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_") && e.name !== "manifest.md");
   if (mdFiles.length === 0) {
     console.log('No playbooks found. Create one with "syntaur create-playbook <name>".');
@@ -11086,8 +11756,8 @@ async function listPlaybooksCommand() {
   console.log(`${"Slug".padEnd(30)} ${"Name".padEnd(30)} Description`);
   console.log(`${"\u2500".repeat(30)} ${"\u2500".repeat(30)} ${"\u2500".repeat(40)}`);
   for (const entry of mdFiles) {
-    const filePath = resolve30(dir, entry.name);
-    const raw = await readFile16(filePath, "utf-8");
+    const filePath = resolve33(dir, entry.name);
+    const raw = await readFile19(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     const name = parsed.name || slug;
@@ -11101,8 +11771,8 @@ init_paths();
 init_parser2();
 init_fs();
 import { Command } from "commander";
-import { readFile as readFile17 } from "fs/promises";
-import { resolve as resolve31 } from "path";
+import { readFile as readFile20 } from "fs/promises";
+import { resolve as resolve34 } from "path";
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function resolveWorkspace(options) {
   if (options.global) return "_global";
@@ -11383,10 +12053,10 @@ todoCommand.command("archive").description("Archive completed todos and their lo
       (e) => e.itemIds.every((id) => completedIds.has(id))
     );
     const archFile = archivePath(todosPath, workspace, checklist.archiveInterval);
-    await ensureDir(resolve31(todosPath, "archive"));
+    await ensureDir(resolve34(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
-      archContent = await readFile17(archFile, "utf-8");
+      archContent = await readFile20(archFile, "utf-8");
       archContent = archContent.trimEnd() + "\n\n";
     } else {
       archContent = `---
@@ -11574,20 +12244,20 @@ backupCommand.command("config").description("Show or update backup configuration
 import { Command as Command3 } from "commander";
 
 // src/utils/doctor/index.ts
-import { fileURLToPath as fileURLToPath5 } from "url";
-import { readFile as readFile21 } from "fs/promises";
-import { dirname as dirname8, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
+import { readFile as readFile24 } from "fs/promises";
+import { dirname as dirname11, join as join5 } from "path";
 
 // src/utils/doctor/context.ts
 init_config2();
 init_paths();
 init_fs();
 import Database2 from "better-sqlite3";
-import { resolve as resolve32 } from "path";
+import { resolve as resolve35 } from "path";
 async function buildCheckContext(cwd = process.cwd()) {
   const config = await readConfig();
   const root = syntaurRoot();
-  const dbPath = resolve32(root, "syntaur.db");
+  const dbPath = resolve35(root, "syntaur.db");
   let db2 = null;
   let dbError = null;
   if (await fileExists(dbPath)) {
@@ -11621,10 +12291,10 @@ function closeCheckContext(ctx) {
 // src/utils/doctor/checks/env.ts
 init_fs();
 init_paths();
-import { resolve as resolve33, isAbsolute as isAbsolute3 } from "path";
-import { readFile as readFile18, stat as stat2 } from "fs/promises";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname7, join as join3 } from "path";
+import { resolve as resolve36, isAbsolute as isAbsolute3 } from "path";
+import { readFile as readFile21, stat as stat4 } from "fs/promises";
+import { fileURLToPath as fileURLToPath6 } from "url";
+import { dirname as dirname10, join as join4 } from "path";
 var CATEGORY = "env";
 var syntaurRootExists = {
   id: "env.syntaur-root-exists",
@@ -11632,7 +12302,7 @@ var syntaurRootExists = {
   title: "~/.syntaur/ directory exists",
   async run(ctx) {
     try {
-      const s = await stat2(ctx.syntaurRoot);
+      const s = await stat4(ctx.syntaurRoot);
       if (!s.isDirectory()) {
         return err(this, `${ctx.syntaurRoot} exists but is not a directory`, [
           ctx.syntaurRoot
@@ -11662,7 +12332,7 @@ var configValid = {
   category: CATEGORY,
   title: "~/.syntaur/config.md is valid",
   async run(ctx) {
-    const configPath = resolve33(ctx.syntaurRoot, "config.md");
+    const configPath = resolve36(ctx.syntaurRoot, "config.md");
     if (!await fileExists(configPath)) {
       return {
         id: this.id,
@@ -11679,7 +12349,7 @@ var configValid = {
         autoFixable: false
       };
     }
-    const content = await readFile18(configPath, "utf-8");
+    const content = await readFile21(configPath, "utf-8");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fmMatch || fmMatch[1].trim() === "") {
       return {
@@ -11954,15 +12624,15 @@ async function readLocalVersion() {
 }
 async function readLocalPkg() {
   try {
-    const here = fileURLToPath4(import.meta.url);
-    let dir = dirname7(here);
+    const here = fileURLToPath6(import.meta.url);
+    let dir = dirname10(here);
     for (let i = 0; i < 6; i++) {
-      const candidate = join3(dir, "package.json");
+      const candidate = join4(dir, "package.json");
       try {
-        const text = await readFile18(candidate, "utf-8");
+        const text = await readFile21(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
-        dir = dirname7(dir);
+        dir = dirname10(dir);
       }
     }
     return null;
@@ -12011,8 +12681,8 @@ function versionGte(a, b) {
 
 // src/utils/doctor/checks/structure.ts
 init_fs();
-import { resolve as resolve34 } from "path";
-import { readdir as readdir12, stat as stat3 } from "fs/promises";
+import { resolve as resolve37 } from "path";
+import { readdir as readdir13, stat as stat5 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
   "projects",
@@ -12031,7 +12701,7 @@ var projectsDir = {
   category: CATEGORY2,
   title: "projects/ directory exists",
   async run(ctx) {
-    const p = resolve34(ctx.syntaurRoot, "projects");
+    const p = resolve37(ctx.syntaurRoot, "projects");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -12056,7 +12726,7 @@ var playbooksDir2 = {
   category: CATEGORY2,
   title: "playbooks/ directory exists",
   async run(ctx) {
-    const p = resolve34(ctx.syntaurRoot, "playbooks");
+    const p = resolve37(ctx.syntaurRoot, "playbooks");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -12081,7 +12751,7 @@ var todosDirValid = {
   category: CATEGORY2,
   title: "todos/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve34(ctx.syntaurRoot, "todos");
+    const p = resolve37(ctx.syntaurRoot, "todos");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -12092,7 +12762,7 @@ var todosDirValid = {
         autoFixable: false
       };
     }
-    const s = await stat3(p);
+    const s = await stat5(p);
     if (!s.isDirectory()) {
       return {
         id: this.id,
@@ -12112,7 +12782,7 @@ var serversDirValid = {
   category: CATEGORY2,
   title: "servers/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve34(ctx.syntaurRoot, "servers");
+    const p = resolve37(ctx.syntaurRoot, "servers");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -12123,7 +12793,7 @@ var serversDirValid = {
         autoFixable: false
       };
     }
-    const s = await stat3(p);
+    const s = await stat5(p);
     if (!s.isDirectory()) {
       return {
         id: this.id,
@@ -12143,7 +12813,7 @@ var knownFilesRecognized = {
   category: CATEGORY2,
   title: "No unexpected top-level entries under ~/.syntaur/",
   async run(ctx) {
-    const entries = await readdir12(ctx.syntaurRoot, { withFileTypes: true });
+    const entries = await readdir13(ctx.syntaurRoot, { withFileTypes: true });
     const unexpected = [];
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
@@ -12157,7 +12827,7 @@ var knownFilesRecognized = {
       title: this.title,
       status: "warn",
       detail: `unexpected top-level entries: ${unexpected.join(", ")}`,
-      affected: unexpected.map((n) => resolve34(ctx.syntaurRoot, n)),
+      affected: unexpected.map((n) => resolve37(ctx.syntaurRoot, n)),
       remediation: {
         kind: "manual",
         suggestion: "Review these entries \u2014 they may be leftover state from older versions",
@@ -12186,8 +12856,8 @@ function pass2(check) {
 
 // src/utils/doctor/checks/project.ts
 init_fs();
-import { resolve as resolve35 } from "path";
-import { readdir as readdir13, stat as stat4 } from "fs/promises";
+import { resolve as resolve38 } from "path";
+import { readdir as readdir14, stat as stat6 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
   "project.md",
@@ -12211,15 +12881,15 @@ var PROJECT_MARKERS = ["project.md", "manifest.md", "assignments"];
 async function listProjects2(ctx) {
   const dir = ctx.config.defaultProjectDir;
   if (!await fileExists(dir)) return [];
-  const entries = await readdir13(dir, { withFileTypes: true });
+  const entries = await readdir14(dir, { withFileTypes: true });
   const result = [];
   for (const e of entries) {
     if (!e.isDirectory()) continue;
     if (e.name.startsWith(".") || e.name.startsWith("_")) continue;
-    const projectDir = resolve35(dir, e.name);
+    const projectDir = resolve38(dir, e.name);
     let looksLikeProject = false;
     for (const marker of PROJECT_MARKERS) {
-      if (await fileExists(resolve35(projectDir, marker))) {
+      if (await fileExists(resolve38(projectDir, marker))) {
         looksLikeProject = true;
         break;
       }
@@ -12238,7 +12908,7 @@ var requiredFiles = {
     for (const projectDir of projects) {
       const missing = [];
       for (const rel of REQUIRED_PROJECT_FILES) {
-        const p = resolve35(projectDir, rel);
+        const p = resolve38(projectDir, rel);
         if (!await fileExists(p)) missing.push(rel);
       }
       if (missing.length === 0) continue;
@@ -12248,7 +12918,7 @@ var requiredFiles = {
         title: this.title,
         status: "error",
         detail: `project at ${projectDir} is missing: ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve35(projectDir, m)),
+        affected: missing.map((m) => resolve38(projectDir, m)),
         remediation: {
           kind: "manual",
           suggestion: "Recreate the missing scaffold files from templates",
@@ -12271,9 +12941,9 @@ var manifestStale = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const manifestPath = resolve35(projectDir, "manifest.md");
+      const manifestPath = resolve38(projectDir, "manifest.md");
       if (!await fileExists(manifestPath)) continue;
-      const manifestMtime = (await stat4(manifestPath)).mtimeMs;
+      const manifestMtime = (await stat6(manifestPath)).mtimeMs;
       const newestAssignment = await newestAssignmentMtime(projectDir);
       if (newestAssignment === 0) continue;
       if (newestAssignment > manifestMtime) {
@@ -12305,7 +12975,7 @@ var orphanFiles = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const entries = await readdir13(projectDir, { withFileTypes: true });
+      const entries = await readdir14(projectDir, { withFileTypes: true });
       const orphans = [];
       for (const e of entries) {
         if (e.name.startsWith(".")) continue;
@@ -12320,7 +12990,7 @@ var orphanFiles = {
         title: this.title,
         status: "warn",
         detail: `project at ${projectDir} has unexpected entries: ${orphans.join(", ")}`,
-        affected: orphans.map((o) => resolve35(projectDir, o)),
+        affected: orphans.map((o) => resolve38(projectDir, o)),
         autoFixable: false
       });
     }
@@ -12330,20 +13000,20 @@ var orphanFiles = {
 };
 var projectChecks = [requiredFiles, manifestStale, orphanFiles];
 async function newestAssignmentMtime(projectDir) {
-  const assignmentsRoot = resolve35(projectDir, "assignments");
+  const assignmentsRoot = resolve38(projectDir, "assignments");
   if (!await fileExists(assignmentsRoot)) return 0;
   let newest = 0;
   let entries;
   try {
-    entries = await readdir13(assignmentsRoot, { withFileTypes: true });
+    entries = await readdir14(assignmentsRoot, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const assignmentMd = resolve35(assignmentsRoot, e.name, "assignment.md");
+    const assignmentMd = resolve38(assignmentsRoot, e.name, "assignment.md");
     try {
-      const s = await stat4(assignmentMd);
+      const s = await stat6(assignmentMd);
       if (s.mtimeMs > newest) newest = s.mtimeMs;
     } catch {
     }
@@ -12365,28 +13035,28 @@ init_fs();
 init_parser();
 init_types();
 init_paths();
-import { resolve as resolve36 } from "path";
-import { readdir as readdir14, readFile as readFile19 } from "fs/promises";
+import { resolve as resolve39 } from "path";
+import { readdir as readdir15, readFile as readFile22 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
 async function listAssignments(ctx) {
   const result = { withAssignmentMd: [], orphanFolders: [] };
   const projectsDir2 = ctx.config.defaultProjectDir;
   if (await fileExists(projectsDir2)) {
-    const projects = await readdir14(projectsDir2, { withFileTypes: true });
+    const projects = await readdir15(projectsDir2, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-      const assignmentsDir2 = resolve36(projectsDir2, m.name, "assignments");
+      const assignmentsDir2 = resolve39(projectsDir2, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir14(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir15(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-        const assignmentDir = resolve36(assignmentsDir2, a.name);
-        const assignmentMd = resolve36(assignmentDir, "assignment.md");
+        const assignmentDir = resolve39(assignmentsDir2, a.name);
+        const assignmentMd = resolve39(assignmentDir, "assignment.md");
         const entry = {
-          projectDir: resolve36(projectsDir2, m.name),
+          projectDir: resolve39(projectsDir2, m.name),
           projectSlug: m.name,
           assignmentDir,
           assignmentSlug: a.name,
@@ -12402,12 +13072,12 @@ async function listAssignments(ctx) {
   }
   const standaloneRoot = assignmentsDir();
   if (await fileExists(standaloneRoot)) {
-    const entries = await readdir14(standaloneRoot, { withFileTypes: true });
+    const entries = await readdir15(standaloneRoot, { withFileTypes: true });
     for (const a of entries) {
       if (!a.isDirectory()) continue;
       if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-      const assignmentDir = resolve36(standaloneRoot, a.name);
-      const assignmentMd = resolve36(assignmentDir, "assignment.md");
+      const assignmentDir = resolve39(standaloneRoot, a.name);
+      const assignmentMd = resolve39(assignmentDir, "assignment.md");
       const entry = {
         projectDir: standaloneRoot,
         projectSlug: null,
@@ -12485,7 +13155,7 @@ var invalidStatus = {
     const allowed = configuredStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve36(a.assignmentDir, "assignment.md");
+      const path = resolve39(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (!allowed.has(parsed.status)) {
@@ -12518,7 +13188,7 @@ var workspaceMissing = {
     const terminal = terminalStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve36(a.assignmentDir, "assignment.md");
+      const path = resolve39(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (terminal.has(parsed.status)) continue;
@@ -12565,12 +13235,12 @@ var requiredFilesByStatus = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const assignmentPath = resolve36(a.assignmentDir, "assignment.md");
+      const assignmentPath = resolve39(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(assignmentPath);
       if (!parsed) continue;
       const missing = [];
       if (STATUSES_REQUIRING_HANDOFF.has(parsed.status)) {
-        const handoffPath = resolve36(a.assignmentDir, "handoff.md");
+        const handoffPath = resolve39(a.assignmentDir, "handoff.md");
         if (!await fileExists(handoffPath)) missing.push("handoff.md");
       }
       if (missing.length === 0) continue;
@@ -12580,7 +13250,7 @@ var requiredFilesByStatus = {
         title: this.title,
         status: "warn",
         detail: `${a.projectSlug}/${a.assignmentSlug} (status: ${parsed.status}) is missing ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve36(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve39(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create the missing ${missing.join(" and ")} files for this assignment`,
@@ -12603,7 +13273,7 @@ var companionFilesScaffolded = {
     for (const a of withAssignmentMd) {
       const missing = [];
       for (const filename of ["progress.md", "comments.md"]) {
-        if (!await fileExists(resolve36(a.assignmentDir, filename))) {
+        if (!await fileExists(resolve39(a.assignmentDir, filename))) {
           missing.push(filename);
         }
       }
@@ -12615,7 +13285,7 @@ var companionFilesScaffolded = {
         title: this.title,
         status: "warn",
         detail: `${label} is missing ${missing.join(" and ")} (pre-v2.0 assignment \u2014 not required, but scaffolding them keeps the dashboard and CLIs consistent)`,
-        affected: missing.map((m) => resolve36(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve39(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create ${missing.join(" and ")} with the renderProgress/renderComments templates, or re-scaffold via the CLI`,
@@ -12648,7 +13318,7 @@ var typeDefinition = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve36(a.assignmentDir, "assignment.md");
+      const path = resolve39(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (!parsed.type) continue;
@@ -12682,7 +13352,7 @@ var projectFrontmatterMatchesContainer = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve36(a.assignmentDir, "assignment.md");
+      const path = resolve39(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (a.standalone) {
@@ -12737,7 +13407,7 @@ var assignmentChecks = [
 ];
 async function parseSafe(path) {
   try {
-    const content = await readFile19(path, "utf-8");
+    const content = await readFile22(path, "utf-8");
     return parseAssignmentFull(content);
   } catch {
     return null;
@@ -12756,7 +13426,7 @@ function pass4(check, detail) {
 
 // src/utils/doctor/checks/dashboard.ts
 init_fs();
-import { resolve as resolve37 } from "path";
+import { resolve as resolve40 } from "path";
 var CATEGORY5 = "dashboard";
 var dbReachable = {
   id: "dashboard.db-reachable",
@@ -12770,7 +13440,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `could not open syntaur.db: ${ctx.dbError ?? "unknown error"}`,
-        affected: [resolve37(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve40(ctx.syntaurRoot, "syntaur.db")],
         remediation: {
           kind: "manual",
           suggestion: "Start the dashboard once (`syntaur dashboard`) to initialize the DB, or restore it from backup",
@@ -12788,7 +13458,7 @@ var dbReachable = {
           title: this.title,
           status: "error",
           detail: 'syntaur.db is missing the expected "sessions" table',
-          affected: [resolve37(ctx.syntaurRoot, "syntaur.db")],
+          affected: [resolve40(ctx.syntaurRoot, "syntaur.db")],
           autoFixable: false
         };
       }
@@ -12800,7 +13470,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `syntaur.db query failed: ${err2 instanceof Error ? err2.message : String(err2)}`,
-        affected: [resolve37(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve40(ctx.syntaurRoot, "syntaur.db")],
         autoFixable: false
       };
     }
@@ -12826,7 +13496,7 @@ var ghostSessions = {
     const results = [];
     for (const row of rows) {
       if (!row.project_slug) continue;
-      const projectPath = resolve37(projectsDir2, row.project_slug, "project.md");
+      const projectPath = resolve40(projectsDir2, row.project_slug, "project.md");
       if (!await fileExists(projectPath)) {
         results.push({
           id: this.id,
@@ -12845,7 +13515,7 @@ var ghostSessions = {
         continue;
       }
       if (row.assignment_slug) {
-        const assignmentPath = resolve37(
+        const assignmentPath = resolve40(
           projectsDir2,
           row.project_slug,
           "assignments",
@@ -12897,7 +13567,7 @@ function skipped(check, reason) {
 
 // src/utils/doctor/checks/integrations.ts
 init_fs();
-import { readdir as readdir15 } from "fs/promises";
+import { readdir as readdir16 } from "fs/promises";
 var CATEGORY6 = "integrations";
 var claudePluginLinked = {
   id: "integrations.claude-plugin-linked",
@@ -12959,7 +13629,7 @@ var backupConfigured = {
     if (ctx.config.backup?.repo) return pass6(this);
     const projectsDir2 = ctx.config.defaultProjectDir;
     if (!await fileExists(projectsDir2)) return skipped2(this, "no projects dir");
-    const entries = await readdir15(projectsDir2, { withFileTypes: true });
+    const entries = await readdir16(projectsDir2, { withFileTypes: true });
     const hasProjects = entries.some((e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("_"));
     if (!hasProjects) return skipped2(this, "no projects yet");
     return {
@@ -13002,8 +13672,8 @@ function skipped2(check, reason) {
 init_fs();
 init_parser();
 init_types();
-import { resolve as resolve38 } from "path";
-import { readFile as readFile20 } from "fs/promises";
+import { resolve as resolve41 } from "path";
+import { readFile as readFile23 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
 function hasAnyAssignmentField(ctx) {
@@ -13015,12 +13685,12 @@ function isStandaloneSession(ctx) {
   return !hasAnyAssignmentField(ctx) && typeof ctx.sessionId === "string" && ctx.sessionId.length > 0;
 }
 async function loadContext(ctx) {
-  const path = resolve38(ctx.cwd, ".syntaur", "context.json");
+  const path = resolve41(ctx.cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) {
     return { data: null, path, exists: false, parseError: null };
   }
   try {
-    const raw = await readFile20(path, "utf-8");
+    const raw = await readFile23(path, "utf-8");
     return { data: JSON.parse(raw), path, exists: true, parseError: null };
   } catch (err2) {
     return {
@@ -13095,7 +13765,7 @@ var contextAssignmentResolves = {
     if (!exists) return skipped3(this, "no context to resolve");
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to resolve");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve38(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve41(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       return {
         id: this.id,
@@ -13124,10 +13794,10 @@ var contextTerminal = {
     if (!exists) return skipped3(this, "no context to check");
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to check");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve38(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve41(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
-      const content = await readFile20(assignmentMd, "utf-8");
+      const content = await readFile23(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       const terminal = terminalStatuses2(ctx);
       if (terminal.has(parsed.status)) {
@@ -13270,15 +13940,15 @@ async function finalize(checks) {
 }
 async function readVersion() {
   try {
-    const here = fileURLToPath5(import.meta.url);
-    let dir = dirname8(here);
+    const here = fileURLToPath7(import.meta.url);
+    let dir = dirname11(here);
     for (let i = 0; i < 6; i++) {
       try {
-        const raw = await readFile21(join4(dir, "package.json"), "utf-8");
+        const raw = await readFile24(join5(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
-        dir = dirname8(dir);
+        dir = dirname11(dir);
       }
     }
     return null;
@@ -13411,8 +14081,8 @@ var doctorCommand = new Command3("doctor").description("Diagnose Syntaur state a
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve39 } from "path";
-import { readFile as readFile22 } from "fs/promises";
+import { resolve as resolve42 } from "path";
+import { readFile as readFile25 } from "fs/promises";
 init_timestamp();
 init_assignment_resolver();
 function shortId() {
@@ -13444,7 +14114,7 @@ async function commentCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve39(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve42(baseDir, options.project, "assignments", target);
     assignmentRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -13454,13 +14124,13 @@ async function commentCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     assignmentRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const commentsPath = resolve39(assignmentDir, "comments.md");
+  const commentsPath = resolve42(assignmentDir, "comments.md");
   const timestamp = nowTimestamp();
   const author = options.author ?? process.env.USER ?? "unknown";
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile22(commentsPath, "utf-8");
+    currentContent = await readFile25(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -13497,8 +14167,8 @@ ${entry}`;
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve40 } from "path";
-import { readFile as readFile23 } from "fs/promises";
+import { resolve as resolve43 } from "path";
+import { readFile as readFile26 } from "fs/promises";
 init_timestamp();
 init_assignment_resolver();
 function setTopLevelField3(content, key, value) {
@@ -13523,7 +14193,7 @@ async function requestCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve40(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve43(baseDir, options.project, "assignments", target);
     targetRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -13533,12 +14203,12 @@ async function requestCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     targetRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const assignmentMdPath = resolve40(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve43(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     throw new Error(`assignment.md not found at ${assignmentMdPath}`);
   }
   const source = options.from ?? process.env.SYNTAUR_ASSIGNMENT ?? "unknown";
-  let content = await readFile23(assignmentMdPath, "utf-8");
+  let content = await readFile26(assignmentMdPath, "utf-8");
   const todoLine = `- [ ] ${text.trim()} (from: ${source})`;
   const todosHeading = /^## Todos\s*$/m;
   if (todosHeading.test(content)) {
@@ -13566,10 +14236,10 @@ ${todoLine}
 
 // src/cli-default-command.ts
 init_config2();
-import { readdir as readdir16 } from "fs/promises";
+import { readdir as readdir17 } from "fs/promises";
 async function hasAnyProjectContent(projectsDir2) {
   try {
-    const entries = await readdir16(projectsDir2, { withFileTypes: true });
+    const entries = await readdir17(projectsDir2, { withFileTypes: true });
     return entries.some((entry) => entry.isDirectory());
   } catch {
     return false;
@@ -13605,21 +14275,21 @@ async function getDefaultCommandName() {
 // src/utils/npx-prompt.ts
 init_paths();
 init_fs();
-import { fileURLToPath as fileURLToPath7 } from "url";
-import { readFile as readFile25 } from "fs/promises";
-import { dirname as dirname10, join as join6, resolve as resolve41 } from "path";
+import { fileURLToPath as fileURLToPath9 } from "url";
+import { readFile as readFile28 } from "fs/promises";
+import { dirname as dirname13, join as join7, resolve as resolve44 } from "path";
 import { spawn as spawn3 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
-import { fileURLToPath as fileURLToPath6 } from "url";
-import { readFile as readFile24 } from "fs/promises";
-import { dirname as dirname9, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath8 } from "url";
+import { readFile as readFile27 } from "fs/promises";
+import { dirname as dirname12, join as join6 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
-    const scriptPath = fileURLToPath6(scriptUrl);
-    const pkgRoot = dirname9(dirname9(scriptPath));
-    const raw = await readFile24(join5(pkgRoot, "package.json"), "utf-8");
+    const scriptPath = fileURLToPath8(scriptUrl);
+    const pkgRoot = dirname12(dirname12(scriptPath));
+    const raw = await readFile27(join6(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -13628,13 +14298,13 @@ async function readPackageVersion(scriptUrl) {
 }
 
 // src/utils/npx-prompt.ts
-var STATE_FILE = resolve41(syntaurRoot(), "npx-install.json");
+var STATE_FILE = resolve44(syntaurRoot(), "npx-install.json");
 var META_ARGS = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version", "help"]);
 var GLOBAL_VERSION_TIMEOUT_MS = 2e3;
 function isRunningViaNpx(scriptUrl) {
   let scriptPath;
   try {
-    scriptPath = fileURLToPath7(scriptUrl);
+    scriptPath = fileURLToPath9(scriptUrl);
   } catch {
     return false;
   }
@@ -13649,7 +14319,7 @@ function isRunningViaNpx(scriptUrl) {
 async function readState() {
   if (!await fileExists(STATE_FILE)) return null;
   try {
-    const raw = await readFile25(STATE_FILE, "utf-8");
+    const raw = await readFile28(STATE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -13660,10 +14330,10 @@ async function writeState(state) {
 `);
 }
 async function resolveNpmBin() {
-  const nodeDir = dirname10(process.execPath);
+  const nodeDir = dirname13(process.execPath);
   const isWin = process.platform === "win32";
   const npmName = isWin ? "npm.cmd" : "npm";
-  const nearNode = join6(nodeDir, npmName);
+  const nearNode = join7(nodeDir, npmName);
   if (await fileExists(nearNode)) {
     return { cmd: nearNode, shell: false };
   }
@@ -13706,9 +14376,9 @@ async function readGlobalVersion() {
   });
   if (!rootPath) return null;
   try {
-    const manifestPath = join6(rootPath, "syntaur", "package.json");
+    const manifestPath = join7(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
-    const raw = await readFile25(manifestPath, "utf-8");
+    const raw = await readFile28(manifestPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -14003,7 +14673,7 @@ program.command("setup").description("Initialize Syntaur and optionally install
     process.exit(1);
   }
 });
-program.command("install-plugin").description("Install the Syntaur Claude Code plugin").option("--force", "Overwrite an existing Syntaur-managed install").option("--target-dir <path>", "Install the plugin at a specific directory").option("--link", "Use a symlink instead of copying files (repo-local dev only)").action(async (options) => {
+program.command("install-plugin").description("Install the Syntaur Claude Code plugin").option("--force", "Overwrite an existing Syntaur-managed install").option("--target-dir <path>", "Install the plugin at a specific directory").option("--link", "Use a symlink instead of copying files (repo-local dev only)").option("--force-skills", "Overwrite user-edited skills in ~/.claude/skills").option("--skip-skills", "Do not install protocol skills into ~/.claude/skills").action(async (options) => {
   try {
     await installPluginCommand({ ...options, promptForTarget: true });
   } catch (error) {
@@ -14014,7 +14684,61 @@ program.command("install-plugin").description("Install the Syntaur Claude Code p
     process.exit(1);
   }
 });
-program.command("install-codex-plugin").description("Install the Syntaur Codex plugin and marketplace entry").option("--force", "Overwrite an existing Syntaur-managed install").option("--target-dir <path>", "Install the plugin at a specific directory").option("--marketplace-path <path>", "Write the marketplace entry to a specific file").option("--link", "Use a symlink instead of copying files (repo-local dev only)").action(async (options) => {
+program.command("install-statusline").description(
+  "Install the syntaur statusLine for Claude Code. Augments ~/.claude/settings.json; wraps any existing script by default."
+).option("--mode <mode>", "replace | wrap | skip | ask (default: ask, wrap in non-TTY)", "ask").option("--link", "Symlink the installed script to the package source (dev mode)").action(async (options) => {
+  try {
+    const rawMode = (options.mode ?? "ask").toLowerCase();
+    const valid = ["replace", "wrap", "skip", "ask"];
+    if (!valid.includes(rawMode)) {
+      throw new Error(
+        `Invalid --mode "${rawMode}". Must be one of: ${valid.join(", ")}.`
+      );
+    }
+    await installStatuslineCommand({
+      mode: rawMode,
+      link: options.link
+    });
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("uninstall-statusline").description(
+  "Remove the syntaur statusLine. Restores the previously configured command from backup if present."
+).option("--keep-script", "Leave ~/.syntaur/statusline.sh on disk (only edit settings.json)").action(async (options) => {
+  try {
+    await uninstallStatuslineCommand({ keepScript: options.keepScript });
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("configure-statusline").description(
+  "Configure which segments (git, assignment, session, model, ctx, cwd, wrap) appear in the syntaur statusLine and in what order."
+).option(
+  "--preset <name>",
+  `Preset shortcut. Choices: ${Object.keys(PRESETS).join(", ")}.`
+).option(
+  "--segments <list>",
+  'Comma-separated segment list, e.g. "git,assignment,session,model,ctx".'
+).option("--separator <string>", 'Segment separator (default " \xB7 ")').option("--wrap <path>", 'Path to an external statusline script to compose as a "wrap" segment').option("--preview", "Print the resolved config and a preview line without writing").action(async (options) => {
+  try {
+    await configureStatuslineCommand(options);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("uninstall-skills").description("Remove Syntaur protocol skills from ~/.claude/skills and/or ~/.codex/skills").option("--claude", "Remove from ~/.claude/skills").option("--codex", "Remove from ~/.codex/skills").option("--all", "Remove from both").action(async (options) => {
+  try {
+    await uninstallSkillsCommand(options);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("install-codex-plugin").description("Install the Syntaur Codex plugin and marketplace entry").option("--force", "Overwrite an existing Syntaur-managed install").option("--target-dir <path>", "Install the plugin at a specific directory").option("--marketplace-path <path>", "Write the marketplace entry to a specific file").option("--link", "Use a symlink instead of copying files (repo-local dev only)").option("--force-skills", "Overwrite user-edited skills in ~/.codex/skills").option("--skip-skills", "Do not install protocol skills into ~/.codex/skills").action(async (options) => {
   try {
     await installCodexPluginCommand({ ...options, promptForTarget: true });
   } catch (error) {