tracerkit 1.11.3 → 1.13.0

package/README.md

@@ -19,9 +19,9 @@ Named after the tracer-bullet technique from _The Pragmatic Programmer_: **Trace
 
 ## Why TracerKit?
 
-AI assistants work best with small, well-scoped tasks — not sprawling layers or flat task lists. TracerKit structures every feature as **tracer-bullet vertical slices**: each phase cuts through every layer (schema → service → API → UI → tests) and is demoable on its own. Integration problems surface early, not at the end.
+AI assistants work best with small, well-scoped tasks, not sprawling layers or flat task lists. TracerKit structures every feature as **tracer-bullet vertical slices**: each phase cuts through every layer (schema → service → API → UI → tests) and is demoable on its own. Integration problems surface early, not at the end.
 
-The workflow is three skills: **define** (`/tk:prd`), **plan** (`/tk:plan`), **verify** (`/tk:check`). Skills are pure Markdown with zero runtime deps — the AI reads your specs directly, counts progress, and archives completed work. No build step, no CLI at runtime.
+The workflow is three skills: **define** (`/tk:prd`), **plan** (`/tk:plan`), **verify** (`/tk:check`). Skills are pure Markdown with zero runtime deps. The AI reads your specs directly, counts progress, and archives completed work. No build step, no CLI at runtime.
 
 ## Get Started
 
@@ -32,7 +32,7 @@ npm install -g tracerkit
 tracerkit init
 ```
 
-Skills are installed to `~/.claude/skills/`, available in every project. Safe to re-run — adds missing skills without overwriting ones you've modified.
+Skills are installed to `~/.claude/skills/`, available in every project. Safe to re-run: adds missing skills without overwriting ones you've modified.
 
 <details>
 <summary>Per-project install (team members get skills via git)</summary>
@@ -54,7 +54,7 @@ Inside Claude Code, run:
 /plugin install tk@claude-plugins-official
 ```
 
-Run `/reload-plugins` if needed. Skills are available immediately — no build step, no config.
+Run `/reload-plugins` if needed. Skills are available immediately, no build step, no config.
 
 </details>
 
@@ -91,6 +91,20 @@ AI:  | Feature           | Status      | Age | Progress | Next
 
 See [Examples](docs/examples.md) for full walkthroughs.
 
+<details>
+<summary>GitHub Issues as storage backend</summary>
+
+Same skills, same workflow. Storage is configured per-project:
+
+```bash
+tracerkit config storage github         # set current project to use GitHub
+tracerkit config github.repo org/repo   # set target repo
+```
+
+PRDs and plans become GitHub Issues with `tk:prd` and `tk:plan` labels. On `/tk:check` pass, issues are closed instead of archived locally. Each project can use a different backend; local is the default. See [Configuration](docs/configuration.md) for details.
+
+</details>
+
 ## Skills
 
 TracerKit ships skills that take a feature from idea to verified archive.
@@ -99,19 +113,19 @@ TracerKit ships skills that take a feature from idea to verified archive.
 
 Interactive interview that explores your codebase, asks scoping questions one at a time, designs deep modules, and writes a structured PRD.
 
-**Output:** `.tracerkit/prds/<slug>.md`
+**Output:** `.tracerkit/prds/<slug>.md` (local) or GitHub Issue with `tk:prd` label
 
 ### `/tk:plan <slug>`: Create an implementation plan
 
 Reads a PRD and breaks it into phased **tracer-bullet vertical slices**. Each phase is a thin but complete path through every layer (schema, service, API, UI, tests), demoable on its own.
 
-**Output:** `.tracerkit/plans/<slug>.md`
+**Output:** `.tracerkit/plans/<slug>.md` (local) or GitHub Issue with `tk:plan` label
 
 ### `/tk:brief`: Session briefing
 
 Shows active features, their progress, and suggested focus. Use at the start of a session to orient.
 
-**Output:** Feature dashboard in the terminal — no files written.
+**Output:** Feature dashboard in the terminal. No files written.
 
 ### `/tk:check [slug]`: Verify and archive
 
@@ -119,15 +133,15 @@ Verifies the codebase against the plan's done-when checkboxes. Runs tests, valid
 
 Without arguments, shows a feature dashboard with status and progress before asking which feature to check.
 
-**Output:** Verdict block in `.tracerkit/plans/<slug>.md`. On `done`: `.tracerkit/archives/<slug>/prd.md` + `.tracerkit/archives/<slug>/plan.md`
+**Output:** Verdict block appended to the plan. On `done`: archives to `.tracerkit/archives/<slug>/` (local) or closes both issues (GitHub).
 
 ## Docs
 
 | Document                                         | Description                                        |
 | ------------------------------------------------ | -------------------------------------------------- |
 | [Examples](docs/examples.md)                     | Walk through end-to-end usage scenarios            |
-| [CLI Reference](docs/cli-reference.md)           | Lifecycle commands: init, update, uninstall        |
-| [Configuration](docs/configuration.md)           | Configure custom artifact paths via `config.json`  |
+| [CLI Reference](docs/cli-reference.md)           | Commands: init, update, config, uninstall          |
+| [Configuration](docs/configuration.md)           | Storage backends, GitHub options, custom paths     |
 | [Metadata Lifecycle](docs/metadata-lifecycle.md) | Understand YAML frontmatter states and transitions |
 | [Comparison](docs/comparison.md)                 | Compare TracerKit to Spec Kit, Kiro, and OpenSpec  |
 

package/dist/bin.js

@@ -1,44 +1,98 @@
 #!/usr/bin/env node
-import { a as e, i as t, n, r, s as i, t as a } from "./uninstall-BhTMOfMb.js";
-import { readFileSync as o } from "node:fs";
-import { dirname as s, resolve as c } from "node:path";
-import { fileURLToPath as l } from "node:url";
-import { homedir as u } from "node:os";
+import { a as e, c as t, d as n, f as r, i, l as a, n as o, o as s, r as c, t as l } from "./uninstall-9tiXr-15.js";
+import { existsSync as u, readFileSync as d, statSync as f } from "node:fs";
+import { dirname as p, join as m, resolve as h } from "node:path";
+import { fileURLToPath as g } from "node:url";
+import { homedir as _ } from "node:os";
+//#region src/commands/config.ts
+function v(e, t) {
+	let [n, r] = t;
+	return n ? r ? x(e, n, r) : b(e, n) : y(e);
+}
+function y(e) {
+	let t = n(e), r = t.storage === "local" ? {
+		storage: t.storage,
+		paths: t.paths
+	} : t;
+	return JSON.stringify(r, null, 2).split("\n");
+}
+function b(e, t) {
+	let r = C(n(e), t);
+	return r === void 0 ? [`Unknown key: ${t}`] : typeof r == "object" ? [JSON.stringify(r, null, 2)] : [String(r)];
+}
+function x(e, t, n) {
+	r(e, w(t, n));
+	let i = [`✓ Set ${t} = ${n}`];
+	return S(e, i), i;
+}
+function S(e, t) {
+	a.some((t) => u(m(e, ".claude", "skills", t))) && (i(e, n(e)), t.push("✓ Skills re-rendered"));
+}
+function C(e, t) {
+	let n = t.split("."), r = e;
+	for (let e of n) {
+		if (typeof r != "object" || !r) return;
+		r = r[e];
+	}
+	return r;
+}
+function w(e, t) {
+	let n = e.split("."), r = {}, i = r;
+	for (let e = 0; e < n.length - 1; e++) {
+		let t = {};
+		i[n[e]] = t, i = t;
+	}
+	return i[n[n.length - 1]] = t, r;
+}
+//#endregion
 //#region src/cli.ts
