cc-mirror 1.2.1 → 1.4.0

package/dist/cc-mirror.mjs

@@ -39,9 +39,17 @@ var parseArgs = (argv) => {
       if (value2) opts.env.push(value2);
       continue;
     }
-    const [key, inlineValue] = arg.startsWith("--") ? arg.slice(2).split("=") : [null, null];
+    const [key, inlineValue] = arg.startsWith("--") ? arg.slice(2).split("=") : [void 0, void 0];
     if (!key) continue;
-    const value = inlineValue ?? args.shift();
+    let value;
+    if (inlineValue !== void 0) {
+      value = inlineValue;
+    } else {
+      const next = args[0];
+      if (next && !next.startsWith("-")) {
+        value = args.shift();
+      }
+    }
     if (value !== void 0) {
       opts[key] = value;
     } else {
@@ -104,6 +112,7 @@ COMMANDS
   remove <name>                Remove a variant
   doctor                       Health check all variants
   tweak <name>                 Launch tweakcc customization
+  tasks [operation]            Manage team tasks (list, show, create, update, delete, clean)
 
 OPTIONS (create/quick)
   --name <name>                Variant name (becomes CLI command)
@@ -2456,6 +2465,63 @@ var removeOrchestratorSkill = (configDir) => {
     return { status: "failed", message };
   }
 };
