@gitpm/cli 0.1.0 → 0.1.16

package/dist/index.js

@@ -2,35 +2,16 @@
 
 // src/index.ts
 import { readFileSync } from "fs";
-import { dirname, join as join2 } from "path";
+import { dirname as dirname4, join as join3 } from "path";
 import { fileURLToPath } from "url";
-import { Command as Command7 } from "commander";
+import { Command as Command20 } from "commander";
 
-// src/commands/import.ts
-import { importFromGitHub } from "@gitpm/sync-github";
-import { importFromGitLab } from "@gitpm/sync-gitlab";
+// src/commands/archive.ts
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { archiveOldEntities } from "@gitpm/core";
 import chalk2 from "chalk";
 import { Command } from "commander";
-import ora from "ora";
-
-// src/utils/auth.ts
-import { execSync } from "child_process";
-async function resolveToken(cliToken) {
-  if (cliToken) return cliToken;
-  const envToken = process.env.GITHUB_TOKEN;
-  if (envToken) return envToken;
-  try {
-    const ghToken = execSync("gh auth token", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    if (ghToken) return ghToken;
-  } catch {
-  }
-  throw new Error(
-    "No GitHub token found. Provide via --token flag, GITHUB_TOKEN env var, or install GitHub CLI (gh) and run 'gh auth login'."
-  );
-}
 
 // src/utils/config.ts
 import { resolve } from "path";
@@ -49,6 +30,681 @@ function printError(msg) {
 function printWarning(msg) {
   console.warn(chalk.yellow(`\u26A0 ${msg}`));
 }
+function progressBar(ratio, width) {
+  const filled = Math.round(ratio * width);
+  const empty = width - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  if (ratio >= 0.75) return chalk.green(bar);
+  if (ratio >= 0.25) return chalk.yellow(bar);
+  return chalk.red(bar);
+}
+
+// src/commands/archive.ts
+async function cleanupSyncState(metaDir, entityIds) {
+  const statePath = join(metaDir, "sync", "github-state.json");
+  let raw;
+  try {
+    raw = await readFile(statePath, "utf-8");
+  } catch {
+    return 0;
+  }
+  const state = JSON.parse(raw);
+  let removed = 0;
+  for (const id of entityIds) {
+    if (state.entities?.[id]) {
+      delete state.entities[id];
+      removed++;
+    }
+  }
+  if (removed > 0) {
+    await writeFile(statePath, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+  }
+  return removed;
+}
+var archiveCommand = new Command("archive").description(
+  "Move done/cancelled entities older than N days to .meta/archive/"
+).option(
+  "-d, --days <number>",
+  "Number of days after which done items are archived",
+  "7"
+).option("--dry-run", "List files that would be archived without moving them").action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const daysOld = Number.parseInt(opts.days, 10);
+  const dryRun = opts.dryRun ?? false;
+  if (Number.isNaN(daysOld) || daysOld < 0) {
+    printError("--days must be a non-negative integer");
+    process.exit(1);
+  }
+  if (dryRun) {
+    printWarning("Dry run \u2014 no files will be moved");
+  }
+  const result = await archiveOldEntities(metaDir, { daysOld, dryRun });
+  if (!result.ok) {
+    printError(result.error.message);
+    process.exit(1);
+  }
+  const { archivedFiles, archivedEntityIds } = result.value;
+  if (archivedFiles.length === 0) {
+    console.log(
+      chalk2.dim(
+        `No done/cancelled entities older than ${daysOld} day(s) found.`
+      )
+    );
+    return;
+  }
+  for (const file of archivedFiles) {
+    const label = dryRun ? "would archive" : "archived";
+    console.log(chalk2.dim(`  ${label}: ${file}`));
+  }
+  if (!dryRun && archivedEntityIds.length > 0) {
+    const removed = await cleanupSyncState(metaDir, archivedEntityIds);
+    if (removed > 0) {
+      console.log(chalk2.dim(`  removed ${removed} entries from sync state`));
+    }
+  }
+  console.log();
+  if (dryRun) {
+    printWarning(
+      `${archivedFiles.length} file(s) would be archived (dry run)`
+    );
+  } else {
+    printSuccess(
+      `Archived ${archivedFiles.length} file(s) to .meta/archive/`
+    );
+  }
+});
+
+// src/commands/audit.ts
+import { relative } from "path";
+import {
+  auditTree,
+  parseTree,
+  resolveRefs
+} from "@gitpm/core";
+import chalk3 from "chalk";
+import { Command as Command2 } from "commander";
+function printSection(title, items) {
+  if (items.length === 0) return;
+  console.log(chalk3.bold.yellow(`  ${title} (${items.length})`));
+  for (const item of items) {
+    const rel = relative(process.cwd(), item.filePath);
+    console.log(
+      `    ${chalk3.dim("\u2022")} ${item.title} ${chalk3.dim("\u2014")} ${item.reason}`
+    );
+    console.log(`      ${chalk3.dim(rel)}`);
+  }
+  console.log();
+}
+function printDuplicates(pairs) {
+  if (pairs.length === 0) return;
+  console.log(chalk3.bold.yellow(`  Duplicate Candidates (${pairs.length})`));
+  for (const { a, b, similarity } of pairs) {
+    const pct3 = Math.round(similarity * 100);
+    console.log(
+      `    ${chalk3.dim("\u2022")} ${a.title} ${chalk3.dim("\u2194")} ${b.title} ${chalk3.cyan(`${pct3}%`)}`
+    );
+  }
+  console.log();
+}
+function printReport(report) {
+  console.log();
+  console.log(chalk3.bold("  Project Audit"));
+  console.log(chalk3.dim(`  ${"\u2500".repeat(13)}`));
+  console.log(
+    `  ${report.summary.total} entities scanned, ${report.summary.issues} issue(s) found`
+  );
+  console.log();
+  printSection("Stale Stories", report.stale);
+  printSection("Orphan Stories (no epic)", report.orphans);
+  printSection("Empty Bodies", report.emptyBodies);
+  printSection("Zombie Epics (all stories done)", report.zombieEpics);
+  printDuplicates(report.duplicates);
+}
+var STALE_BUCKETS = [
+  { label: "30-59 days", min: 30, max: 60 },
+  { label: "60-89 days", min: 60, max: 90 },
+  { label: "90+ days", min: 90, max: Number.POSITIVE_INFINITY }
+];
+var MARKDOWN_DEFAULT_STALE_DAYS = STALE_BUCKETS[0].min;
+function staleBucketLabel(item) {
+  if (item.daysSinceUpdate == null) return "Unknown age";
+  if (item.daysSinceUpdate < STALE_BUCKETS[0].min) return "< 30 days";
+  for (const bucket of STALE_BUCKETS) {
+    if (item.daysSinceUpdate >= bucket.min && item.daysSinceUpdate < bucket.max) {
+      return bucket.label;
+    }
+  }
+  return STALE_BUCKETS[STALE_BUCKETS.length - 1].label;
+}
+function groupStaleByBucket(items) {
+  const order = [
+    "< 30 days",
+    ...STALE_BUCKETS.map((b) => b.label),
+    "Unknown age"
+  ];
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const label = staleBucketLabel(item);
+    const bucket = groups.get(label) ?? [];
+    bucket.push(item);
+    groups.set(label, bucket);
+  }
+  return order.filter((label) => groups.has(label)).map((label) => [label, groups.get(label)]);
+}
+function escapeMdCell(value) {
+  return value.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+function mdTable(headers, rows) {
+  const headerLine = `| ${headers.join(" | ")} |`;
+  const sepLine = `| ${headers.map(() => "---").join(" | ")} |`;
+  const rowLines = rows.map((row) => `| ${row.join(" | ")} |`);
+  return [headerLine, sepLine, ...rowLines].join("\n");
+}
+function itemToRow(item) {
+  return [
+    escapeMdCell(item.id),
+    escapeMdCell(item.title),
+    escapeMdCell(relative(process.cwd(), item.filePath)),
+    escapeMdCell(item.reason)
+  ];
+}
+function mdItemSection(title, items) {
+  const lines = [`## ${title} (${items.length})`, ""];
+  if (items.length === 0) {
+    lines.push("None.", "");
+    return lines;
+  }
+  lines.push(
+    mdTable(["ID", "Title", "File", "Reason"], items.map(itemToRow)),
+    ""
+  );
+  return lines;
+}
+function buildMarkdownReport(report) {
+  const lines = [
+    "# Project Audit",
+    "",
+    `${report.summary.total} entities scanned, ${report.summary.issues} issue(s) found.`,
+    ""
+  ];
+  lines.push(`## Stale (${report.stale.length})`, "");
+  if (report.stale.length === 0) {
+    lines.push("None.", "");
+  } else {
+    for (const [label, items] of groupStaleByBucket(report.stale)) {
+      lines.push(
+        `### ${label} (${items.length})`,
+        "",
+        mdTable(["ID", "Title", "File", "Reason"], items.map(itemToRow)),
+        ""
+      );
+    }
+  }
+  lines.push(...mdItemSection("Orphans", report.orphans));
+  lines.push(`## Duplicates (${report.duplicates.length})`, "");
+  if (report.duplicates.length === 0) {
+    lines.push("None.", "");
+  } else {
+    lines.push(
+      mdTable(
+        ["A", "B", "Similarity"],
+        report.duplicates.map((d) => [
+          escapeMdCell(`${d.a.title} (${d.a.id})`),
+          escapeMdCell(`${d.b.title} (${d.b.id})`),
+          `${Math.round(d.similarity * 100)}%`
+        ])
+      ),
+      ""
+    );
+  }
+  lines.push(...mdItemSection("Empty bodies", report.emptyBodies));
+  lines.push(...mdItemSection("Zombie epics", report.zombieEpics));
+  return lines.join("\n");
+}
+var auditCommand = new Command2("audit").description(
+  "Detect stale issues, orphans, duplicates, and project hygiene issues"
+).option(
+  "--stale-days <days>",
+  `Days before a todo is considered stale (${MARKDOWN_DEFAULT_STALE_DAYS} with --markdown unless set)`,
+  (value) => Number.parseInt(value, 10),
+  90
+).option("--json", "Output as JSON").option(
+  "--markdown",
+  "Output as a Markdown report with age-tiered stale sections (for CI artifacts)"
+).action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const parseResult = await parseTree(metaDir);
+  if (!parseResult.ok) {
+    printError(parseResult.error.message);
+    process.exit(1);
+  }
+  const resolveResult = resolveRefs(parseResult.value);
+  if (!resolveResult.ok) {
+    printError(resolveResult.error.message);
+    process.exit(1);
+  }
+  const staleDaysIsDefault = cmd.getOptionValueSource("staleDays") === "default";
+  const staleDays = opts.markdown && staleDaysIsDefault ? MARKDOWN_DEFAULT_STALE_DAYS : opts.staleDays;
+  const report = auditTree(resolveResult.value, { staleDays });
+  if (opts.markdown) {
+    console.log(buildMarkdownReport(report));
+  } else if (opts.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else if (report.summary.issues === 0) {
+    printSuccess("No issues found \u2014 project is clean!");
+  } else {
+    printReport(report);
+  }
+  if (report.summary.issues > 0) {
+    process.exit(1);
+  }
+});
+
+// src/commands/commit.ts
+import { execFileSync, execSync } from "child_process";
+import { Command as Command3 } from "commander";
+var commitCommand = new Command3("commit").description("Commit all .meta/ changes atomically").requiredOption("-m, --message <message>", "Commit message").option("--author <author>", 'Git author (e.g. "Name <email>")').action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  try {
+    execFileSync("git", ["add", metaDir], { stdio: "pipe" });
+    try {
+      execSync("git diff --cached --quiet", { stdio: "pipe" });
+      printError("No changes to commit in .meta/");
+      process.exit(1);
+    } catch {
+    }
+    const args = ["commit", "-m", opts.message];
+    if (opts.author) {
+      args.push("--author", opts.author);
+    }
+    const env = { ...process.env, SKIP: "commitizen" };
+    const result = execFileSync("git", args, {
+      stdio: "pipe",
+      env,
+      encoding: "utf-8"
+    });
+    const hashMatch = result.match(/\[[\w-/]+ ([a-f0-9]+)\]/);
+    const hash = hashMatch ? hashMatch[1] : "";
+    printSuccess(`Committed${hash ? ` (${hash})` : ""}: ${opts.message}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.stderr || err.message : String(err);
+    printError(`Commit failed: ${message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/context.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import {
+  computeEpicProgress,
+  computeMilestoneProgress,
+  parseTree as parseTree2,
+  resolveRefs as resolveRefs2
+} from "@gitpm/core";
+import { Command as Command4 } from "commander";
+var CONTEXT_START_MARKER = "<!-- gitpm:context:start -->";
+var CONTEXT_END_MARKER = "<!-- gitpm:context:end -->";
+var DONE_STATUSES = /* @__PURE__ */ new Set(["done", "cancelled"]);
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["in_progress", "in_review"]);
+var MAX_UNASSIGNED_ITEMS = 10;
+function sanitizeTitle(title) {
+  let current = title;
+  let previous;
+  do {
+    previous = current;
+    current = current.replace(/<!--[\s\S]*?-->/g, " ");
+  } while (current !== previous);
+  return current.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\s+/g, " ").trim();
+}
+function localDate(date = /* @__PURE__ */ new Date()) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function pct(ratio) {
+  return `${Math.round(ratio * 100)}%`;
+}
+function findActiveMilestone(tree) {
+  const active = tree.milestones.filter((m) => !DONE_STATUSES.has(m.status));
+  const sorted = [...active].sort((a, b) => {
+    if (!a.target_date && !b.target_date) return 0;
+    if (!a.target_date) return 1;
+    if (!b.target_date) return -1;
+    return a.target_date.localeCompare(b.target_date);
+  });
+  return sorted[0];
+}
+function findCurrentSprint(tree, today) {
+  const inRange = tree.sprints.filter((s) => {
+    if (DONE_STATUSES.has(s.status)) return false;
+    const start = s.start_date.slice(0, 10);
+    const end = s.end_date.slice(0, 10);
+    return today >= start && today <= end;
+  });
+  return inRange.find((s) => s.status === "in_progress") ?? inRange[0];
+}
+function findActiveEpics(tree) {
+  return tree.epics.filter((e) => ACTIVE_STATUSES.has(e.status));
+}
+function findUnassignedItems(tree) {
+  return tree.stories.filter(
+    (s) => !DONE_STATUSES.has(s.status) && !ACTIVE_STATUSES.has(s.status) && s.assignee == null
+  ).map((s) => ({ title: s.title, epicTitle: s.resolvedEpic?.title }));
+}
+function renderContext(tree, today = localDate()) {
+  const lines = [];
+  lines.push("## Project Context (generated by gitpm)");
+  lines.push("");
+  lines.push("### Active Milestone");
+  const milestone = findActiveMilestone(tree);
+  if (milestone) {
+    const progress = computeMilestoneProgress(milestone, tree.epics);
+    const due = milestone.target_date ? ` \u2014 due ${milestone.target_date.slice(0, 10)}` : "";
+    lines.push(
+      `**${sanitizeTitle(milestone.title)}** \u2014 ${pct(progress.progress)} done (${progress.done}/${progress.total} stories)${due}`
+    );
+  } else {
+    lines.push("No active milestone.");
+  }
+  lines.push("");
+  lines.push("### Current Sprint");
+  const sprint = findCurrentSprint(tree, today);
+  if (sprint) {
+    const total = sprint.resolvedStories.length;
+    const done = sprint.resolvedStories.filter(
+      (s) => DONE_STATUSES.has(s.status)
+    ).length;
+    const start = sprint.start_date.slice(0, 10);
+    const end = sprint.end_date.slice(0, 10);
+    lines.push(
+      `**${sanitizeTitle(sprint.title)}** \u2014 ${done}/${total} stories done (${start} \u2192 ${end})`
+    );
+  } else {
+    lines.push("No sprint currently active.");
+  }
+  lines.push("");
+  lines.push("### Active Epics");
+  const activeEpics = findActiveEpics(tree);
+  if (activeEpics.length > 0) {
+    for (const epic of activeEpics) {
+      const progress = computeEpicProgress(epic);
+      lines.push(
+        `- **${sanitizeTitle(epic.title)}** \u2014 ${progress.done}/${progress.total} done`
+      );
+    }
+  } else {
+    lines.push("No active epics.");
+  }
+  lines.push("");
+  lines.push("### Unassigned Backlog");
+  const unassigned = findUnassignedItems(tree);
+  if (unassigned.length > 0) {
+    for (const item of unassigned.slice(0, MAX_UNASSIGNED_ITEMS)) {
+      const epic = item.epicTitle ? ` (${sanitizeTitle(item.epicTitle)})` : "";
+      lines.push(`- ${sanitizeTitle(item.title)}${epic}`);
+    }
+    if (unassigned.length > MAX_UNASSIGNED_ITEMS) {
+      lines.push(`- \u2026and ${unassigned.length - MAX_UNASSIGNED_ITEMS} more`);
+    }
+  } else {
+    lines.push("None.");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findOwnLineMarkers(haystack, marker) {
+  const pattern = new RegExp(
+    `^[ \\t]*${escapeRegExp(marker)}[ \\t]*(?=\\r?$)`,
+    "gm"
+  );
+  return [...haystack.matchAll(pattern)].map((m) => ({
+    start: m.index,
+    end: m.index + m[0].length
+  }));
+}
+function spliceIntoClaudeMd(existing, section) {
+  const block = `${CONTEXT_START_MARKER}
+
+${section}
+${CONTEXT_END_MARKER}`;
+  const starts = findOwnLineMarkers(existing, CONTEXT_START_MARKER);
+  const ends = findOwnLineMarkers(existing, CONTEXT_END_MARKER);
+  if (starts.length === 0 && ends.length === 0) {
+    const trimmed = existing.replace(/\n+$/, "");
+    const separator = trimmed.length > 0 ? "\n\n" : "";
+    return { ok: true, value: `${trimmed}${separator}${block}
+` };
+  }
+  const [start] = starts;
+  const [end] = ends;
+  if (starts.length !== 1 || ends.length !== 1 || start === void 0 || end === void 0 || end.start < start.end) {
+    return {
+      ok: false,
+      error: new Error(
+        `CLAUDE.md has unbalanced gitpm context markers (found ${starts.length} start, ${ends.length} end on their own lines; expected exactly one "${CONTEXT_START_MARKER}" line followed by one "${CONTEXT_END_MARKER}" line). Fix the markers manually and re-run.`
+      )
+    };
+  }
+  const before = existing.slice(0, start.start);
+  const after = existing.slice(end.end);
+  return { ok: true, value: `${before}${block}${after}` };
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function isEnoent(err) {
+  return typeof err === "object" && err !== null && err.code === "ENOENT";
+}
+var contextCommand = new Command4("context").description(
+  "Generate project context (milestone, sprint, epics, unassigned backlog) from the .meta tree"
+).option("--output <file>", "Write context to a file instead of stdout").option(
+  "--update",
+  "Splice context into ./CLAUDE.md between gitpm:context markers"
+).action(async (opts, cmd) => {
+  if (opts.update && opts.output) {
+    printError("--update and --output cannot be used together");
+    process.exit(1);
+  }
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const parseResult = await parseTree2(metaDir);
+  if (!parseResult.ok) {
+    printError(parseResult.error.message);
+    process.exit(1);
+  }
+  const resolveResult = resolveRefs2(parseResult.value);
+  if (!resolveResult.ok) {
+    printError(resolveResult.error.message);
+    process.exit(1);
+  }
+  const section = renderContext(resolveResult.value);
+  if (opts.update) {
+    const claudeMdPath = resolve2(process.cwd(), "CLAUDE.md");
+    let existing = "";
+    try {
+      existing = await readFile2(claudeMdPath, "utf-8");
+    } catch (err) {
+      if (!isEnoent(err)) {
+        printError(`Failed to read ${claudeMdPath}: ${errorMessage(err)}`);
+        process.exit(1);
+      }
+    }
+    const updated = spliceIntoClaudeMd(existing, section);
+    if (!updated.ok) {
+      printError(updated.error.message);
+      process.exit(1);
+    }
+    try {
+      await writeFile2(claudeMdPath, updated.value, "utf-8");
+    } catch (err) {
+      printError(`Failed to write ${claudeMdPath}: ${errorMessage(err)}`);
+      process.exit(1);
+    }
+    printSuccess(`Updated ${claudeMdPath}`);
+    return;
+  }
+  if (opts.output) {
+    const outputPath = resolve2(process.cwd(), opts.output);
+    try {
+      await writeFile2(outputPath, `${section}
+`, "utf-8");
+    } catch (err) {
+      printError(`Failed to write ${outputPath}: ${errorMessage(err)}`);
+      process.exit(1);
+    }
+    printSuccess(`Wrote context to ${outputPath}`);
+    return;
+  }
+  console.log(section);
+});
+
+// src/commands/create.ts
+import { relative as relative2 } from "path";
+import {
+  createEpic,
+  createMilestone,
+  createStory,
+  parseTree as parseTree3
+} from "@gitpm/core";
+import { Command as Command5 } from "commander";
+var storySubcommand = new Command5("story").description("Create a new story").requiredOption("--title <title>", "Story title").option(
+  "--priority <priority>",
+  "Priority (low, medium, high, critical)",
+  "medium"
+).option("--status <status>", "Initial status", "backlog").option("--labels <labels>", "Comma-separated labels").option("--epic <epic>", "Epic ID or directory slug to place story under").option("--assignee <assignee>", "Assignee").option("--estimate <estimate>", "Estimate (number)").option("--body <body>", "Body content").action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  let epicId;
+  let epicSlug;
+  if (opts.epic) {
+    const parseResult = await parseTree3(metaDir);
+    if (!parseResult.ok) {
+      printError(parseResult.error.message);
+      process.exit(1);
+    }
+    const matchById = parseResult.value.epics.find((e) => e.id === opts.epic);
+    if (matchById) {
+      epicId = matchById.id;
+      const parts = matchById.filePath.split("/");
+      const epicIdx = parts.indexOf("epics");
+      if (epicIdx >= 0 && epicIdx + 1 < parts.length) {
+        epicSlug = parts[epicIdx + 1];
+      }
+    } else {
+      const matchBySlug = parseResult.value.epics.find(
+        (e) => e.filePath.includes(`/epics/${opts.epic}/`)
+      );
+      if (matchBySlug) {
+        epicId = matchBySlug.id;
+        epicSlug = opts.epic;
+      } else {
+        printError(`Epic not found: ${opts.epic}`);
+        process.exit(1);
+      }
+    }
+  }
+  const result = await createStory(metaDir, {
+    title: opts.title,
+    priority: opts.priority,
+    status: opts.status,
+    labels: opts.labels ? opts.labels.split(",").map((s) => s.trim()) : void 0,
+    epicId,
+    epicSlug,
+    assignee: opts.assignee,
+    estimate: opts.estimate ? Number(opts.estimate) : void 0,
+    body: opts.body
+  });
+  if (!result.ok) {
+    printError(result.error.message);
+    process.exit(1);
+  }
+  const rel = relative2(process.cwd(), result.value.filePath);
+  printSuccess(`Created story ${result.value.id} at ${rel}`);
+});
+var epicSubcommand = new Command5("epic").description("Create a new epic").requiredOption("--title <title>", "Epic title").option(
+  "--priority <priority>",
+  "Priority (low, medium, high, critical)",
+  "medium"
+).option("--status <status>", "Initial status", "backlog").option("--labels <labels>", "Comma-separated labels").option("--milestone <milestone>", "Milestone ID to link").option("--owner <owner>", "Owner").option("--body <body>", "Body content").action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const result = await createEpic(metaDir, {
+    title: opts.title,
+    priority: opts.priority,
+    status: opts.status,
+    labels: opts.labels ? opts.labels.split(",").map((s) => s.trim()) : void 0,
+    milestoneId: opts.milestone,
+    owner: opts.owner,
+    body: opts.body
+  });
+  if (!result.ok) {
+    printError(result.error.message);
+    process.exit(1);
+  }
+  const rel = relative2(process.cwd(), result.value.filePath);
+  printSuccess(`Created epic ${result.value.id} at ${rel}`);
+});
+var milestoneSubcommand = new Command5("milestone").description("Create a new milestone").requiredOption("--title <title>", "Milestone title").option("--status <status>", "Initial status", "backlog").option("--target-date <date>", "Target date (ISO format)").option("--body <body>", "Body content").action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const result = await createMilestone(metaDir, {
+    title: opts.title,
+    status: opts.status,
+    targetDate: opts.targetDate,
+    body: opts.body
+  });
+  if (!result.ok) {
+    printError(result.error.message);
+    process.exit(1);
+  }
+  const rel = relative2(process.cwd(), result.value.filePath);
+  printSuccess(`Created milestone ${result.value.id} at ${rel}`);
+});
+var createCommand = new Command5("create").description("Create a new .meta/ entity").addCommand(storySubcommand).addCommand(epicSubcommand).addCommand(milestoneSubcommand);
+
+// src/commands/import.ts
+import { dirname } from "path";
+import {
+  findAdapterByName,
+  loadAdapters,
+  loadGitpmConfig,
+  runHooks
+} from "@gitpm/core";
+import chalk4 from "chalk";
+import { Command as Command6 } from "commander";
+import ora from "ora";
+
+// src/utils/auth.ts
+import { execSync as execSync2 } from "child_process";
+function ghAuthToken() {
+  try {
+    const token = execSync2("gh auth token", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return token || void 0;
+  } catch {
+    return void 0;
+  }
+}
+var ADAPTER_CREDENTIALS = {
+  github: { tokenEnv: "GITHUB_TOKEN", fallback: ghAuthToken },
+  gitlab: { tokenEnv: "GITLAB_TOKEN" },
+  jira: { tokenEnv: "JIRA_TOKEN", emailEnv: "JIRA_EMAIL" },
+  bitbucket: { tokenEnv: "BITBUCKET_TOKEN", emailEnv: "BITBUCKET_EMAIL" }
+};
+function envValue(name) {
+  if (!name) return void 0;
+  return process.env[name] || void 0;
+}
+function resolveCredentials(adapterName, cliToken) {
+  const spec = ADAPTER_CREDENTIALS[adapterName];
+  const token = cliToken || envValue(spec?.tokenEnv) || spec?.fallback?.() || void 0;
+  const email = envValue(spec?.emailEnv);
+  return { token, email };
+}
 
 // src/commands/import.ts
 var VALID_LINK_STRATEGIES = [
@@ -56,48 +712,55 @@ var VALID_LINK_STRATEGIES = [
   "sub-issues",
   "milestone",
   "labels",
-  "all"
-];
-var VALID_GITLAB_LINK_STRATEGIES = [
-  "body-refs",
-  "native-epics",
-  "milestone",
-  "labels",
-  "all"
+  "score",
+  "all",
+  "native-epics"
 ];
-var importCommand = new Command("import").description("Import project data from GitHub or GitLab into .meta/").option(
+var importCommand = new Command6("import").description("Import project data from a remote platform into .meta/").option(
   "--source <source>",
-  "Source platform: github or gitlab (default: github)",
+  "Source platform: github, gitlab, jira, linear, or bitbucket (default: github)",
   "github"
 ).option("--repo <owner/repo>", "GitHub repository (owner/repo)").option(
   "--project <value>",
-  "GitHub Project number or GitLab project path (namespace/project)"
-).option("--token <token>", "Personal access token").option("--base-url <url>", "GitLab base URL (default: https://gitlab.com)").option(
+  "GitHub Project number, GitLab project path (namespace/project), or Jira project key"
+).option("--token <token>", "Personal access token").option(
+  "--base-url <url>",
+  "GitLab base URL (default: https://gitlab.com) or Jira site URL"
+).option("--site <host>", "Jira site, e.g. mycompany.atlassian.net").option("--project-key <key>", "Jira project key, e.g. PROJ").option("--board <id>", "Jira board ID (optional, for sprint import)").option("--team <id>", "Linear team ID").option(
+  "--api-key <key>",
+  "Linear API key (default: LINEAR_API_KEY environment variable)"
+).option(
   "--link-strategy <strategy>",
   "Epic-story linkage strategy (default: all)"
-).action(async (opts, cmd) => {
+).option("--adapter <name>", "Force a specific adapter by name").action(async (opts, cmd) => {
   const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
-  const source = opts.source;
-  if (source === "gitlab") {
-    await importGitLab(opts, metaDir);
-  } else if (source === "github") {
-    await importGitHub(opts, metaDir);
-  } else {
-    printError(`Unknown source "${source}". Use "github" or "gitlab".`);
+  const source = opts.adapter ?? opts.source;
+  const rootDir = dirname(metaDir);
+  const configResult = await loadGitpmConfig(rootDir);
+  if (!configResult.ok) {
+    printError(`Failed to load config: ${configResult.error.message}`);
     process.exit(1);
   }
-});
-async function importGitHub(opts, metaDir) {
-  const repo = opts.repo;
-  if (!repo || !repo.includes("/") || repo.split("/").length !== 2) {
-    printError('--repo is required for GitHub import. Expected "owner/repo".');
+  const config = configResult.value;
+  const adaptersResult = await loadAdapters(config, rootDir);
+  if (!adaptersResult.ok) {
+    printError(`Failed to load adapters: ${adaptersResult.error.message}`);
     process.exit(1);
   }
-  let token;
-  try {
-    token = await resolveToken(opts.token);
-  } catch (err) {
-    printError(err instanceof Error ? err.message : "Failed to resolve token.");
+  const adapter = findAdapterByName(adaptersResult.value, source);
+  if (!adapter) {
+    const available = adaptersResult.value.map((a) => a.name);
+    if (available.length === 0) {
+      printError(
+        `Adapter "${source}" is not installed. Install it with:
+  npm install -g @gitpm/sync-${source}`
+      );
+    } else {
+      printError(
+        `Adapter "${source}" not found. Available: ${available.join(", ")}
+Install it with: npm install -g @gitpm/sync-${source}`
+      );
+    }
     process.exit(1);
   }
   const linkStrategy = opts.linkStrategy;
@@ -109,49 +772,28 @@ async function importGitHub(opts, metaDir) {
     );
     process.exit(1);
   }
-  const spinner = ora("Importing from GitHub...").start();
-  const result = await importFromGitHub({
-    token,
-    repo,
-    projectNumber: opts.project ? Number.parseInt(opts.project, 10) : void 0,
+  const { token, email } = resolveCredentials(adapter.name, opts.token);
+  const preHook = await runHooks(config, "pre-import", {
     metaDir,
-    linkStrategy
+    event: "pre-import",
+    adapterName: adapter.name
   });
-  if (!result.ok) {
-    spinner.fail("Import failed.");
-    printError(result.error.message);
-    process.exit(1);
-  }
-  spinner.succeed("Import complete.");
-  printImportSummary(result.value);
-}
-async function importGitLab(opts, metaDir) {
-  const project = opts.project ?? opts.repo;
-  if (!project) {
-    printError("--project (namespace/project) is required for GitLab import.");
-    process.exit(1);
-  }
-  const token = opts.token ?? process.env.GITLAB_TOKEN;
-  if (!token) {
-    printError(
-      "No GitLab token found. Provide via --token flag or GITLAB_TOKEN env var."
-    );
-    process.exit(1);
-  }
-  const linkStrategy = opts.linkStrategy;
-  if (linkStrategy && !VALID_GITLAB_LINK_STRATEGIES.includes(
-    linkStrategy
-  )) {
-    printError(
-      `Invalid link strategy "${linkStrategy}". Must be one of: ${VALID_GITLAB_LINK_STRATEGIES.join(", ")}`
-    );
+  if (!preHook.ok) {
+    printError(`Pre-import hook failed: ${preHook.error.message}`);
     process.exit(1);
   }
-  const spinner = ora("Importing from GitLab...").start();
-  const result = await importFromGitLab({
+  const spinner = ora(`Importing from ${adapter.displayName}...`).start();
+  const jira = resolveJiraOptions(adapter.name, opts);
+  const result = await adapter.import({
     token,
-    project,
+    email,
+    repo: opts.repo,
+    project: opts.project ?? opts.repo,
+    projectNumber: opts.project && !Number.isNaN(Number.parseInt(opts.project, 10)) ? Number.parseInt(opts.project, 10) : void 0,
     baseUrl: opts.baseUrl,
+    ...jira,
+    teamId: opts.team,
+    apiKey: opts.apiKey,
     metaDir,
     linkStrategy
   });
@@ -162,11 +804,27 @@ async function importGitLab(opts, metaDir) {
   }
   spinner.succeed("Import complete.");
   printImportSummary(result.value);
+  await runHooks(config, "post-import", {
+    metaDir,
+    event: "post-import",
+    adapterName: adapter.name,
+    result: result.value
+  });
+});
+function resolveJiraOptions(adapterName, opts) {
+  const isJira = adapterName === "jira";
+  const site = opts.site ?? (isJira && opts.baseUrl ? siteFromUrl(opts.baseUrl) : void 0);
+  const projectKey = opts.projectKey ?? (isJira ? opts.project : void 0);
+  const boardId = opts.board !== void 0 && !Number.isNaN(Number.parseInt(opts.board, 10)) ? Number.parseInt(opts.board, 10) : void 0;
+  return { site, projectKey, boardId };
+}
+function siteFromUrl(url) {
+  return url.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/\/+$/, "");
 }
 function printImportSummary(value) {
   const { milestones, epics, stories, totalFiles } = value;
   console.log();
-  console.log(chalk2.bold("Summary:"));
+  console.log(chalk4.bold("Summary:"));
   console.log(`  Milestones: ${milestones}`);
   console.log(`  Epics:      ${epics}`);
   console.log(`  Stories:    ${stories}`);
@@ -175,16 +833,203 @@ function printImportSummary(value) {
   printSuccess(
     `Imported ${milestones + epics + stories} entities (${totalFiles} files).`
   );
-  console.log(chalk2.dim("Run `gitpm validate` to verify the imported tree."));
+  console.log(chalk4.dim("Run `gitpm validate` to verify the imported tree."));
 }
 
 // src/commands/init.ts
-import { readdir } from "fs/promises";
-import { join } from "path";
+import { mkdir, readdir, stat, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join2, relative as relative3, resolve as resolve3 } from "path";
 import { scaffoldMeta } from "@gitpm/core";
 import { input } from "@inquirer/prompts";
-import chalk3 from "chalk";
-import { Command as Command2 } from "commander";
+import chalk5 from "chalk";
+import { Command as Command7 } from "commander";
+
+// src/templates/claude-skill.ts
+var GITPM_SKILL_TEMPLATE = `---
+name: gitpm
+description: Use when working with .meta/ project management entities (stories, epics, milestones, roadmaps, PRDs) in a project that uses GitPM. Provides commands to query, filter, read, update fields, create, move, and commit entities without manual file parsing. Prefer these over grep/read/Edit on .meta/ files.
+---
+
+# gitpm \u2014 Project management via .meta/ files
+
+This project uses [GitPM](https://github.com/yevheniidehtiar/gitpm) to manage project management data (stories, epics, milestones, roadmaps, PRDs) as files under \`.meta/\`. Entities are Markdown files with YAML frontmatter, synced bidirectionally with GitHub Issues.
+
+## When to use the \`gitpm\` CLI vs reading files directly
+
+**Prefer \`gitpm\` commands** \u2014 they are 10\xD7 fewer tool calls than grep+read+Edit loops and validate writes against the schema:
+
+| Goal | Use |
+|---|---|
+| Find tasks by status / priority / label / epic | \`gitpm query\` |
+| Display one entity (or an epic + its stories) | \`gitpm show\` |
+| Update a frontmatter field (status, priority, labels, assignee) | \`gitpm set\` |
+| Create a new story / epic / milestone | \`gitpm create\` |
+| Move a story between epics (or to/from orphan) | \`gitpm move\` |
+| Stage + commit all .meta/ changes atomically | \`gitpm commit\` |
+| Push local .meta/ to GitHub Issues | \`gitpm push\` |
+| Pull GitHub Issues into local .meta/ | \`gitpm pull\` |
+| Bidirectional sync | \`gitpm sync\` |
+| Validate the whole tree | \`gitpm validate\` |
+
+**Avoid** \`grep\` / \`cat\` / \`Edit\` directly on \`.meta/*.md\` unless you truly need a raw view. The CLI preserves frontmatter ordering, validates against Zod schemas, and keeps GitHub sync state consistent.
+
+## Common recipes
+
+### Find all in-progress stories
+\`\`\`bash
+gitpm query --type story --status in_progress
+\`\`\`
+
+### Find high/critical stories across all types
+\`\`\`bash
+gitpm query --priority high,critical --format table
+\`\`\`
+
+### Show an epic and every story under it
+\`\`\`bash
+gitpm show --epic auth-system
+\`\`\`
+
+### Show a specific story with its full body
+\`\`\`bash
+gitpm show .meta/epics/auth/stories/login.md --full
+\`\`\`
+
+### Change a story's status to in_progress
+\`\`\`bash
+gitpm set .meta/epics/auth/stories/login.md status=in_progress
+\`\`\`
+
+### Append labels (array operation)
+\`\`\`bash
+gitpm set .meta/stories/onboarding.md labels+=backend labels+=security
+\`\`\`
+
+### Remove a label
+\`\`\`bash
+gitpm set .meta/stories/onboarding.md labels-=stale
+\`\`\`
+
+### Create a new story under an existing epic
+\`\`\`bash
+gitpm create story \\
+  --title "Add OAuth callback handler" \\
+  --epic auth-system \\
+  --priority high \\
+  --labels backend,oauth
+\`\`\`
+
+### Create a standalone story (no epic)
+\`\`\`bash
+gitpm create story --title "Flaky test in checkout" --priority medium
+\`\`\`
+
+### Move a story from orphan into an epic
+\`\`\`bash
+gitpm move .meta/stories/orphan.md --to-epic auth-system
+\`\`\`
+
+### Commit all .meta/ changes
+\`\`\`bash
+gitpm commit -m "feat(pm): progress auth-system stories"
+\`\`\`
+
+### Push local changes to GitHub Issues
+\`\`\`bash
+gitpm push --token "$GITHUB_TOKEN"
+\`\`\`
+
+## Field update syntax for \`gitpm set\`
+
+| Syntax | Effect |
+|---|---|
+| \`field=value\` | Replace the value |
+| \`field+=value\` | Append to an array field (labels, dependencies) |
+| \`field-=value\` | Remove from an array field |
+| \`field=null\` | Clear the value |
+
+Multiple assignments in one call are applied atomically:
+\`\`\`bash
+gitpm set .meta/stories/auth.md status=in_progress assignee=alice labels+=urgent
+\`\`\`
+
+## Entity layout
+
+\`\`\`
+.meta/
+\u251C\u2500\u2500 roadmap/
+\u2502   \u251C\u2500\u2500 roadmap.yaml              # top-level roadmap
+\u2502   \u2514\u2500\u2500 milestones/*.md           # milestones
+\u251C\u2500\u2500 epics/
+\u2502   \u2514\u2500\u2500 <slug>/
+\u2502       \u251C\u2500\u2500 epic.md               # the epic
+\u2502       \u2514\u2500\u2500 stories/*.md          # stories nested under this epic
+\u251C\u2500\u2500 stories/*.md                  # orphan stories (no epic)
+\u251C\u2500\u2500 prds/*.md                     # product requirements docs
+\u2514\u2500\u2500 sync/
+    \u251C\u2500\u2500 github-config.yaml
+    \u2514\u2500\u2500 github-state.json
+\`\`\`
+
+## Allowed field values
+
+- **status**: \`backlog\` \xB7 \`todo\` \xB7 \`in_progress\` \xB7 \`in_review\` \xB7 \`done\` \xB7 \`cancelled\`
+- **priority**: \`low\` \xB7 \`medium\` \xB7 \`high\` \xB7 \`critical\`
+
+## After modifying .meta/ files
+
+Always run \`gitpm push\` so GitHub Issues stay in sync:
+
+\`\`\`bash
+gitpm push --token "$GITHUB_TOKEN"
+\`\`\`
+
+Use \`gitpm sync --strategy local-wins\` when you have both local edits and remote changes.
+
+## Story lifecycle (three-state flow)
+
+Stories move through four states tied to the release pipeline:
+
+\`\`\`
+todo \u2500\u2500\u25BA in_progress \u2500\u2500\u25BA in_review \u2500\u2500\u25BA done
+\`\`\`
+
+**You are responsible for the first two transitions only** \u2014 the release-please
+CI job promotes \`in_review\` \u2192 \`done\` automatically, and \`post-merge-sync.yml\`
+closes the GitHub issue once the release PR merges.
+
+| Transition | Who | When |
+|---|---|---|
+| \`todo\` \u2192 \`in_progress\` | **You** | Before writing any code for the story |
+| \`in_progress\` \u2192 \`in_review\` | **You** | Inside the work PR itself, committed with the code |
+| \`in_review\` \u2192 \`done\` | release-please bot | When the release PR is created/updated |
+| GitHub issue closes | post-merge-sync bot | After the release PR merges |
+
+**Rule 1 \u2014 When you start work on a story, flip it to in_progress:**
+\`\`\`bash
+gitpm set .meta/epics/<epic>/stories/<story>.md status=in_progress
+\`\`\`
+
+**Rule 2 \u2014 When you raise the PR that implements the story, do two things in the same PR:**
+
+1. Flip the story's status in the diff:
+   \`\`\`bash
+   gitpm set .meta/epics/<epic>/stories/<story>.md status=in_review
+   \`\`\`
+2. Reference the story file path(s) in the PR body under "Related GitPM stories" (the PR template has a section for it).
+
+**Do NOT manually set status=done or close GitHub issues** \u2014 both are handled by CI. Setting \`status=done\` yourself short-circuits the release PR audit surface.
+
+If a PR has no \`.meta/\` story (docs, tooling, typo fix): skip both rules. CI will find 0 \`in_review\` stories and exit cleanly.
+
+## Help
+
+- \`gitpm --help\` \u2014 list all commands
+- \`gitpm <command> --help\` \u2014 flags for a specific command
+- \`gitpm validate\` \u2014 run before committing to catch schema errors
+`;
+
+// src/commands/init.ts
 async function collectFiles(dir, prefix = "") {
   const entries = await readdir(dir, { withFileTypes: true });
   const results = [];
@@ -192,7 +1037,7 @@ async function collectFiles(dir, prefix = "") {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
       results.push(rel);
-      const children = await collectFiles(join(dir, entry.name), rel);
+      const children = await collectFiles(join2(dir, entry.name), rel);
       results.push(...children);
     } else {
       results.push(rel);
@@ -200,65 +1045,243 @@ async function collectFiles(dir, prefix = "") {
   }
   return results;
 }
-var initCommand = new Command2("init").description("Initialize a new .meta/ project structure").argument("[project-name]", "Name of the project").action(async (nameArg, _opts, cmd) => {
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function scaffoldClaudeSkill(metaDir) {
+  const projectRoot = dirname2(resolve3(metaDir));
+  const skillDir = join2(projectRoot, ".claude", "skills", "gitpm");
+  const skillPath = join2(skillDir, "SKILL.md");
+  if (await fileExists(skillPath)) {
+    return {
+      status: "skipped",
+      path: skillPath,
+      reason: "already exists"
+    };
+  }
+  await mkdir(skillDir, { recursive: true });
+  await writeFile3(skillPath, GITPM_SKILL_TEMPLATE, "utf-8");
+  return { status: "created", path: skillPath };
+}
+var initCommand = new Command7("init").description("Initialize a new .meta/ project structure").argument("[project-name]", "Name of the project").option(
+  "--no-claude-skill",
+  "Skip writing the Claude Code skill into .claude/skills/gitpm/"
+).action(
+  async (nameArg, opts, cmd) => {
+    const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+    let projectName = nameArg;
+    if (!projectName) {
+      projectName = await input({
+        message: "Project name:",
+        required: true
+      });
+    }
+    const result = await scaffoldMeta(metaDir, projectName);
+    if (!result.ok) {
+      printError(result.error.message);
+      process.exit(1);
+    }
+    const files = await collectFiles(metaDir);
+    console.log();
+    console.log(chalk5.bold(".meta/"));
+    for (const file of files) {
+      const parts = file.split("/");
+      const indent = "  ".repeat(parts.length);
+      const name = parts[parts.length - 1];
+      const isDir = !name.includes(".");
+      console.log(`${indent}${isDir ? chalk5.blue(`${name}/`) : name}`);
+    }
+    const fileCount = files.filter((f) => f.includes(".")).length;
+    console.log();
+    printSuccess(`Created ${fileCount} files in .meta/`);
+    if (opts.claudeSkill !== false) {
+      const skillResult = await scaffoldClaudeSkill(metaDir);
+      const relPath = relative3(process.cwd(), skillResult.path) || skillResult.path;
+      if (skillResult.status === "created") {
+        printSuccess(`Installed Claude Code skill at ${relPath}`);
+      } else {
+        console.log(
+          chalk5.dim(
+            `\u2022 Claude Code skill at ${relPath} ${skillResult.reason} \u2014 skipped`
+          )
+        );
+      }
+    }
+  }
+);
+
+// src/commands/move.ts
+import { relative as relative4, resolve as resolve4 } from "path";
+import { moveStory } from "@gitpm/core";
+import { Command as Command8 } from "commander";
+var moveCommand = new Command8("move").description("Move a story between epics or to standalone").argument("<file>", "Path to the story file").option("--to-epic <epic>", "Move to an epic (by ID or directory slug)").option("--to-orphan", "Move out of an epic to .meta/stories/").action(async (file, opts, cmd) => {
   const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
-  let projectName = nameArg;
-  if (!projectName) {
-    projectName = await input({
-      message: "Project name:",
-      required: true
-    });
+  const filePath = resolve4(process.cwd(), file);
+  if (!opts.toEpic && !opts.toOrphan) {
+    printError("Specify --to-epic or --to-orphan");
+    process.exit(1);
   }
-  const result = await scaffoldMeta(metaDir, projectName);
+  const result = await moveStory(metaDir, filePath, {
+    toEpic: opts.toEpic,
+    toOrphan: opts.toOrphan
+  });
   if (!result.ok) {
     printError(result.error.message);
     process.exit(1);
   }
-  const files = await collectFiles(metaDir);
-  console.log();
-  console.log(chalk3.bold(".meta/"));
-  for (const file of files) {
-    const parts = file.split("/");
-    const indent = "  ".repeat(parts.length);
-    const name = parts[parts.length - 1];
-    const isDir = !name.includes(".");
-    console.log(`${indent}${isDir ? chalk3.blue(`${name}/`) : name}`);
-  }
-  const fileCount = files.filter((f) => f.includes(".")).length;
-  console.log();
-  printSuccess(`Created ${fileCount} files in .meta/`);
+  const oldRel = relative4(process.cwd(), result.value.oldPath);
+  const newRel = relative4(process.cwd(), result.value.newPath);
+  printSuccess(`Moved ${oldRel} \u2192 ${newRel}`);
+});
+
+// src/commands/next.ts
+import { relative as relative5 } from "path";
+import { parseTree as parseTree4 } from "@gitpm/core";
+import chalk6 from "chalk";
+import { Command as Command9 } from "commander";
+var PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+var PICKABLE_STATUSES = /* @__PURE__ */ new Set(["backlog", "todo"]);
+var nextCommand = new Command9("next").description("Show the next stories ready to be picked up").option("-n, --count <number>", "Number of stories to show", "5").option(
+  "-a, --assignee <name>",
+  "Filter by assignee (case-insensitive match)"
+).action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const count = Number.parseInt(opts.count, 10);
+  const parseResult = await parseTree4(metaDir);
+  if (!parseResult.ok) {
+    printError(parseResult.error.message);
+    process.exit(1);
+  }
+  let stories = parseResult.value.stories.filter((s) => PICKABLE_STATUSES.has(s.status)).sort((a, b) => {
+    const pa = PRIORITY_ORDER[a.priority] ?? 99;
+    const pb = PRIORITY_ORDER[b.priority] ?? 99;
+    if (pa !== pb) return pa - pb;
+    if (a.status !== b.status) return a.status === "todo" ? -1 : 1;
+    return 0;
+  });
+  if (opts.assignee) {
+    const needle = opts.assignee.toLowerCase();
+    stories = stories.filter(
+      (s) => s.assignee != null && s.assignee.toLowerCase() === needle
+    );
+  }
+  stories = stories.slice(0, count);
+  if (stories.length === 0) {
+    console.log(chalk6.yellow("No stories ready to be picked up."));
+    return;
+  }
+  console.log(chalk6.bold(`Next ${stories.length} stories to pick up:
+`));
+  for (const story of stories) {
+    const file = relative5(process.cwd(), story.filePath);
+    const pri = formatPriority(story.priority);
+    const status = chalk6.dim(`[${story.status}]`);
+    const assignee = story.assignee ? chalk6.cyan(`@${story.assignee}`) : chalk6.dim("unassigned");
+    console.log(`  ${pri} ${status} ${story.title} ${assignee}`);
+    console.log(`    ${chalk6.dim(file)}
+`);
+  }
 });
+function formatPriority(p) {
+  switch (p) {
+    case "critical":
+      return chalk6.red("\u25CF");
+    case "high":
+      return chalk6.yellow("\u25CF");
+    case "medium":
+      return chalk6.blue("\u25CF");
+    case "low":
+      return chalk6.dim("\u25CF");
+    default:
+      return chalk6.dim("\u25CB");
+  }
+}
 
 // src/commands/pull.ts
-import {
-  loadConfig as loadGitHubConfig,
-  syncWithGitHub
-} from "@gitpm/sync-github";
-import {
-  loadConfig as loadGitLabConfig,
-  syncWithGitLab
-} from "@gitpm/sync-gitlab";
-import chalk5 from "chalk";
-import { Command as Command3 } from "commander";
+import { runHooks as runHooks2 } from "@gitpm/core";
+import chalk8 from "chalk";
+import { Command as Command10 } from "commander";
 import ora2 from "ora";
 
+// src/utils/adapters.ts
+import { dirname as dirname3 } from "path";
+import {
+  detectAdapter,
+  findAdapterByName as findAdapterByName2,
+  loadAdapters as loadAdapters2,
+  loadGitpmConfig as loadGitpmConfig2
+} from "@gitpm/core";
+async function resolveAdapter(metaDir, adapterName) {
+  const rootDir = dirname3(metaDir);
+  const configResult = await loadGitpmConfig2(rootDir);
+  if (!configResult.ok) {
+    printError(`Failed to load config: ${configResult.error.message}`);
+    process.exit(1);
+  }
+  const config = configResult.value;
+  const adaptersResult = await loadAdapters2(config, rootDir);
+  if (!adaptersResult.ok) {
+    printError(adaptersResult.error.message);
+    printError(
+      "No sync adapters installed. Install at least one adapter package, e.g.:\n  npm install -g @gitpm/sync-github\n  npm install -g @gitpm/sync-gitlab\n  npm install -g @gitpm/sync-jira\n  npm install -g @gitpm/sync-linear\n  npm install -g @gitpm/sync-bitbucket"
+    );
+    process.exit(1);
+  }
+  const adapters = adaptersResult.value;
+  if (adapters.length === 0) {
+    printError(
+      "No sync adapters installed. Install at least one adapter package, e.g.:\n  npm install -g @gitpm/sync-github"
+    );
+    process.exit(1);
+  }
+  let adapter = null;
+  if (adapterName) {
+    adapter = findAdapterByName2(adapters, adapterName);
+    if (!adapter) {
+      printError(
+        `Adapter "${adapterName}" not found. Available: ${adapters.map((a) => a.name).join(", ")}`
+      );
+      process.exit(1);
+    }
+  } else {
+    adapter = await detectAdapter(adapters, metaDir);
+    if (!adapter) {
+      printError(
+        "No sync config found. Run `gitpm import` first to set up sync."
+      );
+      process.exit(1);
+    }
+  }
+  return { adapter, config };
+}
+
 // src/utils/conflict-ui.ts
 import { select } from "@inquirer/prompts";
-import chalk4 from "chalk";
+import chalk7 from "chalk";
 async function promptConflictResolution(conflicts) {
   const resolutions = [];
   for (const conflict of conflicts) {
     console.log();
-    console.log(chalk4.yellow("\u2501\u2501\u2501 CONFLICT \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+    console.log(chalk7.yellow("\u2501\u2501\u2501 CONFLICT \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
     console.log(
-      `Entity: ${chalk4.bold(`"${conflict.entityTitle}"`)} (${conflict.entityId})`
+      `Entity: ${chalk7.bold(`"${conflict.entityTitle}"`)} (${conflict.entityId})`
     );
     console.log(`Type:   ${conflict.entityType}`);
     console.log(`Field:  ${conflict.field}`);
     console.log();
-    console.log(`  Local:  ${chalk4.green(String(conflict.localValue))}`);
-    console.log(`  Remote: ${chalk4.blue(String(conflict.remoteValue))}`);
-    console.log(chalk4.yellow("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+    console.log(`  Local:  ${chalk7.green(String(conflict.localValue))}`);
+    console.log(`  Remote: ${chalk7.blue(String(conflict.remoteValue))}`);
+    console.log(chalk7.yellow("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
     const pick = await select({
       message: "How do you want to resolve this conflict?",
       choices: [
@@ -279,40 +1302,37 @@ async function promptConflictResolution(conflicts) {
 }
 
 // src/commands/pull.ts
-var pullCommand = new Command3("pull").description("Pull changes from GitHub or GitLab into local .meta/").option("--token <token>", "Personal access token").option(
+var VALID_STRATEGIES = ["local-wins", "remote-wins", "ask"];
+var pullCommand = new Command10("pull").description("Pull changes from remote platform into local .meta/").option("--token <token>", "Personal access token").option(
   "--strategy <strategy>",
   "Conflict resolution strategy (local-wins, remote-wins, ask)",
   "remote-wins"
-).action(async (opts, cmd) => {
+).option("--adapter <name>", "Force a specific adapter (e.g. github, gitlab)").action(async (opts, cmd) => {
   const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
-  const strategy = opts.strategy;
-  const ghConfig = await loadGitHubConfig(metaDir);
-  const glConfig = await loadGitLabConfig(metaDir);
-  if (glConfig.ok) {
-    await pullFromGitLab(opts, metaDir, glConfig.value, strategy);
-  } else if (ghConfig.ok) {
-    await pullFromGitHub(opts, metaDir, ghConfig.value.repo, strategy);
-  } else {
+  if (!VALID_STRATEGIES.includes(opts.strategy)) {
     printError(
-      "No sync config found. Run `gitpm import` first to set up sync."
+      `Invalid strategy "${opts.strategy}". Must be one of: ${VALID_STRATEGIES.join(", ")}`
     );
     process.exit(1);
   }
-});
-async function pullFromGitHub(opts, metaDir, repo, strategy) {
-  let token;
-  try {
-    token = await resolveToken(opts.token);
-  } catch (err) {
-    printError(err instanceof Error ? err.message : "Failed to resolve token.");
+  const strategy = opts.strategy;
+  const { adapter, config } = await resolveAdapter(metaDir, opts.adapter);
+  const { token, email } = resolveCredentials(adapter.name, opts.token);
+  const preHook = await runHooks2(config, "pre-sync", {
+    metaDir,
+    event: "pre-sync",
+    adapterName: adapter.name
+  });
+  if (!preHook.ok) {
+    printError(`Pre-sync hook failed: ${preHook.error.message}`);
     process.exit(1);
   }
-  const spinner = ora2("Pulling from GitHub...").start();
-  const result = await syncWithGitHub({
+  const spinner = ora2(`Pulling from ${adapter.displayName}...`).start();
+  const result = await adapter.sync({
     token,
-    repo,
+    email,
     metaDir,
-    strategy: strategy === "ask" ? "ask" : strategy
+    strategy
   });
   if (!result.ok) {
     spinner.fail("Pull failed.");
@@ -321,281 +1341,962 @@ async function pullFromGitHub(opts, metaDir, repo, strategy) {
   }
   spinner.succeed("Pull complete.");
   await handleConflictsAndPrint(result.value, strategy);
-}
-async function pullFromGitLab(opts, metaDir, config, strategy) {
-  const token = opts.token ?? process.env.GITLAB_TOKEN;
-  if (!token) {
-    printError(
-      "No GitLab token found. Provide via --token flag or GITLAB_TOKEN env var."
+  await runHooks2(config, "post-sync", {
+    metaDir,
+    event: "post-sync",
+    adapterName: adapter.name,
+    result: result.value
+  });
+});
+async function handleConflictsAndPrint(result, strategy) {
+  const { pulled, conflicts, resolved, skipped } = result;
+  if (strategy === "ask" && conflicts.length > 0) {
+    console.log();
+    console.log(
+      chalk8.yellow(`${conflicts.length} conflict(s) require resolution:`)
+    );
+    const resolutions = await promptConflictResolution(
+      conflicts
+    );
+    console.log(
+      chalk8.dim(
+        `Resolved ${resolutions.length}, skipped ${conflicts.length - resolutions.length}`
+      )
     );
+  }
+  console.log();
+  console.log(chalk8.bold("Pull Summary:"));
+  console.log(`  Pulled: ${pulled.milestones + pulled.issues} changes`);
+  console.log(`  Conflicts resolved: ${resolved}`);
+  console.log(`  Skipped: ${skipped}`);
+  console.log();
+  printSuccess("Pull complete.");
+}
+
+// src/commands/push.ts
+import { runHooks as runHooks3 } from "@gitpm/core";
+import { confirm } from "@inquirer/prompts";
+import chalk9 from "chalk";
+import { Command as Command11 } from "commander";
+import ora3 from "ora";
+var pushCommand = new Command11("push").description("Push local .meta/ changes to remote platform").option("--token <token>", "Personal access token").option("--team <id>", "Linear team ID").option(
+  "--api-key <key>",
+  "Linear API key (default: LINEAR_API_KEY environment variable)"
+).option("--dry-run", "Preview changes without pushing").option("--yes", "Skip confirmation prompt").option("--adapter <name>", "Force a specific adapter (e.g. github, gitlab)").action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const { adapter, config } = await resolveAdapter(metaDir, opts.adapter);
+  const { token, email } = resolveCredentials(adapter.name, opts.token);
+  if (opts.dryRun) {
+    const spinner = ora3("Calculating changes...").start();
+    const result2 = await adapter.export({
+      token,
+      email,
+      metaDir,
+      teamId: opts.team,
+      apiKey: opts.apiKey,
+      dryRun: true
+    });
+    if (!result2.ok) {
+      spinner.fail("Dry run failed.");
+      printError(result2.error.message);
+      process.exit(1);
+    }
+    spinner.succeed("Dry run complete.");
+    printPreview(result2.value);
+    if (result2.value.failures?.length) {
+      printFailures(result2.value.failures, "Would fail:");
+      process.exit(1);
+    }
+    return;
+  }
+  const previewSpinner = ora3("Calculating changes...").start();
+  const preview = await adapter.export({
+    token,
+    email,
+    metaDir,
+    teamId: opts.team,
+    apiKey: opts.apiKey,
+    dryRun: true
+  });
+  if (!preview.ok) {
+    previewSpinner.fail("Failed to calculate changes.");
+    printError(preview.error.message);
     process.exit(1);
   }
-  const spinner = ora2("Pulling from GitLab...").start();
-  const result = await syncWithGitLab({
+  previewSpinner.succeed("Changes calculated.");
+  printPreview(preview.value);
+  printFailures(preview.value.failures ?? [], "Would fail:");
+  if (preview.value.totalChanges === 0) {
+    printSuccess("Nothing to push \u2014 already in sync.");
+    return;
+  }
+  if (!opts.yes) {
+    const confirmed = await confirm({
+      message: `Push these changes to ${adapter.displayName}?`,
+      default: false
+    });
+    if (!confirmed) {
+      console.log(chalk9.dim("Push cancelled."));
+      return;
+    }
+  }
+  const preHook = await runHooks3(config, "pre-export", {
+    metaDir,
+    event: "pre-export",
+    adapterName: adapter.name
+  });
+  if (!preHook.ok) {
+    printError(`Pre-export hook failed: ${preHook.error.message}`);
+    process.exit(1);
+  }
+  const pushSpinner = ora3(`Pushing to ${adapter.displayName}...`).start();
+  const result = await adapter.export({
     token,
-    project: config.project,
-    projectId: config.project_id,
-    baseUrl: config.base_url,
+    email,
     metaDir,
-    strategy: strategy === "ask" ? "ask" : strategy
+    teamId: opts.team,
+    apiKey: opts.apiKey,
+    dryRun: false
+  });
+  if (!result.ok) {
+    pushSpinner.fail("Push failed.");
+    printError(result.error.message);
+    process.exit(1);
+  }
+  const { created, updated, failures = [] } = result.value;
+  if (failures.length > 0) {
+    pushSpinner.warn(
+      `Push finished with ${failures.length} failed ${failures.length === 1 ? "entity" : "entities"}.`
+    );
+  } else {
+    pushSpinner.succeed("Push complete.");
+  }
+  console.log(
+    `  Created ${created.milestones + created.issues}, Updated ${updated.milestones + updated.issues}`
+  );
+  printFailures(failures);
+  await runHooks3(config, "post-export", {
+    metaDir,
+    event: "post-export",
+    adapterName: adapter.name,
+    result: result.value
+  });
+  if (failures.length > 0) {
+    process.exit(1);
+  }
+});
+function printFailures(failures, heading = "Failed:") {
+  if (failures.length === 0) return;
+  console.log();
+  console.log(chalk9.red.bold(heading));
+  for (const failure of failures) {
+    console.log(
+      `  ${chalk9.red("\u2717")} ${failure.title} ${chalk9.dim(`(${failure.entityId})`)}: ${failure.message}`
+    );
+  }
+  console.log();
+}
+function printPreview(result) {
+  console.log();
+  console.log(chalk9.bold("Changes to push:"));
+  console.log(`  New milestones: ${result.created.milestones}`);
+  console.log(`  New issues:     ${result.created.issues}`);
+  console.log(`  Updated milestones: ${result.updated.milestones}`);
+  console.log(`  Updated issues:     ${result.updated.issues}`);
+  console.log(`  Total changes:  ${result.totalChanges}`);
+  console.log();
+}
+
+// src/commands/quality.ts
+import { relative as relative6 } from "path";
+import {
+  loadQualityConfig,
+  parseTree as parseTree5,
+  resolveRefs as resolveRefs3,
+  scoreEntities
+} from "@gitpm/core";
+import chalk10 from "chalk";
+import { Command as Command12 } from "commander";
+function gradeColor(grade) {
+  switch (grade) {
+    case "A":
+      return chalk10.green;
+    case "B":
+      return chalk10.cyan;
+    case "C":
+      return chalk10.yellow;
+    case "D":
+      return chalk10.magenta;
+    default:
+      return chalk10.red;
+  }
+}
+function gradeForAverage(avg) {
+  if (avg >= 8) return "A";
+  if (avg >= 6) return "B";
+  if (avg >= 4) return "C";
+  if (avg >= 2) return "D";
+  return "F";
+}
+function printReport2(report) {
+  console.log();
+  console.log(chalk10.bold("  Entity Quality Report"));
+  console.log(chalk10.dim(`  ${"\u2500".repeat(21)}`));
+  const grades = [
+    { grade: "A", range: "8-9", count: report.distribution.A },
+    { grade: "B", range: "6-7", count: report.distribution.B },
+    { grade: "C", range: "4-5", count: report.distribution.C },
+    { grade: "D", range: "2-3", count: report.distribution.D },
+    { grade: "F", range: "0-1", count: report.distribution.F }
+  ];
+  for (const { grade, range, count } of grades) {
+    const label = `${grade} (${range}):`;
+    const unit = count === 1 ? "entity" : "entities";
+    console.log(`  ${gradeColor(grade)(label.padEnd(10))} ${count} ${unit}`);
+  }
+  const avgGrade = gradeForAverage(report.average);
+  console.log();
+  console.log(
+    `  Average: ${report.average.toFixed(1)} (${gradeColor(avgGrade)(avgGrade)})`
+  );
+  const lowest = report.entities.filter((e) => e.score < 6).sort((a, b) => a.score - b.score).slice(0, 10);
+  if (lowest.length > 0) {
+    console.log();
+    console.log(chalk10.bold("  Lowest scoring:"));
+    for (const e of lowest) {
+      const rel = relative6(process.cwd(), e.filePath);
+      const color = gradeColor(e.grade);
+      console.log(
+        `    ${color(`[${e.grade}]`)} ${e.id} (${e.score}/${e.maxScore}) ${chalk10.dim("\u2014")} ${chalk10.dim(rel)}`
+      );
+    }
+  }
+  console.log();
+}
+var qualityCommand = new Command12("quality").description("Score entity quality across the .meta/ tree").option(
+  "--threshold <number>",
+  "Minimum average score (overrides config)",
+  Number.parseFloat
+).action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const parseResult = await parseTree5(metaDir);
+  if (!parseResult.ok) {
+    printError(parseResult.error.message);
+    process.exit(1);
+  }
+  const resolveResult = resolveRefs3(parseResult.value);
+  if (!resolveResult.ok) {
+    printError(resolveResult.error.message);
+    process.exit(1);
+  }
+  const configResult = await loadQualityConfig(metaDir);
+  if (!configResult.ok) {
+    printError(configResult.error.message);
+    process.exit(1);
+  }
+  const config = configResult.value;
+  const report = scoreEntities(resolveResult.value, config);
+  if (report.entities.length === 0) {
+    console.log(chalk10.dim("  No scorable entities found in .meta/"));
+    return;
+  }
+  printReport2(report);
+  const threshold = opts.threshold ?? config?.threshold?.min_average;
+  if (threshold != null && report.average < threshold) {
+    printError(
+      `Average score ${report.average.toFixed(1)} is below threshold ${threshold}`
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/query.ts
+import { filterEntities, formatEntities, parseTree as parseTree6 } from "@gitpm/core";
+import { Command as Command13 } from "commander";
+var DEFAULT_FIELDS = [
+  "id",
+  "title",
+  "type",
+  "status",
+  "priority",
+  "filePath"
+];
+var queryCommand = new Command13("query").description("Query and filter .meta/ entities").option(
+  "--type <types>",
+  "Entity types (comma-separated: story,epic,milestone,prd)"
+).option("--status <statuses>", "Filter by status (comma-separated)").option("--priority <priorities>", "Filter by priority (comma-separated)").option("--label <labels>", "Filter by labels (comma-separated, match any)").option("--epic <epic>", "Filter stories by epic ID or directory slug").option("--assignee <assignee>", "Filter by assignee").option("--search <text>", "Text search in title and body").option(
+  "--fields <fields>",
+  "Fields to display (comma-separated)",
+  DEFAULT_FIELDS.join(",")
+).option("--format <format>", "Output format: table, json, csv", "table").action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const parseResult = await parseTree6(metaDir);
+  if (!parseResult.ok) {
+    printError(parseResult.error.message);
+    process.exit(1);
+  }
+  const filter = {};
+  if (opts.type) {
+    filter.type = opts.type.split(",").map((s) => s.trim());
+  }
+  if (opts.status) {
+    filter.status = opts.status.split(",").map((s) => s.trim());
+  }
+  if (opts.priority) {
+    filter.priority = opts.priority.split(",").map((s) => s.trim());
+  }
+  if (opts.label) {
+    filter.labels = opts.label.split(",").map((s) => s.trim());
+  }
+  if (opts.epic) {
+    filter.epic = opts.epic;
+  }
+  if (opts.assignee) {
+    filter.assignee = opts.assignee;
+  }
+  if (opts.search) {
+    filter.search = opts.search;
+  }
+  const entities = filterEntities(parseResult.value, filter);
+  const fields = opts.fields.split(",").map((s) => s.trim());
+  const output = formatEntities(entities, { fields, format: opts.format });
+  console.log(output);
+});
+
+// src/commands/set.ts
+import { resolve as resolve5 } from "path";
+import {
+  applyAssignments,
+  parseAssignment,
+  parseFile,
+  writeFile as writeFile4
+} from "@gitpm/core";
+import { Command as Command14 } from "commander";
+var setCommand = new Command14("set").description("Update frontmatter fields on a .meta/ entity").argument("<file>", "Path to the entity file").argument(
+  "<assignments...>",
+  "Field assignments (field=value, field+=value, field-=value)"
+).action(async (file, assignments) => {
+  const filePath = resolve5(process.cwd(), file);
+  const parseResult = await parseFile(filePath);
+  if (!parseResult.ok) {
+    printError(parseResult.error.message);
+    process.exit(1);
+  }
+  const parsed = [];
+  for (const expr of assignments) {
+    const result = parseAssignment(expr);
+    if (!result.ok) {
+      printError(result.error.message);
+      process.exit(1);
+    }
+    parsed.push(result.value);
+  }
+  const applyResult = applyAssignments(parseResult.value, parsed);
+  if (!applyResult.ok) {
+    printError(applyResult.error.message);
+    process.exit(1);
+  }
+  const writeResult = await writeFile4(applyResult.value, filePath);
+  if (!writeResult.ok) {
+    printError(writeResult.error.message);
+    process.exit(1);
+  }
+  printSuccess(`Updated ${file}`);
+});
+
+// src/commands/show.ts
+import { relative as relative7, resolve as resolve6 } from "path";
+import { parseTree as parseTree7, resolveRefs as resolveRefs4 } from "@gitpm/core";
+import chalk11 from "chalk";
+import { Command as Command15 } from "commander";
+function formatFieldValue(key, value) {
+  if (value === null || value === void 0) return chalk11.dim("\u2014");
+  if (Array.isArray(value)) {
+    return value.length > 0 ? value.join(", ") : chalk11.dim("[]");
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  if (key === "priority") {
+    const p = String(value);
+    switch (p) {
+      case "critical":
+        return chalk11.red(p);
+      case "high":
+        return chalk11.yellow(p);
+      case "medium":
+        return chalk11.blue(p);
+      default:
+        return chalk11.dim(p);
+    }
+  }
+  if (key === "status") {
+    const s = String(value);
+    switch (s) {
+      case "done":
+        return chalk11.green(s);
+      case "in_progress":
+      case "in_review":
+        return chalk11.cyan(s);
+      case "cancelled":
+        return chalk11.strikethrough(chalk11.dim(s));
+      default:
+        return s;
+    }
+  }
+  return String(value);
+}
+var RESOLVED_KEYS = /* @__PURE__ */ new Set([
+  "resolvedStories",
+  "resolvedEpic",
+  "resolvedEpics",
+  "resolvedMilestone",
+  "resolvedMilestones",
+  "resolvedPrds"
+]);
+function displayEntity(entity, full) {
+  const { filePath, body, ...frontmatter } = entity;
+  console.log(chalk11.bold(entity.title));
+  console.log(chalk11.dim(relative7(process.cwd(), entity.filePath)));
+  console.log();
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (key === "title" || RESOLVED_KEYS.has(key)) continue;
+    console.log(`  ${chalk11.dim(`${key}:`)} ${formatFieldValue(key, value)}`);
+  }
+  if (full && typeof body === "string" && body.trim()) {
+    console.log();
+    console.log(body);
+  }
+  console.log();
+}
+function displayStoryRow(story) {
+  const pri = story.priority;
+  let priBullet;
+  switch (pri) {
+    case "critical":
+      priBullet = chalk11.red("\u25CF");
+      break;
+    case "high":
+      priBullet = chalk11.yellow("\u25CF");
+      break;
+    case "medium":
+      priBullet = chalk11.blue("\u25CF");
+      break;
+    default:
+      priBullet = chalk11.dim("\u25CF");
+  }
+  const status = chalk11.dim(`[${story.status}]`);
+  const id = chalk11.dim(`(${story.id})`);
+  console.log(`  ${priBullet} ${status} ${story.title} ${id}`);
+}
+var showCommand = new Command15("show").description("Display .meta/ entities with structured output").argument("[target]", "Entity file path or ID").option("--epic <epic>", "Show an epic and all its stories (by ID or slug)").option(
+  "--milestone <milestone>",
+  "Show a milestone and linked epics (by ID)"
+).option("--full", "Include body content", false).option("--format <format>", "Output format: pretty, json", "pretty").action(async (target, opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const parseResult = await parseTree7(metaDir);
+  if (!parseResult.ok) {
+    printError(parseResult.error.message);
+    process.exit(1);
+  }
+  const tree = parseResult.value;
+  if (!opts.epic && !opts.milestone) {
+    if (!target) {
+      printError("Specify a target, --epic, or --milestone");
+      process.exit(1);
+    }
+    const entity = findEntity(tree, target);
+    if (!entity) {
+      printError(`Entity not found: ${target}`);
+      process.exit(1);
+    }
+    if (opts.format === "json") {
+      console.log(JSON.stringify(entity, null, 2));
+    } else {
+      displayEntity(entity, opts.full);
+    }
+    return;
+  }
+  const resolveResult = resolveRefs4(tree);
+  if (!resolveResult.ok) {
+    printError(resolveResult.error.message);
+    process.exit(1);
+  }
+  const resolved = resolveResult.value;
+  if (opts.epic) {
+    const epic = findEpic(resolved, opts.epic);
+    if (!epic) {
+      printError(`Epic not found: ${opts.epic}`);
+      process.exit(1);
+    }
+    if (opts.format === "json") {
+      console.log(
+        JSON.stringify({ epic, stories: epic.resolvedStories }, null, 2)
+      );
+    } else {
+      displayEntity(epic, opts.full);
+      if (epic.resolvedStories.length > 0) {
+        console.log(chalk11.bold(`Stories (${epic.resolvedStories.length}):`));
+        for (const story of epic.resolvedStories) {
+          displayStoryRow(story);
+        }
+        console.log();
+      }
+    }
+    return;
+  }
+  if (opts.milestone) {
+    const ms = findMilestone(resolved, opts.milestone);
+    if (!ms) {
+      printError(`Milestone not found: ${opts.milestone}`);
+      process.exit(1);
+    }
+    if (opts.format === "json") {
+      console.log(
+        JSON.stringify({ milestone: ms, epics: ms.resolvedEpics }, null, 2)
+      );
+    } else {
+      displayEntity(ms, opts.full);
+      if (ms.resolvedEpics.length > 0) {
+        console.log(chalk11.bold(`Epics (${ms.resolvedEpics.length}):`));
+        for (const epic of ms.resolvedEpics) {
+          displayStoryRow(epic);
+        }
+        console.log();
+      }
+    }
+    return;
+  }
+});
+function findEpic(resolved, epicRef) {
+  return resolved.epics.find(
+    (e) => e.id === epicRef || e.filePath.includes(`/epics/${epicRef}/`)
+  );
+}
+function findMilestone(resolved, milestoneRef) {
+  return resolved.milestones.find((m) => m.id === milestoneRef);
+}
+function findEntity(tree, target) {
+  const all = [
+    ...tree.stories,
+    ...tree.epics,
+    ...tree.milestones,
+    ...tree.roadmaps,
+    ...tree.prds
+  ];
+  const resolved = resolve6(process.cwd(), target);
+  const byPath = all.find((e) => e.filePath === resolved);
+  if (byPath) return byPath;
+  return all.find((e) => e.id === target);
+}
+
+// src/commands/sprint.ts
+import { relative as relative8, resolve as resolvePath } from "path";
+import {
+  createSprint,
+  parseTree as parseTree8,
+  resolveRefs as resolveRefs5,
+  writeFile as writeFile5
+} from "@gitpm/core";
+import { checkbox, confirm as confirm2 } from "@inquirer/prompts";
+import chalk12 from "chalk";
+import { Command as Command16 } from "commander";
+function sprintProgress(sprint) {
+  const total = sprint.resolvedStories.length;
+  const done = sprint.resolvedStories.filter(
+    (s) => s.status === "done" || s.status === "cancelled"
+  ).length;
+  return { done, total, ratio: total > 0 ? done / total : 0 };
+}
+function isPickableStory(story) {
+  return story.status === "todo" || story.status === "backlog";
+}
+function findSprintByIdOrPath(sprints, idOrPath) {
+  const looksLikePath = idOrPath.includes("/") || idOrPath.endsWith(".md");
+  if (looksLikePath) {
+    const target = resolvePath(process.cwd(), idOrPath);
+    return sprints.find((s) => resolvePath(s.filePath) === target);
+  }
+  return sprints.find((s) => s.id === idOrPath);
+}
+function printPointsSummary(totalPoints, capacity) {
+  if (capacity === void 0) {
+    console.log(chalk12.dim(`  Points: ${totalPoints} pts (no capacity set)`));
+    return;
+  }
+  const ratio = capacity > 0 ? totalPoints / capacity : totalPoints > 0 ? 1 : 0;
+  const bar = progressBar(Math.min(ratio, 1), 16);
+  const label = `${totalPoints}/${capacity} pts`;
+  if (totalPoints > capacity) {
+    console.log(`  ${bar} ${chalk12.red(`${label} \u2014 over capacity`)}`);
+  } else {
+    console.log(`  ${bar} ${label}`);
+  }
+}
+var sprintCreateCommand = new Command16("create").description("Create a new sprint").requiredOption("--title <title>", "Sprint title").requiredOption("--start <date>", "Start date (YYYY-MM-DD)").requiredOption("--end <date>", "End date (YYYY-MM-DD)").option("--capacity <points>", "Story point capacity", Number.parseInt).action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const result = await createSprint(metaDir, {
+    title: opts.title,
+    startDate: opts.start,
+    endDate: opts.end,
+    capacity: opts.capacity
   });
   if (!result.ok) {
-    spinner.fail("Pull failed.");
     printError(result.error.message);
     process.exit(1);
   }
-  spinner.succeed("Pull complete.");
-  await handleConflictsAndPrint(result.value, strategy);
-}
-async function handleConflictsAndPrint(result, strategy) {
-  const { pulled, conflicts, resolved, skipped } = result;
-  if (strategy === "ask" && conflicts.length > 0) {
-    console.log();
+  const rel = relative8(process.cwd(), result.value.filePath);
+  printSuccess(`Created sprint: ${rel} (${result.value.id})`);
+});
+var sprintListCommand = new Command16("list").description("List all sprints with progress").option("--json", "Output as JSON").action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const parseResult = await parseTree8(metaDir);
+  if (!parseResult.ok) {
+    printError(parseResult.error.message);
+    process.exit(1);
+  }
+  const resolveResult = resolveRefs5(parseResult.value);
+  if (!resolveResult.ok) {
+    printError(resolveResult.error.message);
+    process.exit(1);
+  }
+  const sprints = resolveResult.value.sprints;
+  if (opts.json) {
+    const data = sprints.map((sp) => {
+      const { done, total, ratio } = sprintProgress(sp);
+      return {
+        id: sp.id,
+        title: sp.title,
+        status: sp.status,
+        start_date: sp.start_date,
+        end_date: sp.end_date,
+        capacity: sp.capacity,
+        stories: total,
+        done,
+        progress: ratio
+      };
+    });
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (sprints.length === 0) {
     console.log(
-      chalk5.yellow(`${conflicts.length} conflict(s) require resolution:`)
+      chalk12.dim("  No sprints found. Create one with: gitpm sprint create")
     );
-    const resolutions = await promptConflictResolution(
-      conflicts
+    return;
+  }
+  console.log();
+  console.log(chalk12.bold("  Sprints"));
+  console.log(chalk12.dim(`  ${"\u2500".repeat(7)}`));
+  for (const sp of sprints) {
+    const { done, total, ratio } = sprintProgress(sp);
+    const pct3 = Math.round(ratio * 100);
+    const dateRange = chalk12.dim(
+      `${sp.start_date.slice(0, 10)} \u2192 ${sp.end_date.slice(0, 10)}`
     );
+    const cap = sp.capacity ? chalk12.dim(` (cap: ${sp.capacity}pts)`) : "";
     console.log(
-      chalk5.dim(
-        `Resolved ${resolutions.length}, skipped ${conflicts.length - resolutions.length}`
-      )
+      `  ${progressBar(ratio, 16)} ${pct3}% ${sp.title} ${dateRange}${cap}`
+    );
+    console.log(
+      `  ${" ".repeat(16)}  ${chalk12.dim(`${done}/${total} stories`)} ${chalk12.cyan(sp.status)}`
     );
   }
   console.log();
-  console.log(chalk5.bold("Pull Summary:"));
-  console.log(`  Pulled: ${pulled.milestones + pulled.issues} changes`);
-  console.log(`  Conflicts resolved: ${resolved}`);
-  console.log(`  Skipped: ${skipped}`);
-  console.log();
-  printSuccess("Pull complete.");
-}
-
-// src/commands/push.ts
-import {
-  exportToGitHub,
-  loadConfig as loadGitHubConfig2
-} from "@gitpm/sync-github";
-import {
-  exportToGitLab,
-  loadConfig as loadGitLabConfig2
-} from "@gitpm/sync-gitlab";
-import { confirm } from "@inquirer/prompts";
-import chalk6 from "chalk";
-import { Command as Command4 } from "commander";
-import ora3 from "ora";
-var pushCommand = new Command4("push").description("Push local .meta/ changes to GitHub or GitLab").option("--token <token>", "Personal access token").option("--dry-run", "Preview changes without pushing").option("--yes", "Skip confirmation prompt").action(async (opts, cmd) => {
+});
+var sprintShowCommand = new Command16("show").description("Show sprint details").argument("<sprint-id>", "Sprint ID").action(async (sprintId, _opts, cmd) => {
   const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
-  const ghConfig = await loadGitHubConfig2(metaDir);
-  const glConfig = await loadGitLabConfig2(metaDir);
-  if (glConfig.ok) {
-    await pushToGitLab(opts, metaDir, glConfig.value);
-  } else if (ghConfig.ok) {
-    await pushToGitHub(opts, metaDir, ghConfig.value.repo);
-  } else {
-    printError(
-      "No sync config found. Run `gitpm import` first to set up sync."
-    );
+  const parseResult = await parseTree8(metaDir);
+  if (!parseResult.ok) {
+    printError(parseResult.error.message);
     process.exit(1);
   }
-});
-async function pushToGitHub(opts, metaDir, repo) {
-  let token;
-  try {
-    token = await resolveToken(opts.token);
-  } catch (err) {
-    printError(err instanceof Error ? err.message : "Failed to resolve token.");
+  const resolveResult = resolveRefs5(parseResult.value);
+  if (!resolveResult.ok) {
+    printError(resolveResult.error.message);
     process.exit(1);
   }
-  if (opts.dryRun) {
-    const spinner = ora3("Calculating changes...").start();
-    const result2 = await exportToGitHub({ token, repo, metaDir, dryRun: true });
-    if (!result2.ok) {
-      spinner.fail("Dry run failed.");
-      printError(result2.error.message);
-      process.exit(1);
-    }
-    spinner.succeed("Dry run complete.");
-    printPreview(result2.value);
-    return;
-  }
-  const previewSpinner = ora3("Calculating changes...").start();
-  const preview = await exportToGitHub({
-    token,
-    repo,
-    metaDir,
-    dryRun: true
-  });
-  if (!preview.ok) {
-    previewSpinner.fail("Failed to calculate changes.");
-    printError(preview.error.message);
+  const sprint = resolveResult.value.sprints.find((s) => s.id === sprintId);
+  if (!sprint) {
+    printError(`Sprint not found: ${sprintId}`);
     process.exit(1);
   }
-  previewSpinner.succeed("Changes calculated.");
-  printPreview(preview.value);
-  if (preview.value.totalChanges === 0) {
-    printSuccess("Nothing to push \u2014 already in sync.");
-    return;
+  const { done, total, ratio } = sprintProgress(sprint);
+  const pct3 = Math.round(ratio * 100);
+  console.log();
+  console.log(chalk12.bold(`  ${sprint.title}`));
+  console.log(chalk12.dim(`  ${"\u2500".repeat(sprint.title.length)}`));
+  console.log(`  Status: ${chalk12.cyan(sprint.status)}`);
+  console.log(
+    `  Period: ${sprint.start_date.slice(0, 10)} \u2192 ${sprint.end_date.slice(0, 10)}`
+  );
+  if (sprint.capacity) console.log(`  Capacity: ${sprint.capacity} pts`);
+  console.log(
+    `  Progress: ${progressBar(ratio, 16)} ${pct3}% (${done}/${total})`
+  );
+  console.log();
+  if (sprint.resolvedStories.length > 0) {
+    console.log(chalk12.bold("  Stories:"));
+    for (const story of sprint.resolvedStories) {
+      const statusColor = story.status === "done" ? chalk12.green : story.status === "in_progress" ? chalk12.yellow : chalk12.dim;
+      console.log(
+        `    ${statusColor("\u25CF")} ${story.title} ${chalk12.dim(`[${story.status}]`)}`
+      );
+    }
+  } else {
+    console.log(chalk12.dim("  No stories assigned."));
   }
-  if (!opts.yes) {
-    const confirmed = await confirm({
-      message: "Push these changes to GitHub?",
-      default: false
+  console.log();
+});
+var sprintPlanCommand = new Command16("plan").description(
+  "Plan a sprint by picking stories to include (interactively, or via --add/--remove)"
+).argument("<sprint>", "Sprint ID or file path").option(
+  "--add <story-id...>",
+  "Add story IDs to the sprint (non-interactive)"
+).option(
+  "--remove <story-id...>",
+  "Remove story IDs from the sprint (non-interactive)"
+).action(
+  async (sprintArg, opts, cmd) => {
+    const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+    const parseResult = await parseTree8(metaDir);
+    if (!parseResult.ok) {
+      printError(parseResult.error.message);
+      process.exit(1);
+    }
+    const resolveResult = resolveRefs5(parseResult.value);
+    if (!resolveResult.ok) {
+      printError(resolveResult.error.message);
+      process.exit(1);
+    }
+    const sprint = findSprintByIdOrPath(
+      resolveResult.value.sprints,
+      sprintArg
+    );
+    if (!sprint) {
+      printError(`Sprint not found: ${sprintArg}`);
+      process.exit(1);
+    }
+    const allStories = resolveResult.value.stories;
+    const storyById = new Map(allStories.map((s) => [s.id, s]));
+    const currentIds = new Set(sprint.stories.map((ref) => ref.id));
+    const otherSprintsByStory = /* @__PURE__ */ new Map();
+    for (const other of resolveResult.value.sprints) {
+      if (other.id === sprint.id) continue;
+      if (other.status === "done" || other.status === "cancelled") continue;
+      for (const ref of other.stories) {
+        const titles = otherSprintsByStory.get(ref.id) ?? [];
+        if (!titles.includes(other.title)) titles.push(other.title);
+        otherSprintsByStory.set(ref.id, titles);
+      }
+    }
+    const pointsFor = (ids) => [...ids].reduce(
+      (sum, id) => sum + (storyById.get(id)?.estimate ?? 0),
+      0
+    );
+    const warnAlreadyPlanned = (ids) => {
+      for (const id of ids) {
+        if (currentIds.has(id)) continue;
+        const others = otherSprintsByStory.get(id);
+        if (others) {
+          const title = storyById.get(id)?.title ?? id;
+          const names = others.map((t) => `"${t}"`).join(", ");
+          printWarning(
+            others.length === 1 ? `Story "${title}" is already in sprint ${names}; its points will count toward both.` : `Story "${title}" is already in ${others.length} other sprints (${names}); its points will count toward all of them.`
+          );
+        }
+      }
+    };
+    let nextIds;
+    const nonInteractive = Boolean(opts.add?.length || opts.remove?.length);
+    if (nonInteractive) {
+      const addIds = opts.add ?? [];
+      const unknownIds = addIds.filter((id) => !storyById.has(id));
+      if (unknownIds.length > 0) {
+        printError(
+          `Unknown story ID${unknownIds.length > 1 ? "s" : ""}: ${unknownIds.join(", ")}`
+        );
+        process.exit(1);
+      }
+      nextIds = new Set(currentIds);
+      for (const id of addIds) nextIds.add(id);
+      for (const id of opts.remove ?? []) nextIds.delete(id);
+      warnAlreadyPlanned(nextIds);
+    } else {
+      const pickable = allStories.filter(isPickableStory);
+      const untouchedIds = new Set(
+        [...currentIds].filter(
+          (id) => !storyById.has(id) || !isPickableStory(storyById.get(id))
+        )
+      );
+      if (pickable.length === 0) {
+        console.log(
+          chalk12.dim("  No todo/backlog stories available to plan.")
+        );
+        nextIds = currentIds;
+      } else {
+        const selected = await checkbox({
+          message: `Select stories for "${sprint.title}"`,
+          choices: pickable.map((story) => {
+            const others = otherSprintsByStory.get(story.id);
+            const inOthers = others ? ` ${chalk12.yellow(`(in ${others.join(", ")})`)}` : "";
+            return {
+              name: `${story.title} ${chalk12.dim(`[${story.priority}]`)} ${chalk12.dim(`(${story.estimate ?? "?"} pts)`)}${inOthers}`,
+              value: story.id,
+              checked: currentIds.has(story.id)
+            };
+          })
+        });
+        nextIds = /* @__PURE__ */ new Set([...untouchedIds, ...selected]);
+        warnAlreadyPlanned(nextIds);
+        console.log();
+        printPointsSummary(pointsFor(nextIds), sprint.capacity);
+        const proceed = await confirm2({
+          message: `Save this selection to "${sprint.title}"?`,
+          default: true
+        });
+        if (!proceed) {
+          console.log(chalk12.dim("  Cancelled \u2014 no changes written."));
+          return;
+        }
+      }
+    }
+    const totalPoints = pointsFor(nextIds);
+    const seenIds = /* @__PURE__ */ new Set();
+    const keptRefs = sprint.stories.filter((ref) => {
+      if (!nextIds.has(ref.id) || seenIds.has(ref.id)) return false;
+      seenIds.add(ref.id);
+      return true;
     });
-    if (!confirmed) {
-      console.log(chalk6.dim("Push cancelled."));
-      return;
+    const addedRefs = [...nextIds].filter((id) => !currentIds.has(id)).map((id) => ({ id }));
+    const { resolvedStories: _resolvedStories, ...sprintBase } = sprint;
+    const updatedSprint = {
+      ...sprintBase,
+      stories: [...keptRefs, ...addedRefs],
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const writeResult = await writeFile5(updatedSprint, sprint.filePath);
+    if (!writeResult.ok) {
+      printError(writeResult.error.message);
+      process.exit(1);
     }
+    console.log();
+    printSuccess(
+      `Updated sprint "${sprint.title}" (${nextIds.size} ${nextIds.size === 1 ? "story" : "stories"})`
+    );
+    printPointsSummary(totalPoints, sprint.capacity);
+    console.log();
   }
-  const pushSpinner = ora3("Pushing to GitHub...").start();
-  const result = await exportToGitHub({ token, repo, metaDir, dryRun: false });
-  if (!result.ok) {
-    pushSpinner.fail("Push failed.");
-    printError(result.error.message);
-    process.exit(1);
-  }
-  pushSpinner.succeed("Push complete.");
-  const { created, updated } = result.value;
+);
+var sprintCommand = new Command16("sprint").description("Manage sprints (time-boxed iterations)").addCommand(sprintCreateCommand).addCommand(sprintListCommand).addCommand(sprintShowCommand).addCommand(sprintPlanCommand);
+
+// src/commands/status.ts
+import {
+  computeProjectProgress,
+  parseTree as parseTree9,
+  resolveRefs as resolveRefs6
+} from "@gitpm/core";
+import chalk13 from "chalk";
+import { Command as Command17 } from "commander";
+function pct2(ratio) {
+  return `${Math.round(ratio * 100)}%`;
+}
+function printProjectProgress(progress) {
+  console.log();
+  console.log(chalk13.bold("  Project Status"));
+  console.log(chalk13.dim(`  ${"\u2500".repeat(14)}`));
+  const { overall } = progress;
   console.log(
-    `  Created ${created.milestones + created.issues}, Updated ${updated.milestones + updated.issues}`
+    `  ${progressBar(overall.progress, 20)} ${pct2(overall.progress)} (${overall.done}/${overall.total} stories)`
   );
-}
-async function pushToGitLab(opts, metaDir, config) {
-  const token = opts.token ?? process.env.GITLAB_TOKEN;
-  if (!token) {
-    printError(
-      "No GitLab token found. Provide via --token flag or GITLAB_TOKEN env var."
+  console.log();
+  for (const ms of progress.milestones) {
+    const dateStr = ms.targetDate ? chalk13.dim(` \u2014 due ${ms.targetDate.slice(0, 10)}`) : "";
+    console.log(
+      chalk13.bold(`  \u{1F4CC} ${ms.title}`) + dateStr + chalk13.dim(` (${pct2(ms.progress)})`)
     );
-    process.exit(1);
+    for (const ep of ms.epics) {
+      const counts = chalk13.dim(
+        `${ep.done}/${ep.total} done` + (ep.inProgress > 0 ? `, ${ep.inProgress} active` : "") + (ep.blocked > 0 ? `, ${ep.blocked} blocked` : "")
+      );
+      console.log(
+        `    ${progressBar(ep.progress, 16)} ${pct2(ep.progress)} ${ep.title}`
+      );
+      console.log(`    ${" ".repeat(16)}  ${counts}`);
+    }
+    if (ms.epics.length === 0) {
+      console.log(chalk13.dim("    (no epics linked)"));
+    }
+    console.log();
   }
-  if (opts.dryRun) {
-    const spinner = ora3("Calculating changes...").start();
-    const result2 = await exportToGitLab({
-      token,
-      project: config.project,
-      projectId: config.project_id,
-      baseUrl: config.base_url,
-      metaDir,
-      dryRun: true
-    });
-    if (!result2.ok) {
-      spinner.fail("Dry run failed.");
-      printError(result2.error.message);
-      process.exit(1);
+  if (progress.orphanEpics.length > 0) {
+    console.log(chalk13.bold("  Unlinked Epics"));
+    for (const ep of progress.orphanEpics) {
+      const counts = chalk13.dim(`${ep.done}/${ep.total} done`);
+      console.log(
+        `    ${progressBar(ep.progress, 16)} ${pct2(ep.progress)} ${ep.title}  ${counts}`
+      );
     }
-    spinner.succeed("Dry run complete.");
-    printPreview(result2.value);
-    return;
+    console.log();
   }
-  const previewSpinner = ora3("Calculating changes...").start();
-  const preview = await exportToGitLab({
-    token,
-    project: config.project,
-    projectId: config.project_id,
-    baseUrl: config.base_url,
-    metaDir,
-    dryRun: true
-  });
-  if (!preview.ok) {
-    previewSpinner.fail("Failed to calculate changes.");
-    printError(preview.error.message);
+}
+var statusCommand = new Command17("status").description("Show project progress across milestones and epics").option("--json", "Output as JSON").action(async (opts, cmd) => {
+  const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+  const parseResult = await parseTree9(metaDir);
+  if (!parseResult.ok) {
+    printError(parseResult.error.message);
     process.exit(1);
   }
-  previewSpinner.succeed("Changes calculated.");
-  printPreview(preview.value);
-  if (preview.value.totalChanges === 0) {
-    printSuccess("Nothing to push \u2014 already in sync.");
-    return;
+  const resolveResult = resolveRefs6(parseResult.value);
+  if (!resolveResult.ok) {
+    printError(resolveResult.error.message);
+    process.exit(1);
   }
-  if (!opts.yes) {
-    const confirmed = await confirm({
-      message: "Push these changes to GitLab?",
-      default: false
-    });
-    if (!confirmed) {
-      console.log(chalk6.dim("Push cancelled."));
-      return;
-    }
+  const progress = computeProjectProgress(resolveResult.value);
+  if (opts.json) {
+    console.log(JSON.stringify(progress, null, 2));
+    return;
   }
-  const pushSpinner = ora3("Pushing to GitLab...").start();
-  const result = await exportToGitLab({
-    token,
-    project: config.project,
-    projectId: config.project_id,
-    baseUrl: config.base_url,
-    metaDir,
-    dryRun: false
-  });
-  if (!result.ok) {
-    pushSpinner.fail("Push failed.");
-    printError(result.error.message);
-    process.exit(1);
+  if (progress.overall.total === 0) {
+    console.log(chalk13.dim("  No stories found in .meta/"));
+    return;
   }
-  pushSpinner.succeed("Push complete.");
-  const { created, updated } = result.value;
-  console.log(
-    `  Created ${created.milestones + created.issues}, Updated ${updated.milestones + updated.issues}`
-  );
-}
-function printPreview(result) {
-  console.log();
-  console.log(chalk6.bold("Changes to push:"));
-  console.log(`  New milestones: ${result.created.milestones}`);
-  console.log(`  New issues:     ${result.created.issues}`);
-  console.log(`  Updated milestones: ${result.updated.milestones}`);
-  console.log(`  Updated issues:     ${result.updated.issues}`);
-  console.log(`  Total changes:  ${result.totalChanges}`);
-  console.log();
-}
+  printProjectProgress(progress);
+});
 
 // src/commands/sync.ts
-import {
-  loadConfig as loadGitHubConfig3,
-  syncWithGitHub as syncWithGitHub2
-} from "@gitpm/sync-github";
-import {
-  loadConfig as loadGitLabConfig3,
-  syncWithGitLab as syncWithGitLab2
-} from "@gitpm/sync-gitlab";
-import { confirm as confirm2 } from "@inquirer/prompts";
-import chalk7 from "chalk";
-import { Command as Command5 } from "commander";
+import { runHooks as runHooks4 } from "@gitpm/core";
+import { confirm as confirm3 } from "@inquirer/prompts";
+import chalk14 from "chalk";
+import { Command as Command18 } from "commander";
 import ora4 from "ora";
-var syncCommand = new Command5("sync").description("Bidirectional sync between local .meta/ and GitHub/GitLab").option("--token <token>", "Personal access token").option(
+var VALID_STRATEGIES2 = ["local-wins", "remote-wins", "ask"];
+var syncCommand = new Command18("sync").description("Bidirectional sync between local .meta/ and remote platform").option("--token <token>", "Personal access token").option(
   "--strategy <strategy>",
   "Conflict resolution strategy (local-wins, remote-wins, ask)",
   "ask"
-).option("--dry-run", "Preview changes without syncing").option("--yes", "Skip confirmation prompt").action(async (opts, cmd) => {
+).option("--team <id>", "Linear team ID").option(
+  "--api-key <key>",
+  "Linear API key (default: LINEAR_API_KEY environment variable)"
+).option("--dry-run", "Preview changes without syncing").option("--yes", "Skip confirmation prompt").option("--adapter <name>", "Force a specific adapter (e.g. github, gitlab)").action(async (opts, cmd) => {
   const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
-  const strategy = opts.strategy;
-  const ghConfig = await loadGitHubConfig3(metaDir);
-  const glConfig = await loadGitLabConfig3(metaDir);
-  if (glConfig.ok) {
-    await syncGitLab(opts, metaDir, glConfig.value, strategy);
-  } else if (ghConfig.ok) {
-    await syncGitHub(opts, metaDir, ghConfig.value.repo, strategy);
-  } else {
+  if (!VALID_STRATEGIES2.includes(opts.strategy)) {
     printError(
-      "No sync config found. Run `gitpm import` first to set up sync."
+      `Invalid strategy "${opts.strategy}". Must be one of: ${VALID_STRATEGIES2.join(", ")}`
     );
     process.exit(1);
   }
-});
-async function syncGitHub(opts, metaDir, repo, strategy) {
-  let token;
-  try {
-    token = await resolveToken(opts.token);
-  } catch (err) {
-    printError(err instanceof Error ? err.message : "Failed to resolve token.");
-    process.exit(1);
-  }
+  const strategy = opts.strategy;
+  const { adapter, config } = await resolveAdapter(metaDir, opts.adapter);
+  const { token, email } = resolveCredentials(adapter.name, opts.token);
   if (opts.dryRun) {
     const spinner2 = ora4("Calculating sync changes...").start();
-    const result2 = await syncWithGitHub2({
+    const result2 = await adapter.sync({
       token,
-      repo,
+      email,
       metaDir,
+      teamId: opts.team,
+      apiKey: opts.apiKey,
       strategy,
       dryRun: true
     });
@@ -605,81 +2306,36 @@ async function syncGitHub(opts, metaDir, repo, strategy) {
       process.exit(1);
     }
     spinner2.succeed("Dry run complete.");
-    printSyncSummary(result2.value, "GitHub");
+    printSyncSummary(result2.value, adapter.displayName);
     return;
   }
   if (!opts.yes) {
-    const confirmed = await confirm2({
-      message: "Run bidirectional sync with GitHub?",
+    const confirmed = await confirm3({
+      message: `Run bidirectional sync with ${adapter.displayName}?`,
       default: true
     });
     if (!confirmed) {
-      console.log(chalk7.dim("Sync cancelled."));
+      console.log(chalk14.dim("Sync cancelled."));
       return;
     }
   }
-  const spinner = ora4("Syncing with GitHub...").start();
-  const result = await syncWithGitHub2({
-    token,
-    repo,
+  const preHook = await runHooks4(config, "pre-sync", {
     metaDir,
-    strategy: strategy === "ask" ? "ask" : strategy
+    event: "pre-sync",
+    adapterName: adapter.name
   });
-  if (!result.ok) {
-    spinner.fail("Sync failed.");
-    printError(result.error.message);
-    process.exit(1);
-  }
-  spinner.succeed("Sync complete.");
-  await handleConflicts(result.value, strategy);
-  printSyncSummary(result.value, "GitHub");
-}
-async function syncGitLab(opts, metaDir, config, strategy) {
-  const token = opts.token ?? process.env.GITLAB_TOKEN;
-  if (!token) {
-    printError(
-      "No GitLab token found. Provide via --token flag or GITLAB_TOKEN env var."
-    );
+  if (!preHook.ok) {
+    printError(`Pre-sync hook failed: ${preHook.error.message}`);
     process.exit(1);
   }
-  if (opts.dryRun) {
-    const spinner2 = ora4("Calculating sync changes...").start();
-    const result2 = await syncWithGitLab2({
-      token,
-      project: config.project,
-      projectId: config.project_id,
-      baseUrl: config.base_url,
-      metaDir,
-      strategy,
-      dryRun: true
-    });
-    if (!result2.ok) {
-      spinner2.fail("Dry run failed.");
-      printError(result2.error.message);
-      process.exit(1);
-    }
-    spinner2.succeed("Dry run complete.");
-    printSyncSummary(result2.value, "GitLab");
-    return;
-  }
-  if (!opts.yes) {
-    const confirmed = await confirm2({
-      message: "Run bidirectional sync with GitLab?",
-      default: true
-    });
-    if (!confirmed) {
-      console.log(chalk7.dim("Sync cancelled."));
-      return;
-    }
-  }
-  const spinner = ora4("Syncing with GitLab...").start();
-  const result = await syncWithGitLab2({
+  const spinner = ora4(`Syncing with ${adapter.displayName}...`).start();
+  const result = await adapter.sync({
     token,
-    project: config.project,
-    projectId: config.project_id,
-    baseUrl: config.base_url,
+    email,
     metaDir,
-    strategy: strategy === "ask" ? "ask" : strategy
+    teamId: opts.team,
+    apiKey: opts.apiKey,
+    strategy
   });
   if (!result.ok) {
     spinner.fail("Sync failed.");
@@ -688,20 +2344,26 @@ async function syncGitLab(opts, metaDir, config, strategy) {
   }
   spinner.succeed("Sync complete.");
   await handleConflicts(result.value, strategy);
-  printSyncSummary(result.value, "GitLab");
-}
+  printSyncSummary(result.value, adapter.displayName);
+  await runHooks4(config, "post-sync", {
+    metaDir,
+    event: "post-sync",
+    adapterName: adapter.name,
+    result: result.value
+  });
+});
 async function handleConflicts(result, strategy) {
   const { conflicts } = result;
   if (strategy === "ask" && conflicts.length > 0) {
     console.log();
     console.log(
-      chalk7.yellow(`${conflicts.length} conflict(s) require resolution:`)
+      chalk14.yellow(`${conflicts.length} conflict(s) require resolution:`)
     );
     const resolutions = await promptConflictResolution(
       conflicts
     );
     console.log(
-      chalk7.dim(
+      chalk14.dim(
         `Resolved ${resolutions.length}, skipped ${conflicts.length - resolutions.length}`
       )
     );
@@ -710,35 +2372,68 @@ async function handleConflicts(result, strategy) {
 function printSyncSummary(result, platform) {
   const pushedTotal = result.pushed.milestones + result.pushed.issues;
   const pulledTotal = result.pulled.milestones + result.pulled.issues;
+  const failedCount = result.failedEntities?.length ?? 0;
+  if (result.resumedFromCheckpoint) {
+    console.log();
+    console.log(chalk14.yellow("Resumed from previous checkpoint."));
+  }
   console.log();
-  console.log(chalk7.bold("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
-  console.log(chalk7.bold("\u2502           Sync Complete              \u2502"));
-  console.log(chalk7.bold("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"));
   console.log(
-    `${chalk7.bold("\u2502")} Pushed to ${platform.padEnd(6)} \u2502 ${String(pushedTotal).padEnd(17)} ${chalk7.bold("\u2502")}`
+    chalk14.bold(
+      "\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"
+    )
+  );
+  console.log(chalk14.bold("\u2502           Sync Complete              \u2502"));
+  console.log(
+    chalk14.bold(
+      "\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"
+    )
+  );
+  console.log(
+    `${chalk14.bold("\u2502")} Pushed to ${platform.padEnd(6)} \u2502 ${String(pushedTotal).padEnd(17)} ${chalk14.bold("\u2502")}`
+  );
+  console.log(
+    `${chalk14.bold("\u2502")} Pulled to local  \u2502 ${String(pulledTotal).padEnd(17)} ${chalk14.bold("\u2502")}`
   );
   console.log(
-    `${chalk7.bold("\u2502")} Pulled to local  \u2502 ${String(pulledTotal).padEnd(17)} ${chalk7.bold("\u2502")}`
+    `${chalk14.bold("\u2502")} Conflicts        \u2502 ${String(`${result.resolved} resolved`).padEnd(17)} ${chalk14.bold("\u2502")}`
   );
   console.log(
-    `${chalk7.bold("\u2502")} Conflicts        \u2502 ${String(`${result.resolved} resolved`).padEnd(17)} ${chalk7.bold("\u2502")}`
+    `${chalk14.bold("\u2502")} Skipped          \u2502 ${String(result.skipped).padEnd(17)} ${chalk14.bold("\u2502")}`
   );
+  if (failedCount > 0) {
+    console.log(
+      `${chalk14.bold("\u2502")} ${chalk14.red("Failed")}           \u2502 ${chalk14.red(String(failedCount).padEnd(17))} ${chalk14.bold("\u2502")}`
+    );
+  }
   console.log(
-    `${chalk7.bold("\u2502")} Errors           \u2502 ${String(result.skipped).padEnd(17)} ${chalk7.bold("\u2502")}`
+    chalk14.bold(
+      "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"
+    )
   );
-  console.log(chalk7.bold("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+  if (failedCount > 0 && result.failedEntities) {
+    console.log();
+    console.log(
+      chalk14.red(
+        `${failedCount} entity sync(s) failed. A checkpoint was saved \u2014 re-run sync to resume.`
+      )
+    );
+    for (const f of result.failedEntities) {
+      console.log(chalk14.dim(`  ${f.entityId}: ${f.error}`));
+    }
+  }
   console.log();
   printSuccess("Sync complete.");
 }
 
 // src/commands/validate.ts
-import { relative } from "path";
-import { parseTree, resolveRefs, validateTree } from "@gitpm/core";
-import chalk8 from "chalk";
-import { Command as Command6 } from "commander";
-var validateCommand = new Command6("validate").description("Validate the .meta/ project tree").action(async (_opts, cmd) => {
+import { relative as relative9 } from "path";
+import { parseTree as parseTree10, resolveRefs as resolveRefs7, validateTree } from "@gitpm/core";
+import chalk15 from "chalk";
+import { Command as Command19 } from "commander";
+var validateCommand = new Command19("validate").description("Validate the .meta/ project tree").action(async (_opts, cmd) => {
   const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
-  const parseResult = await parseTree(metaDir);
+  const parseResult = await parseTree10(metaDir);
   if (!parseResult.ok) {
     printError(parseResult.error.message);
     process.exit(1);
@@ -746,28 +2441,28 @@ var validateCommand = new Command6("validate").description("Validate the .meta/
   const tree = parseResult.value;
   if (tree.errors.length > 0) {
     for (const err of tree.errors) {
-      const rel = relative(process.cwd(), err.filePath);
-      console.log(chalk8.red(`  \u2717 ${rel}: ${err.message}`));
+      const rel = relative9(process.cwd(), err.filePath);
+      console.log(chalk15.red(`  \u2717 ${rel}: ${err.message}`));
     }
   }
-  const resolveResult = resolveRefs(tree);
+  const resolveResult = resolveRefs7(tree);
   if (!resolveResult.ok) {
     printError(resolveResult.error.message);
     process.exit(1);
   }
   const result = validateTree(resolveResult.value);
   for (const err of result.errors) {
-    const rel = err.filePath ? relative(process.cwd(), err.filePath) : "";
+    const rel = err.filePath ? relative9(process.cwd(), err.filePath) : "";
     const location = rel ? `${rel}: ` : "";
     const id = err.entityId ? `[${err.entityId}] ` : "";
-    console.log(chalk8.red(`  \u2717 ${location}${id}${err.code}: ${err.message}`));
+    console.log(chalk15.red(`  \u2717 ${location}${id}${err.code}: ${err.message}`));
   }
   for (const warn of result.warnings) {
-    const rel = warn.filePath ? relative(process.cwd(), warn.filePath) : "";
+    const rel = warn.filePath ? relative9(process.cwd(), warn.filePath) : "";
     const location = rel ? `${rel}: ` : "";
     const id = warn.entityId ? `[${warn.entityId}] ` : "";
     console.log(
-      chalk8.yellow(`  \u26A0 ${location}${id}${warn.code}: ${warn.message}`)
+      chalk15.yellow(`  \u26A0 ${location}${id}${warn.code}: ${warn.message}`)
     );
   }
   if (!result.valid) {
@@ -786,16 +2481,29 @@ var validateCommand = new Command6("validate").description("Validate the .meta/
 });
 
 // src/index.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
+var __dirname = dirname4(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  readFileSync(join2(__dirname, "..", "package.json"), "utf-8")
+  readFileSync(join3(__dirname, "..", "package.json"), "utf-8")
 );
-var program = new Command7();
+var program = new Command20();
 program.name("gitpm").description("Git-native project management").version(pkg.version).option("--meta-dir <path>", "Path to .meta directory", ".meta").option("--token <token>", "Personal access token (GitHub or GitLab)");
 program.addCommand(initCommand);
 program.addCommand(validateCommand);
+program.addCommand(qualityCommand);
+program.addCommand(nextCommand);
+program.addCommand(queryCommand);
+program.addCommand(showCommand);
+program.addCommand(setCommand);
+program.addCommand(createCommand);
+program.addCommand(moveCommand);
+program.addCommand(commitCommand);
 program.addCommand(importCommand);
 program.addCommand(pushCommand);
 program.addCommand(pullCommand);
 program.addCommand(syncCommand);
+program.addCommand(statusCommand);
+program.addCommand(sprintCommand);
+program.addCommand(auditCommand);
+program.addCommand(archiveCommand);
+program.addCommand(contextCommand);
 program.parse();