-var { version: d } = JSON.parse(o(c(s(l(import.meta.url)), "..", "package.json"), "utf8")), f = Math.max(...t.map((e) => `${e.name} ${e.args}`.length)), p = [
+var { version: T } = JSON.parse(d(h(p(g(import.meta.url)), "..", "package.json"), "utf8")), E = Math.max(...e.map((e) => `${e.name} ${e.args}`.length)), D = [
 	"Usage: tracerkit <command> [path]",
 	"",
 	"Commands:",
-	...t.map((e) => `  ${`${e.name} ${e.args}`.padEnd(f + 2)}${e.desc}`),
+	...e.map((e) => `  ${`${e.name} ${e.args}`.padEnd(E + 2)}${e.desc}`),
 	"",
 	"Options:",
 	"  --force           Overwrite modified files during update",
 	"  --help, -h        Show this help message",
 	"  --version, -v     Print version",
 	"",
-	"All commands default to the home directory when no path is given."
+	"init/update/uninstall default to the home directory when no path is given.",
+	"config defaults to the current working directory."
 ];
-function m(e, t = u()) {
+function O(e) {
+	if (!e) return !1;
+	try {
+		return f(h(e)).isDirectory();
+	} catch {
+		return !1;
+	}
+}
+function k(e, t = _()) {
 	let n = e.find((e) => !e.startsWith("-"));
-	return n ? c(n) : t;
-}
-function h(t) {
-	if (t.includes(i.help) || t.includes("-h")) return p;
-	if (t.includes(i.version) || t.includes("-v")) return [`tracerkit/${d}`];
-	let o = t[0], s = t.slice(1);
-	if (e.includes(o)) return [`"${o}" has been removed — skills handle this now.`, "Run `tracerkit update` to get the latest skills."];
-	switch (o) {
-		case "init": return n(m(s));
+	return n ? h(n) : t;
+}
+function A(e) {
+	if (e.includes(t.help) || e.includes("-h")) return D;
+	if (e.includes(t.version) || e.includes("-v")) return [`tracerkit/${T}`];
+	let n = e[0], r = e.slice(1);
+	if (s.includes(n)) return [`"${n}" has been removed — skills handle this now.`, "Run `tracerkit update` to get the latest skills."];
+	switch (n) {
+		case "init": return o(k(r));
 		case "update": {
-			let e = s.includes(i.force), t = r(m(s.filter((e) => e !== i.force)), { force: e });
-			return t.push("", "Updated to the latest TracerKit."), t.push("If using Claude Code, restart your session to load changes."), t;
+			let e = r.includes(t.force), n = c(k(r.filter((e) => e !== t.force)), { force: e });
+			return n.push("", "Updated to the latest TracerKit."), n.push("If using Claude Code, restart your session to load changes."), n;
+		}
+		case "config": {
+			let e = O(r[0]);
+			return v(e ? h(r[0]) : process.cwd(), e ? r.slice(1) : r);
 		}
-		case "uninstall": return a(m(s));
-		default: return p;
+		case "uninstall": return l(k(r));
+		default: return D;
 	}
 }
 //#endregion
 //#region src/bin.ts
-var g = h(process.argv.slice(2));
-for (let e of g) console.log(e);
+var j = A(process.argv.slice(2));
+for (let e of j) console.log(e);
 //#endregion

package/dist/index.js

@@ -1,2 +1,2 @@
-import { c as e, i as t, n, o as r, r as i, t as a } from "./uninstall-BhTMOfMb.js";
-export { t as COMMANDS, r as DEPRECATED_SKILLS, e as SKILL_NAMES, n as init, a as uninstall, i as update };
+import { a as e, l as t, n, r, s as i, t as a } from "./uninstall-9tiXr-15.js";
+export { e as COMMANDS, i as DEPRECATED_SKILLS, t as SKILL_NAMES, n as init, a as uninstall, r as update };

package/dist/uninstall-9tiXr-15.js

@@ -0,0 +1,205 @@
+import { existsSync as e, mkdirSync as t, readFileSync as n, readdirSync as r, rmSync as i, writeFileSync as a } from "node:fs";
+import { dirname as o, join as s } from "node:path";
+import { createHash as c } from "node:crypto";
+import { fileURLToPath as l } from "node:url";
+//#region src/config.ts
+var u = "local", d = [u, "github"], f = {
+	prds: ".tracerkit/prds",
+	plans: ".tracerkit/plans",
+	archives: ".tracerkit/archives"
+}, p = { labels: {
+	prd: "tk:prd",
+	plan: "tk:plan"
+} };
+function m(t) {
+	let r = s(t, ".tracerkit", "config.json");
+	if (!e(r)) return {
+		storage: u,
+		paths: { ...f },
+		github: { ...p }
+	};
+	let i;
+	try {
+		i = JSON.parse(n(r, "utf8"));
+	} catch {
+		throw Error("Invalid .tracerkit/config.json — expected valid JSON");
+	}
+	return {
+		storage: h(i.storage),
+		paths: g(i.paths),
+		github: _(i.github)
+	};
+}
+function h(e) {
+	return typeof e == "string" && d.includes(e) ? e : u;
+}
+function g(e) {
+	let t = b(e) ? e : {};
+	return {
+		prds: typeof t.prds == "string" ? t.prds : f.prds,
+		plans: typeof t.plans == "string" ? t.plans : f.plans,
+		archives: typeof t.archives == "string" ? t.archives : f.archives
+	};
+}
+function _(e) {
+	let t = b(e) ? e : {}, n = b(t.labels) ? t.labels : {};
+	return {
+		...typeof t.repo == "string" ? { repo: t.repo } : {},
+		labels: {
+			prd: typeof n.prd == "string" ? n.prd : p.labels.prd,
+			plan: typeof n.plan == "string" ? n.plan : p.labels.plan
+		}
+	};
+}
+function v(r, i) {
+	let c = s(r, ".tracerkit", "config.json");
+	t(o(c), { recursive: !0 });
+	let l = {};
+	if (e(c)) try {
+		l = JSON.parse(n(c, "utf8"));
+	} catch {
+		l = {};
+	}
+	let u = y(l, i);
+	a(c, JSON.stringify(u, null, 2) + "\n");
+}
+function y(e, t) {
+	let n = { ...e };
+	for (let e of Object.keys(t)) b(n[e]) && b(t[e]) ? n[e] = y(n[e], t[e]) : n[e] = t[e];
+	return n;
+}
+function b(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+var x = [
+	"tk:brief",
+	"tk:prd",
+	"tk:plan",
+	"tk:check"
+], S = ["tk:verify"], C = {
+	force: "--force",
+	help: "--help",
+	version: "--version"
+}, w = [
+	"brief",
+	"progress",
+	"archive"
+], T = [
+	{
+		name: "init",
+		args: "[path]",
+		desc: "Install skills to ~/.claude/skills/ (or [path] if given)"
+	},
+	{
+		name: "update",
+		args: "[path]",
+		desc: "Refresh unchanged files from latest version, skip modified"
+	},
+	{
+		name: "config",
+		args: "[path] [key] [value]",
+		desc: "Get or set TracerKit configuration"
+	},
+	{
+		name: "uninstall",
+		args: "[path]",
+		desc: "Remove TracerKit skill directories, keep .tracerkit/ artifacts"
+	}
+], E = s(o(l(import.meta.url)), "..", "skills");
+function D(e, t = "") {
+	let n = r(e, { withFileTypes: !0 }), i = [];
+	for (let r of n) {
+		let n = t ? `${t}/${r.name}` : r.name;
+		r.isDirectory() ? i.push(...D(s(e, r.name), n)) : i.push(n);
+	}
+	return i.sort();
+}
+function O(e) {
+	return `.claude/skills/tk:${e}`;
+}
+function k(e) {
+	return e.slice(18);
+}
+function A(e, t) {
+	let n = e;
+	return t.paths.prds !== f.prds && (n = n.replaceAll(f.prds, t.paths.prds)), t.paths.plans !== f.plans && (n = n.replaceAll(f.plans, t.paths.plans)), t.paths.archives !== f.archives && (n = n.replaceAll(f.archives, t.paths.archives)), t.github?.repo && (n = n.replaceAll("{{github.repo}}", t.github.repo)), t.github?.labels?.prd && (n = n.replaceAll("{{github.labels.prd}}", t.github.labels.prd)), t.github?.labels?.plan && (n = n.replaceAll("{{github.labels.plan}}", t.github.labels.plan)), n;
+}
+function j(e, r, i) {
+	let c = i ?? D(E).map(O);
+	for (let i of c) {
+		let c = s(E, k(i)), l = s(e, i);
+		t(o(l), { recursive: !0 }), a(l, A(n(c, "utf8"), r));
+	}
+	return { copied: c };
+}
+function M(e) {
+	return c("sha256").update(e).digest("hex");
+}
+function N(t, r) {
+	let i = D(E).map(O), a = [], o = [], c = [];
+	for (let l of i) {
+		let i = s(t, l);
+		if (!e(i)) c.push(l);
+		else {
+			let e = A(n(s(E, k(l)), "utf8"), r);
+			M(Buffer.from(e)) === M(n(i)) ? a.push(l) : o.push(l);
+		}
+	}
+	return {
+		unchanged: a,
+		modified: o,
+		missing: c
+	};
+}
+//#endregion
+//#region src/commands/update.ts
+function P(t, n) {
+	if (!x.some((n) => e(s(t, ".claude", "skills", n)))) throw Error("TracerKit not initialized — run `tracerkit init` first");
+	let r = m(t), { unchanged: a, modified: o, missing: c } = N(t, r), l = [];
+	for (let n of S) {
+		let r = s(t, ".claude", "skills", n);
+		e(r) && (i(r, {
+			recursive: !0,
+			force: !0
+		}), l.push(`✗ .claude/skills/${n}/ removed (deprecated)`));
+	}
+	let u = n?.force ?? !1, d = [
+		...a,
+		...c,
+		...u ? o : []
+	];
+	if (d.length > 0) {
+		j(t, r, d);
+		for (let e of a) l.push(`✓ ${e}`);
+		for (let e of c) l.push(`✓ ${e} (added)`);
+		if (u) for (let e of o) l.push(`✓ ${e} (replaced)`);
+	}
+	if (!u && o.length > 0) {
+		for (let e of o) l.push(`⚠ ${e} (skipped — modified)`);
+		l.push("", "Run `tracerkit update --force` to replace modified files with latest versions.");
+	}
+	return l;
+}
+//#endregion
+//#region src/commands/init.ts
+function F(t) {
+	if (x.some((n) => e(s(t, ".claude", "skills", n)))) return P(t, { force: !1 });
+	let { copied: n } = j(t, m(t));
+	return n.map((e) => `✓ ${e}`);
+}
+//#endregion
+//#region src/commands/uninstall.ts
+function I(t) {
+	if (!x.some((n) => e(s(t, ".claude", "skills", n)))) throw Error("TracerKit not initialized — nothing to uninstall");
+	let n = [];
+	for (let r of x) {
+		let a = s(t, ".claude", "skills", r);
+		e(a) && (i(a, {
+			recursive: !0,
+			force: !0
+		}), n.push(`✗ .claude/skills/${r}/ removed`));
+	}
+	return n;
+}
+//#endregion
+export { T as a, C as c, m as d, v as f, j as i, x as l, F as n, w as o, P as r, S as s, I as t, u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tracerkit",
-  "version": "1.11.3",
+  "version": "1.13.0",
   "description": "Spec-driven workflow for Claude Code: replace ad-hoc prompts with PRD → plan → verify.",
   "license": "MIT",
   "author": {

package/skills/brief/SKILL.md

@@ -2,45 +2,62 @@
 description: Session briefing — shows active features, progress, and suggested focus. Use at the start of a session to orient.
 ---
 
+**Config**: read `.tracerkit/config.json` (default: `local`). Follow matching `<!-- if:local/github -->` blocks. GitHub: use `github.repo` from config or git remote.
+
 # Session Briefing
 
-Get a quick overview of all active features, their progress, and what to focus on next.
+Overview of active features, progress, and suggested focus.
 
 ## Pre-loaded context
 
+<!-- if:local -->
+
 - Available PRDs: !`ls .tracerkit/prds/ 2>&1`
+  <!-- end:local -->
+  <!-- if:github -->
+- Available PRDs: list open GitHub Issues with label `{{github.labels.prd}}`
+<!-- end:github -->
 
 ## Algorithm
 
-Follow these steps exactly to build the briefing table:
-
 ### 1. Discover features
 
-For each `.md` file in `.tracerkit/prds/`:
+<!-- if:local -->
+
+For each `.md` file in `.tracerkit/prds/`: parse frontmatter, extract `status` and `created`. Skip `status: done`. Slug = filename without `.md`.
 
-1. Read the file
-2. Parse YAML frontmatter (the block between `---` fences at the top)
-3. Extract `status` and `created` fields
-4. Skip files where `status: done`
-5. The slug is the filename without `.md`
+   <!-- end:local -->
+   <!-- if:github -->
+
+List open GitHub Issues with label `{{github.labels.prd}}`:
+
+6. For each issue, parse the `<!-- tk:metadata -->` comment in the body
+7. Extract `status` and `created` fields from the metadata
+8. Also check labels: `tk:created`, `tk:in-progress`
+9. Skip issues with `tk:done` label
+10. The slug is extracted from the title: `[{{github.labels.prd}}] <slug>: ...`
+<!-- end:github -->
 
 ### 2. Count progress from plans
 
-For each slug, check if `.tracerkit/plans/<slug>.md` exists. If it does:
+<!-- if:local -->
+
+For each slug with a plan at `.tracerkit/plans/<slug>.md`:
 
-1. Read the plan file
-2. Find every `## Phase N` heading (regex: `^## Phase \d+`)
-3. Within each phase section (until the next `## ` heading), count:
-   - Checked items: lines matching `^- \[x\] ` (case-insensitive)
-   - Unchecked items: lines matching `^- \[ \] `
-4. Sum checked and total across all phases → `checked/total`
-5. Find the first unchecked item (`^- \[ \] (.+)`) in the entire plan — that's the "Next" value. Strip any trailing `[tag]` markers.
+Count `- [x]` and `- [ ]` lines under each `## Phase N` heading. Sum → `checked/total`. First unchecked item → "Next" (strip trailing `[tag]`). No plan → `—`.
 
-If no plan exists, progress is `—` and next is `—`.
+<!-- end:local -->
+<!-- if:github -->
+
+For each slug, find plan issue with label `{{github.labels.plan}}` and matching title. If found:
+
+Count `- [x]` and `- [ ]` lines under each `## Phase N` heading. Sum → `checked/total`. First unchecked item → "Next" (strip trailing `[tag]`). No plan → `—`.
+
+<!-- end:github -->
 
 ### 3. Build the table
 
-Sort features by `created` date ascending (no-date entries last). Calculate age from `created`:
+Sort by `created` ascending (no-date last). Age from `created`:
 
 - < 7 days → `Nd` (e.g. `3d`)
 - < 30 days → `Nw` (e.g. `2w`)
@@ -72,8 +89,13 @@ Append below the table:
 
 ### 5. Offer next steps
 
-Ask the user what they'd like to do:
+<!-- if:local -->
+
+Options: continue focused feature (read plan at `.tracerkit/plans/<slug>.md`), `/tk:prd` for new feature, `/tk:check <slug>` for progress.
+
+<!-- end:local -->
+<!-- if:github -->
+
+Options: continue focused feature (read plan issue), `/tk:prd` for new feature, `/tk:check <slug>` for progress.
 
-- Continue the focused feature (read its plan at `.tracerkit/plans/<slug>.md`)
-- Start a new feature with `/tk:prd`
-- Check progress on a feature with `/tk:check <slug>`
+<!-- end:github -->

package/skills/check/SKILL.md

@@ -3,13 +3,21 @@ description: Verify implementation against plan. Shows progress, finds blockers,
 argument-hint: '[slug]'
 ---
 
+**Config**: read `.tracerkit/config.json` (default: `local`). Follow matching `<!-- if:local/github -->` blocks. GitHub: use `github.repo` from config or git remote.
+
 # Check Implementation
 
 Check implementation against a plan. Update checks, stamp findings, transition status, and archive when done.
 
 ## Pre-loaded context
 
+<!-- if:local -->
+
 - Available plans: !`ls .tracerkit/plans/ 2>&1`
+  <!-- end:local -->
+  <!-- if:github -->
+- Available plans: list open GitHub Issues with label `{{github.labels.plan}}`
+<!-- end:github -->
 
 ## Input
 
@@ -25,38 +33,60 @@ If no argument is provided, build a summary table before asking which one to che
 | <slug>  | ...    | 3/7      |
 ```
 
+<!-- if:local -->
+
 For each `.md` file in `.tracerkit/prds/`:
 
 1. Read the file, parse YAML frontmatter (block between `---` fences)
 2. Extract `status` — use `unknown` if missing
 3. If `.tracerkit/plans/<slug>.md` exists, count progress (see Progress Algorithm below). Show `—` if no plan.
+   <!-- end:local -->
+   <!-- if:github -->
 
-After the table, ask which feature to verify.
+   List open GitHub Issues with label `{{github.labels.prd}}`:
 
-## Progress Algorithm
+4. For each PRD issue, extract `status` from labels (`tk:created`, `tk:in-progress`)
+5. Find matching plan issue with label `{{github.labels.plan}}` and same slug in title
+6. If plan issue exists, count progress from checkboxes in its body (see Progress Algorithm below). Show `—` if no plan.
+<!-- end:github -->
 
-To count progress for a plan file:
+Ask which feature to verify.
 
-1. Find every `## Phase N` heading (regex: `^## Phase \d+`)
-2. Within each phase section (until the next `## ` heading), count:
-   - Checked: lines matching `^- \[x\] ` (case-insensitive)
-   - Unchecked: lines matching `^- \[ \] `
-3. Per-phase output: `  Phase N — title: checked/total`
-4. Sum across all phases → `Total: checked/total`
+## Progress Algorithm
+
+Count `- [x]` and `- [ ]` lines under each `## Phase N` heading. Per-phase: `Phase N — title: checked/total`. Sum → `Total: checked/total`.
 
 ## Workflow
 
 ### 1. Load the plan
 
-Read `.tracerkit/plans/<slug>.md`. If it does not exist, list available plans and ask.
+<!-- if:local -->
+
+Read `.tracerkit/plans/<slug>.md`. If missing, list plans and ask.
+
+<!-- end:local -->
+<!-- if:github -->
+
+Find plan issue: open issue with label `{{github.labels.plan}}`, title matching `[{{github.labels.plan}}] <slug>:`. If missing, list plans and ask.
+
+<!-- end:github -->
 
 ### 2. Load the PRD
 
-Read the source PRD referenced in the plan header (`> Source PRD: ...`).
+<!-- if:local -->
+
+Read source PRD referenced in plan header (`> Source PRD: ...`).
+
+<!-- end:local -->
+<!-- if:github -->
+
+Read source PRD issue referenced in plan body (`> Source PRD: #<number>`).
+
+<!-- end:github -->
 
 ### 3. Fast-path: check if implementation exists
 
-Before launching a subagent, check whether the primary module file(s) from Phase 1 exist. If none exist, skip the subagent entirely and report `0/N — not yet started`. List Phase 1's "Done when" items as next steps and jump to Step 5.
+If primary module file(s) from Phase 1 don't exist, skip subagent — report `0/N — not yet started`, list Phase 1 done-when items, jump to Step 5.
 
 ### 3b. Launch read-only review
 
@@ -76,8 +106,17 @@ Collect findings into two categories:
 
 ### 3c. Update checkboxes
 
+<!-- if:local -->
+
 Using the subagent's report, update each checkbox in `.tracerkit/plans/<slug>.md` to `[x]` or `[ ]`.
 
+<!-- end:local -->
+<!-- if:github -->
+
+Using the subagent's report, update each checkbox in the plan issue body to `[x]` or `[ ]` by editing the issue.
+
+<!-- end:github -->
+
 ### 4. Determine outcome
 
 Based on checks and findings, decide the status transition:
@@ -88,7 +127,7 @@ Based on checks and findings, decide the status transition:
 
 ### 5. Report to user
 
-Count progress per phase using the Progress Algorithm above, then print the verdict report:
+Count progress per phase (Progress Algorithm), then print:
 
 ```markdown
 ## Verification: <slug>
@@ -112,8 +151,17 @@ Total: checked/total
 
 ### 6. Stamp the plan
 
+<!-- if:local -->
+
 Append a verdict block at the bottom of `.tracerkit/plans/<slug>.md`:
 
+<!-- end:local -->
+<!-- if:github -->
+
+Append a verdict block at the bottom of the plan issue body by editing the issue:
+
+<!-- end:github -->
+
 ```markdown
 ---
 
@@ -129,21 +177,25 @@ If a previous verdict block exists, replace it with the new one.
 
 ### 7. On `done` — archive
 
-If all checks pass and zero BLOCKERS, perform these steps in order:
+If all checks pass and zero BLOCKERS:
+
+<!-- if:local -->
+
+Archive to `.tracerkit/archives/<slug>/`:
+
+1. Copy PRD → `prd.md` (set `status: done`, add `completed` timestamp in frontmatter)
+2. Copy plan → `plan.md` (append `## Archived` with date)
+3. Delete originals
 
-1. Create directory `.tracerkit/archives/<slug>/`
-2. If `.tracerkit/prds/<slug>.md` exists:
-   - Read the PRD file
-   - In the YAML frontmatter (between `---` fences), find the `status:` line and replace its value with `done`. If no `status:` line exists, add `status: done` as a new line inside the frontmatter block.
-   - Add a `completed: <current UTC ISO 8601 timestamp>` line inside the frontmatter block (e.g. `completed: 2025-06-15T14:30:00Z`)
-   - Write the updated content to `.tracerkit/archives/<slug>/prd.md`
-3. Read `.tracerkit/plans/<slug>.md`
-   - Append to the end: `\n## Archived\n\nArchived on YYYY-MM-DD.\n`
-   - Write the result to `.tracerkit/archives/<slug>/plan.md`
-4. Delete `.tracerkit/prds/<slug>.md` (if it exists)
-5. Delete `.tracerkit/plans/<slug>.md`
+<!-- end:local -->
+<!-- if:github -->
 
-Tell the user: archived to `.tracerkit/archives/<slug>/`, one-line summary of the feature.
+1. PRD issue: add `tk:done`, remove `tk:in-progress`, set metadata `status: done` + `completed` timestamp
+2. Close PRD issue (reason: `completed`)
+3. Close plan issue (reason: `completed`)
+4. If current PR exists, reference it in closing comment on PRD issue
+
+<!-- end:github -->
 
 ### 8. On `in_progress` (no blockers)
 
@@ -159,10 +211,3 @@ List the blockers to fix, then re-run `/tk:check <slug>`.
 - The only file writes this skill makes are: checkboxes + verdict block in the plan, and the archive steps on `done`
 - Never modify implementation code — only observe and report
 - If the PRD file is missing but all checks pass, warn and proceed — archive the plan only (skip PRD steps in archive)
-
-## Error Handling
-
-- Plan not found — list available plans and ask
-- PRD referenced in plan not found — warn and continue with plan checks only
-- `.tracerkit/plans/` missing — tell user to run `/tk:plan` first
-- `.tracerkit/archives/<slug>/` already exists — warn and ask whether to remove it first

package/skills/plan/SKILL.md

@@ -1,41 +1,76 @@
 ---
-description: Turn a PRD into a multi-phase implementation plan using tracer-bullet vertical slices, saved to .tracerkit/plans/. Use after /tk:prd.
+description: Turn a PRD into a multi-phase implementation plan using tracer-bullet vertical slices. Use after /tk:prd.
 argument-hint: '[slug]'
 ---
 
+**Config**: read `.tracerkit/config.json` (default: `local`). Follow matching `<!-- if:local/github -->` blocks. GitHub: use `github.repo` from config or git remote.
+
 # PRD to Plan
 
-Break a PRD into phased vertical slices (tracer bullets). Output: `.tracerkit/plans/<slug>.md`.
+Break a PRD into phased vertical slices (tracer bullets).
+
+<!-- if:local -->
+
+Output: `.tracerkit/plans/<slug>.md`.
+
+<!-- end:local -->
+<!-- if:github -->
+
+Output: a GitHub Issue with label `{{github.labels.plan}}`.
+
+<!-- end:github -->
 
 ## Pre-loaded context
 
+<!-- if:local -->
+
 - Available PRDs: !`ls .tracerkit/prds/ 2>&1`
+  <!-- end:local -->
+  <!-- if:github -->
+- Available PRDs: list open GitHub Issues with label `{{github.labels.prd}}`
+<!-- end:github -->
 
 ## Input
 
 The argument (if provided) is: $ARGUMENTS
 
-Use the argument as `<slug>` if given. If no argument is provided, list available PRDs and ask which one to plan.
+Use argument as `<slug>`. If empty, list available PRDs and ask.
 
 ## Workflow
 
 ### 1. Read the PRD
 
-Read `.tracerkit/prds/<slug>.md`. If it does not exist, list available PRDs and ask.
+<!-- if:local -->
+
+Read `.tracerkit/prds/<slug>.md`. If missing, list PRDs and ask. If `.tracerkit/plans/<slug>.md` exists, ask: overwrite or new name?
 
-If `.tracerkit/plans/<slug>.md` already exists, tell the user and ask whether to overwrite or pick a new name.
+<!-- end:local -->
+<!-- if:github -->
+
+Find PRD issue: open issue with label `{{github.labels.prd}}`, title matching `[{{github.labels.prd}}] <slug>:`. If missing, list PRDs and ask. If plan issue with label `{{github.labels.plan}}` and matching title exists, ask: update or new name?
+
+<!-- end:github -->
 
 ### 1b. Update PRD status
 
-Update the YAML frontmatter in `.tracerkit/prds/<slug>.md` to `status: in_progress`. Change only the `status` field — do not touch any other frontmatter fields or the markdown content below the closing `---`.
+<!-- if:local -->
+
+Set `status: in_progress` in `.tracerkit/prds/<slug>.md` frontmatter. Change only `status`.
+
+<!-- end:local -->
+<!-- if:github -->
 
-If the PRD has no frontmatter, skip this step silently.
+Update the PRD issue:
+
+- Remove `tk:created` label, add `tk:in-progress` label
+- Update the `<!-- tk:metadata -->` comment in the issue body to `status: in_progress`
+<!-- end:github -->
 
 ### 2. Explore the codebase
 
-Understand current architecture, existing patterns, and integration points. If you already have codebase context from a prior step in this conversation (e.g., you just ran `/tk:prd`), skip the exploration and note which context you're reusing.
+Map architecture, patterns, integration points. Skip if codebase context exists from prior step.
 
-**Research protocol**: codebase first, then project docs. If you cannot verify a technical claim from these sources, flag it as uncertain — never fabricate.
+**Research protocol**: codebase first, then docs. Unverifiable claims → flag as uncertain, never fabricate.
 
 ### 3. Identify durable architectural decisions
 
@@ -49,7 +84,7 @@ Before slicing, extract decisions that hold across all phases:
 
 ### 4. Draft vertical slices
 
-Each phase is a thin **tracer bullet** — a narrow but complete path through every integration layer (schema, service, API, UI, tests). A completed phase is demoable on its own.
+Each phase: thin vertical slice through all layers (schema → service → API → UI → tests). Demoable alone.
 
 **Deriving tasks from the PRD:**
 
@@ -67,9 +102,9 @@ Each phase is a thin **tracer bullet** — a narrow but complete path through ev
 
 **Phase naming:** use a goal phrase answering "what can we demo when this is done?" (e.g., "Phase 1 — Revenue visible end-to-end"), not a layer name.
 
-**Done when:** write as a checkbox list of atomic, verifiable conditions — not prose. Each item must pass this test: _"Can an agent verify this by reading files, running a command, or checking a test result — with no subjective judgment?"_ Bad: "API is clean". Good: "`GET /api/revenue` returns `{ total: number }`". The agent marks `[x]` during implementation to track progress.
+**Done when:** checkbox list of atomic, verifiable conditions (not prose). Test: "Can an agent verify by reading files, running a command, or checking a test?" Agent marks `[x]` during implementation.
 
-**When to use layer-by-layer instead:** If the PRD has complex schema changes that all modules depend on and no single user story can stand alone without the full schema, build the data foundation first, then slice the rest vertically.
+**Layer-by-layer exception:** if complex schema changes underpin all modules and no story stands alone, build data foundation first, then slice vertically.
 
 **Phase count thresholds:**
 
@@ -87,23 +122,43 @@ Assign an agent tag to tasks where appropriate:
 
 ### 5. Quiz the user
 
-Present the breakdown. For each phase show:
-
-- **Title**: short goal phrase
-- **User stories covered**: which PRD stories this addresses
-- **Done when**: the testable condition
-
-Ask: Does the granularity feel right? Should any phases merge or split? Iterate until approved.
+Present breakdown (title, user stories covered, done-when per phase). Ask: granularity right? Merge or split? Iterate until approved.
 
 ### 6. Save plan
 
-Save to `.tracerkit/plans/<slug>.md` (create `.tracerkit/plans/` if missing).
+<!-- if:local -->
+
+Save to `.tracerkit/plans/<slug>.md` (create dir if missing).
 
 ```markdown
 # Plan: <Feature Name>
 
 > Source PRD: `.tracerkit/prds/<slug>.md`
+```
+
+<!-- end:local -->
+<!-- if:github -->
+
+Ensure labels exist: `{{github.labels.plan}}`, `tk:in-progress` (create if missing).
+
+Create GitHub Issue — title: `[{{github.labels.plan}}] <slug>: Plan: <Feature Title>`, labels: `{{github.labels.plan}}`, `tk:in-progress`.
+
+```markdown
+<!-- tk:metadata
+source_prd: #<PRD issue number>
+slug: <slug>
+-->
+
+# Plan: <Feature Name>
 
+> Source PRD: #<PRD issue number>
+```
+
+<!-- end:github -->
+
+Use this structure for the plan body:
+
+```markdown
 ## Architectural Decisions
 
 Durable decisions that apply across all phases:
@@ -138,7 +193,7 @@ Carried forward from PRD verbatim.
 Gaps found in the PRD needing resolution. Blank if none.
 ```
 
-Print saved path and one line per phase: `Phase N — <title> (<condition summary>)`. Then ask: "Run `/tk:check <slug>` when ready?"
+Print one line per phase: `Phase N — <title> (<condition summary>)`. Then ask: "Run `/tk:check <slug>` when ready?"
 
 ## Rules
 
@@ -146,11 +201,10 @@ Print saved path and one line per phase: `Phase N — <title> (<condition summar
 - Each phase must be demoable end-to-end on its own
 - "Done when" must be a checkbox list of testable conditions, not prose
 - **Safety valve**: if a phase has >5 "Done when" items, stop and split it into smaller phases before continuing
+<!-- if:local -->
 - Never modify the source PRD content — only update frontmatter status fields
+  <!-- end:local -->
+  <!-- if:github -->
+- Never modify the source PRD content — only update metadata and labels
+<!-- end:github -->
 - Carry PRD's Out of Scope forward verbatim
-
-## Error Handling
-
-- PRD not found — list available PRDs and ask
-- PRD missing sections — note gaps inline and continue
-- `.tracerkit/plans/` missing — create it

package/skills/prd/SKILL.md

@@ -1,23 +1,29 @@
 ---
-description: Create a PRD through user interview, codebase exploration, and module design, saved to .tracerkit/prds/. Use when starting a new feature or change.
+description: Create a PRD through user interview, codebase exploration, and module design. Use when starting a new feature or change.
 argument-hint: <idea>
 ---
 
+**Config**: read `.tracerkit/config.json` (default: `local`). Follow matching `<!-- if:local/github -->` blocks. GitHub: use `github.repo` from config or git remote.
+
 # PRD Writing
 
-Skip steps already satisfied. If user provided a description via arguments, skip to Step 2.
+Skip satisfied steps. If argument provided, skip to Step 2.
 
 ## Pre-loaded context
 
+<!-- if:local -->
+
 - Existing PRDs: !`ls .tracerkit/prds/ 2>&1`
+  <!-- end:local -->
+  <!-- if:github -->
+- Existing PRDs: list open GitHub Issues with label `{{github.labels.prd}}`
+<!-- end:github -->
 
 ## Input
 
 The argument is: $ARGUMENTS
 
-If the argument is empty, go straight to Step 1 (gather problem description). After gathering the idea, derive the slug from the idea.
-
-If the argument is provided, derive a slug using this exact algorithm:
+If empty, go to Step 1; derive slug after gathering the idea. If provided, derive slug:
 
 1. Take only the text before the first `—` or `–` (if present)
 2. Lowercase the text
@@ -25,9 +31,16 @@ If the argument is provided, derive a slug using this exact algorithm:
 4. Take the first 4 remaining words (or fewer if less exist)
 5. Join with hyphens → `<slug>`
 
-The output file is `.tracerkit/prds/<slug>.md`.
+<!-- if:local -->
+
+Output: `.tracerkit/prds/<slug>.md`. If exists, ask: overwrite or new name?
+
+<!-- end:local -->
+<!-- if:github -->
+
+Output: GitHub Issue with label `{{github.labels.prd}}`, title `[{{github.labels.prd}}] <slug>: <Feature Title>`. If matching issue exists, ask: update or new slug?
 
-If `.tracerkit/prds/<slug>.md` already exists, tell the user and ask whether to overwrite or pick a new name.
+<!-- end:github -->
 
 ## Workflow
 
@@ -37,129 +50,86 @@ Ask the user for a detailed description of the problem and any solution ideas.
 
 ### 2. Explore codebase
 
-Verify assertions and map current state: data models, services, API routes, frontend structure, and test patterns. Note what exists vs. what must be built.
+Map current state: data models, services, API routes, frontend, tests. Note exists vs. must build.
 
-**Research protocol**: codebase first, then project docs. If you cannot verify a technical claim from these sources, flag it as uncertain — never fabricate.
+**Research protocol**: codebase first, then docs. Unverifiable claims → flag as uncertain, never fabricate.
 
 ### 3. Interview
 
-Interview relentlessly, one question at a time. Lead with your recommended answer; let the user confirm or correct. If a question can be answered by exploring code, explore instead of asking. For terse answers, offer concrete options (A/B/C).
-
-Walk these branches. **Skip rule**: skip a branch when the project type makes it irrelevant (e.g., skip Display/Access/Navigation for CLIs and libraries) AND the user's idea does not mention it.
-
-- **Scope & Surface** — Where does this live? New page/view or integrated? Which user roles? _Skip if_: single-surface project (CLI, library) with no new entry points.
-- **Data & Concepts** — Precise definitions for each new concept. What data exists, what's missing? _Never skip_ — every feature has data.
-- **Behavior & Interaction** — How does the user interact? Sorting, filtering, search, time ranges? _Skip if_: feature is purely internal/backend with no user-facing behavior change.
-- **Display & Output** — Numbers, tables, charts, forms? Exportable? URL-driven state? _Skip if_: no UI or formatted output involved.
-- **Access & Privacy** — Who sees what? Role-based restrictions? Sensitive data concerns? _Skip if_: single-user project with no auth layer.
-- **Boundaries** — What is explicitly out of scope? Adjacent features to defer? _Never skip_ — scope control prevents creep.
-- **Integration** — Schema changes? New or extended services? External dependencies? _Skip if_: self-contained change touching no external systems or storage.
-
-### 3b. Gray area checkpoint
-
-Before continuing, scan the interview for gray areas. Something is a gray area if any of these are true:
-
-- **Vague answer**: user said "maybe", "probably", "I think", or gave a one-word answer to a multi-part question
-- **Contradiction**: two answers conflict (e.g., "no auth needed" but "only admins can access")
-- **Unstated assumption**: you filled in a detail the user never confirmed
-- **Ambiguous scope**: a feature boundary is unclear (could be in or out of scope)
+One question at a time. Lead with your recommended answer. Explore code instead of asking when possible. Offer A/B/C for terse answers.
 
-Present as a numbered list:
+| Branch           | Key questions                           | Skip when                        |
+| ---------------- | --------------------------------------- | -------------------------------- |
+| Scope & Surface  | Where? New page or integrated? Roles?   | CLI/library, no new entry points |
+| Data & Concepts  | Definitions, existing vs missing data   | Never skip                       |
+| Behavior         | Interaction patterns, filtering, search | No user-facing behavior          |
+| Display          | Numbers, tables, charts, exports        | No UI                            |
+| Access & Privacy | Who sees what? Sensitive data?          | Single-user, no auth             |
+| Boundaries       | Out of scope, deferred features         | Never skip                       |
+| Integration      | Schema, services, external deps         | Self-contained change            |
 
-```
-Gray areas found:
-1. <ambiguity> — assumed <X>, confirm?
-2. <ambiguity> — two options: A or B
-```
+### 3b. Gray areas
 
-If the list is empty, say "No gray areas found" and move on. Otherwise, resolve each item with the user before proceeding.
+Surface ambiguities, contradictions, unstated assumptions. Present numbered list. Resolve all before continuing.
 
 ### 4. Design modules
 
-Sketch major modules to build or modify. Favor **deep modules** — a simple interface (1–3 entry points) hiding a large implementation that rarely changes, over shallow modules where the interface is nearly as complex as the implementation.
+Sketch modules. Favor **deep modules** — simple interface (1-3 entry points) hiding large implementation over shallow modules where interface ≈ implementation.
 
-Signals of shallow design: many small functions with 1:1 query mapping, callers compose multiple calls, adding a feature requires changing the interface.
+Shallow signals: many small 1:1 functions, callers compose multiple calls, feature changes require interface changes.
 
-Present modules to user. Confirm which need tests.
+Present modules. Confirm which need tests.
 
 ### 5. Write PRD
 
-Save to `.tracerkit/prds/<slug>.md` (create `.tracerkit/prds/` if missing).
+<!-- if:local -->
+
+Save to `.tracerkit/prds/<slug>.md` (create dir if missing).
 
 ```markdown
 ---
-created: <current UTC timestamp, ISO 8601, e.g. 2025-06-15T14:30:00Z>
+created: <UTC ISO 8601>
 status: created
 ---
 
 # Feature Name
+```
 
-## Problem Statement
-
-The problem from the user's perspective. Focus on pain and impact.
-
-## Current State
-
-What exists today that this feature changes or builds on. Skip for greenfield.
+<!-- end:local -->
+<!-- if:github -->
 
-- Relevant modules, services, or UI surfaces already in place
-- Current behavior the user experiences
-- Known limitations or workarounds
+Ensure labels exist: `{{github.labels.prd}}`, `tk:created` (create if missing).
 
-## Solution
+Create GitHub Issue — title: `[{{github.labels.prd}}] <slug>: <Feature Title>`, labels: `{{github.labels.prd}}`, `tk:created`.
 
-The solution from the user's perspective. Describe the experience, not the architecture.
+```markdown
+<!-- tk:metadata
+created: <UTC ISO 8601>
+status: created
+-->
 
-## User Stories
+# Feature Name
+```
 
-Long numbered list. Cover happy path, edge cases, error states.
+<!-- end:github -->
 
-1. As a <actor>, I want <feature>, so that <benefit>
+PRD body structure (same for local file and issue body). Omit empty sections. No file paths or code snippets.
 
+```
+## Problem Statement
+## Current State (skip if greenfield)
+## Solution (user experience, not architecture)
+## User Stories (numbered, cover happy + edge + error)
 ## Implementation Decisions
-
-### New Modules
-
-- Module name, purpose, and public interface (function signatures with param types)
-- Why each module exists as a separate unit
-
-### Architectural Decisions
-
-- Key definitions (precise meaning of domain terms)
-- Data flow from storage to display
-- State management approach
-
+### New Modules (name, purpose, interface signatures)
+### Architectural Decisions (definitions, data flow, state)
 ### Schema Changes
-
-- New tables/columns needed, or "None required"
-
 ### API Contracts
-
-- New routes, request/response shapes
-
 ### Navigation
-
-- Where the feature is accessed, new routes added
-
-Do NOT include file paths or code snippets — they go stale.
-
-Omit any section whose content would be "None required" — only include sections with actual content.
-
-## Testing Decisions
-
-- What makes a good test (behavior, not implementation)
-- Which modules need tests
-- Key test cases (empty state, boundaries, isolation)
-- Prior art: similar test patterns in the codebase
-
-## Out of Scope
-
-Explicit list. Be specific — vague exclusions invite scope creep.
+## Testing Decisions (behavior tests, key cases, prior art)
+## Out of Scope (be specific)
 ```
 
-Tell the user: file created, one-line summary. Then ask: "Run `/tk:plan <slug>` next?"
-
-## Error Handling
+---
 
-- `.tracerkit/prds/` missing — create it
-- Scope larger than expected — surface and re-scope with user before continuing
+Then ask: "Run `/tk:plan <slug>` next?"

package/dist/uninstall-BhTMOfMb.js

@@ -1,153 +0,0 @@
-import { existsSync as e, mkdirSync as t, readFileSync as n, readdirSync as r, rmSync as i, writeFileSync as a } from "node:fs";
-import { dirname as o, join as s } from "node:path";
-import { createHash as c } from "node:crypto";
-import { fileURLToPath as l } from "node:url";
-//#region src/config.ts
-var u = {
-	prds: ".tracerkit/prds",
-	plans: ".tracerkit/plans",
-	archives: ".tracerkit/archives"
-};
-function d(t) {
-	let r = s(t, ".tracerkit", "config.json");
-	if (!e(r)) return { paths: { ...u } };
-	let i, a;
-	try {
-		i = n(r, "utf8"), a = JSON.parse(i);
-	} catch {
-		throw Error("Invalid .tracerkit/config.json — expected valid JSON");
-	}
-	let o = typeof a.paths == "object" && a.paths !== null ? a.paths : {};
-	return { paths: {
-		prds: typeof o.prds == "string" ? o.prds : u.prds,
-		plans: typeof o.plans == "string" ? o.plans : u.plans,
-		archives: typeof o.archives == "string" ? o.archives : u.archives
-	} };
-}
-var f = [
-	"tk:brief",
-	"tk:prd",
-	"tk:plan",
-	"tk:check"
-], p = ["tk:verify"], m = {
-	force: "--force",
-	help: "--help",
-	version: "--version"
-}, h = [
-	"brief",
-	"progress",
-	"archive"
-], g = [
-	{
-		name: "init",
-		args: "[path]",
-		desc: "Install skills to ~/.claude/skills/ (or [path] if given)"
-	},
-	{
-		name: "update",
-		args: "[path]",
-		desc: "Refresh unchanged files from latest version, skip modified"
-	},
-	{
-		name: "uninstall",
-		args: "[path]",
-		desc: "Remove TracerKit skill directories, keep .tracerkit/ artifacts"
-	}
-], _ = s(o(l(import.meta.url)), "..", "skills");
-function v(e, t = "") {
-	let n = r(e, { withFileTypes: !0 }), i = [];
-	for (let r of n) {
-		let n = t ? `${t}/${r.name}` : r.name;
-		r.isDirectory() ? i.push(...v(s(e, r.name), n)) : i.push(n);
-	}
-	return i.sort();
-}
-function y(e) {
-	return `.claude/skills/tk:${e}`;
-}
-function b(e) {
-	return e.slice(18);
-}
-function x(e, t) {
-	let n = e;
-	return t.paths.prds !== u.prds && (n = n.replaceAll(u.prds, t.paths.prds)), t.paths.plans !== u.plans && (n = n.replaceAll(u.plans, t.paths.plans)), t.paths.archives !== u.archives && (n = n.replaceAll(u.archives, t.paths.archives)), n;
-}
-function S(e, r, i) {
-	let c = i ?? v(_).map(y);
-	for (let i of c) {
-		let c = s(_, b(i)), l = s(e, i);
-		t(o(l), { recursive: !0 }), a(l, x(n(c, "utf8"), r));
-	}
-	return { copied: c };
-}
-function C(e) {
-	return c("sha256").update(e).digest("hex");
-}
-function w(t, r) {
-	let i = v(_).map(y), a = [], o = [], c = [];
-	for (let l of i) {
-		let i = s(t, l);
-		if (!e(i)) c.push(l);
-		else {
-			let e = x(n(s(_, b(l)), "utf8"), r);
-			C(Buffer.from(e)) === C(n(i)) ? a.push(l) : o.push(l);
-		}
-	}
-	return {
-		unchanged: a,
-		modified: o,
-		missing: c
-	};
-}
-//#endregion
-//#region src/commands/update.ts
-function T(t, n) {
-	if (!f.some((n) => e(s(t, ".claude", "skills", n)))) throw Error("TracerKit not initialized — run `tracerkit init` first");
-	let r = d(t), { unchanged: a, modified: o, missing: c } = w(t, r), l = [];
-	for (let n of p) {
-		let r = s(t, ".claude", "skills", n);
-		e(r) && (i(r, {
-			recursive: !0,
-			force: !0
-		}), l.push(`✗ .claude/skills/${n}/ removed (deprecated)`));
-	}
-	let u = n?.force ?? !1, m = [
-		...a,
-		...c,
-		...u ? o : []
-	];
-	if (m.length > 0) {
-		S(t, r, m);
-		for (let e of a) l.push(`✓ ${e}`);
-		for (let e of c) l.push(`✓ ${e} (added)`);
-		if (u) for (let e of o) l.push(`✓ ${e} (replaced)`);
-	}
-	if (!u && o.length > 0) {
-		for (let e of o) l.push(`⚠ ${e} (skipped — modified)`);
-		l.push("", "Run `tracerkit update --force` to replace modified files with latest versions.");
-	}
-	return l;
-}
-//#endregion
-//#region src/commands/init.ts
-function E(t) {
-	if (f.some((n) => e(s(t, ".claude", "skills", n)))) return T(t);
-	let { copied: n } = S(t, d(t));
-	return n.map((e) => `✓ ${e}`);
-}
-//#endregion
-//#region src/commands/uninstall.ts
-function D(t) {
-	if (!f.some((n) => e(s(t, ".claude", "skills", n)))) throw Error("TracerKit not initialized — nothing to uninstall");
-	let n = [];
-	for (let r of f) {
-		let a = s(t, ".claude", "skills", r);
-		e(a) && (i(a, {
-			recursive: !0,
-			force: !0
-		}), n.push(`✗ .claude/skills/${r}/ removed`));
-	}
-	return n;
-}
-//#endregion
-export { h as a, f as c, g as i, E as n, p as o, T as r, m as s, D as t };