+var TASK_MANAGER_SKILL_NAME = "task-manager";
+var findBundledTaskManagerSkillDir = () => {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = path7.dirname(thisFile);
+  const devPath = path7.join(thisDir, "..", "skills", TASK_MANAGER_SKILL_NAME);
+  if (fs6.existsSync(devPath)) return devPath;
+  const distPath = path7.join(thisDir, "skills", TASK_MANAGER_SKILL_NAME);
+  if (fs6.existsSync(distPath)) return distPath;
+  const distPath2 = path7.join(thisDir, "..", "skills", TASK_MANAGER_SKILL_NAME);
+  if (fs6.existsSync(distPath2)) return distPath2;
+  return null;
+};
+var installTaskManagerSkill = (configDir) => {
+  const sourceDir = findBundledTaskManagerSkillDir();
+  if (!sourceDir) {
+    return { status: "failed", message: "bundled task-manager skill not found" };
+  }
+  const skillsDir = path7.join(configDir, "skills");
+  const targetDir = path7.join(skillsDir, TASK_MANAGER_SKILL_NAME);
+  const markerPath = path7.join(targetDir, MANAGED_MARKER);
+  try {
+    ensureDir2(skillsDir);
+    if (fs6.existsSync(targetDir) && !fs6.existsSync(markerPath)) {
+      return { status: "skipped", message: "existing skill is user-managed", path: targetDir };
+    }
+    if (fs6.existsSync(targetDir)) {
+      fs6.rmSync(targetDir, { recursive: true, force: true });
+    }
+    copyDir(sourceDir, targetDir);
+    fs6.writeFileSync(
+      markerPath,
+      JSON.stringify({ managedBy: "cc-mirror", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)
+    );
+    return { status: "installed", path: targetDir };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { status: "failed", message };
+  }
+};
+var removeTaskManagerSkill = (configDir) => {
+  const skillsDir = path7.join(configDir, "skills");
+  const targetDir = path7.join(skillsDir, TASK_MANAGER_SKILL_NAME);
+  const markerPath = path7.join(targetDir, MANAGED_MARKER);
+  if (!fs6.existsSync(targetDir)) {
+    return { status: "skipped", message: "skill not installed" };
+  }
+  if (!fs6.existsSync(markerPath)) {
+    return { status: "skipped", message: "skill is user-managed, not removing" };
+  }
+  try {
+    fs6.rmSync(targetDir, { recursive: true, force: true });
+    return { status: "removed", path: targetDir };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { status: "failed", message };
+  }
+};
 var spawnAsync = (cmd, args) => {
   return new Promise((resolve) => {
     const child = spawn3(cmd, args, { stdio: "pipe" });
@@ -2612,7 +2678,7 @@ var TeamModeStep = class {
     this.patchCli(ctx);
   }
   patchCli(ctx) {
-    const { state, params, paths } = ctx;
+    const { state, paths } = ctx;
     const cliPath = path9.join(paths.npmDir, "node_modules", "@anthropic-ai", "claude-code", "cli.js");
     const backupPath = `${cliPath}.backup`;
     if (!fs8.existsSync(cliPath)) {
@@ -2643,8 +2709,8 @@ var TeamModeStep = class {
       try {
         const settings = JSON.parse(fs8.readFileSync(settingsPath, "utf8"));
         settings.env = settings.env || {};
-        if (!settings.env.CLAUDE_CODE_TEAM_NAME) {
-          settings.env.CLAUDE_CODE_TEAM_NAME = params.name;
+        if (!settings.env.CLAUDE_CODE_TEAM_MODE) {
+          settings.env.CLAUDE_CODE_TEAM_MODE = "1";
         }
         if (!settings.env.CLAUDE_CODE_AGENT_TYPE) {
           settings.env.CLAUDE_CODE_AGENT_TYPE = "team-lead";
@@ -2666,6 +2732,12 @@ var TeamModeStep = class {
     } else if (skillResult.status === "failed") {
       state.notes.push(`Warning: orchestrator skill install failed: ${skillResult.message}`);
     }
+    const taskSkillResult = installTaskManagerSkill(paths.configDir);
+    if (taskSkillResult.status === "installed") {
+      state.notes.push("Task manager skill installed");
+    } else if (taskSkillResult.status === "failed") {
+      state.notes.push(`Warning: task-manager skill install failed: ${taskSkillResult.message}`);
+    }
     const systemPromptsDir = path9.join(paths.tweakDir, "system-prompts");
     const copiedFiles = copyTeamPackPrompts(systemPromptsDir);
     if (copiedFiles.length > 0) {
@@ -3615,23 +3687,23 @@ var writeWrapper = (wrapperPath, configDir, binaryPath, runtime = "node") => {
     'if [[ "${CC_MIRROR_UNSET_AUTH_TOKEN:-0}" != "0" ]]; then',
     "  unset ANTHROPIC_AUTH_TOKEN",
     "fi",
-    "# Dynamic team name: scoped by project folder, with optional TEAM modifier",
-    'if [[ -n "$CLAUDE_CODE_TEAM_NAME" ]]; then',
+    "# Dynamic team name: purely directory-based, with optional TEAM modifier",
+    "# Check for CLAUDE_CODE_TEAM_MODE (not TEAM_NAME) to avoid Claude Code overwriting",
+    'if [[ -n "${CLAUDE_CODE_TEAM_MODE:-}" ]]; then',
     "  __cc_git_root=$(git rev-parse --show-toplevel 2>/dev/null || pwd)",
     '  __cc_folder_name=$(basename "$__cc_git_root")',
-    '  if [[ -n "$TEAM" ]]; then',
-    "    # Base team name + project folder + TEAM modifier",
-    '    export CLAUDE_CODE_TEAM_NAME="${CLAUDE_CODE_TEAM_NAME}-${__cc_folder_name}-${TEAM}"',
+    '  if [[ -n "${TEAM:-}" ]]; then',
+    "    # Folder name + TEAM modifier",
+    '    export CLAUDE_CODE_TEAM_NAME="${__cc_folder_name}-${TEAM}"',
     "  else",
-    "    # Base team name + project folder (auto-scoped)",
-    '    export CLAUDE_CODE_TEAM_NAME="${CLAUDE_CODE_TEAM_NAME}-${__cc_folder_name}"',
+    "    # Just folder name (pure directory-based)",
+    '    export CLAUDE_CODE_TEAM_NAME="${__cc_folder_name}"',
     "  fi",
-    'elif [[ -n "$TEAM" ]]; then',
-    "  # TEAM alias set but no base team name in settings",
+    'elif [[ -n "${TEAM:-}" ]]; then',
+    "  # TEAM env var set without team mode in settings - use folder + TEAM",
     "  __cc_git_root=$(git rev-parse --show-toplevel 2>/dev/null || pwd)",
     '  __cc_folder_name=$(basename "$__cc_git_root")',
-    '  __cc_variant_name=$(basename "$(dirname "$CLAUDE_CONFIG_DIR")")',
-    '  export CLAUDE_CODE_TEAM_NAME="${__cc_variant_name}-${__cc_folder_name}-${TEAM}"',
+    '  export CLAUDE_CODE_TEAM_NAME="${__cc_folder_name}-${TEAM}"',
     "fi",
     ...splash,
     execLine,
@@ -4111,9 +4183,15 @@ var TeamModeUpdateStep = class {
     } else if (skillResult.status === "failed") {
       state.notes.push(`Warning: orchestrator skill removal failed: ${skillResult.message}`);
     }
+    const taskSkillResult = removeTaskManagerSkill(meta.configDir);
+    if (taskSkillResult.status === "removed") {
+      state.notes.push("Task manager skill removed");
+    } else if (taskSkillResult.status === "failed") {
+      state.notes.push(`Warning: task-manager skill removal failed: ${taskSkillResult.message}`);
+    }
   }
   patchCli(ctx) {
-    const { state, meta, name, paths } = ctx;
+    const { state, meta, paths } = ctx;
     const cliPath = path18.join(paths.npmDir, "node_modules", "@anthropic-ai", "claude-code", "cli.js");
     const backupPath = `${cliPath}.backup`;
     if (!fs13.existsSync(cliPath)) {
@@ -4145,8 +4223,8 @@ var TeamModeUpdateStep = class {
       try {
         const settings = JSON.parse(fs13.readFileSync(settingsPath, "utf8"));
         settings.env = settings.env || {};
-        if (!settings.env.CLAUDE_CODE_TEAM_NAME) {
-          settings.env.CLAUDE_CODE_TEAM_NAME = name;
+        if (!settings.env.CLAUDE_CODE_TEAM_MODE) {
+          settings.env.CLAUDE_CODE_TEAM_MODE = "1";
         }
         if (!settings.env.CLAUDE_CODE_AGENT_TYPE) {
           settings.env.CLAUDE_CODE_AGENT_TYPE = "team-lead";
@@ -4169,6 +4247,12 @@ var TeamModeUpdateStep = class {
     } else if (skillResult.status === "failed") {
       state.notes.push(`Warning: orchestrator skill install failed: ${skillResult.message}`);
     }
+    const taskSkillResult = installTaskManagerSkill(meta.configDir);
+    if (taskSkillResult.status === "installed") {
+      state.notes.push("Task manager skill installed");
+    } else if (taskSkillResult.status === "failed") {
+      state.notes.push(`Warning: task-manager skill install failed: ${taskSkillResult.message}`);
+    }
     const systemPromptsDir = path18.join(meta.tweakDir, "system-prompts");
     const copiedFiles = copyTeamPackPrompts(systemPromptsDir);
     if (copiedFiles.length > 0) {
@@ -5028,6 +5112,1034 @@ async function runCreateCommand({ opts, quickMode }) {
   }
 }
 
+// src/core/tasks/store.ts
+import fs15 from "node:fs";
+import path25 from "node:path";
+function getTasksDir(rootDir, variant, team) {
+  return path25.join(rootDir, variant, "config", "tasks", team);
+}
+function listTaskIds(tasksDir) {
+  if (!fs15.existsSync(tasksDir)) return [];
+  return fs15.readdirSync(tasksDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", "")).sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+}
+function loadTask(tasksDir, id) {
+  const taskPath = path25.join(tasksDir, `${id}.json`);
+  if (!fs15.existsSync(taskPath)) return null;
+  return readJson(taskPath);
+}
+function loadAllTasks(tasksDir) {
+  const ids = listTaskIds(tasksDir);
+  return ids.map((id) => loadTask(tasksDir, id)).filter((task) => task !== null);
+}
+function saveTask(tasksDir, task) {
+  fs15.mkdirSync(tasksDir, { recursive: true });
+  const taskPath = path25.join(tasksDir, `${task.id}.json`);
+  writeJson(taskPath, task);
+}
+function deleteTask(tasksDir, id) {
+  const taskPath = path25.join(tasksDir, `${id}.json`);
+  if (!fs15.existsSync(taskPath)) return false;
+  fs15.unlinkSync(taskPath);
+  return true;
+}
+function getNextTaskId(tasksDir) {
+  const ids = listTaskIds(tasksDir);
+  if (ids.length === 0) return "1";
+  const maxId = Math.max(...ids.map((id) => parseInt(id, 10)));
+  return String(maxId + 1);
+}
+function createTask(tasksDir, subject, description, opts) {
+  const id = getNextTaskId(tasksDir);
+  const task = {
+    id,
+    subject,
+    description,
+    status: "open",
+    owner: opts?.owner,
+    references: [],
+    blocks: opts?.blocks || [],
+    blockedBy: opts?.blockedBy || [],
+    comments: []
+  };
+  saveTask(tasksDir, task);
+  return task;
+}
+function listTeams(rootDir, variant) {
+  const tasksRoot = path25.join(rootDir, variant, "config", "tasks");
+  if (!fs15.existsSync(tasksRoot)) return [];
+  return fs15.readdirSync(tasksRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+
+// src/core/tasks/resolve.ts
+import fs16 from "node:fs";
+import path26 from "node:path";
+import { execSync } from "node:child_process";
+function detectVariantFromEnv() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR;
+  if (!configDir) return null;
+  const match = configDir.match(/\.cc-mirror\/([^/]+)\/config/);
+  return match ? match[1] : null;
+}
+function detectCurrentTeam(cwd) {
+  const teamFromEnv = process.env.CLAUDE_CODE_TEAM_NAME;
+  if (teamFromEnv) {
+    return teamFromEnv;
+  }
+  const workDir = cwd || process.cwd();
+  let gitRoot;
+  try {
+    gitRoot = execSync("git rev-parse --show-toplevel 2>/dev/null", {
+      cwd: workDir,
+      encoding: "utf8"
+    }).trim();
+  } catch {
+    gitRoot = workDir;
+  }
+  const folderName = path26.basename(gitRoot);
+  const teamModifier = process.env.TEAM;
+  if (teamModifier) {
+    return `${folderName}-${teamModifier}`;
+  }
+  return folderName;
+}
+function listVariantsWithTasks(rootDir) {
+  const variants = listVariants(rootDir);
+  return variants.map((v) => v.name).filter((name) => {
+    const tasksRoot = path26.join(rootDir, name, "config", "tasks");
+    return fs16.existsSync(tasksRoot);
+  });
+}
+function resolveContext(opts) {
+  const { rootDir, variant, team, allVariants, allTeams, cwd } = opts;
+  const locations = [];
+  let variants;
+  if (allVariants) {
+    variants = listVariantsWithTasks(rootDir);
+  } else if (variant) {
+    variants = [variant];
+  } else {
+    const envVariant = detectVariantFromEnv();
+    if (envVariant) {
+      variants = [envVariant];
+    } else {
+      const variantsWithTasks = listVariantsWithTasks(rootDir);
+      variants = variantsWithTasks.length > 0 ? [variantsWithTasks[0]] : [];
+    }
+  }
+  for (const v of variants) {
+    let teams;
+    if (allTeams) {
+      teams = listTeams(rootDir, v);
+    } else if (team) {
+      teams = [team];
+    } else {
+      const detectedTeam = detectCurrentTeam(cwd);
+      const availableTeams = listTeams(rootDir, v);
+      if (availableTeams.includes(detectedTeam)) {
+        teams = [detectedTeam];
+      } else if (availableTeams.length > 0) {
+        teams = availableTeams;
+      } else {
+        teams = [];
+      }
+    }
+    for (const t of teams) {
+      const tasksDir = path26.join(rootDir, v, "config", "tasks", t);
+      if (fs16.existsSync(tasksDir)) {
+        locations.push({ variant: v, team: t, tasksDir });
+      }
+    }
+  }
+  return { locations };
+}
+
+// src/core/tasks/queries.ts
+function isBlocked(task, allTasks) {
+  if (task.blockedBy.length === 0) return false;
+  const taskMap = new Map(allTasks.map((t) => [t.id, t]));
+  return task.blockedBy.some((id) => {
+    const blockingTask = taskMap.get(id);
+    return blockingTask && blockingTask.status === "open";
+  });
+}
+function isBlocking(task) {
+  return task.blocks.length > 0;
+}
+function filterTasks(tasks, filter, allTasks) {
+  let filtered = [...tasks];
+  const taskContext = allTasks || tasks;
+  if (filter.status && filter.status !== "all") {
+    filtered = filtered.filter((t) => t.status === filter.status);
+  }
+  if (filter.blocked !== void 0) {
+    if (filter.blocked) {
+      filtered = filtered.filter((t) => isBlocked(t, taskContext));
+    } else {
+      filtered = filtered.filter((t) => !isBlocked(t, taskContext));
+    }
+  }
+  if (filter.blocking !== void 0) {
+    if (filter.blocking) {
+      filtered = filtered.filter((t) => isBlocking(t));
+    } else {
+      filtered = filtered.filter((t) => !isBlocking(t));
+    }
+  }
+  if (filter.owner) {
+    filtered = filtered.filter((t) => t.owner === filter.owner);
+  }
+  if (filter.limit && filter.limit > 0) {
+    filtered = filtered.slice(0, filter.limit);
+  }
+  return filtered;
+}
+function getTaskSummary(tasks) {
+  const open = tasks.filter((t) => t.status === "open");
+  const resolved = tasks.filter((t) => t.status === "resolved");
+  const blocked = open.filter((t) => isBlocked(t, tasks));
+  return {
+    total: tasks.length,
+    open: open.length,
+    resolved: resolved.length,
+    blocked: blocked.length
+  };
+}
+function sortTasksById(tasks) {
+  return [...tasks].sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
+}
+
+// src/cli/commands/tasks/output.ts
+function truncate(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 3) + "...";
+}
+function pad(text, width) {
+  return text.padEnd(width);
+}
+function formatTaskTable(tasks, location, summary) {
+  const lines = [];
+  const { variant, team } = location;
+  lines.push(`TASKS (${variant} / ${team}) - ${summary.open} open, ${summary.resolved} resolved`);
+  lines.push("\u2500".repeat(70));
+  lines.push(`${pad("ID", 5)} ${pad("STATUS", 10)} ${pad("SUBJECT", 45)} BLOCKED`);
+  lines.push("\u2500".repeat(70));
+  for (const task of tasks) {
+    const blocked = isBlocked(task, tasks) ? "\u25CF" : "";
+    const status = task.status;
+    const subject = truncate(task.subject, 45);
+    lines.push(`${pad(task.id, 5)} ${pad(status, 10)} ${pad(subject, 45)} ${blocked}`);
+  }
+  lines.push("\u2500".repeat(70));
+  if (summary.blocked > 0) {
+    lines.push("\u25CF = blocked by unresolved tasks");
+  }
+  return lines.join("\n");
+}
+function formatMultiLocationTaskTable(tasksByLocation) {
+  const sections = [];
+  for (const { location, tasks, summary } of tasksByLocation) {
+    sections.push(formatTaskTable(tasks, location, summary));
+    sections.push("");
+  }
+  return sections.join("\n");
+}
+function formatTaskDetail(task, location, allTasks) {
+  const lines = [];
+  const { variant, team } = location;
+  lines.push(`TASK #${task.id} (${variant} / ${team})`);
+  lines.push("\u2550".repeat(60));
+  lines.push("");
+  lines.push(`Subject:     ${task.subject}`);
+  lines.push(`Status:      ${task.status}`);
+  lines.push(`Owner:       ${task.owner || "(unassigned)"}`);
+  lines.push("");
+  if (task.description) {
+    lines.push("Description:");
+    const descLines = task.description.split("\n");
+    for (const line of descLines.slice(0, 10)) {
+      lines.push(`  ${line}`);
+    }
+    if (descLines.length > 10) {
+      lines.push(`  ... (${descLines.length - 10} more lines)`);
+    }
+    lines.push("");
+  }
+  if (task.blockedBy.length > 0 || task.blocks.length > 0) {
+    lines.push("Dependencies:");
+    if (task.blockedBy.length > 0) {
+      const blockedByStatus = task.blockedBy.map((id) => {
+        const t = allTasks.find((t2) => t2.id === id);
+        return t ? `#${id} (${t.status})` : `#${id} (?)`;
+      });
+      lines.push(`  Blocked by: ${blockedByStatus.join(", ")}`);
+    }
+    if (task.blocks.length > 0) {
+      lines.push(`  Blocks:     ${task.blocks.map((id) => `#${id}`).join(", ")}`);
+    }
+    lines.push("");
+  }
+  if (task.references.length > 0) {
+    lines.push(`References:  ${task.references.map((id) => `#${id}`).join(", ")}`);
+    lines.push("");
+  }
+  if (task.comments.length > 0) {
+    lines.push(`Comments (${task.comments.length}):`);
+    for (const comment of task.comments) {
+      lines.push(`  \u250C\u2500 ${comment.author} ${"\u2500".repeat(Math.max(0, 50 - comment.author.length))}`);
+      const commentLines = comment.content.split("\n");
+      for (const line of commentLines) {
+        lines.push(`  \u2502 ${line}`);
+      }
+      lines.push("  \u2514" + "\u2500".repeat(55));
+    }
+  }
+  return lines.join("\n");
+}
+function formatTasksJson(tasks, location, summary) {
+  return JSON.stringify(
+    {
+      variant: location.variant,
+      team: location.team,
+      tasks,
+      summary
+    },
+    null,
+    2
+  );
+}
+function formatTaskJson(task, location) {
+  return JSON.stringify(
+    {
+      variant: location.variant,
+      team: location.team,
+      task
+    },
+    null,
+    2
+  );
+}
+function formatMultiLocationJson(tasksByLocation) {
+  return JSON.stringify(
+    {
+      locations: tasksByLocation.map(({ location, tasks, summary }) => ({
+        variant: location.variant,
+        team: location.team,
+        tasks,
+        summary
+      }))
+    },
+    null,
+    2
+  );
+}
+function formatCleanResults(results) {
+  const lines = [];
+  for (const { location, deleted, dryRun } of results) {
+    const action = dryRun ? "Would delete" : "Deleted";
+    lines.push(`${location.variant} / ${location.team}: ${action} ${deleted.length} tasks`);
+    if (deleted.length > 0 && deleted.length <= 10) {
+      lines.push(`  IDs: ${deleted.join(", ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/tasks/list.ts
+function runTasksList(opts) {
+  const context = resolveContext({
+    rootDir: opts.rootDir,
+    variant: opts.variant,
+    team: opts.team,
+    allVariants: opts.allVariants,
+    allTeams: opts.allTeams
+  });
+  if (context.locations.length === 0) {
+    console.log("No task locations found. Check variant and team settings.");
+    return;
+  }
+  const tasksByLocation = context.locations.map((location) => {
+    const allTasks = loadAllTasks(location.tasksDir);
+    const filteredTasks = filterTasks(
+      allTasks,
+      {
+        status: opts.status || "open",
+        blocked: opts.blocked,
+        blocking: opts.blocking,
+        owner: opts.owner,
+        limit: opts.limit
+      },
+      allTasks
+    );
+    const sortedTasks = sortTasksById(filteredTasks);
+    const summary = getTaskSummary(allTasks);
+    return { location, tasks: sortedTasks, summary };
+  });
+  if (opts.json) {
+    if (tasksByLocation.length === 1) {
+      const { location, tasks, summary } = tasksByLocation[0];
+      console.log(formatTasksJson(tasks, location, summary));
+    } else {
+      console.log(formatMultiLocationJson(tasksByLocation));
+    }
+  } else {
+    if (tasksByLocation.length === 1) {
+      const { location, tasks, summary } = tasksByLocation[0];
+      console.log(formatTaskTable(tasks, location, summary));
+    } else {
+      console.log(formatMultiLocationTaskTable(tasksByLocation));
+    }
+  }
+}
+
+// src/cli/commands/tasks/show.ts
+function runTasksShow(opts) {
+  const context = resolveContext({
+    rootDir: opts.rootDir,
+    variant: opts.variant,
+    team: opts.team
+  });
+  if (context.locations.length === 0) {
+    console.error("No task locations found. Check variant and team settings.");
+    process.exitCode = 1;
+    return;
+  }
+  for (const location of context.locations) {
+    const task = loadTask(location.tasksDir, opts.taskId);
+    if (task) {
+      const allTasks = loadAllTasks(location.tasksDir);
+      if (opts.json) {
+        console.log(formatTaskJson(task, location));
+      } else {
+        console.log(formatTaskDetail(task, location, allTasks));
+      }
+      return;
+    }
+  }
+  console.error(`Task #${opts.taskId} not found.`);
+  process.exitCode = 1;
+}
+
+// src/cli/commands/tasks/create.ts
+function runTasksCreate(opts) {
+  const context = resolveContext({
+    rootDir: opts.rootDir,
+    variant: opts.variant,
+    team: opts.team
+  });
+  let location = context.locations[0];
+  if (!location) {
+    const team = opts.team || detectCurrentTeam();
+    const variant = opts.variant;
+    if (!variant) {
+      console.error("No variant specified. Use --variant to specify a variant.");
+      process.exitCode = 1;
+      return;
+    }
+    const tasksDir = getTasksDir(opts.rootDir, variant, team);
+    location = { variant, team, tasksDir };
+  }
+  const task = createTask(location.tasksDir, opts.subject, opts.description || "", {
+    owner: opts.owner,
+    blocks: opts.blocks,
+    blockedBy: opts.blockedBy
+  });
+  if (opts.json) {
+    console.log(formatTaskJson(task, location));
+  } else {
+    console.log(`Created task #${task.id}: ${task.subject}`);
+    console.log(`Location: ${location.variant} / ${location.team}`);
+  }
+}
+
+// src/cli/commands/tasks/update.ts
+function runTasksUpdate(opts) {
+  const context = resolveContext({
+    rootDir: opts.rootDir,
+    variant: opts.variant,
+    team: opts.team
+  });
+  if (context.locations.length === 0) {
+    console.error("No task locations found. Check variant and team settings.");
+    process.exitCode = 1;
+    return;
+  }
+  for (const location of context.locations) {
+    const task = loadTask(location.tasksDir, opts.taskId);
+    if (!task) continue;
+    if (opts.subject) task.subject = opts.subject;
+    if (opts.description) task.description = opts.description;
+    if (opts.status) task.status = opts.status;
+    if (opts.owner !== void 0) task.owner = opts.owner || void 0;
+    if (opts.addBlocks) {
+      for (const id of opts.addBlocks) {
+        if (!task.blocks.includes(id)) task.blocks.push(id);
+      }
+    }
+    if (opts.removeBlocks) {
+      task.blocks = task.blocks.filter((id) => !opts.removeBlocks.includes(id));
+    }
+    if (opts.addBlockedBy) {
+      for (const id of opts.addBlockedBy) {
+        if (!task.blockedBy.includes(id)) task.blockedBy.push(id);
+      }
+    }
+    if (opts.removeBlockedBy) {
+      task.blockedBy = task.blockedBy.filter((id) => !opts.removeBlockedBy.includes(id));
+    }
+    if (opts.addComment) {
+      task.comments.push({
+        author: opts.commentAuthor || "cli",
+        content: opts.addComment
+      });
+    }
+    saveTask(location.tasksDir, task);
+    if (opts.json) {
+      console.log(formatTaskJson(task, location));
+    } else {
+      console.log(`Updated task #${task.id}: ${task.subject}`);
+    }
+    return;
+  }
+  console.error(`Task #${opts.taskId} not found.`);
+  process.exitCode = 1;
+}
+
+// src/cli/commands/tasks/delete.ts
+import * as readline2 from "node:readline";
+async function confirm(prompt2) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(prompt2, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function runTasksDelete(opts) {
+  const context = resolveContext({
+    rootDir: opts.rootDir,
+    variant: opts.variant,
+    team: opts.team
+  });
+  if (context.locations.length === 0) {
+    console.error("No task locations found. Check variant and team settings.");
+    process.exitCode = 1;
+    return;
+  }
+  for (const location of context.locations) {
+    const task = loadTask(location.tasksDir, opts.taskId);
+    if (!task) continue;
+    if (!opts.force) {
+      const confirmed = await confirm(`Delete task #${task.id} "${task.subject}"? [y/N] `);
+      if (!confirmed) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const deleted = deleteTask(location.tasksDir, opts.taskId);
+    if (deleted) {
+      if (opts.json) {
+        console.log(JSON.stringify({ deleted: true, taskId: opts.taskId }));
+      } else {
+        console.log(`Deleted task #${opts.taskId}`);
+      }
+    } else {
+      console.error(`Failed to delete task #${opts.taskId}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  console.error(`Task #${opts.taskId} not found.`);
+  process.exitCode = 1;
+}
+
+// src/cli/commands/tasks/clean.ts
+import fs17 from "node:fs";
+import path27 from "node:path";
+import * as readline3 from "node:readline";
+async function confirm2(prompt2) {
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(prompt2, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+function getTaskAge(tasksDir, taskId) {
+  const taskPath = path27.join(tasksDir, `${taskId}.json`);
+  try {
+    const stats = fs17.statSync(taskPath);
+    const now = Date.now();
+    const mtime = stats.mtime.getTime();
+    return Math.floor((now - mtime) / (1e3 * 60 * 60 * 24));
+  } catch {
+    return null;
+  }
+}
+function filterTasksForClean(tasks, tasksDir, opts) {
+  let candidates = [...tasks];
+  if (opts.resolved) {
+    candidates = candidates.filter((t) => t.status === "resolved");
+  }
+  if (opts.olderThan !== void 0) {
+    candidates = candidates.filter((t) => {
+      const age = getTaskAge(tasksDir, t.id);
+      return age !== null && age >= opts.olderThan;
+    });
+  }
+  return candidates;
+}
+async function runTasksClean(opts) {
+  const context = resolveContext({
+    rootDir: opts.rootDir,
+    variant: opts.variant,
+    team: opts.team,
+    allVariants: opts.allVariants,
+    allTeams: opts.allTeams
+  });
+  if (context.locations.length === 0) {
+    console.log("No task locations found. Check variant and team settings.");
+    return;
+  }
+  if (!opts.resolved && opts.olderThan === void 0) {
+    console.error("Error: Specify at least one filter (--resolved or --older-than).");
+    process.exitCode = 1;
+    return;
+  }
+  const results = [];
+  let totalToDelete = 0;
+  for (const location of context.locations) {
+    const tasks = loadAllTasks(location.tasksDir);
+    const toDelete = filterTasksForClean(tasks, location.tasksDir, opts);
+    totalToDelete += toDelete.length;
+    results.push({
+      location,
+      deleted: toDelete.map((t) => t.id),
+      dryRun: opts.dryRun || false
+    });
+  }
+  if (totalToDelete === 0) {
+    console.log("No tasks match the cleanup criteria.");
+    return;
+  }
+  console.log(formatCleanResults(results));
+  if (opts.dryRun) {
+    console.log(`
+Dry run: ${totalToDelete} tasks would be deleted.`);
+    return;
+  }
+  if (!opts.force) {
+    const confirmed = await confirm2(`
+Delete ${totalToDelete} tasks? [y/N] `);
+    if (!confirmed) {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+  let deletedCount = 0;
+  for (const result of results) {
+    for (const taskId of result.deleted) {
+      if (deleteTask(result.location.tasksDir, taskId)) {
+        deletedCount++;
+      }
+    }
+  }
+  if (opts.json) {
+    console.log(
+      JSON.stringify({
+        deleted: deletedCount,
+        locations: results.map((r) => ({
+          variant: r.location.variant,
+          team: r.location.team,
+          taskIds: r.deleted
+        }))
+      })
+    );
+  } else {
+    console.log(`
+Deleted ${deletedCount} tasks.`);
+  }
+}
+
+// src/cli/commands/tasks/graph.ts
+function buildDependencyLine(task, allTasks, depth, visited) {
+  const lines = [];
+  const indent = "  ".repeat(depth);
+  const prefix = depth === 0 ? "" : "\u2514\u2500 ";
+  if (visited.has(task.id)) {
+    lines.push(`${indent}${prefix}#${task.id} (circular ref)`);
+    return lines;
+  }
+  visited.add(task.id);
+  const statusIcon = task.status === "resolved" ? "\u2713" : isBlocked(task, allTasks) ? "\u25CF" : "\u25CB";
+  lines.push(`${indent}${prefix}[${statusIcon}] #${task.id}: ${task.subject.slice(0, 50)}`);
+  const blockedTasks = allTasks.filter((t) => t.blockedBy.includes(task.id));
+  for (const blocked of blockedTasks) {
+    lines.push(...buildDependencyLine(blocked, allTasks, depth + 1, new Set(visited)));
+  }
+  return lines;
+}
+function formatTaskGraph(tasks, variant, team) {
+  const lines = [];
+  lines.push(`TASK DEPENDENCY GRAPH (${variant} / ${team})`);
+  lines.push("\u2550".repeat(60));
+  lines.push("");
+  lines.push("Legend: [\u2713] resolved  [\u25CB] open  [\u25CF] blocked");
+  lines.push("");
+  const roots = tasks.filter((t) => t.blockedBy.length === 0);
+  const visited = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    if (!visited.has(root.id)) {
+      const treeLines = buildDependencyLine(root, tasks, 0, /* @__PURE__ */ new Set());
+      lines.push(...treeLines);
+      lines.push("");
+      for (const line of treeLines) {
+        const match = line.match(/#(\d+)/);
+        if (match) visited.add(match[1]);
+      }
+    }
+  }
+  const orphans = tasks.filter((t) => !visited.has(t.id) && t.blockedBy.length > 0);
+  if (orphans.length > 0) {
+    lines.push("\u2500".repeat(40));
+    lines.push("Orphan tasks (blockedBy non-existent tasks):");
+    for (const task of orphans) {
+      const statusIcon = task.status === "resolved" ? "\u2713" : "\u25CB";
+      lines.push(`  [${statusIcon}] #${task.id}: ${task.subject.slice(0, 50)}`);
+      lines.push(`      blockedBy: ${task.blockedBy.join(", ")}`);
+    }
+  }
+  lines.push("");
+  lines.push("\u2500".repeat(60));
+  const open = tasks.filter((t) => t.status === "open");
+  const blocked = open.filter((t) => isBlocked(t, tasks));
+  const ready = open.filter((t) => !isBlocked(t, tasks));
+  lines.push(`Total: ${tasks.length} | Open: ${open.length} | Ready: ${ready.length} | Blocked: ${blocked.length}`);
+  return lines.join("\n");
+}
+function runTasksGraph(opts) {
+  const context = resolveContext({
+    rootDir: opts.rootDir,
+    variant: opts.variant,
+    team: opts.team
+  });
+  if (context.locations.length === 0) {
+    console.log("No task locations found. Check variant and team settings.");
+    return;
+  }
+  const location = context.locations[0];
+  const tasks = loadAllTasks(location.tasksDir);
+  if (tasks.length === 0) {
+    console.log(`No tasks found in ${location.variant} / ${location.team}`);
+    return;
+  }
+  console.log(formatTaskGraph(tasks, location.variant, location.team));
+}
+
+// src/cli/commands/tasks/archive.ts
+import fs18 from "node:fs";
+import path28 from "node:path";
+function getArchiveDir(tasksDir) {
+  return path28.join(path28.dirname(tasksDir), "archive", path28.basename(tasksDir));
+}
+function archiveTask(tasksDir, task) {
+  const archiveDir = getArchiveDir(tasksDir);
+  fs18.mkdirSync(archiveDir, { recursive: true });
+  const archivedTask = {
+    ...task,
+    archivedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const archivePath = path28.join(archiveDir, `${task.id}.json`);
+  writeJson(archivePath, archivedTask);
+  return deleteTask(tasksDir, task.id);
+}
+async function runTasksArchive(opts) {
+  const context = resolveContext({
+    rootDir: opts.rootDir,
+    variant: opts.variant,
+    team: opts.team
+  });
+  if (context.locations.length === 0) {
+    console.error("No task locations found. Check variant and team settings.");
+    process.exitCode = 1;
+    return;
+  }
+  const location = context.locations[0];
+  if (opts.taskId) {
+    const task = loadTask(location.tasksDir, opts.taskId);
+    if (!task) {
+      console.error(`Task #${opts.taskId} not found.`);
+      process.exitCode = 1;
+      return;
+    }
+    if (opts.dryRun) {
+      console.log(`Would archive task #${task.id}: ${task.subject}`);
+      return;
+    }
+    if (archiveTask(location.tasksDir, task)) {
+      if (opts.json) {
+        console.log(JSON.stringify({ archived: [task.id] }));
+      } else {
+        console.log(`Archived task #${task.id}: ${task.subject}`);
+      }
+    }
+    return;
+  }
+  if (opts.resolved) {
+    const tasks = loadAllTasks(location.tasksDir);
+    const resolvedTasks = tasks.filter((t) => t.status === "resolved");
+    if (resolvedTasks.length === 0) {
+      console.log("No resolved tasks to archive.");
+      return;
+    }
+    if (opts.dryRun) {
+      console.log(`Would archive ${resolvedTasks.length} resolved tasks:`);
+      for (const task of resolvedTasks.slice(0, 10)) {
+        console.log(`  #${task.id}: ${task.subject.slice(0, 50)}`);
+      }
+      if (resolvedTasks.length > 10) {
+        console.log(`  ... and ${resolvedTasks.length - 10} more`);
+      }
+      return;
+    }
+    const archived = [];
+    for (const task of resolvedTasks) {
+      if (archiveTask(location.tasksDir, task)) {
+        archived.push(task.id);
+      }
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ archived }));
+    } else {
+      console.log(`Archived ${archived.length} tasks to:`);
+      console.log(`  ${getArchiveDir(location.tasksDir)}`);
+    }
+    return;
+  }
+  console.error("Specify --resolved to archive all resolved tasks, or provide a task ID.");
+  process.exitCode = 1;
+}
+
+// src/cli/commands/tasks.ts
+function parseIds(value) {
+  if (!value) return void 0;
+  return value.split(",").map((s) => s.trim());
+}
+function showTasksHelp() {
+  console.log(`
+cc-mirror tasks - Manage team tasks
+
+USAGE:
+  cc-mirror tasks [operation] [id] [options]
+
+OPERATIONS:
+  list              List tasks (default if no operation specified)
+  show <id>         Show detailed task info
+  create            Create a new task
+  update <id>       Update an existing task
+  delete <id>       Delete a task (permanent)
+  archive [id]      Move task(s) to archive (preserves history)
+  clean             Bulk delete tasks (permanent)
+  graph             Show task dependency graph
+
+GLOBAL OPTIONS:
+  --variant <name>  Target variant (auto-detects if omitted)
+  --all-variants    Show tasks across all variants
+  --team <name>     Target team name
+  --all             Show all teams in variant(s)
+  --json            Output as JSON
+  --help            Show this help
+
+LIST OPTIONS:
+  --status <s>      Filter: open, resolved, all (default: open)
+  --blocked         Show only blocked tasks
+  --blocking        Show only tasks blocking others
+  --owner <id>      Filter by owner
+  --limit <n>       Limit results (default: 50)
+
+CREATE OPTIONS:
+  --subject <text>  Task subject (required)
+  --description <t> Task description
+  --owner <id>      Assign owner
+  --blocks <ids>    Comma-separated task IDs this task blocks
+  --blocked-by <ids> Comma-separated task IDs that block this task
+
+UPDATE OPTIONS:
+  --subject <text>  Update subject
+  --description <t> Update description
+  --status <s>      Set status: open or resolved
+  --owner <id>      Set owner (empty string to unassign)
+  --add-blocks <ids>        Add blocking relationships
+  --remove-blocks <ids>     Remove blocking relationships
+  --add-blocked-by <ids>    Add blocked-by relationships
+  --remove-blocked-by <ids> Remove blocked-by relationships
+  --add-comment <text>      Add a comment
+  --comment-author <id>     Comment author (default: cli)
+
+CLEAN OPTIONS:
+  --resolved        Delete all resolved tasks
+  --older-than <n>  Delete tasks older than N days
+  --dry-run         Preview without deleting
+  --force           Skip confirmation
+
+EXAMPLES:
+  cc-mirror tasks                           # List open tasks
+  cc-mirror tasks --status all              # List all tasks
+  cc-mirror tasks show 5                    # Show task #5
+  cc-mirror tasks create --subject "Fix bug" --description "..."
+  cc-mirror tasks update 5 --status resolved
+  cc-mirror tasks delete 5 --force
+  cc-mirror tasks clean --resolved --dry-run
+`);
+}
+async function runTasksCommand({ opts }) {
+  const rootDir = opts.root || DEFAULT_ROOT;
+  const positional = opts._ || [];
+  if (opts.help || opts.h) {
+    showTasksHelp();
+    return;
+  }
+  const operation = positional[0];
+  const taskId = positional[1];
+  const variant = opts.variant;
+  const team = opts.team;
+  const allVariants = Boolean(opts["all-variants"]);
+  const allTeams = Boolean(opts.all);
+  const json = Boolean(opts.json);
+  switch (operation) {
+    case "show": {
+      if (!taskId) {
+        console.error("Error: Task ID required. Usage: cc-mirror tasks show <id>");
+        process.exitCode = 1;
+        return;
+      }
+      runTasksShow({ rootDir, taskId, variant, team, json });
+      break;
+    }
+    case "create": {
+      const subject = opts.subject;
+      if (!subject) {
+        console.error("Error: --subject required for create.");
+        process.exitCode = 1;
+        return;
+      }
+      runTasksCreate({
+        rootDir,
+        subject,
+        description: opts.description,
+        variant,
+        team,
+        owner: opts.owner,
+        blocks: parseIds(opts.blocks),
+        blockedBy: parseIds(opts["blocked-by"]),
+        json
+      });
+      break;
+    }
+    case "update": {
+      if (!taskId) {
+        console.error("Error: Task ID required. Usage: cc-mirror tasks update <id>");
+        process.exitCode = 1;
+        return;
+      }
+      runTasksUpdate({
+        rootDir,
+        taskId,
+        variant,
+        team,
+        subject: opts.subject,
+        description: opts.description,
+        status: opts.status,
+        owner: opts.owner,
+        addBlocks: parseIds(opts["add-blocks"]),
+        removeBlocks: parseIds(opts["remove-blocks"]),
+        addBlockedBy: parseIds(opts["add-blocked-by"]),
+        removeBlockedBy: parseIds(opts["remove-blocked-by"]),
+        addComment: opts["add-comment"],
+        commentAuthor: opts["comment-author"],
+        json
+      });
+      break;
+    }
+    case "delete": {
+      if (!taskId) {
+        console.error("Error: Task ID required. Usage: cc-mirror tasks delete <id>");
+        process.exitCode = 1;
+        return;
+      }
+      await runTasksDelete({
+        rootDir,
+        taskId,
+        variant,
+        team,
+        force: Boolean(opts.force),
+        json
+      });
+      break;
+    }
+    case "clean": {
+      await runTasksClean({
+        rootDir,
+        variant,
+        team,
+        allVariants,
+        allTeams,
+        resolved: Boolean(opts.resolved),
+        olderThan: opts["older-than"] !== void 0 ? Number(opts["older-than"]) : void 0,
+        dryRun: Boolean(opts["dry-run"]),
+        force: Boolean(opts.force),
+        json
+      });
+      break;
+    }
+    case "graph": {
+      runTasksGraph({ rootDir, variant, team });
+      break;
+    }
+    case "archive": {
+      await runTasksArchive({
+        rootDir,
+        variant,
+        team,
+        taskId,
+        resolved: Boolean(opts.resolved),
+        dryRun: Boolean(opts["dry-run"]),
+        force: Boolean(opts.force),
+        json
+      });
+      break;
+    }
+    case "list":
+    case void 0: {
+      runTasksList({
+        rootDir,
+        variant,
+        team,
+        allVariants,
+        allTeams,
+        status: opts.status || "open",
+        blocked: opts.blocked !== void 0 ? Boolean(opts.blocked) : void 0,
+        blocking: opts.blocking !== void 0 ? Boolean(opts.blocking) : void 0,
+        owner: opts.owner,
+        limit: opts.limit !== void 0 ? Number(opts.limit) : 50,
+        json
+      });
+      break;
+    }
+    default:
+      console.error(`Unknown operation: ${operation}`);
+      console.error('Run "cc-mirror tasks --help" for usage.');
+      process.exitCode = 1;
+  }
+}
+
 // src/cli/index.ts
 var main = async () => {
   const argv = process.argv.slice(2);
@@ -5039,7 +6151,8 @@ var main = async () => {
   const opts = parseArgs(argv);
   const quickMode = cmd === "quick" || Boolean(opts.quick || opts.simple);
   if (cmd === "quick") cmd = "create";
-  if (cmd === "help" || cmd === "--help" || opts.help) {
+  const commandsWithOwnHelp = ["tasks"];
+  if (cmd === "help" || cmd === "--help" || opts.help && !commandsWithOwnHelp.includes(cmd)) {
     printHelp();
     return;
   }
@@ -5070,6 +6183,9 @@ var main = async () => {
     case "create":
       await runCreateCommand({ opts, quickMode });
       break;
+    case "tasks":
+      await runTasksCommand({ opts });
+      break;
     default:
       printHelp();
   }