@trail-pm/cli 0.1.0

package/dist/chunk-SFBMB3UT.js

@@ -0,0 +1,1622 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/core/compile-snapshot.ts
+import fs from "fs";
+import path from "path";
+
+// src/schemas/snapshot.ts
+import { z as z2 } from "zod";
+
+// src/schemas/task.ts
+import { z } from "zod";
+var TaskStatusSchema = z.enum([
+  "draft",
+  "todo",
+  "in_progress",
+  "in_review",
+  "done",
+  "cancelled"
+]);
+var isoDateStringSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected ISO date string (YYYY-MM-DD)");
+var TaskGitHubSchema = z.object({
+  issue_number: z.number().int(),
+  synced_at: z.string().datetime({ offset: true }),
+  url: z.string().url()
+}).nullable();
+var TaskAiSchema = z.object({
+  summary: z.string().optional(),
+  acceptance_criteria: z.array(z.string()).optional(),
+  implementation_context: z.array(z.string()).optional(),
+  test_strategy: z.array(z.string()).optional(),
+  constraints: z.array(z.string()).optional()
+}).strict().optional();
+var TaskSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string().optional(),
+  status: TaskStatusSchema,
+  priority: z.enum(["p0", "p1", "p2", "p3"]).optional(),
+  type: z.enum(["feature", "bug", "chore", "epic"]),
+  assignee: z.string().optional(),
+  milestone: z.string().optional(),
+  branch: z.string().optional(),
+  labels: z.array(z.string()).default([]),
+  parent: z.string().nullable().optional(),
+  depends_on: z.array(z.string()).default([]),
+  blocks: z.array(z.string()).default([]),
+  due_date: isoDateStringSchema.optional(),
+  start_date: isoDateStringSchema.optional(),
+  estimate: z.enum(["xs", "sm", "md", "lg", "xl"]).optional(),
+  github: TaskGitHubSchema.optional(),
+  refs: z.array(
+    z.object({
+      type: z.string(),
+      path: z.string()
+    }).strict()
+  ).default([]),
+  ai: TaskAiSchema,
+  created_at: z.string().datetime({ offset: true }),
+  updated_at: z.string().datetime({ offset: true })
+}).strict();
+
+// src/schemas/snapshot.ts
+var SnapshotSchema = z2.object({
+  generated_at: z2.string().datetime({ offset: true }),
+  tasks: z2.array(TaskSchema),
+  warnings: z2.array(
+    z2.object({
+      code: z2.string(),
+      message: z2.string(),
+      taskId: z2.string().optional()
+    }).strict()
+  )
+}).strict();
+
+// src/core/compile-snapshot.ts
+var UNKNOWN_DEPENDENCY = "UNKNOWN_DEPENDENCY";
+var DEPENDENCY_CYCLE = "DEPENDENCY_CYCLE";
+function detectCycles(taskIds, deps) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const stack = [];
+  function recordCycle(fromIndex) {
+    cycles.push(stack.slice(fromIndex));
+  }
+  function dfs(u) {
+    visiting.add(u);
+    stack.push(u);
+    for (const v of deps.get(u) ?? []) {
+      if (!taskIds.has(v)) {
+        continue;
+      }
+      if (visiting.has(v)) {
+        const i = stack.indexOf(v);
+        if (i !== -1) {
+          recordCycle(i);
+        }
+        continue;
+      }
+      if (!visited.has(v)) {
+        dfs(v);
+      }
+    }
+    stack.pop();
+    visiting.delete(u);
+    visited.add(u);
+  }
+  for (const id of taskIds) {
+    if (!visited.has(id)) {
+      dfs(id);
+    }
+  }
+  return cycles;
+}
+function formatCycle(nodes) {
+  return nodes.join(" \u2192 ");
+}
+function compileSnapshot(tasks, now) {
+  const generatedAt = (now ?? /* @__PURE__ */ new Date()).toISOString();
+  const taskList = [...tasks];
+  const taskIds = new Set(taskList.map((t) => t.id));
+  const deps = /* @__PURE__ */ new Map();
+  for (const t of taskList) {
+    deps.set(t.id, t.depends_on ?? []);
+  }
+  const warnings = [];
+  for (const t of taskList) {
+    for (const depId of t.depends_on ?? []) {
+      if (!taskIds.has(depId)) {
+        warnings.push({
+          code: UNKNOWN_DEPENDENCY,
+          message: `Task "${t.id}" depends on unknown task id "${depId}"`,
+          taskId: t.id
+        });
+      }
+    }
+  }
+  for (const cycle of detectCycles(taskIds, deps)) {
+    warnings.push({
+      code: DEPENDENCY_CYCLE,
+      message: `Dependency cycle: ${formatCycle(cycle)}`,
+      taskId: cycle[0]
+    });
+  }
+  return {
+    generated_at: generatedAt,
+    tasks: taskList,
+    warnings
+  };
+}
+function writeSnapshot(snapshotPath, snapshot) {
+  const parsed = SnapshotSchema.parse(snapshot);
+  const dir = path.dirname(snapshotPath);
+  fs.mkdirSync(dir, { recursive: true });
+  const body = `${JSON.stringify(parsed, null, 2)}
+`;
+  fs.writeFileSync(snapshotPath, body, "utf8");
+}
+
+// src/core/paths.ts
+import fs2 from "fs";
+import path2 from "path";
+var MAX_TRAIL_ROOT_WALK = 20;
+function findTrailRoot(startDir) {
+  let dir = path2.resolve(startDir);
+  for (let i = 0; i < MAX_TRAIL_ROOT_WALK; i++) {
+    const configPath = path2.join(dir, ".trail", "config.json");
+    if (fs2.existsSync(configPath)) {
+      return dir;
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return null;
+}
+function trailPaths(root) {
+  const trailDir = path2.join(root, ".trail");
+  return {
+    root,
+    trailDir,
+    tasksDir: path2.join(trailDir, "tasks"),
+    configPath: path2.join(trailDir, "config.json"),
+    snapshotPath: path2.join(trailDir, "snapshot.json"),
+    gitignorePath: path2.join(trailDir, ".gitignore")
+  };
+}
+
+// src/core/task-store.ts
+import fs3 from "fs";
+import path3 from "path";
+function toValidationError(zodError, context) {
+  const issues = zodError.issues.map(
+    (i) => `${i.path.length ? i.path.join(".") : "(root)"}: ${i.message}`
+  );
+  return {
+    code: "VALIDATION_FAILED",
+    message: context ? `Task validation failed (${context})` : "Task validation failed",
+    details: zodError.message,
+    issues
+  };
+}
+function throwValidationFailed(err) {
+  const e = new Error(`[VALIDATION_FAILED] ${err.message}`);
+  e.name = "TrailError";
+  e.trailError = err;
+  throw e;
+}
+function isTaskStoreValidationError(e) {
+  return e instanceof Error && "trailError" in e && typeof e.trailError === "object" && e.trailError !== null && "code" in e.trailError && e.trailError.code === "VALIDATION_FAILED";
+}
+function listTaskFiles(tasksDir) {
+  const names = fs3.readdirSync(tasksDir);
+  return names.filter(
+    (n) => n.endsWith(".json") && n !== "snapshot.json"
+  ).sort((a, b) => a.localeCompare(b));
+}
+function readTaskFile(filePath) {
+  let raw;
+  try {
+    raw = JSON.parse(fs3.readFileSync(filePath, "utf8"));
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      throwValidationFailed({
+        code: "VALIDATION_FAILED",
+        message: "Invalid JSON in task file",
+        details: filePath
+      });
+    }
+    throw e;
+  }
+  const parsed = TaskSchema.safeParse(raw);
+  if (!parsed.success) {
+    throwValidationFailed(toValidationError(parsed.error, filePath));
+  }
+  return parsed.data;
+}
+function writeTaskFile(filePath, task) {
+  const parsed = TaskSchema.safeParse(task);
+  if (!parsed.success) {
+    throwValidationFailed(toValidationError(parsed.error, filePath));
+  }
+  const dir = path3.dirname(filePath);
+  fs3.mkdirSync(dir, { recursive: true });
+  const body = `${JSON.stringify(parsed.data, null, 2)}
+`;
+  fs3.writeFileSync(filePath, body, "utf8");
+}
+function loadAllTasks(tasksDir) {
+  if (!fs3.existsSync(tasksDir)) {
+    return [];
+  }
+  const files = listTaskFiles(tasksDir);
+  return files.map((name) => readTaskFile(path3.join(tasksDir, name)));
+}
+function findTaskFileById(tasksDir, id) {
+  if (!fs3.existsSync(tasksDir)) {
+    return null;
+  }
+  const direct = path3.join(tasksDir, `${id}.json`);
+  if (fs3.existsSync(direct)) {
+    const task = readTaskFile(direct);
+    if (task.id === id) {
+      return { filePath: direct, task };
+    }
+  }
+  for (const name of listTaskFiles(tasksDir)) {
+    const filePath = path3.join(tasksDir, name);
+    const task = readTaskFile(filePath);
+    if (task.id === id) {
+      return { filePath, task };
+    }
+  }
+  return null;
+}
+
+// src/cli/json.ts
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+// src/cli/commands/context.ts
+function buildContextPacket(task, allTasks) {
+  const depTasks = task.depends_on.map((id) => allTasks.find((t) => t.id === id)).filter((t) => t !== void 0);
+  return {
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    priority: task.priority,
+    goal: task.ai?.summary ?? task.description,
+    depends_on: task.depends_on,
+    depends_on_titles: Object.fromEntries(
+      depTasks.map((t) => [t.id, t.title])
+    ),
+    implementation_context: task.ai?.implementation_context ?? [],
+    constraints: task.ai?.constraints ?? [],
+    definition_of_done: task.ai?.acceptance_criteria ?? [],
+    test_strategy: task.ai?.test_strategy ?? [],
+    refs: task.refs,
+    github: task.github
+  };
+}
+function runContext(options) {
+  const root = findTrailRoot(process.cwd());
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: process.cwd()
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const resolved = findTaskFileById(paths.tasksDir, options.id);
+  if (resolved === null) {
+    throw new Error(`No task with id "${options.id}"`);
+  }
+  const allTasks = loadAllTasks(paths.tasksDir);
+  printJson(buildContextPacket(resolved.task, allTasks));
+}
+
+// src/core/deps.ts
+function uniq(ids) {
+  return [...new Set(ids)];
+}
+function addDependency(tasksDir, taskId, dependsOnId, updatedAtIso) {
+  if (taskId === dependsOnId) {
+    throw new Error("A task cannot depend on itself");
+  }
+  const a = findTaskFileById(tasksDir, taskId);
+  const b = findTaskFileById(tasksDir, dependsOnId);
+  if (a === null) {
+    throw new Error(`No task with id "${taskId}"`);
+  }
+  if (b === null) {
+    throw new Error(`No task with id "${dependsOnId}"`);
+  }
+  const nextA = {
+    ...a.task,
+    depends_on: uniq([...a.task.depends_on, dependsOnId]),
+    updated_at: updatedAtIso
+  };
+  const nextB = {
+    ...b.task,
+    blocks: uniq([...b.task.blocks, taskId]),
+    updated_at: updatedAtIso
+  };
+  writeTaskFile(a.filePath, nextA);
+  writeTaskFile(b.filePath, nextB);
+}
+function removeDependency(tasksDir, taskId, dependsOnId, updatedAtIso) {
+  const a = findTaskFileById(tasksDir, taskId);
+  const b = findTaskFileById(tasksDir, dependsOnId);
+  if (a === null) {
+    throw new Error(`No task with id "${taskId}"`);
+  }
+  if (b === null) {
+    throw new Error(`No task with id "${dependsOnId}"`);
+  }
+  const nextA = {
+    ...a.task,
+    depends_on: a.task.depends_on.filter((x) => x !== dependsOnId),
+    updated_at: updatedAtIso
+  };
+  const nextB = {
+    ...b.task,
+    blocks: b.task.blocks.filter((x) => x !== taskId),
+    updated_at: updatedAtIso
+  };
+  writeTaskFile(a.filePath, nextA);
+  writeTaskFile(b.filePath, nextB);
+}
+function listDependencyEdges(tasks) {
+  const edges = [];
+  for (const t of tasks) {
+    for (const d of t.depends_on) {
+      edges.push({ from: t.id, to: d });
+    }
+  }
+  return edges;
+}
+
+// src/cli/read-context.ts
+import fs5 from "fs";
+
+// src/core/auth.ts
+import * as childProcess from "child_process";
+var AUTH_HINT = "Set GITHUB_TOKEN or install gh and run gh auth login";
+function authRequired(message) {
+  return {
+    ok: false,
+    error: {
+      code: "AUTH_REQUIRED",
+      message,
+      hint: AUTH_HINT
+    }
+  };
+}
+function resolveGitHubToken(env) {
+  const e = env ?? process.env;
+  const fromEnv = e.GITHUB_TOKEN;
+  if (typeof fromEnv === "string" && fromEnv.trim() !== "") {
+    return { ok: true, token: fromEnv.trim() };
+  }
+  try {
+    const out = childProcess.execFileSync("gh", ["auth", "token"], {
+      encoding: "utf-8"
+    });
+    const token = out.trim();
+    if (token === "") {
+      return authRequired("GitHub CLI returned an empty token");
+    }
+    return { ok: true, token };
+  } catch {
+    return authRequired(
+      "No GitHub token found; could not read from environment or gh CLI"
+    );
+  }
+}
+
+// src/core/errors.ts
+function formatTrailError(error) {
+  const lines = [`[${error.code}] ${error.message}`];
+  switch (error.code) {
+    case "AUTH_REQUIRED": {
+      if (error.hint) {
+        lines.push(error.hint);
+      }
+      break;
+    }
+    case "AUTH_FAILED": {
+      break;
+    }
+    case "NOT_A_TRAIL_REPO": {
+      if (error.path) {
+        lines.push(`Path: ${error.path}`);
+      }
+      break;
+    }
+    case "VALIDATION_FAILED": {
+      if (error.details) {
+        lines.push(error.details);
+      }
+      if (error.issues && error.issues.length > 0) {
+        for (const issue of error.issues) {
+          lines.push(`  - ${issue}`);
+        }
+      }
+      break;
+    }
+    case "GITHUB_API": {
+      if (error.status !== void 0) {
+        lines.push(`HTTP status: ${error.status}`);
+      }
+      if (error.body) {
+        lines.push(error.body);
+      }
+      break;
+    }
+    case "SYNC_CONFLICT": {
+      if (error.paths && error.paths.length > 0) {
+        lines.push(`Paths: ${error.paths.join(", ")}`);
+      }
+      break;
+    }
+    default: {
+      const _exhaustive = error;
+      return _exhaustive;
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/core/github-client.ts
+var USER_AGENT = "trail-cli/0.0.1";
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/$/, "");
+}
+var GitHubClient = class {
+  token;
+  baseUrl;
+  constructor(token, baseUrl = "https://api.github.com") {
+    this.token = token;
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+  }
+  async request(method, path8, body) {
+    const url = `${this.baseUrl}${path8.startsWith("/") ? path8 : `/${path8}`}`;
+    const headers = new Headers({
+      Authorization: `Bearer ${this.token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      "User-Agent": USER_AGENT
+    });
+    if (body !== void 0) {
+      headers.set("Content-Type", "application/json");
+    }
+    return fetch(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async parseJson(response) {
+    const text = await response.text();
+    if (!response.ok) {
+      const snippet = text.slice(0, 200);
+      throw new Error(`GitHub API ${response.status}: ${snippet}`);
+    }
+    return JSON.parse(text);
+  }
+  async listIssues(owner, repo, params) {
+    const search = new URLSearchParams({
+      state: params.state,
+      per_page: String(params.per_page),
+      page: String(params.page)
+    });
+    const path8 = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues?${search}`;
+    const response = await this.request("GET", path8);
+    return this.parseJson(response);
+  }
+  async getIssue(owner, repo, issueNumber) {
+    const path8 = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${issueNumber}`;
+    const response = await this.request("GET", path8);
+    return this.parseJson(response);
+  }
+  async updateIssue(owner, repo, issueNumber, patch) {
+    const path8 = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${issueNumber}`;
+    const response = await this.request("PATCH", path8, patch);
+    return this.parseJson(response);
+  }
+  async createIssueComment(owner, repo, issueNumber, body) {
+    const path8 = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${issueNumber}/comments`;
+    const response = await this.request("POST", path8, { body });
+    return this.parseJson(response);
+  }
+  /** Create a new issue. Returns the created issue (same shape as list/get). */
+  async createIssue(owner, repo, input) {
+    const path8 = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues`;
+    const response = await this.request("POST", path8, {
+      title: input.title,
+      body: input.body ?? "",
+      labels: input.labels ?? []
+    });
+    return this.parseJson(response);
+  }
+};
+
+// src/core/sync.ts
+import fs4 from "fs";
+import path4 from "path";
+
+// src/core/github-mapper.ts
+function statusFromIssue(issue, existing) {
+  if (issue.state === "closed") {
+    return "done";
+  }
+  const prev = existing?.status;
+  if (prev === "in_progress" || prev === "in_review") {
+    return prev;
+  }
+  return "todo";
+}
+function parseIssueTimestamp(issue, fallback) {
+  if (issue.updated_at.trim() === "") {
+    return fallback.toISOString();
+  }
+  return issue.updated_at;
+}
+function issueToTask(issue, existing, now) {
+  const updatedAt = parseIssueTimestamp(issue, now);
+  const createdAt = existing?.created_at ?? (issue.updated_at.trim() !== "" ? issue.updated_at : now.toISOString());
+  const raw = {
+    id: String(issue.number),
+    title: issue.title,
+    description: issue.body ?? "",
+    status: statusFromIssue(issue, existing),
+    type: existing?.type ?? "feature",
+    labels: issue.labels.map((l) => l.name),
+    assignee: issue.assignee?.login,
+    milestone: issue.milestone?.title,
+    depends_on: existing?.depends_on ?? [],
+    blocks: existing?.blocks ?? [],
+    refs: existing?.refs ?? [],
+    ai: existing?.ai,
+    branch: existing?.branch,
+    estimate: existing?.estimate,
+    priority: existing?.priority,
+    parent: existing?.parent,
+    due_date: existing?.due_date,
+    start_date: existing?.start_date,
+    github: {
+      issue_number: issue.number,
+      synced_at: now.toISOString(),
+      url: issue.html_url
+    },
+    created_at: createdAt,
+    updated_at: updatedAt
+  };
+  return TaskSchema.parse(raw);
+}
+function taskToIssueUpdate(task) {
+  const labels = [...task.labels];
+  if (task.priority) {
+    const priorityLabel = `priority:${task.priority}`;
+    if (!labels.includes(priorityLabel)) {
+      labels.push(priorityLabel);
+    }
+  }
+  const state = task.status === "done" || task.status === "cancelled" ? "closed" : "open";
+  return {
+    title: task.title,
+    body: task.description ?? "",
+    state,
+    labels
+  };
+}
+
+// src/core/sync.ts
+var ISSUES_PER_PAGE = 100;
+async function pullSync(options) {
+  const { client, owner, repo, tasksDir } = options;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  let page = 1;
+  for (; ; ) {
+    const issues = await client.listIssues(owner, repo, {
+      state: "all",
+      per_page: ISSUES_PER_PAGE,
+      page
+    });
+    if (issues.length === 0) {
+      break;
+    }
+    for (const issue of issues) {
+      const filePath = path4.join(tasksDir, `${issue.number}.json`);
+      let existing = null;
+      if (fs4.existsSync(filePath)) {
+        existing = readTaskFile(filePath);
+      }
+      const task = issueToTask(issue, existing, now);
+      writeTaskFile(filePath, task);
+    }
+    if (issues.length < ISSUES_PER_PAGE) {
+      break;
+    }
+    page += 1;
+  }
+}
+function isLinkedTask(task) {
+  return task.github != null && typeof task.github === "object";
+}
+async function pushSync(options) {
+  const { client, owner, repo, tasks } = options;
+  for (const task of tasks) {
+    if (task.status === "draft") {
+      continue;
+    }
+    if (!isLinkedTask(task)) {
+      continue;
+    }
+    const patch = taskToIssueUpdate(task);
+    await client.updateIssue(owner, repo, task.github.issue_number, patch);
+  }
+}
+async function fullSync(options) {
+  const { client, owner, repo, tasksDir, snapshotPath, now } = options;
+  await pullSync({ client, owner, repo, tasksDir, now });
+  const tasks = loadAllTasks(tasksDir);
+  await pushSync({ client, owner, repo, tasks });
+  const snapshot = compileSnapshot(tasks, now);
+  writeSnapshot(snapshotPath, snapshot);
+}
+
+// src/core/maybe-pull.ts
+async function maybePullBeforeRead(config, paths) {
+  if (!config.sync.auto_sync_on_command || config.sync.preset === "offline") {
+    return;
+  }
+  const tokenResult = resolveGitHubToken();
+  if (!tokenResult.ok) {
+    console.warn(
+      `Warning: ${formatTrailError(tokenResult.error)} \u2014 continuing with local tasks.`
+    );
+    return;
+  }
+  const client = new GitHubClient(tokenResult.token);
+  const { owner, repo } = config.github;
+  try {
+    await pullSync({ client, owner, repo, tasksDir: paths.tasksDir });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.warn(`Warning: auto-pull failed (${msg}) \u2014 continuing with local tasks.`);
+  }
+}
+
+// src/schemas/config.ts
+import { z as z3 } from "zod";
+var TrailConfigSchema = z3.object({
+  github: z3.object({
+    owner: z3.string(),
+    repo: z3.string()
+  }).strict(),
+  sync: z3.object({
+    preset: z3.enum(["collaborative", "solo", "offline"]),
+    auto_sync_on_command: z3.boolean(),
+    ui_poll_interval_seconds: z3.number(),
+    ui_idle_backoff: z3.boolean()
+  }).strict(),
+  /** Last successful full sync; useful for future `trail status` and similar. */
+  last_full_sync_at: z3.string().datetime({ offset: true }).optional()
+}).strict();
+
+// src/cli/read-context.ts
+async function loadTrailReadContext(cwd) {
+  const root = findTrailRoot(cwd);
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: cwd
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const raw = fs5.readFileSync(paths.configPath, "utf-8");
+  const config = TrailConfigSchema.parse(JSON.parse(raw));
+  await maybePullBeforeRead(config, paths);
+  const tasks = loadAllTasks(paths.tasksDir);
+  return { root, paths, config, tasks };
+}
+
+// src/cli/commands/list.ts
+var DEFAULT_LIMIT = 25;
+var HIDDEN_BY_DEFAULT = /* @__PURE__ */ new Set(["done", "cancelled"]);
+function selectTasksForList(tasks, options) {
+  const all = options.all === true;
+  const limit = options.limit ?? DEFAULT_LIMIT;
+  const statusFilter = options.status;
+  const labelFilter = options.label;
+  let rows = tasks.filter((t) => all || !HIDDEN_BY_DEFAULT.has(t.status));
+  if (statusFilter !== void 0) {
+    rows = rows.filter((t) => t.status === statusFilter);
+  }
+  if (labelFilter !== void 0) {
+    rows = rows.filter((t) => t.labels.includes(labelFilter));
+  }
+  rows.sort((a, b) => a.id.localeCompare(b.id, void 0, { numeric: true }));
+  return rows.slice(0, limit);
+}
+function slimTask(t) {
+  return {
+    id: t.id,
+    title: t.title,
+    status: t.status,
+    priority: t.priority,
+    labels: t.labels
+  };
+}
+function formatTable(tasks) {
+  const idW = Math.max(4, ...tasks.map((t) => t.id.length), 2);
+  const statusW = Math.max(6, ...tasks.map((t) => t.status.length), 6);
+  const header = `${"ID".padEnd(idW)}  ${"STATUS".padEnd(statusW)}  TITLE`;
+  console.log(header);
+  console.log("-".repeat(header.length));
+  for (const t of tasks) {
+    console.log(`${t.id.padEnd(idW)}  ${t.status.padEnd(statusW)}  ${t.title}`);
+  }
+}
+async function runList(options) {
+  const { tasks } = await loadTrailReadContext(process.cwd());
+  const rows = selectTasksForList(tasks, options);
+  if (options.json) {
+    printJson(rows.map(slimTask));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log("No tasks match the filters.");
+    return;
+  }
+  formatTable(rows);
+}
+
+// src/core/next-task.ts
+var TERMINAL = /* @__PURE__ */ new Set(["done", "cancelled"]);
+function priorityRank(p) {
+  switch (p) {
+    case "p0":
+      return 0;
+    case "p1":
+      return 1;
+    case "p2":
+      return 2;
+    case "p3":
+      return 3;
+    default:
+      return 4;
+  }
+}
+function compareTaskIds(a, b) {
+  if (/^\d+$/.test(a) && /^\d+$/.test(b)) {
+    const ba = BigInt(a);
+    const bb = BigInt(b);
+    return ba < bb ? -1 : ba > bb ? 1 : 0;
+  }
+  return a.localeCompare(b);
+}
+function dependencyResolved(dep) {
+  if (dep === void 0) {
+    return false;
+  }
+  return TERMINAL.has(dep.status);
+}
+function isTaskBlocked(task, byId) {
+  for (const depId of task.depends_on) {
+    if (!dependencyResolved(byId.get(depId))) {
+      return true;
+    }
+  }
+  return false;
+}
+function selectNextTask(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const candidates = tasks.filter(
+    (t) => !TERMINAL.has(t.status) && !isTaskBlocked(t, byId)
+  );
+  if (candidates.length === 0) {
+    return null;
+  }
+  candidates.sort((a, b) => {
+    const pr = priorityRank(a.priority) - priorityRank(b.priority);
+    if (pr !== 0) {
+      return pr;
+    }
+    return compareTaskIds(a.id, b.id);
+  });
+  return candidates[0] ?? null;
+}
+
+// src/cli/run-cli.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { Command, Option } from "commander";
+import { ZodError } from "zod";
+
+// src/cli/commands/create.ts
+import path5 from "path";
+
+// src/core/draft-id.ts
+import { randomBytes } from "crypto";
+function generateDraftId() {
+  return `draft-${randomBytes(4).toString("hex")}`;
+}
+
+// src/core/rebuild-snapshot.ts
+function rebuildSnapshot(paths, now = /* @__PURE__ */ new Date()) {
+  const tasks = loadAllTasks(paths.tasksDir);
+  const snapshot = compileSnapshot(tasks, now);
+  writeSnapshot(paths.snapshotPath, snapshot);
+}
+
+// src/cli/commands/create.ts
+function runCreate(options) {
+  const root = findTrailRoot(process.cwd());
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: process.cwd()
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const now = /* @__PURE__ */ new Date();
+  const iso = now.toISOString();
+  const id = generateDraftId();
+  const raw = {
+    id,
+    title: options.title,
+    description: options.description ?? "",
+    status: "draft",
+    type: options.type ?? "feature",
+    labels: [],
+    depends_on: [],
+    blocks: [],
+    refs: [],
+    created_at: iso,
+    updated_at: iso
+  };
+  if (options.priority !== void 0) {
+    raw.priority = options.priority;
+  }
+  const task = TaskSchema.parse(raw);
+  const filePath = path5.join(paths.tasksDir, `${id}.json`);
+  writeTaskFile(filePath, task);
+  rebuildSnapshot(paths, now);
+  console.log(`Created draft task ${id}`);
+  console.log(`  File: ${filePath}`);
+}
+
+// src/cli/commands/dep.ts
+function runDepAdd(taskId, dependsOnId) {
+  const root = findTrailRoot(process.cwd());
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: process.cwd()
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const iso = (/* @__PURE__ */ new Date()).toISOString();
+  addDependency(paths.tasksDir, taskId, dependsOnId, iso);
+  rebuildSnapshot(paths, new Date(iso));
+  console.log(`Added dependency: ${taskId} depends on ${dependsOnId}`);
+}
+function runDepRemove(taskId, dependsOnId) {
+  const root = findTrailRoot(process.cwd());
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: process.cwd()
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const iso = (/* @__PURE__ */ new Date()).toISOString();
+  removeDependency(paths.tasksDir, taskId, dependsOnId, iso);
+  rebuildSnapshot(paths, new Date(iso));
+  console.log(`Removed dependency: ${taskId} no longer depends on ${dependsOnId}`);
+}
+
+// src/cli/commands/done.ts
+import fs6 from "fs";
+function isLinkedTask2(task) {
+  return task.github != null && typeof task.github === "object";
+}
+function conventionalPrefix(type) {
+  switch (type) {
+    case "bug":
+      return "fix";
+    case "chore":
+      return "chore";
+    case "epic":
+    case "feature":
+      return "feat";
+    default:
+      return "feat";
+  }
+}
+async function runDone(options) {
+  const root = findTrailRoot(process.cwd());
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: process.cwd()
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const raw = fs6.readFileSync(paths.configPath, "utf-8");
+  const config = TrailConfigSchema.parse(JSON.parse(raw));
+  const resolved = findTaskFileById(paths.tasksDir, options.id);
+  if (resolved === null) {
+    throw new Error(`No task with id "${options.id}"`);
+  }
+  const now = /* @__PURE__ */ new Date();
+  const iso = now.toISOString();
+  let next = {
+    ...resolved.task,
+    status: "done",
+    updated_at: iso
+  };
+  writeTaskFile(resolved.filePath, next);
+  const offline = config.sync.preset === "offline";
+  const tokenResult = resolveGitHubToken();
+  if (!offline && tokenResult.ok && isLinkedTask2(next)) {
+    const client = new GitHubClient(tokenResult.token);
+    const { owner, repo } = config.github;
+    const n = next.github.issue_number;
+    await client.createIssueComment(owner, repo, n, options.message);
+    await client.updateIssue(
+      owner,
+      repo,
+      n,
+      taskToIssueUpdate(next)
+    );
+    const synced = {
+      ...next,
+      github: {
+        ...next.github,
+        synced_at: now.toISOString()
+      }
+    };
+    writeTaskFile(resolved.filePath, synced);
+    next = synced;
+  }
+  rebuildSnapshot(paths, now);
+  if (isLinkedTask2(next)) {
+    const prefix = conventionalPrefix(next.type);
+    const oneLine = options.message.replace(/\s+/g, " ").trim();
+    console.log(
+      `Suggested commit: ${prefix}: ${oneLine} (closes #${next.github.issue_number})`
+    );
+  }
+}
+
+// src/cli/commands/graph.ts
+function runGraph(options) {
+  const root = findTrailRoot(process.cwd());
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: process.cwd()
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const tasks = loadAllTasks(paths.tasksDir);
+  const edges = listDependencyEdges(tasks);
+  if (options.json) {
+    printJson(edges);
+    return;
+  }
+  if (edges.length === 0) {
+    console.log("No dependencies.");
+    return;
+  }
+  for (const e of edges) {
+    console.log(`${e.from}  \u2192  depends on  \u2192  ${e.to}`);
+  }
+}
+
+// src/cli/commands/init.ts
+import * as childProcess2 from "child_process";
+import fs7 from "fs";
+import path6 from "path";
+
+// src/cli/templates/user-agents.md.ts
+var USER_AGENTS_MD = `# Trail \u2014 Agent workflow
+
+This repository uses [Trail](https://github.com/joeydekruis/trail) for GitHub-native task tracking. Task JSON lives in \`.trail/tasks/\`; GitHub Issues are the remote source of truth when online.
+
+## Before coding
+
+1. Run \`trail sync\` (or rely on collaborative mode) so local tasks match GitHub.
+2. Run \`trail next\` (or \`trail next --json\`) to pick the highest-priority unblocked task.
+3. Run \`trail context <id>\` to load a compact JSON work packet for your session.
+
+## While working
+
+- Update status: \`trail update <id> --status in_progress\`
+- Use \`trail list\`, \`trail show <id>\`, and \`trail validate\` as needed.
+
+## When finished
+
+1. \`trail done <id> "what you did"\` \u2014 closes the linked GitHub issue when configured.
+2. Commit using the suggested message (includes \`closes #N\` when linked).
+
+## Docs
+
+- Trail design (upstream): see your fork or \`trail\` repo \`docs/superpowers/specs/\`
+`;
+
+// src/cli/commands/init.ts
+var GITIGNORE_LINES = ["snapshot.json", "export/", "*.tmp"];
+function parseRemoteUrl(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  const sshMatch = /^git@github\.com:([^/]+)\/([^/\s]+)$/.exec(trimmed);
+  if (sshMatch) {
+    const owner = sshMatch[1];
+    const repoRaw = sshMatch[2];
+    if (owner === void 0 || repoRaw === void 0) {
+      return null;
+    }
+    let repo = repoRaw;
+    if (repo.endsWith(".git")) {
+      repo = repo.slice(0, -".git".length);
+    }
+    return { owner, repo };
+  }
+  const httpsMatch = /^https?:\/\/github\.com\/([^/]+)\/([^/?#]+)/.exec(trimmed);
+  if (httpsMatch) {
+    const owner = httpsMatch[1];
+    const repoRaw = httpsMatch[2];
+    if (owner === void 0 || repoRaw === void 0) {
+      return null;
+    }
+    let repo = repoRaw;
+    if (repo.endsWith(".git")) {
+      repo = repo.slice(0, -".git".length);
+    }
+    return { owner, repo };
+  }
+  return null;
+}
+function resolveGitRepoRoot(cwd) {
+  try {
+    const out = childProcess2.execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf-8"
+    });
+    return out.trim();
+  } catch {
+    return cwd;
+  }
+}
+function getOriginRemoteUrl(repoRoot) {
+  try {
+    return childProcess2.execFileSync("git", ["remote", "get-url", "origin"], {
+      cwd: repoRoot,
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function runInit(options) {
+  const cwd = process.cwd();
+  const root = path6.resolve(resolveGitRepoRoot(cwd));
+  const configPath = path6.join(root, ".trail", "config.json");
+  if (fs7.existsSync(configPath)) {
+    const err = {
+      code: "VALIDATION_FAILED",
+      message: "Trail is already initialized (.trail/config.json exists)."
+    };
+    throw err;
+  }
+  const hasOwner = options.owner !== void 0 && options.owner !== "";
+  const hasRepo = options.repo !== void 0 && options.repo !== "";
+  if (hasOwner !== hasRepo) {
+    const err = {
+      code: "VALIDATION_FAILED",
+      message: "Provide both --owner and --repo, or neither to use git remote origin."
+    };
+    throw err;
+  }
+  let owner;
+  let repo;
+  if (hasOwner && hasRepo) {
+    owner = options.owner;
+    repo = options.repo;
+  } else {
+    const remoteUrl = getOriginRemoteUrl(root);
+    const parsed = remoteUrl ? parseRemoteUrl(remoteUrl) : null;
+    if (!parsed) {
+      const err = {
+        code: "VALIDATION_FAILED",
+        message: "Could not determine GitHub owner/repo. Set --owner and --repo or add a github.com origin remote."
+      };
+      throw err;
+    }
+    owner = parsed.owner;
+    repo = parsed.repo;
+  }
+  const preset = options.preset;
+  const config = TrailConfigSchema.parse({
+    github: { owner, repo },
+    sync: {
+      preset,
+      auto_sync_on_command: preset === "collaborative",
+      ui_poll_interval_seconds: 30,
+      ui_idle_backoff: true
+    }
+  });
+  const trailDir = path6.join(root, ".trail");
+  const tasksDir = path6.join(trailDir, "tasks");
+  fs7.mkdirSync(trailDir, { recursive: true });
+  fs7.mkdirSync(tasksDir, { recursive: true });
+  fs7.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+  const gitignorePath = path6.join(trailDir, ".gitignore");
+  fs7.writeFileSync(gitignorePath, `${GITIGNORE_LINES.join("\n")}
+`, "utf-8");
+  if (options.skipAgentsMd !== true) {
+    const agentsPath = path6.join(root, "AGENTS.md");
+    if (!fs7.existsSync(agentsPath)) {
+      fs7.writeFileSync(agentsPath, USER_AGENTS_MD, "utf-8");
+      console.log(`Wrote ${agentsPath}`);
+    } else {
+      console.log(`Skipped AGENTS.md (file already exists)`);
+    }
+  }
+  console.log(`Initialized Trail project at ${root}`);
+}
+
+// src/cli/commands/next.ts
+async function runNext(options) {
+  const { tasks } = await loadTrailReadContext(process.cwd());
+  const next = selectNextTask(tasks);
+  if (next === null) {
+    if (options.json) {
+      printJson(null);
+    } else {
+      console.log("No eligible next task.");
+    }
+    return;
+  }
+  if (options.json) {
+    printJson(next);
+    return;
+  }
+  const pri = next.priority ?? "\u2014";
+  console.log(`Next: ${next.id} \u2014 ${next.title} (${next.status}, ${pri})`);
+}
+
+// src/cli/commands/promote.ts
+import fs8 from "fs";
+import path7 from "path";
+async function runPromote(options) {
+  const root = findTrailRoot(process.cwd());
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: process.cwd()
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const raw = fs8.readFileSync(paths.configPath, "utf-8");
+  const config = TrailConfigSchema.parse(JSON.parse(raw));
+  if (config.sync.preset === "offline") {
+    throw new Error("Cannot promote a draft in offline mode (no GitHub access).");
+  }
+  const tokenResult = resolveGitHubToken();
+  if (!tokenResult.ok) {
+    throw tokenResult.error;
+  }
+  const resolved = findTaskFileById(paths.tasksDir, options.id);
+  if (resolved === null) {
+    throw new Error(`No task with id "${options.id}"`);
+  }
+  const draft = resolved.task;
+  if (draft.status !== "draft") {
+    throw new Error(`Task "${options.id}" is not a draft (status is ${draft.status}).`);
+  }
+  if (draft.github != null) {
+    throw new Error(`Task "${options.id}" is already linked to GitHub.`);
+  }
+  const now = /* @__PURE__ */ new Date();
+  const client = new GitHubClient(tokenResult.token);
+  const { owner, repo } = config.github;
+  const issue = await client.createIssue(owner, repo, {
+    title: draft.title,
+    body: draft.description || "",
+    labels: draft.labels
+  });
+  const promoted = issueToTask(issue, draft, now);
+  fs8.unlinkSync(resolved.filePath);
+  const newPath = path7.join(paths.tasksDir, `${issue.number}.json`);
+  writeTaskFile(newPath, promoted);
+  rebuildSnapshot(paths, now);
+  console.log(`Promoted ${draft.id} \u2192 GitHub issue #${issue.number}`);
+  console.log(`  File: ${newPath}`);
+  console.log(`  URL: ${issue.html_url}`);
+}
+
+// src/cli/commands/show.ts
+async function runShow(options) {
+  const { tasks } = await loadTrailReadContext(process.cwd());
+  const task = tasks.find((t) => t.id === options.id);
+  if (task === void 0) {
+    throw new Error(`No task with id "${options.id}"`);
+  }
+  if (options.json) {
+    printJson(task);
+    return;
+  }
+  console.log(`${task.id}  ${task.status}  ${task.title}`);
+  if (task.description) {
+    console.log();
+    console.log(task.description);
+  }
+}
+
+// src/cli/commands/status.ts
+async function runStatus(options) {
+  const { config, tasks } = await loadTrailReadContext(process.cwd());
+  const counts = {};
+  for (const s of TaskStatusSchema.options) {
+    counts[s] = 0;
+  }
+  for (const t of tasks) {
+    counts[t.status] = (counts[t.status] ?? 0) + 1;
+  }
+  const payload = { counts };
+  if (config.last_full_sync_at !== void 0) {
+    payload.last_full_sync_at = config.last_full_sync_at;
+  }
+  if (options.json) {
+    printJson(payload);
+    return;
+  }
+  console.log("Tasks by status:");
+  for (const s of TaskStatusSchema.options) {
+    console.log(`  ${s}: ${counts[s] ?? 0}`);
+  }
+  if (config.last_full_sync_at !== void 0) {
+    console.log(`Last full sync: ${config.last_full_sync_at}`);
+  } else {
+    console.log("Last full sync: (not recorded)");
+  }
+}
+
+// src/cli/commands/sync.ts
+import fs9 from "fs";
+async function runSync(options) {
+  const root = findTrailRoot(process.cwd());
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: process.cwd()
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const raw = fs9.readFileSync(paths.configPath, "utf-8");
+  const config = TrailConfigSchema.parse(JSON.parse(raw));
+  if (config.sync.preset === "offline") {
+    throw new Error("Cannot sync in offline mode");
+  }
+  const tokenResult = resolveGitHubToken();
+  if (!tokenResult.ok) {
+    throw tokenResult.error;
+  }
+  const client = new GitHubClient(tokenResult.token);
+  const { owner, repo } = config.github;
+  const { tasksDir, snapshotPath } = paths;
+  const pullOnly = options.pull === true && options.push !== true;
+  const pushOnly = options.push === true && options.pull !== true;
+  if (pullOnly) {
+    await pullSync({ client, owner, repo, tasksDir });
+    return;
+  }
+  if (pushOnly) {
+    const tasks = loadAllTasks(tasksDir);
+    await pushSync({ client, owner, repo, tasks });
+    return;
+  }
+  await fullSync({ client, owner, repo, tasksDir, snapshotPath });
+}
+
+// src/cli/commands/update.ts
+import fs10 from "fs";
+var STATUSES = [
+  "draft",
+  "todo",
+  "in_progress",
+  "in_review",
+  "done",
+  "cancelled"
+];
+function isLinkedTask3(task) {
+  return task.github != null && typeof task.github === "object";
+}
+async function runUpdate(options) {
+  const hasField = options.status !== void 0 || options.priority !== void 0 || options.title !== void 0;
+  if (!hasField) {
+    throw new Error("Specify at least one of --status, --priority, or --title");
+  }
+  const root = findTrailRoot(process.cwd());
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: process.cwd()
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const raw = fs10.readFileSync(paths.configPath, "utf-8");
+  const config = TrailConfigSchema.parse(JSON.parse(raw));
+  const resolved = findTaskFileById(paths.tasksDir, options.id);
+  if (resolved === null) {
+    throw new Error(`No task with id "${options.id}"`);
+  }
+  const now = /* @__PURE__ */ new Date();
+  const iso = now.toISOString();
+  let next = {
+    ...resolved.task,
+    updated_at: iso
+  };
+  if (options.status !== void 0) {
+    next = { ...next, status: options.status };
+  }
+  if (options.priority !== void 0) {
+    next = { ...next, priority: options.priority };
+  }
+  if (options.title !== void 0) {
+    next = { ...next, title: options.title };
+  }
+  writeTaskFile(resolved.filePath, next);
+  const offline = config.sync.preset === "offline";
+  const tokenResult = resolveGitHubToken();
+  if (!offline && tokenResult.ok && isLinkedTask3(next)) {
+    const client = new GitHubClient(tokenResult.token);
+    const { owner, repo } = config.github;
+    await client.updateIssue(
+      owner,
+      repo,
+      next.github.issue_number,
+      taskToIssueUpdate(next)
+    );
+    const synced = {
+      ...next,
+      github: {
+        ...next.github,
+        synced_at: now.toISOString()
+      }
+    };
+    writeTaskFile(resolved.filePath, synced);
+  }
+  rebuildSnapshot(paths, now);
+}
+
+// src/cli/commands/validate.ts
+import fs11 from "fs";
+async function runValidate() {
+  const root = findTrailRoot(process.cwd());
+  if (root === null) {
+    const err = {
+      code: "NOT_A_TRAIL_REPO",
+      message: "Not a Trail repository (missing .trail/config.json). Run `trail init` first.",
+      path: process.cwd()
+    };
+    throw err;
+  }
+  const paths = trailPaths(root);
+  const raw = fs11.readFileSync(paths.configPath, "utf-8");
+  TrailConfigSchema.parse(JSON.parse(raw));
+  const tasks = loadAllTasks(paths.tasksDir);
+  const snapshot = compileSnapshot(tasks);
+  for (const w of snapshot.warnings) {
+    console.log(`${w.code}: ${w.message}`);
+  }
+  const hasCycle = snapshot.warnings.some((w) => w.code === DEPENDENCY_CYCLE);
+  return hasCycle ? 1 : 0;
+}
+
+// src/cli/run-cli.ts
+function readCliVersion() {
+  const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  return pkg.version ?? "0.0.0";
+}
+var TRAIL_ERROR_CODES = /* @__PURE__ */ new Set([
+  "AUTH_REQUIRED",
+  "AUTH_FAILED",
+  "NOT_A_TRAIL_REPO",
+  "VALIDATION_FAILED",
+  "GITHUB_API",
+  "SYNC_CONFLICT"
+]);
+function isTrailError(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("code" in value) || !("message" in value)) {
+    return false;
+  }
+  const code = value.code;
+  return typeof code === "string" && TRAIL_ERROR_CODES.has(code);
+}
+function getCliFailureMessage(err) {
+  if (isTrailError(err)) {
+    return formatTrailError(err);
+  }
+  if (err instanceof Error && isTaskStoreValidationError(err)) {
+    return formatTrailError(err.trailError);
+  }
+  if (err instanceof ZodError) {
+    return err.message;
+  }
+  if (err instanceof Error) {
+    return err.message;
+  }
+  return String(err);
+}
+async function runCli(argv) {
+  const program = new Command();
+  program.name("trail").description("GitHub-native task management CLI").version(readCliVersion());
+  program.command("init").description("Initialize a Trail project in the current git repository").addOption(
+    new Option("--preset <name>", "Sync preset").choices(["solo", "collaborative", "offline"]).default("solo")
+  ).option("--owner <name>", "GitHub repository owner (with --repo)").option("--repo <name>", "GitHub repository name (with --owner)").option("--skip-agents-md", "Do not write AGENTS.md at the repository root").action(
+    (opts) => {
+      runInit({
+        preset: opts.preset,
+        owner: opts.owner,
+        repo: opts.repo,
+        skipAgentsMd: opts.skipAgentsMd === true
+      });
+    }
+  );
+  program.command("sync").description("Synchronize local tasks with GitHub Issues").option("--pull", "Only pull from GitHub").option("--push", "Only push to GitHub").action(async (opts) => {
+    await runSync({ pull: opts.pull, push: opts.push });
+  });
+  program.command("list").description("List tasks (excludes done/cancelled unless --all)").option("--all", "Include done and cancelled tasks").addOption(
+    new Option("--limit <n>", "Max tasks to show").default(25).argParser((v) => {
+      const n = parseInt(v, 10);
+      if (Number.isNaN(n) || n < 0) {
+        throw new Error("--limit must be a non-negative integer");
+      }
+      return n;
+    })
+  ).option("--status <status>", "Filter by status").option("--label <label>", "Filter by label (must appear in task.labels)").option("--json", "Print JSON array of slim task objects").action(
+    async (opts) => {
+      await runList(opts);
+    }
+  );
+  program.command("show").description("Show one task by id").argument("<id>", "Task id").option("--json", "Print full task JSON").action(async (id, opts) => {
+    await runShow({ id, json: opts.json });
+  });
+  program.command("status").description("Task counts by status and last sync time").option("--json", "Print JSON").action(async (opts) => {
+    await runStatus(opts);
+  });
+  program.command("next").description("Pick the next actionable task by priority and id").option("--json", "Print full task JSON or null").action(async (opts) => {
+    await runNext(opts);
+  });
+  program.command("update").description("Update a task (local file; pushes to GitHub when linked and online)").argument("<id>", "Task id").addOption(new Option("--status <status>", "New status").choices(STATUSES)).addOption(
+    new Option("--priority <p>", "Priority").choices(["p0", "p1", "p2", "p3"])
+  ).option("--title <text>", "New title").action(
+    async (id, opts) => {
+      await runUpdate({
+        id,
+        status: opts.status,
+        priority: opts.priority,
+        title: opts.title
+      });
+    }
+  );
+  program.command("done").description("Mark a task done, optionally comment and close the GitHub issue").argument("<id>", "Task id").argument("<message...>", "Comment body for the linked issue (and suggested commit hint)").action(async (id, messageParts) => {
+    const message = messageParts.join(" ").trim();
+    if (message === "") {
+      throw new Error("Message is required");
+    }
+    await runDone({ id, message });
+  });
+  program.command("validate").description("Compile snapshot and print validation warnings (exit 1 on dependency cycles)").action(async () => {
+    const code = await runValidate();
+    process.exitCode = code;
+  });
+  program.command("create").description("Create a local draft task (not linked to GitHub until promoted)").requiredOption("--title <text>", "Task title").option("--description <text>", "Description body").addOption(
+    new Option("--type <name>", "Task type").choices(["feature", "bug", "chore", "epic"])
+  ).addOption(new Option("--priority <p>", "Priority").choices(["p0", "p1", "p2", "p3"])).action(
+    (opts) => {
+      runCreate({
+        title: opts.title,
+        description: opts.description,
+        type: opts.type,
+        priority: opts.priority
+      });
+    }
+  );
+  program.command("promote").description("Promote a draft task to a GitHub issue and rename the task file").argument("<id>", "Draft task id").action(async (id) => {
+    await runPromote({ id });
+  });
+  const dep = program.command("dep").description("Add or remove task dependencies");
+  dep.command("add").description("Record that task A depends on task B (updates blocks/depends_on)").argument("<taskId>", "Task id").argument("<dependsOnId>", "Id of the task that must be satisfied first").action((taskId, dependsOnId) => {
+    runDepAdd(taskId, dependsOnId);
+  });
+  dep.command("remove").description("Remove a dependency edge between two tasks").argument("<taskId>", "Task id").argument("<dependsOnId>", "Other task id").action((taskId, dependsOnId) => {
+    runDepRemove(taskId, dependsOnId);
+  });
+  program.command("graph").description("Print task dependency edges").option("--json", "Print JSON array of { from, to } edges").action((opts) => {
+    runGraph(opts);
+  });
+  program.command("context").description("Print a compact JSON context packet for an LLM session").argument("<id>", "Task id").action((id) => {
+    runContext({ id });
+  });
+  program.command("mcp").description("Run the Trail MCP server (stdio; for editor and agent integrations)").action(async () => {
+    const { runMcpServer } = await import("./run-mcp-server-ERHZKM7M.js");
+    await runMcpServer();
+  });
+  await program.parseAsync(argv);
+}
+
+export {
+  __commonJS,
+  __toESM,
+  DEPENDENCY_CYCLE,
+  compileSnapshot,
+  buildContextPacket,
+  listDependencyEdges,
+  loadTrailReadContext,
+  selectTasksForList,
+  selectNextTask,
+  getCliFailureMessage,
+  runCli
+};
+//# sourceMappingURL=chunk-SFBMB3UT.js.map