kodi-dev 0.1.0

package/dist/index.js

@@ -0,0 +1,1654 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/add.ts
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+var PackManifestSchema = z.object({
+  name: z.string().min(1),
+  role: z.string().optional(),
+  framework: z.string().optional(),
+  language: z.string().optional(),
+  /** Fragment merged into the thin root CLAUDE.md (stack line, gate commands, …). */
+  claude_md: z.string().optional()
+});
+function bundledPacksDir() {
+  return fileURLToPath(new URL("../packs/", import.meta.url));
+}
+function resolvePackDir(ref) {
+  if (existsSync(ref) && statSync(ref).isDirectory()) return ref;
+  const bundled = join(bundledPacksDir(), ref);
+  if (existsSync(bundled)) return bundled;
+  throw new Error(
+    `skill-pack "${ref}" not found. Pass a path to a pack directory (no bundled packs yet).`
+  );
+}
+function copyTree(src, dest, force) {
+  const written = [];
+  const walk = (s, d) => {
+    for (const entry of readdirSync(s)) {
+      const sp = join(s, entry);
+      const dp = join(d, entry);
+      if (statSync(sp).isDirectory()) walk(sp, dp);
+      else {
+        if (existsSync(dp) && !force) continue;
+        mkdirSync(dirname(dp), { recursive: true });
+        copyFileSync(sp, dp);
+        written.push(dp);
+      }
+    }
+  };
+  if (existsSync(src)) walk(src, dest);
+  return written;
+}
+function mergeClaudeMd(existing, name, fragment) {
+  const open = `<!-- kodi-pack:${name} -->`;
+  const close = `<!-- /kodi-pack:${name} -->`;
+  const block = `${open}
+${fragment.trim()}
+${close}`;
+  const re = new RegExp(`${open}[\\s\\S]*?${close}`);
+  if (re.test(existing)) return existing.replace(re, block);
+  const base = existing.trimEnd();
+  return (base ? base + "\n\n" : "") + block + "\n";
+}
+function installPack(root, packDir, force = false) {
+  const manifest = PackManifestSchema.parse(parseYaml(readFileSync(join(packDir, "manifest.yaml"), "utf-8")));
+  const skills = copyTree(join(packDir, "skills"), join(root, ".claude", "skills"), force);
+  let claudeMdMerged = false;
+  if (manifest.claude_md) {
+    const claudeMdPath = join(root, "CLAUDE.md");
+    const current = existsSync(claudeMdPath) ? readFileSync(claudeMdPath, "utf-8") : "";
+    writeFileSync(claudeMdPath, mergeClaudeMd(current, manifest.name, manifest.claude_md), "utf-8");
+    claudeMdMerged = true;
+  }
+  const packsPath = join(root, ".claude", "kodi", "packs.yaml");
+  const installed = existsSync(packsPath) ? parseYaml(readFileSync(packsPath, "utf-8"))?.installed ?? [] : [];
+  if (!installed.includes(manifest.name)) installed.push(manifest.name);
+  mkdirSync(dirname(packsPath), { recursive: true });
+  writeFileSync(packsPath, `installed:
+${installed.map((p) => `  - ${p}`).join("\n")}
+`, "utf-8");
+  return { name: manifest.name, skills: skills.map((s) => basename(s)), claudeMdMerged };
+}
+function registerAddCommand(program2) {
+  program2.command("add <pack>").description("Install a skill-pack (bundle of skills + CLAUDE.md fragment) \u2014 explicit only").option("-d, --dir <path>", "target project directory", process.cwd()).option("--force", "overwrite existing skills", false).action((pack, o) => {
+    const res = installPack(String(o.dir), resolvePackDir(pack), o.force);
+    process.stdout.write(
+      `Installed skill-pack "${res.name}"
+  skills: ${res.skills.length ? res.skills.join(", ") : "(none new)"}
+  CLAUDE.md: ${res.claudeMdMerged ? "merged fragment" : "no fragment"}
+`
+    );
+  });
+}
+
+// src/bootstrap.ts
+var ORCHESTRATOR_BOOTSTRAP = `# You are the kodi orchestrator
+
+You run the kodi.dev agent orchestration for THIS project, hosted natively in
+Claude Code. You are the main-loop orchestrator: you talk to the human, adopt
+the phase-orchestrator role when a phase skill runs, and spawn sub-agents to do
+the work. You coordinate through durable artifacts in \`docs/\` and the ticket
+board \u2014 there is no message bus.
+
+## Laws (never violated, even in autonomous mode)
+
+1. **Ask, never assume.** Any genuine decision \u2014 an ADR change, approving a
+   PRD / plan / phase split, a provider config, discovery answers, a scope
+   ambiguity, overwriting a human-approved artifact, or mutating a remote board
+   / PR \u2014 is ALWAYS taken to the human. Autonomy covers only mechanical
+   execution.
+2. **ADR is law.** Follow existing ADRs. Changing an ADR requires explicit
+   human approval, including under automatic mode.
+
+## Phase entry points (explicit \u2014 you do not auto-advance)
+
+- \`/discover\` \u2014 Briefing. You run the grill on the main thread; \`greenfield-wu\`
+  / \`brownfield-wu\` only investigate (no interviewing). Produces \`briefing.md\`
+  + a thin \`CLAUDE.md\`.
+- \`/oplan\` \u2014 Planning. You (main-loop) drive the hub loop: spawn a manager, it
+  returns a plan naming its leaves, you spawn the leaves, you validate; loop
+  until \`qa-planning\` passes. Order: \`detail\` (PRD) then \`architect\` \u2225 \`ux\`,
+  then \`phases\`, then \`qa-planning\`.
+- \`/oreplan <phase>\` \u2014 Re-plan or expand ONE phase; show the diff and get
+  sign-off before overwriting. Never touches the board.
+- \`/tickets\` \u2014 Generate board tickets from the consolidated plan (per phase, on
+  demand) via the \`kodi tickets\` CLI.
+- \`/ticket-start\` \u2014 Build. Spawn the \`build-orchestrator\` sub-agent to drive one
+  ticket as a vertical slice; it closes only when every gate is green.
+
+## Tools
+
+- Manage tickets and PRs ONLY through the \`kodi\` CLI (\`kodi tickets \u2026\`,
+  \`kodi pr \u2026\`) \u2014 it proxies \`gh\`/\`az\` and enforces the templates. Remote
+  mutations are dry-run unless \`--yes\`.
+- The thin \`CLAUDE.md\` is the single source of truth for the stack, gate
+  commands, provider, and installed skill-packs.
+`;
+
+// src/commands/hook.ts
+function registerHookCommand(program2) {
+  const hook = program2.command("hook").description("Emit Claude Code hook output (internal)");
+  hook.command("session-start").description("Emit the orchestrator bootstrap as SessionStart additionalContext").action(() => {
+    const payload = {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext: ORCHESTRATOR_BOOTSTRAP
+      }
+    };
+    process.stdout.write(JSON.stringify(payload));
+  });
+  return hook;
+}
+
+// src/commands/init.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync3,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname3, join as join3, relative } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { stringify as stringifyYaml } from "yaml";
+
+// src/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { parse as parseYaml2 } from "yaml";
+var DEFAULTS = { provider: "local", prefix: "KODI" };
+var STATE_FILE = "kodi-dev.yaml";
+function stateFilePath(root) {
+  return join2(root, ".claude", STATE_FILE);
+}
+function findProjectRoot(cwd = process.cwd()) {
+  let dir = cwd;
+  while (true) {
+    if (existsSync2(stateFilePath(dir))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return cwd;
+    dir = parent;
+  }
+}
+function loadBoardConfig(cwd = process.cwd()) {
+  const path = stateFilePath(findProjectRoot(cwd));
+  if (!existsSync2(path)) return { ...DEFAULTS };
+  try {
+    const raw = parseYaml2(readFileSync2(path, "utf-8")) ?? {};
+    return { ...DEFAULTS, ...raw };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+function localPaths(cwd = process.cwd()) {
+  const root = join2(findProjectRoot(cwd), "docs", "tickets");
+  return {
+    root,
+    backlog: join2(root, "backlog"),
+    done: join2(root, "done"),
+    index: join2(root, "tickets.md")
+  };
+}
+
+// src/exec.ts
+import { spawnSync } from "child_process";
+function quote(args) {
+  return args.map((a) => /^[A-Za-z0-9_./:@=-]+$/.test(a) ? a : `'${a.replace(/'/g, `'\\''`)}'`).join(" ");
+}
+function execRead(args) {
+  const [cmd, ...rest] = args;
+  const r = spawnSync(cmd, rest, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+  if (r.status !== 0) {
+    throw new Error(`\`${quote(args)}\` failed (exit ${r.status}): ${r.stderr?.trim() || ""}`);
+  }
+  return r.stdout ?? "";
+}
+function execMutate(args, dryRun) {
+  const command = quote(args);
+  if (dryRun) {
+    process.stderr.write(`[dry-run] ${command}
+  (re-run with --yes to execute)
+`);
+    return { command, ran: false, stdout: "", stderr: "", code: 0 };
+  }
+  const [cmd, ...rest] = args;
+  const r = spawnSync(cmd, rest, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+  if (r.status !== 0) {
+    throw new Error(`\`${command}\` failed (exit ${r.status}): ${r.stderr?.trim() || ""}`);
+  }
+  return { command, ran: true, stdout: r.stdout ?? "", stderr: r.stderr ?? "", code: r.status ?? 0 };
+}
+
+// src/html.ts
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function inline(s) {
+  return escapeHtml(s).replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/`(.+?)`/g, "<code>$1</code>");
+}
+function mdToHtml(md) {
+  const out2 = [];
+  let list = null;
+  const closeList = () => {
+    if (list) {
+      out2.push("</ul>");
+      list = null;
+    }
+  };
+  for (const raw of md.split("\n")) {
+    const line = raw.trimEnd();
+    if (/^<!--/.test(line.trim())) {
+      closeList();
+      out2.push(line);
+      continue;
+    }
+    if (line.trim() === "") {
+      closeList();
+      continue;
+    }
+    const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+    if (heading) {
+      closeList();
+      const level = heading[1].length;
+      out2.push(`<h${level}>${inline(heading[2])}</h${level}>`);
+      continue;
+    }
+    const item = /^[-*]\s+(.*)$/.exec(line);
+    if (item) {
+      if (!list) {
+        out2.push("<ul>");
+        list = "ul";
+      }
+      out2.push(`<li>${inline(item[1])}</li>`);
+      continue;
+    }
+    closeList();
+    out2.push(`<p>${inline(line)}</p>`);
+  }
+  closeList();
+  return out2.join("\n");
+}
+
+// src/templates/ticket.ts
+import { z as z2 } from "zod";
+var TICKET_STATUSES = [
+  "Pending",
+  "In progress",
+  "To review",
+  "Done",
+  "Blocked"
+];
+var TicketStatusSchema = z2.enum(TICKET_STATUSES);
+var TicketDriversSchema = z2.object({
+  /** PRD this ticket advances, e.g. "docs/prd/0001". */
+  prd: z2.string().optional(),
+  /** Governing ADR(s), e.g. ["docs/adr/0003"]. */
+  adr: z2.array(z2.string()).default([]),
+  /** Security finding remediated, e.g. "docs/security/AUTH-014". */
+  security: z2.string().optional()
+});
+var TicketSchema = z2.object({
+  key: z2.string().regex(/^[A-Z][A-Z0-9]*-\d+$/, "key must look like PREFIX-123").optional(),
+  title: z2.string().min(3, "title must be at least 3 characters"),
+  slug: z2.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be kebab-case").optional(),
+  status: TicketStatusSchema.default("Pending"),
+  summary: z2.string().min(1, "summary is required"),
+  acceptanceCriteria: z2.array(z2.string().min(1)).min(1, "at least one acceptance criterion is required"),
+  nonGoals: z2.array(z2.string().min(1)).default([]),
+  /** Ticket keys that must reach Done before this one can start. */
+  dependencies: z2.array(z2.string()).default([]),
+  drivers: TicketDriversSchema.default({}),
+  /** Linked pull request (branch, URL, or id) — set by `link-pr` / `hand-off`. */
+  prUrl: z2.string().optional(),
+  notes: z2.string().optional()
+});
+function slugify(title) {
+  return title.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "");
+}
+function renderTicketMarkdown(t) {
+  const lines = [];
+  lines.push(`# ${t.key} \u2014 ${t.title}`, "");
+  lines.push(`**Status:** ${t.status}`);
+  if (t.dependencies.length) {
+    lines.push(`**Depends on:** ${t.dependencies.join(", ")}`);
+  }
+  const drivers = [];
+  if (t.drivers.prd) drivers.push(`PRD ${t.drivers.prd}`);
+  if (t.drivers.adr.length) drivers.push(`ADR ${t.drivers.adr.join(", ")}`);
+  if (t.drivers.security) drivers.push(`Security ${t.drivers.security}`);
+  if (drivers.length) lines.push(`**Drivers:** ${drivers.join(" \xB7 ")}`);
+  if (t.prUrl) lines.push(`**PR:** ${t.prUrl}`);
+  lines.push("", "## Summary", "", t.summary, "");
+  lines.push("## Acceptance criteria", "");
+  for (const ac of t.acceptanceCriteria) lines.push(`- [ ] ${ac}`);
+  lines.push("");
+  if (t.nonGoals.length) {
+    lines.push("## Non-goals", "");
+    for (const ng of t.nonGoals) lines.push(`- ${ng}`);
+    lines.push("");
+  }
+  if (t.notes) lines.push("## Notes", "", t.notes, "");
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+
+// src/providers/azure.ts
+var MARKER_RE = /kodi:ticket:([A-Za-z0-9+/=]+)/;
+var DEFAULT_COLUMNS = {
+  todo: "To Do",
+  inProgress: "In Progress",
+  toReview: "To Review",
+  done: "Done"
+};
+function columnForStatus(status, cols) {
+  switch (status) {
+    case "In progress":
+      return cols.inProgress ?? DEFAULT_COLUMNS.inProgress;
+    case "To review":
+      return cols.toReview ?? DEFAULT_COLUMNS.toReview;
+    case "Done":
+      return cols.done ?? DEFAULT_COLUMNS.done;
+    default:
+      return cols.todo;
+  }
+}
+function statusFromColumn(column, cols) {
+  if (column === cols.todo) return "Pending";
+  if (column === (cols.inProgress ?? DEFAULT_COLUMNS.inProgress)) return "In progress";
+  if (column === (cols.toReview ?? DEFAULT_COLUMNS.toReview)) return "To review";
+  if (column === (cols.done ?? DEFAULT_COLUMNS.done)) return "Done";
+  return void 0;
+}
+function descriptionHtml(t) {
+  const canonical = Buffer.from(JSON.stringify({ ...t, key: void 0 })).toString("base64");
+  return `${mdToHtml(renderTicketMarkdown(t))}
+<pre>kodi:ticket:${canonical}</pre>`;
+}
+function parseWorkItem(fields, id, cols = DEFAULT_COLUMNS) {
+  const desc = fields["System.Description"] ?? "";
+  const m = MARKER_RE.exec(desc);
+  if (!m) return null;
+  let json;
+  try {
+    json = Buffer.from(m[1], "base64").toString("utf-8");
+  } catch {
+    return null;
+  }
+  const parsed = TicketSchema.safeParse(JSON.parse(json));
+  if (!parsed.success) return null;
+  const column = fields["System.State"] ?? fields["System.BoardColumn"] ?? "";
+  const status = statusFromColumn(column, cols) ?? parsed.data.status;
+  return { ...parsed.data, key: String(id), slug: parsed.data.slug ?? slugify(parsed.data.title), status };
+}
+function createArgs(coords, title, html, column) {
+  const args = [
+    "az",
+    "boards",
+    "work-item",
+    "create",
+    "--title",
+    title,
+    "--type",
+    "Issue",
+    "--fields",
+    `System.State=${column}`,
+    "--description",
+    html,
+    "--output",
+    "json"
+  ];
+  if (coords.organization) args.push("--organization", coords.organization);
+  if (coords.project) args.push("--project", coords.project);
+  return args;
+}
+var AzureTicketProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.columns = opts.columns ?? DEFAULT_COLUMNS;
+  }
+  opts;
+  name = "azure";
+  columns;
+  coords() {
+    return { organization: this.opts.organization, project: this.opts.project };
+  }
+  // `az boards work-item show/update` accept ONLY --organization; `delete` and
+  // `query` also need --project. `az` flag support is inconsistent per subcommand.
+  orgArgs() {
+    return this.opts.organization ? ["--organization", this.opts.organization] : [];
+  }
+  scopeArgs() {
+    const a = [...this.orgArgs()];
+    if (this.opts.project) a.push("--project", this.opts.project);
+    return a;
+  }
+  async nextId() {
+    return "(assigned by azure on create)";
+  }
+  async create(input) {
+    const slug = input.slug ?? slugify(input.title);
+    const draft = { ...input, key: "(pending)", slug };
+    const html = descriptionHtml(draft);
+    const res = execMutate(
+      createArgs(this.coords(), input.title, html, columnForStatus(input.status, this.columns)),
+      this.opts.dryRun
+    );
+    if (!res.ran) return { ...draft, key: "(dry-run)" };
+    const id = JSON.parse(res.stdout).id;
+    return { ...draft, key: String(id) };
+  }
+  async get(key) {
+    const out2 = execRead(["az", "boards", "work-item", "show", "--id", key, "--output", "json", ...this.orgArgs()]);
+    const wi = JSON.parse(out2);
+    return parseWorkItem(wi.fields ?? {}, wi.id, this.columns);
+  }
+  async list() {
+    const wiql = "SELECT [System.Id] FROM WorkItems WHERE [System.WorkItemType] = 'Issue' ORDER BY [System.Id]";
+    const out2 = execRead(["az", "boards", "query", "--wiql", wiql, "--output", "json", ...this.scopeArgs()]);
+    const rows = JSON.parse(out2);
+    const refs = [];
+    for (const row of rows) {
+      const id = row.id ?? row.fields?.["System.Id"];
+      if (id == null) continue;
+      const t = await this.get(String(id));
+      if (t) refs.push(toRef(t));
+    }
+    return refs;
+  }
+  async listReady() {
+    const all = await this.list();
+    const done = new Set(all.filter((t) => t.status === "Done").map((t) => t.key));
+    const ready = [];
+    const blocked = [];
+    for (const t of all) {
+      if (t.status !== "Pending") continue;
+      const unmet = t.dependencies.filter((d) => !done.has(d));
+      if (unmet.length === 0) ready.push(t);
+      else blocked.push({ ticket: t, blockedBy: unmet });
+    }
+    return { ready, blocked };
+  }
+  async setStatus(key, status) {
+    const current = await this.get(key);
+    if (!current) throw new Error(`work-item ${key} not found`);
+    execMutate(
+      ["az", "boards", "work-item", "update", "--id", key, "--fields", `System.State=${columnForStatus(status, this.columns)}`, ...this.orgArgs()],
+      this.opts.dryRun
+    );
+    return { ...current, status };
+  }
+  async start(key, _p) {
+    return this.setStatus(key, "In progress");
+  }
+  async amend(key, patch) {
+    const current = await this.get(key);
+    if (!current) throw new Error(`work-item ${key} not found`);
+    const merged = { ...current, ...patch, key, slug: current.slug };
+    const fields = [`System.Description=${descriptionHtml(merged)}`];
+    if (patch.title) fields.push(`System.Title=${patch.title}`);
+    const args = ["az", "boards", "work-item", "update", "--id", key];
+    for (const f of fields) args.push("--fields", f);
+    execMutate([...args, ...this.orgArgs()], this.opts.dryRun);
+    return merged;
+  }
+  async delete(key) {
+    execMutate(["az", "boards", "work-item", "delete", "--id", key, "--yes", ...this.scopeArgs()], this.opts.dryRun);
+  }
+};
+function toRef(t) {
+  return { key: t.key, title: t.title, status: t.status, slug: t.slug, dependencies: t.dependencies };
+}
+
+// src/providers/azure-discovery.ts
+var defaultRunner = (args) => execRead(args);
+function normalizeOrgUrl(input) {
+  const s = input.trim().replace(/\/+$/, "");
+  if (!s) return "";
+  if (/^https?:\/\//i.test(s)) return s;
+  if (/\b(dev\.azure\.com|visualstudio\.com)\b/i.test(s)) return `https://${s.replace(/^\/+/, "")}`;
+  return `https://dev.azure.com/${s}`;
+}
+function parseProjects(json) {
+  const data = JSON.parse(json);
+  const items = Array.isArray(data) ? data : data.value ?? [];
+  return items.map((p) => p?.name).filter((n) => typeof n === "string");
+}
+function listProjects(org, run = defaultRunner) {
+  const out2 = run(["az", "devops", "project", "list", "--org", org, "--output", "json"]);
+  return parseProjects(out2);
+}
+function parseProjectInfo(json) {
+  const d = JSON.parse(json);
+  return { processTemplate: d?.capabilities?.processTemplate?.templateName };
+}
+function getProjectInfo(org, project, run = defaultRunner) {
+  try {
+    return parseProjectInfo(
+      run(["az", "devops", "project", "show", "--project", project, "--org", org, "--output", "json"])
+    );
+  } catch {
+    return null;
+  }
+}
+function processSupportsIssues(template) {
+  return template !== "Agile" && template !== "Scrum";
+}
+function parseStates(json) {
+  const d = JSON.parse(json);
+  const items = Array.isArray(d) ? d : d.value ?? [];
+  return items.map((s) => ({ name: s?.name, category: s?.category })).filter((s) => typeof s.name === "string");
+}
+function listIssueStates(org, project, run = defaultRunner) {
+  const out2 = run([
+    "az",
+    "devops",
+    "invoke",
+    "--area",
+    "wit",
+    "--resource",
+    "workItemTypeStates",
+    "--route-parameters",
+    `project=${project}`,
+    "type=Issue",
+    "--org",
+    org,
+    "--detect",
+    "false",
+    "--output",
+    "json"
+  ]);
+  return parseStates(out2);
+}
+function statesInCategory(states, category) {
+  return states.filter((s) => s.category === category).map((s) => s.name);
+}
+
+// src/providers/github-discovery.ts
+var defaultRunner2 = (args) => execRead(args);
+function parseProjects2(json) {
+  const data = JSON.parse(json);
+  const items = Array.isArray(data) ? data : data.projects ?? [];
+  return items.map((p) => ({ number: p?.number, title: p?.title ?? "", id: p?.id ?? "" })).filter((p) => typeof p.number === "number");
+}
+function listProjects2(owner, run = defaultRunner2) {
+  const out2 = run(["gh", "project", "list", "--owner", owner, "--format", "json", "--limit", "100"]);
+  return parseProjects2(out2);
+}
+function resolveViewerLogin(run = defaultRunner2) {
+  return run(["gh", "api", "user", "-q", ".login"]).trim();
+}
+function tokenScopes(run = defaultRunner2) {
+  let out2;
+  try {
+    out2 = run(["gh", "api", "-i", "user"]);
+  } catch {
+    return null;
+  }
+  const m = /^x-oauth-scopes:\s*(.*)$/im.exec(out2);
+  if (!m) return null;
+  return m[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function hasProjectWriteScope(run = defaultRunner2) {
+  const scopes = tokenScopes(run);
+  if (scopes == null) return null;
+  return scopes.includes("project");
+}
+function detectRepo(run = defaultRunner2) {
+  return run(["gh", "repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"]).trim();
+}
+function parseRepos(json) {
+  const data = JSON.parse(json);
+  const items = Array.isArray(data) ? data : data.repositories ?? [];
+  return items.map((r) => r?.nameWithOwner).filter((n) => typeof n === "string");
+}
+function listRepos(owner, run = defaultRunner2) {
+  const out2 = run(["gh", "repo", "list", owner, "--json", "nameWithOwner", "--limit", "200"]);
+  return parseRepos(out2);
+}
+function parseStatusField(json) {
+  const data = JSON.parse(json);
+  const fields = Array.isArray(data) ? data : data.fields ?? [];
+  const status = fields.find(
+    (f) => typeof f?.name === "string" && f.name.toLowerCase() === "status" && Array.isArray(f?.options)
+  );
+  if (!status) return null;
+  const options = status.options.map((o) => ({ id: o?.id, name: o?.name })).filter((o) => typeof o.id === "string" && typeof o.name === "string");
+  return { id: status.id, options };
+}
+function listStatusField(owner, number, run = defaultRunner2) {
+  const out2 = run([
+    "gh",
+    "project",
+    "field-list",
+    String(number),
+    "--owner",
+    owner,
+    "--format",
+    "json",
+    "--limit",
+    "100"
+  ]);
+  return parseStatusField(out2);
+}
+function parseProjectId(json) {
+  return JSON.parse(json)?.id ?? "";
+}
+function fetchProjectMeta(owner, number, run = defaultRunner2) {
+  const projectId = parseProjectId(
+    run(["gh", "project", "view", String(number), "--owner", owner, "--format", "json"])
+  );
+  const statusField = listStatusField(owner, number, run);
+  if (!statusField) {
+    throw new Error(`project #${number} (owner ${owner}) has no single-select "Status" field`);
+  }
+  return { projectId, statusField };
+}
+function optionIdFor(field, columnName) {
+  return field.options.find((o) => o.name.toLowerCase() === columnName.toLowerCase())?.id;
+}
+
+// src/prompt.ts
+import { confirm as inqConfirm, input as inqInput, select as inqSelect } from "@inquirer/prompts";
+function readlinePrompter() {
+  return {
+    async select(message, choices) {
+      if (choices.length === 0) throw new Error(`${message}: no choices available`);
+      if (!process.stdin.isTTY) {
+        throw new Error(`cannot prompt "${message}" in non-interactive mode \u2014 pass the corresponding flag`);
+      }
+      return inqSelect({
+        message,
+        choices: choices.map((c) => ({ value: c, name: c })),
+        loop: false
+      });
+    },
+    async input(message, def) {
+      if (!process.stdin.isTTY) return def ?? "";
+      return inqInput({ message, default: def });
+    },
+    async confirm(message, def = true) {
+      if (!process.stdin.isTTY) return def;
+      return inqConfirm({ message, default: def });
+    },
+    close() {
+    }
+  };
+}
+
+// src/commands/init.ts
+var HOOK_COMMAND = "kodi hook session-start";
+var SESSION_MATCHER = "startup|resume|clear|compact";
+function mergeSessionStartHook(settings) {
+  settings.hooks ??= {};
+  const arr = settings.hooks.SessionStart ??= [];
+  const already = arr.some((e) => e.hooks?.some((h) => h.command === HOOK_COMMAND));
+  if (already) return false;
+  arr.push({ matcher: SESSION_MATCHER, hooks: [{ type: "command", command: HOOK_COMMAND }] });
+  return true;
+}
+function defaultAssetsDir() {
+  return fileURLToPath2(new URL("../assets/", import.meta.url));
+}
+function copyTree2(srcRoot, destRoot, force, reportBase) {
+  const written = [];
+  if (!existsSync3(srcRoot)) return written;
+  const walk = (src, dest) => {
+    for (const entry of readdirSync2(src)) {
+      const s = join3(src, entry);
+      const d = join3(dest, entry);
+      if (statSync2(s).isDirectory()) walk(s, d);
+      else {
+        if (existsSync3(d) && !force) continue;
+        mkdirSync2(dirname3(d), { recursive: true });
+        copyFileSync2(s, d);
+        written.push(join3(reportBase, relative(destRoot, d)));
+      }
+    }
+  };
+  walk(srcRoot, destRoot);
+  return written;
+}
+function copyMarkdownFlat(srcRoot, destDir, force, reportBase) {
+  const written = [];
+  if (!existsSync3(srcRoot)) return written;
+  const walk = (dir) => {
+    for (const entry of readdirSync2(dir)) {
+      const s = join3(dir, entry);
+      if (statSync2(s).isDirectory()) walk(s);
+      else if (entry.endsWith(".md") && entry !== "README.md") {
+        const d = join3(destDir, entry);
+        if (existsSync3(d) && !force) continue;
+        mkdirSync2(destDir, { recursive: true });
+        copyFileSync2(s, d);
+        written.push(join3(reportBase, entry));
+      }
+    }
+  };
+  walk(srcRoot);
+  return written;
+}
+function installHarness(root, opts = {}) {
+  const force = opts.force ?? false;
+  const assetsDir = opts.assetsDir ?? defaultAssetsDir();
+  const claude = join3(root, ".claude");
+  const changed = [];
+  mkdirSync2(claude, { recursive: true });
+  const settingsPath = join3(claude, "settings.json");
+  const settings = existsSync3(settingsPath) ? JSON.parse(readFileSync3(settingsPath, "utf-8")) : {};
+  if (mergeSessionStartHook(settings)) {
+    writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    changed.push(".claude/settings.json (SessionStart hook)");
+  }
+  changed.push(
+    ...copyTree2(join3(assetsDir, "skills"), join3(claude, "skills"), force, ".claude/skills"),
+    ...copyMarkdownFlat(join3(assetsDir, "agents"), join3(claude, "agents"), force, ".claude/agents"),
+    ...copyTree2(join3(assetsDir, "rules"), join3(claude, "rules"), force, ".claude/rules")
+  );
+  for (const sub of ["prd", "adr", "diagrams", "plan", "tickets", "security"]) {
+    mkdirSync2(join3(root, "docs", sub), { recursive: true });
+  }
+  return changed;
+}
+var InitAbort = class extends Error {
+};
+async function configureBoard(prompter, opts = {}) {
+  const provider = opts.provider ?? await prompter.select("Which board provider?", ["local", "github", "azure"]);
+  if (provider === "local") {
+    const prefix = opts.prefix ?? await prompter.input("Ticket key prefix", "KODI");
+    return { provider: "local", prefix: prefix || "KODI" };
+  }
+  if (provider === "github") {
+    return configureGithub(prompter, opts);
+  }
+  const orgInput = opts.org ?? await prompter.input("Azure DevOps organization (name or URL, e.g. acme)");
+  const org = normalizeOrgUrl(orgInput);
+  if (!org) throw new InitAbort("missing: organization.");
+  let projects;
+  try {
+    projects = listProjects(org, opts.runner);
+  } catch (e) {
+    throw new InitAbort(
+      `could not list projects for ${org}. Is \`az\` installed and logged in (az login / az devops login)? ${e instanceof Error ? e.message : ""}`
+    );
+  }
+  if (projects.length === 0) throw new InitAbort(`no projects found in ${org}.`);
+  let project = opts.project;
+  if (project) {
+    if (!projects.includes(project)) {
+      throw new InitAbort(`project "${project}" not found in ${org} (found: ${projects.join(", ")}).`);
+    }
+  } else {
+    project = await prompter.select("Select a project", projects);
+  }
+  const info = getProjectInfo(org, project, opts.runner);
+  if (!info) throw new InitAbort(`project "${project}" is not reachable in ${org}.`);
+  if (!processSupportsIssues(info.processTemplate)) {
+    throw new InitAbort(
+      `project "${project}" uses the ${info.processTemplate} process, which has no "Issue" work-item type. kodi creates tickets as Issues \u2014 use a Basic-process project (or add the Issue type), then re-run \`kodi init\`.`
+    );
+  }
+  let states = [];
+  try {
+    states = listIssueStates(org, project, opts.runner);
+  } catch {
+  }
+  const proposed = statesInCategory(states, "Proposed");
+  const inProg = statesInCategory(states, "InProgress");
+  const completed = statesInCategory(states, "Completed");
+  const pick = async (flag, message, candidates, def) => {
+    if (flag) return flag;
+    if (candidates.length === 1) return candidates[0];
+    if (candidates.length > 1) return prompter.select(message, candidates);
+    return await prompter.input(message, def) || def;
+  };
+  let todo;
+  if (opts.todoColumn) {
+    todo = opts.todoColumn;
+  } else if (states.length > 0 && proposed.length === 0) {
+    throw new InitAbort(
+      'no To Do-type column: the Issue type on this board has no "Proposed" state where new issues can land. Add a To Do column/state to the board, then re-run `kodi init`.'
+    );
+  } else if (proposed.length > 0) {
+    todo = proposed.length === 1 ? proposed[0] : await prompter.select("To Do column (where new issues are created)", proposed);
+  } else {
+    todo = await prompter.input("To Do column (where new issues are created)", DEFAULT_COLUMNS.todo);
+    if (!todo) throw new InitAbort("missing: the To Do column.");
+  }
+  const columns = {
+    todo,
+    inProgress: await pick(opts.inProgressColumn, "In Progress column", inProg, DEFAULT_COLUMNS.inProgress),
+    toReview: await pick(opts.toReviewColumn, "To Review column", inProg, DEFAULT_COLUMNS.toReview),
+    done: await pick(opts.doneColumn, "Done column", completed, DEFAULT_COLUMNS.done)
+  };
+  const repository = opts.repository ?? (await prompter.input("Repository name for pull requests", project) || project);
+  return { provider: "azure", prefix: "KODI", organization: org, project, repository, columns };
+}
+async function configureGithub(prompter, opts) {
+  if (hasProjectWriteScope(opts.runner) === false) {
+    throw new InitAbort(
+      "your gh token can read Projects but not write to them (has read:project, missing project). Run `gh auth refresh -s project --hostname github.com`, then re-run `kodi init`."
+    );
+  }
+  let owner = opts.projectOwner;
+  if (!owner) {
+    const ownerType = opts.ownerType ?? await prompter.select("Is the board owned by an organization or a user?", ["organization", "user"]);
+    if (ownerType === "user") {
+      let login = "";
+      try {
+        login = resolveViewerLogin(opts.runner);
+      } catch {
+      }
+      owner = await prompter.input("GitHub user login (board owner)", login) || login;
+    } else {
+      owner = await prompter.input("GitHub organization login (board owner)");
+    }
+  }
+  if (!owner) throw new InitAbort("missing: project owner.");
+  let projects;
+  try {
+    projects = listProjects2(owner, opts.runner);
+  } catch (e) {
+    throw new InitAbort(
+      `could not list projects for ${owner}. Is \`gh\` installed and logged in (gh auth login), and does your token have the Projects scope (gh auth refresh -s project --hostname github.com)? ${e instanceof Error ? e.message : ""}`
+    );
+  }
+  if (projects.length === 0) throw new InitAbort(`no Projects v2 boards found for owner ${owner}.`);
+  let number = opts.projectNumber;
+  if (number != null) {
+    if (!projects.some((p) => p.number === number)) {
+      throw new InitAbort(
+        `project #${number} not found for ${owner} (found: ${projects.map((p) => `#${p.number} ${p.title}`).join(", ")}).`
+      );
+    }
+  } else {
+    const choice = await prompter.select(
+      "Select a project",
+      projects.map((p) => `#${p.number} ${p.title}`)
+    );
+    number = Number(choice.match(/#(\d+)/)[1]);
+  }
+  const statusField = listStatusField(owner, number, opts.runner);
+  if (!statusField) {
+    throw new InitAbort(
+      `project #${number} has no single-select "Status" field. Add a Status field to the board (every built-in board template has one), then re-run \`kodi init\`.`
+    );
+  }
+  const options = statusField.options.map((o) => o.name);
+  if (options.length === 0) throw new InitAbort(`the Status field on project #${number} has no options.`);
+  const pick = async (flag, message) => {
+    if (flag) return flag;
+    return options.length === 1 ? options[0] : prompter.select(message, options);
+  };
+  const columns = {
+    todo: await pick(opts.todoColumn, "To Do column (where new issues are created)"),
+    inProgress: await pick(opts.inProgressColumn, "In Progress column"),
+    toReview: await pick(opts.toReviewColumn, "To Review column"),
+    done: await pick(opts.doneColumn, "Done column")
+  };
+  let repository = opts.repository;
+  if (!repository) {
+    let detected = "";
+    try {
+      detected = detectRepo(opts.runner);
+    } catch {
+    }
+    let repos = [];
+    try {
+      repos = listRepos(owner, opts.runner);
+    } catch {
+    }
+    if (repos.length > 0) {
+      if (detected && repos.includes(detected)) repos = [detected, ...repos.filter((r) => r !== detected)];
+      repository = await prompter.select("Repository for issues", repos);
+    } else {
+      repository = await prompter.input("Repository for issues (owner/repo)", detected) || detected;
+    }
+  }
+  if (!repository) throw new InitAbort("missing: repository (owner/repo).");
+  return { provider: "github", prefix: "KODI", repository, projectOwner: owner, projectNumber: number, columns };
+}
+function writeState(root, config) {
+  const path = stateFilePath(root);
+  mkdirSync2(dirname3(path), { recursive: true });
+  writeFileSync2(path, stringifyYaml(config), "utf-8");
+  return path;
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Install the kodi harness and configure the board (interactive)").option("-d, --dir <path>", "target project directory", process.cwd()).option("--force", "overwrite existing agents/skills", false).option("--provider <local|github|azure>", "skip the provider prompt").option("--prefix <prefix>", "local ticket key prefix (default KODI)").option("--org <url>", "azure org URL (non-interactive)").option("--project <name>", "azure project (non-interactive)").option("--owner-type <org|user>", "github board owner type (non-interactive)").option("--project-owner <login>", "github Projects owner login (org or user)").option("--project-number <n>", "github Projects board number", (v) => Number(v)).option("--todo-column <name>", "To Do column (non-interactive)").option("--in-progress-column <name>", "In Progress column").option("--to-review-column <name>", "To Review column").option("--done-column <name>", "Done column").option("--repository <name>", "repository for PRs (azure: name; github: owner/repo)").action(async (o) => {
+    const root = String(o.dir);
+    let provider = o.provider;
+    if (!provider && !process.stdin.isTTY) provider = "local";
+    const prompter = readlinePrompter();
+    let config;
+    try {
+      config = await configureBoard(prompter, {
+        provider,
+        prefix: o.prefix,
+        org: o.org,
+        project: o.project,
+        ownerType: o.ownerType,
+        projectOwner: o.projectOwner,
+        projectNumber: o.projectNumber,
+        todoColumn: o.todoColumn,
+        inProgressColumn: o.inProgressColumn,
+        toReviewColumn: o.toReviewColumn,
+        doneColumn: o.doneColumn,
+        repository: o.repository
+      });
+    } catch (e) {
+      if (e instanceof InitAbort) {
+        process.stderr.write(`
+kodi init aborted \u2014 ${e.message}
+`);
+        process.exitCode = 1;
+        return;
+      }
+      throw e;
+    } finally {
+      prompter.close();
+    }
+    const changed = installHarness(root, { force: o.force });
+    const statePath = writeState(root, config);
+    process.stdout.write(
+      `
+kodi init: installed
+${changed.map((c) => `  + ${c}`).join("\n")}
+  + ${relative(root, statePath)} (provider: ${config.provider})
+
+SessionStart wired to \`${HOOK_COMMAND}\` (matchers: ${SESSION_MATCHER}).
+`
+    );
+  });
+}
+
+// src/commands/pr.ts
+import { mkdtempSync, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+
+// src/templates/pr.ts
+import { z as z3 } from "zod";
+var PrSchema = z3.object({
+  title: z3.string().min(3, "title must be at least 3 characters"),
+  summary: z3.string().min(1, "summary is required"),
+  includedChanges: z3.array(z3.string().min(1)).default([]),
+  features: z3.array(z3.string().min(1)).default([]),
+  fixes: z3.array(z3.string().min(1)).default([]),
+  improvements: z3.array(z3.string().min(1)).default([]),
+  relatedIssues: z3.array(z3.string().min(1)).default([]),
+  notes: z3.string().optional(),
+  reviewers: z3.array(z3.string().min(1)).default([])
+});
+function bulletSection(title, items) {
+  if (!items.length) return [];
+  return ["", `## ${title}`, "", ...items.map((i) => `- ${i}`)];
+}
+function renderPrMarkdown(pr) {
+  const lines = ["## Summary", "", pr.summary];
+  lines.push(...bulletSection("Included changes", pr.includedChanges));
+  lines.push(...bulletSection("Features", pr.features));
+  lines.push(...bulletSection("Fixes", pr.fixes));
+  lines.push(...bulletSection("Improvements", pr.improvements));
+  lines.push(...bulletSection("Related issues", pr.relatedIssues));
+  if (pr.notes) lines.push("", "## Notes", "", pr.notes);
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+function renderPrHtml(pr) {
+  return mdToHtml(renderPrMarkdown(pr));
+}
+
+// src/commands/pr.ts
+function resolveTarget(explicit) {
+  if (explicit === "github" || explicit === "azure") return explicit;
+  const p = loadBoardConfig().provider;
+  if (p === "github" || p === "azure") return p;
+  throw new Error(
+    `no PR target: the active provider is "${p}". Configure github/azure with \`kodi init\`, or pass --provider.`
+  );
+}
+function draftFromOptions(o) {
+  if (o.file) return PrSchema.parse(JSON.parse(readFileSync4(String(o.file), "utf-8")));
+  return PrSchema.parse({
+    title: o.title,
+    summary: o.summary,
+    features: o.feature ?? [],
+    fixes: o.fix ?? [],
+    improvements: o.improvement ?? [],
+    includedChanges: o.change ?? [],
+    relatedIssues: o.issue ?? [],
+    notes: o.notes,
+    reviewers: o.reviewer ?? []
+  });
+}
+function githubCreateArgs(pr, bodyFile, source, target, repo) {
+  const args = ["gh", "pr", "create", "--title", pr.title, "--body-file", bodyFile, "--base", target, "--head", source];
+  for (const r of pr.reviewers) args.push("--reviewer", r);
+  if (repo) args.push("--repo", repo);
+  return args;
+}
+function azureCreateArgs(pr, html, source, target, repo) {
+  const args = [
+    "az",
+    "repos",
+    "pr",
+    "create",
+    "--title",
+    pr.title,
+    "--description",
+    html,
+    "--source-branch",
+    source,
+    "--target-branch",
+    target
+  ];
+  if (repo) args.push("--repository", repo);
+  return args;
+}
+function registerPrCommand(program2) {
+  const pr = program2.command("pr").description("Manage pull requests (proxy gh/az) with a validated template");
+  pr.command("create").description("Create a PR from a validated template draft").option("-f, --file <path>", "JSON PR draft (validated against the template)").option("-t, --title <title>").option("-s, --summary <summary>").option("--feature <text>", "feature (repeatable)", collect, []).option("--fix <text>", "fix (repeatable)", collect, []).option("--improvement <text>", "improvement (repeatable)", collect, []).option("--change <text>", "included change (repeatable)", collect, []).option("--issue <ref>", "related issue (repeatable)", collect, []).option("--reviewer <name>", "reviewer (repeatable)", collect, []).option("--notes <text>").requiredOption("--source <branch>", "branch the PR is opened from").requiredOption("--target <branch>", "branch the PR merges into").option("--provider <github|azure>", "override the PR provider").option("--repository <repo>", "repository (gh: OWNER/REPO; az: name)").option("--yes", "execute (default: dry-run)", false).action((o) => {
+    const draft = draftFromOptions(o);
+    const target = resolveTarget(o.provider);
+    const repo = o.repository ?? loadBoardConfig().repository;
+    let args;
+    if (target === "github") {
+      const bodyFile = join4(mkdtempSync(join4(tmpdir(), "kodi-pr-")), "body.md");
+      writeFileSync3(bodyFile, renderPrMarkdown(draft), "utf-8");
+      args = githubCreateArgs(draft, bodyFile, o.source, o.target, repo);
+    } else {
+      args = azureCreateArgs(draft, renderPrHtml(draft), o.source, o.target, repo);
+    }
+    const res = execMutate(args, !o.yes);
+    if (res.ran) process.stdout.write((res.stdout.trim() || "PR created") + "\n");
+  });
+  pr.command("list").description("List open pull requests").option("--provider <github|azure>", "override the PR provider").option("--repository <repo>").action((o) => {
+    const target = resolveTarget(o.provider);
+    const repo = o.repository ?? loadBoardConfig().repository;
+    const args = target === "github" ? ["gh", "pr", "list", ...repo ? ["--repo", repo] : []] : ["az", "repos", "pr", "list", ...repo ? ["--repository", repo] : []];
+    process.stdout.write(execRead(args));
+  });
+  pr.command("abandon <id>").description("Abandon/close a pull request").option("--provider <github|azure>", "override the PR provider").option("--repository <repo>").option("--yes", "execute (default: dry-run)", false).action((id, o) => {
+    const target = resolveTarget(o.provider);
+    const repo = o.repository ?? loadBoardConfig().repository;
+    const args = target === "github" ? ["gh", "pr", "close", id, ...repo ? ["--repo", repo] : []] : ["az", "repos", "pr", "update", "--id", id, "--status", "abandoned"];
+    execMutate(args, !o.yes);
+  });
+  return pr;
+}
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+
+// src/commands/tickets.ts
+import { readFileSync as readFileSync6 } from "fs";
+
+// src/providers/github.ts
+import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync4 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join5 } from "path";
+var MARKER_RE2 = /<!--\s*kodi:ticket\s+(\{[\s\S]*?\})\s*-->/;
+var DEFAULT_COLUMNS2 = {
+  todo: "Todo",
+  inProgress: "In Progress",
+  toReview: "In Progress",
+  done: "Done"
+};
+function columnForStatus2(status, cols) {
+  switch (status) {
+    case "In progress":
+      return cols.inProgress ?? DEFAULT_COLUMNS2.inProgress;
+    case "To review":
+      return cols.toReview ?? DEFAULT_COLUMNS2.toReview;
+    case "Done":
+      return cols.done ?? DEFAULT_COLUMNS2.done;
+    default:
+      return cols.todo;
+  }
+}
+function statusFromColumn2(column, cols) {
+  if (column === cols.todo) return "Pending";
+  if (column === (cols.inProgress ?? DEFAULT_COLUMNS2.inProgress)) return "In progress";
+  if (column === (cols.toReview ?? DEFAULT_COLUMNS2.toReview)) return "To review";
+  if (column === (cols.done ?? DEFAULT_COLUMNS2.done)) return "Done";
+  return void 0;
+}
+function serializeBody(t) {
+  const canonical = JSON.stringify({ ...t, key: void 0 });
+  return `${renderTicketMarkdown(t)}
+<!-- kodi:ticket ${canonical} -->
+`;
+}
+function parseMarker(body) {
+  const m = body ? MARKER_RE2.exec(body) : null;
+  if (!m) return null;
+  const parsed = TicketSchema.safeParse(JSON.parse(m[1]));
+  return parsed.success ? parsed.data : null;
+}
+function parseItems(json) {
+  const data = JSON.parse(json);
+  const items = Array.isArray(data) ? data : data.items ?? [];
+  const out2 = [];
+  for (const it of items) {
+    const content = it?.content ?? {};
+    if (content.type !== "Issue" || typeof content.number !== "number" || typeof it?.id !== "string") continue;
+    out2.push({
+      itemId: it.id,
+      issueNumber: content.number,
+      statusName: typeof it?.status === "string" ? it.status : void 0,
+      body: typeof content.body === "string" ? content.body : void 0
+    });
+  }
+  return out2;
+}
+function createIssueArgs(repo, title, bodyFile) {
+  const args = ["gh", "issue", "create", "--title", title, "--body-file", bodyFile];
+  if (repo) args.push("--repo", repo);
+  return args;
+}
+function itemAddArgs(owner, number, issueUrl) {
+  return ["gh", "project", "item-add", String(number), "--owner", owner, "--url", issueUrl, "--format", "json"];
+}
+function itemEditArgs(projectId, itemId, fieldId, optionId) {
+  return [
+    "gh",
+    "project",
+    "item-edit",
+    "--id",
+    itemId,
+    "--project-id",
+    projectId,
+    "--field-id",
+    fieldId,
+    "--single-select-option-id",
+    optionId
+  ];
+}
+var GithubTicketProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.columns = opts.columns ?? DEFAULT_COLUMNS2;
+  }
+  opts;
+  name = "github";
+  columns;
+  meta;
+  itemsCache;
+  repoArgs() {
+    return this.opts.repo ? ["--repo", this.opts.repo] : [];
+  }
+  /** Resolve (and cache) the project + Status field node ids needed for writes. */
+  projectMeta() {
+    return this.meta ??= fetchProjectMeta(this.opts.owner, this.opts.number);
+  }
+  /** Read (and cache) all board items in one call. */
+  items() {
+    if (this.itemsCache) return this.itemsCache;
+    const out2 = execRead([
+      "gh",
+      "project",
+      "item-list",
+      String(this.opts.number),
+      "--owner",
+      this.opts.owner,
+      "--format",
+      "json",
+      "--limit",
+      "500"
+    ]);
+    return this.itemsCache = parseItems(out2);
+  }
+  /** Body for an item — from item-list when present, else a per-issue fallback fetch. */
+  bodyFor(item) {
+    if (item.body != null) return item.body;
+    return execRead(["gh", "issue", "view", String(item.issueNumber), "--json", "body", "-q", ".body", ...this.repoArgs()]);
+  }
+  toStored(item) {
+    const t = parseMarker(this.bodyFor(item));
+    if (!t) return null;
+    const mapped = item.statusName ? statusFromColumn2(item.statusName, this.columns) : void 0;
+    const status = mapped ?? t.status;
+    return { ...t, key: String(item.issueNumber), slug: t.slug ?? slugify(t.title), status };
+  }
+  async nextId() {
+    return "(assigned by github on create)";
+  }
+  async create(input) {
+    const slug = input.slug ?? slugify(input.title);
+    const draft = { ...input, key: "(pending)", slug };
+    const bodyFile = writeTempBody(serializeBody(draft));
+    const r1 = execMutate(createIssueArgs(this.opts.repo, input.title, bodyFile), this.opts.dryRun);
+    if (!r1.ran) {
+      execMutate(itemAddArgs(this.opts.owner, this.opts.number, "<issue-url>"), this.opts.dryRun);
+      execMutate(itemEditArgs("<project-id>", "<item-id>", "<status-field-id>", "<option-id>"), this.opts.dryRun);
+      return { ...draft, key: "(dry-run)" };
+    }
+    const url = r1.stdout.trim().split("\n").pop() ?? "";
+    const num = url.match(/\/(\d+)\/?$/)?.[1] ?? "?";
+    try {
+      const add = execMutate(itemAddArgs(this.opts.owner, this.opts.number, url), false);
+      const itemId = JSON.parse(add.stdout).id;
+      const meta = this.projectMeta();
+      const optionId = optionIdFor(meta.statusField, columnForStatus2(input.status, this.columns));
+      if (optionId) execMutate(itemEditArgs(meta.projectId, itemId, meta.statusField.id, optionId), false);
+    } catch (e) {
+      throw new Error(
+        `issue #${num} was created (${url}) but could not be added to project #${this.opts.number}: ${e instanceof Error ? e.message : String(e)}
+If your gh token lacks the \`project\` scope, run \`gh auth refresh -s project --hostname github.com\`, then attach it with:
+  gh project item-add ${this.opts.number} --owner ${this.opts.owner} --url ${url}`
+      );
+    }
+    return { ...draft, key: num };
+  }
+  async get(key) {
+    const item = this.items().find((i) => String(i.issueNumber) === key);
+    return item ? this.toStored(item) : null;
+  }
+  async list() {
+    return this.items().map((i) => this.toStored(i)).filter((t) => t !== null).map(toRef2);
+  }
+  async listReady() {
+    const all = await this.list();
+    const done = new Set(all.filter((t) => t.status === "Done").map((t) => t.key));
+    const ready = [];
+    const blocked = [];
+    for (const t of all) {
+      if (t.status !== "Pending") continue;
+      const unmet = t.dependencies.filter((d) => !done.has(d));
+      if (unmet.length === 0) ready.push(t);
+      else blocked.push({ ticket: t, blockedBy: unmet });
+    }
+    return { ready, blocked };
+  }
+  async setStatus(key, status) {
+    const item = this.items().find((i) => String(i.issueNumber) === key);
+    if (!item) throw new Error(`issue ${key} is not on project #${this.opts.number}`);
+    const current = this.toStored(item);
+    if (!current) throw new Error(`issue ${key} has no kodi marker`);
+    const meta = this.projectMeta();
+    const optionId = optionIdFor(meta.statusField, columnForStatus2(status, this.columns));
+    if (!optionId) throw new Error(`no Status option maps to "${status}" on project #${this.opts.number}`);
+    execMutate(itemEditArgs(meta.projectId, item.itemId, meta.statusField.id, optionId), this.opts.dryRun);
+    return { ...current, status };
+  }
+  async start(key, _p) {
+    return this.setStatus(key, "In progress");
+  }
+  async amend(key, patch) {
+    const current = await this.get(key);
+    if (!current) throw new Error(`issue ${key} not found`);
+    const merged = { ...current, ...patch, key, slug: current.slug };
+    const bodyFile = writeTempBody(serializeBody(merged));
+    const args = ["gh", "issue", "edit", key, "--body-file", bodyFile, ...this.repoArgs()];
+    if (patch.title) args.push("--title", patch.title);
+    execMutate(args, this.opts.dryRun);
+    return merged;
+  }
+  async delete(key) {
+    execMutate(["gh", "issue", "delete", key, "--yes", ...this.repoArgs()], this.opts.dryRun);
+  }
+};
+function toRef2(t) {
+  return { key: t.key, title: t.title, status: t.status, slug: t.slug, dependencies: t.dependencies };
+}
+function writeTempBody(body) {
+  const file = join5(mkdtempSync2(join5(tmpdir2(), "kodi-gh-")), "body.md");
+  writeFileSync4(file, body, "utf-8");
+  return file;
+}
+
+// src/providers/local.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync5,
+  rmSync,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { join as join6 } from "path";
+import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
+var FRONTMATTER = /^---\n([\s\S]*?)\n---\n?/;
+var LocalTicketProvider = class {
+  name = "local";
+  prefix;
+  paths;
+  constructor(prefix, cwd = process.cwd()) {
+    this.prefix = prefix;
+    this.paths = localPaths(cwd);
+  }
+  ensureDirs() {
+    mkdirSync3(this.paths.backlog, { recursive: true });
+    mkdirSync3(this.paths.done, { recursive: true });
+  }
+  fileName(t) {
+    return `${t.key}-${t.slug}.md`;
+  }
+  /** Directory a ticket file lives in for a given status. */
+  dirFor(status) {
+    return status === "Done" ? this.paths.done : this.paths.backlog;
+  }
+  allFiles() {
+    const out2 = [];
+    for (const dir of [this.paths.backlog, this.paths.done]) {
+      if (!existsSync4(dir)) continue;
+      for (const file of readdirSync3(dir)) {
+        if (file.endsWith(".md")) out2.push({ dir, file });
+      }
+    }
+    return out2;
+  }
+  parseFile(dir, file) {
+    const raw = readFileSync5(join6(dir, file), "utf-8");
+    const m = FRONTMATTER.exec(raw);
+    if (!m) return null;
+    const meta = parseYaml3(m[1]) ?? {};
+    const parsed = TicketSchema.safeParse(meta);
+    if (!parsed.success || !parsed.data.key || !parsed.data.slug) return null;
+    return parsed.data;
+  }
+  locate(key) {
+    for (const { dir, file } of this.allFiles()) {
+      const ticket = this.parseFile(dir, file);
+      if (ticket && ticket.key === key) return { dir, file, ticket };
+    }
+    return null;
+  }
+  persist(ticket) {
+    this.ensureDirs();
+    const existing = this.locate(ticket.key);
+    if (existing) rmSync(join6(existing.dir, existing.file));
+    const dir = this.dirFor(ticket.status);
+    const body = `---
+${stringifyYaml2(sortTicket(ticket)).trimEnd()}
+---
+
+` + renderTicketMarkdown(ticket);
+    writeFileSync5(join6(dir, this.fileName(ticket)), body, "utf-8");
+    this.writeIndex();
+  }
+  async nextId(prefix = this.prefix) {
+    let max = 0;
+    for (const { dir, file } of this.allFiles()) {
+      const t = this.parseFile(dir, file);
+      if (!t) continue;
+      const m = /^([A-Z][A-Z0-9]*)-(\d+)$/.exec(t.key);
+      if (m && m[1] === prefix) max = Math.max(max, Number(m[2]));
+    }
+    return `${prefix}-${String(max + 1).padStart(3, "0")}`;
+  }
+  async create(input) {
+    const key = input.key ?? await this.nextId(this.prefix);
+    if (this.locate(key)) throw new Error(`ticket ${key} already exists`);
+    const slug = input.slug ?? slugify(input.title);
+    const ticket = { ...input, key, slug };
+    this.persist(ticket);
+    return ticket;
+  }
+  async get(key) {
+    return this.locate(key)?.ticket ?? null;
+  }
+  async list() {
+    const refs = [];
+    for (const { dir, file } of this.allFiles()) {
+      const t = this.parseFile(dir, file);
+      if (t) refs.push(toRef3(t));
+    }
+    return refs.sort((a, b) => a.key.localeCompare(b.key, void 0, { numeric: true }));
+  }
+  async listReady() {
+    const all = await this.list();
+    const doneKeys = new Set(all.filter((t) => t.status === "Done").map((t) => t.key));
+    const ready = [];
+    const blocked = [];
+    for (const t of all) {
+      if (t.status !== "Pending") continue;
+      const unmet = t.dependencies.filter((d) => !doneKeys.has(d));
+      if (unmet.length === 0) ready.push(t);
+      else blocked.push({ ticket: t, blockedBy: unmet });
+    }
+    return { ready, blocked };
+  }
+  async setStatus(key, status) {
+    const found = this.locate(key);
+    if (!found) throw new Error(`ticket ${key} not found`);
+    const ticket = { ...found.ticket, status };
+    this.persist(ticket);
+    return ticket;
+  }
+  async start(key, _provenance) {
+    return this.setStatus(key, "In progress");
+  }
+  async amend(key, patch) {
+    const found = this.locate(key);
+    if (!found) throw new Error(`ticket ${key} not found`);
+    const ticket = { ...found.ticket, ...patch, key, slug: found.ticket.slug };
+    this.persist(ticket);
+    return ticket;
+  }
+  async delete(key) {
+    const found = this.locate(key);
+    if (!found) throw new Error(`ticket ${key} not found`);
+    rmSync(join6(found.dir, found.file));
+    this.writeIndex();
+  }
+  writeIndex() {
+    const refs = [];
+    for (const { dir, file } of this.allFiles()) {
+      const t = this.parseFile(dir, file);
+      if (t) refs.push(toRef3(t));
+    }
+    refs.sort((a, b) => a.key.localeCompare(b.key, void 0, { numeric: true }));
+    const lines = ["# Tickets", "", "| Key | Title | Status | Depends on |", "|---|---|---|---|"];
+    for (const t of refs) {
+      lines.push(`| ${t.key} | ${t.title} | ${t.status} | ${t.dependencies.join(", ") || "\u2014"} |`);
+    }
+    lines.push("");
+    writeFileSync5(this.paths.index, lines.join("\n"), "utf-8");
+  }
+};
+function toRef3(t) {
+  return { key: t.key, title: t.title, status: t.status, slug: t.slug, dependencies: t.dependencies };
+}
+function sortTicket(t) {
+  return {
+    key: t.key,
+    title: t.title,
+    slug: t.slug,
+    status: t.status,
+    dependencies: t.dependencies,
+    drivers: t.drivers,
+    summary: t.summary,
+    acceptanceCriteria: t.acceptanceCriteria,
+    nonGoals: t.nonGoals,
+    ...t.prUrl ? { prUrl: t.prUrl } : {},
+    ...t.notes ? { notes: t.notes } : {}
+  };
+}
+
+// src/providers/index.ts
+function resolveProvider(cwd = process.cwd(), opts = {}) {
+  const cfg = loadBoardConfig(cwd);
+  switch (cfg.provider) {
+    case "local":
+      return new LocalTicketProvider(cfg.prefix, cwd);
+    case "github":
+      return new GithubTicketProvider({
+        repo: cfg.repository,
+        owner: cfg.projectOwner ?? "",
+        number: cfg.projectNumber ?? 0,
+        columns: cfg.columns,
+        dryRun: !opts.yes,
+        cwd
+      });
+    case "azure":
+      return new AzureTicketProvider({
+        organization: cfg.organization,
+        project: cfg.project,
+        columns: cfg.columns,
+        dryRun: !opts.yes,
+        cwd
+      });
+    default:
+      return new LocalTicketProvider(cfg.prefix, cwd);
+  }
+}
+
+// src/commands/tickets.ts
+function out(data, json, human) {
+  if (json) process.stdout.write(JSON.stringify(data) + "\n");
+  else process.stdout.write(human() + "\n");
+}
+function draftFromOptions2(o) {
+  if (o.file) {
+    const raw = JSON.parse(readFileSync6(String(o.file), "utf-8"));
+    return TicketSchema.parse(raw);
+  }
+  return TicketSchema.parse({
+    title: o.title,
+    summary: o.summary,
+    acceptanceCriteria: o.ac ?? [],
+    nonGoals: o.nonGoal ?? [],
+    dependencies: o.dep ?? [],
+    drivers: {
+      prd: o.prd,
+      adr: o.adr ?? [],
+      security: o.security
+    },
+    notes: o.notes
+  });
+}
+function registerTicketsCommand(program2) {
+  const tickets = program2.command("tickets").description("Manage tickets across the active provider (local / github / azure)");
+  tickets.command("create").description("Create a ticket (validates the template)").option("-f, --file <path>", "JSON draft file (validated against the ticket template)").option("-t, --title <title>").option("-s, --summary <summary>").option("--ac <criterion>", "acceptance criterion (repeatable)", collect2, []).option("--non-goal <text>", "non-goal (repeatable)", collect2, []).option("--dep <key>", "dependency ticket key (repeatable)", collect2, []).option("--prd <ref>", "PRD driver").option("--adr <ref>", "ADR driver (repeatable)", collect2, []).option("--security <ref>", "security driver").option("--notes <text>").option("--yes", "execute remote mutations (default: dry-run)", false).option("--json", "machine-readable output", false).action(async (o) => {
+    const draft = draftFromOptions2(o);
+    const created = await resolveProvider(process.cwd(), { yes: o.yes }).create(draft);
+    out(created, o.json, () => `Created ${created.key} (${created.status}) \u2014 ${created.title}`);
+  });
+  tickets.command("list").description("List all tickets").option("--json", "machine-readable output", false).action(async (o) => {
+    const refs = await resolveProvider().list();
+    out(
+      refs,
+      o.json,
+      () => refs.length ? refs.map((t) => `${t.key}  ${t.status.padEnd(12)}  ${t.title}`).join("\n") : "No tickets."
+    );
+  });
+  tickets.command("list-ready").description("List tickets ready to start (no unmet dependency) + the blocked set").option("--json", "machine-readable output", false).action(async (o) => {
+    const res = await resolveProvider().listReady();
+    out(res, o.json, () => {
+      const ready = res.ready.map((t) => `  ${t.key}  ${t.title}`).join("\n") || "  (none)";
+      const blocked = res.blocked.map((b) => `  ${b.ticket.key}  ${b.ticket.title}  \u2190 ${b.blockedBy.join(", ")}`).join("\n") || "  (none)";
+      return `Ready:
+${ready}
+
+Blocked:
+${blocked}`;
+    });
+  });
+  tickets.command("get <key>").description("Show one ticket").option("--json", "machine-readable output", false).action(async (key, o) => {
+    const t = await resolveProvider().get(key);
+    if (!t) {
+      process.stderr.write(`ticket ${key} not found
+`);
+      process.exitCode = 1;
+      return;
+    }
+    out(t, o.json, () => JSON.stringify(t, null, 2));
+  });
+  tickets.command("set-status <key> <status>").description(`Transition a ticket (${TICKET_STATUSES.join(" | ")})`).option("--yes", "execute remote mutations (default: dry-run)", false).option("--json", "machine-readable output", false).action(async (key, status, o) => {
+    if (!TICKET_STATUSES.includes(status)) {
+      process.stderr.write(`invalid status "${status}". One of: ${TICKET_STATUSES.join(", ")}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    const t = await resolveProvider(process.cwd(), { yes: o.yes }).setStatus(key, status);
+    out(t, o.json, () => `${t.key} \u2192 ${t.status}`);
+  });
+  tickets.command("start <key>").description("Mark a ticket started (In progress)").option("--branch <name>").option("--yes", "execute remote mutations (default: dry-run)", false).option("--json", "machine-readable output", false).action(async (key, o) => {
+    const t = await resolveProvider(process.cwd(), { yes: o.yes }).start(key, { branch: o.branch });
+    out(t, o.json, () => `${t.key} \u2192 ${t.status}`);
+  });
+  tickets.command("delete <key>").description("Delete a ticket").option("--yes", "execute remote mutations (default: dry-run)", false).option("--json", "machine-readable output", false).action(async (key, o) => {
+    await resolveProvider(process.cwd(), { yes: o.yes }).delete(key);
+    out({ deleted: key }, o.json, () => `Deleted ${key}`);
+  });
+  tickets.command("next-id").description("Compute the next ticket key").option("--json", "machine-readable output", false).action(async (o) => {
+    const id = await resolveProvider().nextId();
+    out({ nextId: id }, o.json, () => id);
+  });
+  tickets.command("amend <key>").description("Edit a ticket (from --file patch or flags)").option("-f, --file <path>", "JSON patch (validated against the template)").option("-s, --summary <text>").option("--notes <text>").option("--ac <criterion>", "replace acceptance criteria (repeatable)", collect2, []).option("--dep <key>", "replace dependencies (repeatable)", collect2, []).option("--pr <ref>", "link a PR").option("--yes", "execute remote mutations (default: dry-run)", false).option("--json", "machine-readable output", false).action(async (key, o) => {
+    const patch = o.file ? TicketSchema.partial().parse(JSON.parse(readFileSync6(String(o.file), "utf-8"))) : buildPatch(o);
+    const t = await resolveProvider(process.cwd(), { yes: o.yes }).amend(key, patch);
+    out(t, o.json, () => `Amended ${t.key}`);
+  });
+  tickets.command("link-pr <key> <pr>").description("Bind a pull request to a ticket").option("--yes", "execute remote mutations (default: dry-run)", false).option("--json", "machine-readable output", false).action(async (key, pr, o) => {
+    const t = await resolveProvider(process.cwd(), { yes: o.yes }).amend(key, { prUrl: pr });
+    out(t, o.json, () => `${t.key} \u2194 ${pr}`);
+  });
+  tickets.command("deps <key>").description("Read a ticket's dependencies, or declare new ones with --add").option("--add <key>", "declare a dependency (repeatable)", collect2, []).option("--yes", "execute remote mutations (default: dry-run)", false).option("--json", "machine-readable output", false).action(async (key, o) => {
+    const provider = resolveProvider(process.cwd(), { yes: o.yes });
+    const current = await provider.get(key);
+    if (!current) {
+      process.stderr.write(`ticket ${key} not found
+`);
+      process.exitCode = 1;
+      return;
+    }
+    if (o.add.length) {
+      const deps = Array.from(/* @__PURE__ */ new Set([...current.dependencies, ...o.add]));
+      const t = await provider.amend(key, { dependencies: deps });
+      out(t.dependencies, o.json, () => `${key} deps: ${t.dependencies.join(", ") || "(none)"}`);
+    } else {
+      out(current.dependencies, o.json, () => `${key} deps: ${current.dependencies.join(", ") || "(none)"}`);
+    }
+  });
+  tickets.command("hand-off <key>").description("End of slice: move to To review and optionally link the PR").option("--pr <ref>", "link the PR at hand-off").option("--yes", "execute remote mutations (default: dry-run)", false).option("--json", "machine-readable output", false).action(async (key, o) => {
+    const provider = resolveProvider(process.cwd(), { yes: o.yes });
+    if (o.pr) await provider.amend(key, { prUrl: o.pr });
+    const t = await provider.setStatus(key, "To review");
+    out(t, o.json, () => `${t.key} \u2192 ${t.status}${o.pr ? ` (PR ${o.pr})` : ""}`);
+  });
+  return tickets;
+}
+function collect2(value, previous) {
+  return previous.concat([value]);
+}
+function buildPatch(o) {
+  const patch = {};
+  if (o.summary !== void 0) patch.summary = o.summary;
+  if (o.notes !== void 0) patch.notes = o.notes;
+  if (o.ac?.length) patch.acceptanceCriteria = o.ac;
+  if (o.dep?.length) patch.dependencies = o.dep;
+  if (o.pr) patch.prUrl = o.pr;
+  return patch;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("kodi").description("kodi.dev \u2014 Claude Code-native agent orchestrator").version("0.0.0");
+registerTicketsCommand(program);
+registerPrCommand(program);
+registerHookCommand(program);
+registerInitCommand(program);
+registerAddCommand(program);
+program.parseAsync(process.argv).catch((err) => {
+  process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+  process.exitCode = 1;
+});