claude-alfred 0.3.6 → 0.3.8

package/dist/{audit-g6phLGMg.mjs → audit-BoZ1ny8J.mjs}

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { u as rootDir } from "./types-DFsKNXVY.mjs";
+import { n as __esmMin } from "./chunk-CAm0Jl7e.mjs";
+import { d as rootDir, o as init_types } from "./types-BBT-j5-a.mjs";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 //#region src/spec/audit.ts
@@ -14,5 +15,8 @@ function appendAudit(projectPath, entry) {
 		appendFileSync(join(dir, "audit.jsonl"), `${line}\n`);
 	} catch {}
 }
+var init_audit = __esmMin((() => {
+	init_types();
+}));
 //#endregion
-export { appendAudit as t };
+export { init_audit as n, appendAudit as t };

package/dist/chunk-CAm0Jl7e.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+export { __toCommonJS as a, __require as i, __esmMin as n, __toESM as o, __exportAll as r, __commonJSMin as t };

package/dist/cli.mjs

@@ -369,9 +369,9 @@ const main = defineCommand({
 		serve: defineCommand({
 			meta: { description: "Start MCP server (stdio)" },
 			async run() {
-				const { Store } = await import("./store-D4fokoGA.mjs");
-				const { Embedder } = await import("./embedder-CFkDPOku.mjs");
-				const { serveMCP } = await import("./server-uRcvcepv.mjs");
+				const { Store } = await import("./store-8O9WUwMu.mjs").then((n) => (n.t(), n.r));
+				const { Embedder } = await import("./embedder-D3hJoryD.mjs");
+				const { serveMCP } = await import("./server-BheF_pZr.mjs");
 				const store = Store.openDefault();
 				let emb = null;
 				try {
@@ -397,9 +397,9 @@ const main = defineCommand({
 				}
 			},
 			async run({ args }) {
-				const { Store } = await import("./store-D4fokoGA.mjs");
-				const { Embedder } = await import("./embedder-CFkDPOku.mjs");
-				const { startDashboard } = await import("./server-CwcGoHSS.mjs");
+				const { Store } = await import("./store-8O9WUwMu.mjs").then((n) => (n.t(), n.r));
+				const { Embedder } = await import("./embedder-D3hJoryD.mjs");
+				const { startDashboard } = await import("./server-B7dI3oXY.mjs");
 				const projectPath = process.cwd();
 				const store = Store.openDefault();
 				let emb = null;
@@ -422,7 +422,7 @@ const main = defineCommand({
 				description: "Event name"
 			} },
 			async run({ args }) {
-				const { runHook } = await import("./dispatcher-BWa-6qtR.mjs").then((n) => n.t);
+				const { runHook } = await import("./dispatcher-BjpWdTBs.mjs").then((n) => (n.i(), n.t));
 				await runHook(args.event);
 			}
 		}),

package/dist/{helpers-CvI9bVCq.mjs → directives-DjcVEEC8.mjs}

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { c as incrementHitCount, d as searchKnowledgeKeyword, i as getKnowledgeByIDs } from "./knowledge-BgWoLpv7.mjs";
-import { r as vectorSearchKnowledge } from "./vectors-DtWMZUgk.mjs";
-import { i as subTypeHalfLife, n as searchKnowledgeFTS, r as subTypeBoost } from "./fts-Buk8fkl1.mjs";
+import { n as __esmMin } from "./chunk-CAm0Jl7e.mjs";
+import { c as incrementHitCount, f as searchKnowledgeKeyword, i as getKnowledgeByIDs, l as init_knowledge } from "./knowledge-C7rEfFSX.mjs";
+import { i as vectorSearchKnowledge, r as init_vectors } from "./vectors-C3yIO_A5.mjs";
+import { a as subTypeHalfLife, i as subTypeBoost, n as init_fts, r as searchKnowledgeFTS } from "./fts-DUZkPJPD.mjs";
+import { i as init_dispatcher, n as emitAdditionalContext } from "./dispatcher-BjpWdTBs.mjs";
 //#region src/mcp/helpers.ts
-const RECENCY_FLOOR = .5;
 function truncate(s, maxLen) {
 	const runes = [...s];
 	if (runes.length <= maxLen) return s;
@@ -93,5 +94,70 @@ function trackHitCounts(store, scoredDocs) {
 	if (scoredDocs.length === 0) return;
 	incrementHitCount(store, scoredDocs.filter((sd) => sd.doc.id > 0).map((sd) => sd.doc.id));
 }
+var RECENCY_FLOOR;
+var init_helpers = __esmMin((() => {
+	init_fts();
+	init_knowledge();
+	init_vectors();
+	RECENCY_FLOOR = .5;
+}));
 //#endregion
-export { trackHitCounts as n, truncate as r, searchPipeline as t };
+//#region src/hooks/directives.ts
+/**
+* Build a single additionalContext string from directive items.
+* Order: DIRECTIVE → WARNING → CONTEXT.
+* Max 3 DIRECTIVE items (NFR-5). Excess DIRECTIVEs downgraded to WARNING.
+*/
+function buildDirectiveOutput(items) {
+	if (items.length === 0) return "";
+	let directiveCount = 0;
+	return items.map((item) => {
+		if (item.level === "DIRECTIVE") {
+			directiveCount++;
+			if (directiveCount > MAX_DIRECTIVES) return {
+				level: "WARNING",
+				message: item.message
+			};
+		}
+		return item;
+	}).slice().sort((a, b) => LEVEL_ORDER[a.level] - LEVEL_ORDER[b.level]).map((item) => {
+		let block = `[${item.level}] ${item.message}`;
+		if (item.level === "DIRECTIVE") {
+			const rats = (item.rationalizations ?? []).slice();
+			const suffix = item.spiritVsLetter ? `\n${SPIRIT_VS_LETTER}` : "";
+			while (rats.length > 0) {
+				if (`${block}\n${rats.map((r) => `- ${r}`).join("\n")}${suffix}`.length <= MAX_DIRECTIVE_BLOCK_CHARS) break;
+				rats.pop();
+			}
+			if (rats.length > 0) block += `\n${rats.map((r) => `- ${r}`).join("\n")}`;
+			block += suffix;
+			if (block.length > MAX_DIRECTIVE_BLOCK_CHARS) {
+				const messageOnly = `[${item.level}] ${item.message}`;
+				if (messageOnly.length > MAX_DIRECTIVE_BLOCK_CHARS) block = `${messageOnly.slice(0, MAX_DIRECTIVE_BLOCK_CHARS - 3)}...`;
+				else block = messageOnly;
+			}
+		}
+		return block;
+	}).join("\n");
+}
+/**
+* Emit directives via single emitAdditionalContext call (NFR-4).
+*/
+function emitDirectives(eventName, items) {
+	const output = buildDirectiveOutput(items);
+	if (output) emitAdditionalContext(eventName, output);
+}
+var LEVEL_ORDER, MAX_DIRECTIVES, MAX_DIRECTIVE_BLOCK_CHARS, SPIRIT_VS_LETTER;
+var init_directives = __esmMin((() => {
+	init_dispatcher();
+	LEVEL_ORDER = {
+		DIRECTIVE: 0,
+		WARNING: 1,
+		CONTEXT: 2
+	};
+	MAX_DIRECTIVES = 3;
+	MAX_DIRECTIVE_BLOCK_CHARS = 500;
+	SPIRIT_VS_LETTER = "Adapting or shortcutting these steps violates the rule, even if you believe the spirit is preserved.";
+}));
+//#endregion
+export { trackHitCounts as a, searchPipeline as i, init_directives as n, truncate as o, init_helpers as r, emitDirectives as t };

package/dist/{dispatcher-BWa-6qtR.mjs → dispatcher-BjpWdTBs.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { g as __exportAll } from "./types-DFsKNXVY.mjs";
+import { n as __esmMin, r as __exportAll } from "./chunk-CAm0Jl7e.mjs";
 import { resolve } from "node:path";
 //#region src/hooks/dispatcher.ts
 var dispatcher_exports = /* @__PURE__ */ __exportAll({
@@ -89,28 +89,29 @@ async function runHook(event) {
 	}
 }
 async function handleSessionStart(ev, signal) {
-	const { sessionStart } = await import("./session-start-DEx6rrId.mjs");
+	const { sessionStart } = await import("./session-start-Bul0GicD.mjs");
 	await sessionStart(ev, signal);
 }
 async function handlePreCompact(ev, signal) {
-	const { preCompact } = await import("./pre-compact-Cuxb6ryB.mjs");
+	const { preCompact } = await import("./pre-compact-Cdjtld4A.mjs");
 	await preCompact(ev, signal);
 }
 async function handleUserPromptSubmit(ev, signal) {
-	const { userPromptSubmit } = await import("./user-prompt-CsCJ1CKL.mjs");
+	const { userPromptSubmit } = await import("./user-prompt-Bzfgl80c.mjs");
 	await userPromptSubmit(ev, signal);
 }
 async function handlePostToolUse(ev, signal) {
-	const { postToolUse } = await import("./post-tool-wXy5oNCh.mjs");
+	const { postToolUse } = await import("./post-tool-CfnMwY6j.mjs");
 	await postToolUse(ev, signal);
 }
 async function handlePreToolUse(ev, _signal) {
-	const { preToolUse } = await import("./pre-tool-DdZortZJ.mjs");
+	const { preToolUse } = await import("./pre-tool-KpwIhe2F.mjs");
 	await preToolUse(ev);
 }
 async function handleStop(ev, _signal) {
-	const { stop } = await import("./stop-BIwkuqHf.mjs");
+	const { stop } = await import("./stop-BQzq19WO.mjs");
 	await stop(ev);
 }
+var init_dispatcher = __esmMin((() => {}));
 //#endregion
-export { notifyUser as i, emitAdditionalContext as n, extractSection as r, dispatcher_exports as t };
+export { notifyUser as a, init_dispatcher as i, emitAdditionalContext as n, extractSection as r, dispatcher_exports as t };

package/dist/embedder-D3hJoryD.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+import { n as __esmMin } from "./chunk-CAm0Jl7e.mjs";
+//#region src/embedder/voyage.ts
+function envOr(key, fallback) {
+	return process.env[key] || fallback;
+}
+function envIntOr(key, fallback) {
+	const v = process.env[key];
+	if (v) {
+		const n = parseInt(v, 10);
+		if (!Number.isNaN(n) && n > 0) return n;
+	}
+	return fallback;
+}
+function isVoyageTransient(detail) {
+	const lower = detail.toLowerCase();
+	return TRANSIENT_MESSAGE_PATTERNS.some((p) => lower.includes(p));
+}
+function isVoyageTransientStructured(errResp) {
+	if (!errResp) return false;
+	if (errResp.type && TRANSIENT_ERROR_TYPES.has(errResp.type.toLowerCase())) return true;
+	if (errResp.code && TRANSIENT_ERROR_TYPES.has(errResp.code.toLowerCase())) return true;
+	return false;
+}
+async function retryVoyage(fn, signal) {
+	let lastErr;
+	for (let attempt = 0; attempt < 3; attempt++) {
+		if (attempt > 0) {
+			const delay = (1 << attempt) * 1e3;
+			await new Promise((resolve, reject) => {
+				const onAbort = () => {
+					clearTimeout(timer);
+					reject(signal.reason);
+				};
+				const timer = setTimeout(() => {
+					signal?.removeEventListener("abort", onAbort);
+					resolve();
+				}, delay);
+				signal?.addEventListener("abort", onAbort, { once: true });
+			});
+		}
+		try {
+			return await fn();
+		} catch (err) {
+			lastErr = err;
+			if (err instanceof VoyageError) {
+				if (err.status === 429 || err.status >= 500) continue;
+				if (err.status === 400 && (isVoyageTransient(err.detail) || isVoyageTransientStructured(err.errResp))) continue;
+				throw err;
+			}
+		}
+	}
+	throw lastErr;
+}
+var DEFAULT_API_URL, DEFAULT_RERANK_URL, DEFAULT_MODEL, DEFAULT_RERANK_MODEL, DEFAULT_DIMS, VoyageError, TRANSIENT_ERROR_TYPES, TRANSIENT_MESSAGE_PATTERNS, VoyageClient;
+var init_voyage = __esmMin((() => {
+	DEFAULT_API_URL = "https://api.voyageai.com/v1/embeddings";
+	DEFAULT_RERANK_URL = "https://api.voyageai.com/v1/rerank";
+	DEFAULT_MODEL = "voyage-4-large";
+	DEFAULT_RERANK_MODEL = "rerank-2.5";
+	DEFAULT_DIMS = 2048;
+	VoyageError = class extends Error {
+		status;
+		detail;
+		raw;
+		errResp;
+		constructor(status, detail, raw, errResp) {
+			super(status === 401 || status === 403 ? `embedder: voyage returned ${status}: authentication failed (check VOYAGE_API_KEY)` : `embedder: voyage returned ${status}: ${detail}`);
+			this.status = status;
+			this.detail = detail;
+			this.raw = raw;
+			this.errResp = errResp;
+		}
+	};
+	TRANSIENT_ERROR_TYPES = new Set([
+		"temporary_error",
+		"transient_error",
+		"overloaded",
+		"rate_limited",
+		"capacity_exceeded",
+		"service_unavailable"
+	]);
+	TRANSIENT_MESSAGE_PATTERNS = [
+		"request to model",
+		"model is overloaded",
+		"temporarily",
+		"try again",
+		"service unavailable",
+		"internal server error",
+		"over capacity"
+	];
+	VoyageClient = class {
+		apiKey;
+		apiURL;
+		rerankURL;
+		model;
+		rerankModel;
+		dims;
+		constructor(apiKey) {
+			this.apiKey = apiKey;
+			this.apiURL = envOr("VOYAGE_API_URL", DEFAULT_API_URL);
+			this.rerankURL = envOr("VOYAGE_RERANK_API_URL", DEFAULT_RERANK_URL);
+			this.model = envOr("VOYAGE_MODEL", DEFAULT_MODEL);
+			this.rerankModel = envOr("VOYAGE_RERANK_MODEL", DEFAULT_RERANK_MODEL);
+			this.dims = envIntOr("VOYAGE_DIMS", DEFAULT_DIMS);
+		}
+		async embed(texts, inputType, signal) {
+			const payload = {
+				input: texts,
+				model: this.model,
+				input_type: inputType,
+				output_dimension: this.dims
+			};
+			return retryVoyage(() => this.doEmbed(payload, signal), signal);
+		}
+		async doEmbed(payload, signal) {
+			const resp = await fetch(this.apiURL, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${this.apiKey}`
+				},
+				body: JSON.stringify(payload),
+				signal: signal ?? AbortSignal.timeout(3e4)
+			});
+			if (!resp.ok) {
+				const raw = await resp.text().catch(() => "");
+				let errResp;
+				try {
+					const parsed = JSON.parse(raw);
+					if (parsed.detail) errResp = parsed;
+				} catch {}
+				throw new VoyageError(resp.status, errResp?.detail ?? raw, raw, errResp);
+			}
+			return (await resp.json()).data.map((d) => d.embedding);
+		}
+		async embedForSearch(query, signal) {
+			const vecs = await this.embed([query], "query", signal);
+			if (vecs.length === 0) throw new Error("embedder: no embeddings returned");
+			return vecs[0];
+		}
+		async embedForStorage(text, signal) {
+			const vecs = await this.embed([text], "document", signal);
+			if (vecs.length === 0) throw new Error("embedder: no embeddings returned");
+			return vecs[0];
+		}
+		async rerank(query, documents, topK, signal) {
+			const payload = {
+				query,
+				documents,
+				model: this.rerankModel,
+				top_k: topK,
+				return_documents: false
+			};
+			return retryVoyage(() => this.doRerank(payload, signal), signal);
+		}
+		async doRerank(payload, signal) {
+			const resp = await fetch(this.rerankURL, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${this.apiKey}`
+				},
+				body: JSON.stringify(payload),
+				signal: signal ?? AbortSignal.timeout(3e4)
+			});
+			if (!resp.ok) {
+				const raw = await resp.text().catch(() => "");
+				let errResp;
+				try {
+					const parsed = JSON.parse(raw);
+					if (parsed.detail) errResp = parsed;
+				} catch {}
+				throw new VoyageError(resp.status, errResp?.detail ?? raw, raw, errResp);
+			}
+			return (await resp.json()).data.map((d) => ({
+				index: d.index,
+				relevanceScore: d.relevance_score
+			}));
+		}
+	};
+}));
+//#endregion
+//#region src/embedder/index.ts
+var Embedder;
+var init_embedder = __esmMin((() => {
+	init_voyage();
+	Embedder = class Embedder {
+		client;
+		constructor(client) {
+			this.client = client;
+		}
+		static create() {
+			const apiKey = process.env.VOYAGE_API_KEY;
+			if (!apiKey) throw new Error("VOYAGE_API_KEY is required but not set (get a key at https://dash.voyageai.com/)");
+			return new Embedder(new VoyageClient(apiKey));
+		}
+		get dims() {
+			return this.client.dims;
+		}
+		get model() {
+			return this.client.model;
+		}
+		async embedForSearch(query, signal) {
+			return this.client.embedForSearch(query, signal);
+		}
+		async embedForStorage(text, signal) {
+			return this.client.embedForStorage(text, signal);
+		}
+		async embedBatchForStorage(texts, signal) {
+			return this.client.embed(texts, "document", signal);
+		}
+		async validate(signal) {
+			await this.client.embed(["test"], "query", signal);
+		}
+		async rerank(query, documents, topK, signal) {
+			return this.client.rerank(query, documents, topK, signal);
+		}
+	};
+}));
+//#endregion
+init_embedder();
+export { Embedder, init_embedder as t };

package/dist/{epic-D9ksT1k7.mjs → epic-s_BVNu2z.mjs}

@@ -1,84 +1,15 @@
 #!/usr/bin/env node
-import { m as require_dist, n as VALID_SLUG } from "./types-DFsKNXVY.mjs";
+import { n as __esmMin } from "./chunk-CAm0Jl7e.mjs";
+import { h as require_dist, n as VALID_SLUG, o as init_types } from "./types-BBT-j5-a.mjs";
 import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/epic/index.ts
-var import_dist = require_dist();
 function epicsDir(projectPath) {
 	return join(projectPath, ".alfred", "epics");
 }
 function epicActivePath(projectPath) {
 	return join(epicsDir(projectPath), "_active.yaml");
 }
-const STATUS_DRAFT = "draft";
-const STATUS_IN_PROGRESS = "in-progress";
-const STATUS_COMPLETED = "completed";
-const STATUS_NOT_STARTED = "not-started";
-var EpicDir = class {
-	projectPath;
-	slug;
-	constructor(projectPath, slug) {
-		this.projectPath = projectPath;
-		this.slug = slug;
-	}
-	dir() {
-		return join(epicsDir(this.projectPath), this.slug);
-	}
-	epicPath() {
-		return join(this.dir(), "epic.yaml");
-	}
-	exists() {
-		try {
-			return statSync(this.dir()).isDirectory();
-		} catch {
-			return false;
-		}
-	}
-	read() {
-		return (0, import_dist.parse)(readFileSync(this.epicPath(), "utf-8"));
-	}
-	save(ep) {
-		const data = (0, import_dist.stringify)(ep);
-		const tmp = `${this.epicPath()}.tmp`;
-		writeFileSync(tmp, data);
-		renameSync(tmp, this.epicPath());
-	}
-	link(taskSlug, dependsOn) {
-		const ep = this.read();
-		const tasks = ep.tasks ?? [];
-		if (tasks.some((t) => t.slug === taskSlug)) throw new Error(`task "${taskSlug}" already linked to epic "${this.slug}"`);
-		const taskSet = new Set(tasks.map((t) => t.slug));
-		for (const dep of dependsOn) if (!taskSet.has(dep)) throw new Error(`dependency "${dep}" not found in epic "${this.slug}"`);
-		tasks.push({
-			slug: taskSlug,
-			status: STATUS_NOT_STARTED,
-			depends_on: dependsOn.length > 0 ? dependsOn : void 0
-		});
-		ep.tasks = tasks;
-		if (ep.status === "draft") ep.status = STATUS_IN_PROGRESS;
-		this.save(ep);
-	}
-	unlink(taskSlug) {
-		const ep = this.read();
-		const tasks = ep.tasks ?? [];
-		const idx = tasks.findIndex((t) => t.slug === taskSlug);
-		if (idx === -1) throw new Error(`task "${taskSlug}" not linked to epic "${this.slug}"`);
-		tasks.splice(idx, 1);
-		for (const t of tasks) if (t.depends_on) {
-			t.depends_on = t.depends_on.filter((d) => d !== taskSlug);
-			if (t.depends_on.length === 0) t.depends_on = void 0;
-		}
-		ep.tasks = tasks;
-		this.save(ep);
-	}
-	progress() {
-		const tasks = this.read().tasks ?? [];
-		return {
-			completed: tasks.filter((t) => t.status === STATUS_COMPLETED).length,
-			total: tasks.length
-		};
-	}
-};
 function initEpic(projectPath, slug, name) {
 	if (!VALID_SLUG.test(slug)) throw new Error(`invalid epic_slug "${slug}": must be lowercase alphanumeric with hyphens`);
 	const ed = new EpicDir(projectPath, slug);
@@ -221,5 +152,79 @@ function writeActiveEpics(projectPath, state) {
 	writeFileSync(tmp, data);
 	renameSync(tmp, path);
 }
+var import_dist, STATUS_DRAFT, STATUS_IN_PROGRESS, STATUS_COMPLETED, STATUS_NOT_STARTED, EpicDir;
+var init_epic = __esmMin((() => {
+	import_dist = require_dist();
+	init_types();
+	STATUS_DRAFT = "draft";
+	STATUS_IN_PROGRESS = "in-progress";
+	STATUS_COMPLETED = "completed";
+	STATUS_NOT_STARTED = "not-started";
+	EpicDir = class {
+		projectPath;
+		slug;
+		constructor(projectPath, slug) {
+			this.projectPath = projectPath;
+			this.slug = slug;
+		}
+		dir() {
+			return join(epicsDir(this.projectPath), this.slug);
+		}
+		epicPath() {
+			return join(this.dir(), "epic.yaml");
+		}
+		exists() {
+			try {
+				return statSync(this.dir()).isDirectory();
+			} catch {
+				return false;
+			}
+		}
+		read() {
+			return (0, import_dist.parse)(readFileSync(this.epicPath(), "utf-8"));
+		}
+		save(ep) {
+			const data = (0, import_dist.stringify)(ep);
+			const tmp = `${this.epicPath()}.tmp`;
+			writeFileSync(tmp, data);
+			renameSync(tmp, this.epicPath());
+		}
+		link(taskSlug, dependsOn) {
+			const ep = this.read();
+			const tasks = ep.tasks ?? [];
+			if (tasks.some((t) => t.slug === taskSlug)) throw new Error(`task "${taskSlug}" already linked to epic "${this.slug}"`);
+			const taskSet = new Set(tasks.map((t) => t.slug));
+			for (const dep of dependsOn) if (!taskSet.has(dep)) throw new Error(`dependency "${dep}" not found in epic "${this.slug}"`);
+			tasks.push({
+				slug: taskSlug,
+				status: STATUS_NOT_STARTED,
+				depends_on: dependsOn.length > 0 ? dependsOn : void 0
+			});
+			ep.tasks = tasks;
+			if (ep.status === "draft") ep.status = STATUS_IN_PROGRESS;
+			this.save(ep);
+		}
+		unlink(taskSlug) {
+			const ep = this.read();
+			const tasks = ep.tasks ?? [];
+			const idx = tasks.findIndex((t) => t.slug === taskSlug);
+			if (idx === -1) throw new Error(`task "${taskSlug}" not linked to epic "${this.slug}"`);
+			tasks.splice(idx, 1);
+			for (const t of tasks) if (t.depends_on) {
+				t.depends_on = t.depends_on.filter((d) => d !== taskSlug);
+				if (t.depends_on.length === 0) t.depends_on = void 0;
+			}
+			ep.tasks = tasks;
+			this.save(ep);
+		}
+		progress() {
+			const tasks = this.read().tasks ?? [];
+			return {
+				completed: tasks.filter((t) => t.status === STATUS_COMPLETED).length,
+				total: tasks.length
+			};
+		}
+	};
+}));
 //#endregion
-export { removeEpic as a, unlinkTaskFromAllEpics as c, nextActionable as i, initEpic as n, syncTaskStatus as o, listAllEpics as r, topologicalOrder as s, EpicDir as t };
+export { nextActionable as a, topologicalOrder as c, listAllEpics as i, unlinkTaskFromAllEpics as l, initEpic as n, removeEpic as o, init_epic as r, syncTaskStatus as s, EpicDir as t };

package/dist/{fts-Buk8fkl1.mjs → fts-DUZkPJPD.mjs}

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { d as searchKnowledgeKeyword, i as getKnowledgeByIDs, l as mapRow } from "./knowledge-BgWoLpv7.mjs";
-import { n as deserializeFloat32, t as cosineSimilarity } from "./vectors-DtWMZUgk.mjs";
+import { n as __esmMin } from "./chunk-CAm0Jl7e.mjs";
+import { f as searchKnowledgeKeyword, i as getKnowledgeByIDs, l as init_knowledge, u as mapRow } from "./knowledge-C7rEfFSX.mjs";
+import { n as deserializeFloat32, r as init_vectors, t as cosineSimilarity } from "./vectors-C3yIO_A5.mjs";
 //#region src/store/fts.ts
 function subTypeHalfLife(subType) {
 	switch (subType) {
@@ -142,17 +143,6 @@ function expandAliases(store, terms) {
 function sanitizeFTSTerm(term) {
 	return term.replace(/["*^{}]/g, "");
 }
-const CONTRADICTION_PAIRS = [
-	["always", "never"],
-	["must", "must not"],
-	["use", "avoid"],
-	["enable", "disable"],
-	["allow", "deny"],
-	["required", "optional"],
-	["do", "don't"],
-	["add", "remove"],
-	["include", "exclude"]
-];
 function classifyConflict(contentA, contentB) {
 	const lowerA = contentA.toLowerCase();
 	const lowerB = contentB.toLowerCase();
@@ -191,5 +181,21 @@ function fuzzyMatch(query, target) {
 	if (maxDist === 0) maxDist = 1;
 	return levenshtein(query.toLowerCase(), target.toLowerCase()) <= maxDist;
 }
+var CONTRADICTION_PAIRS;
+var init_fts = __esmMin((() => {
+	init_knowledge();
+	init_vectors();
+	CONTRADICTION_PAIRS = [
+		["always", "never"],
+		["must", "must not"],
+		["use", "avoid"],
+		["enable", "disable"],
+		["allow", "deny"],
+		["required", "optional"],
+		["do", "don't"],
+		["add", "remove"],
+		["include", "exclude"]
+	];
+}));
 //#endregion
-export { subTypeHalfLife as i, searchKnowledgeFTS as n, subTypeBoost as r, detectKnowledgeConflicts as t };
+export { subTypeHalfLife as a, subTypeBoost as i, init_fts as n, searchKnowledgeFTS as r, detectKnowledgeConflicts as t };

package/dist/{knowledge-BgWoLpv7.mjs → knowledge-C7rEfFSX.mjs}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { n as __esmMin } from "./chunk-CAm0Jl7e.mjs";
 import { createHash } from "node:crypto";
 //#region src/store/knowledge.ts
 function contentHash(content) {
@@ -168,5 +169,6 @@ function mapRow(r) {
 		enabled: r.enabled === 1
 	};
 }
+var init_knowledge = __esmMin((() => {}));
 //#endregion
-export { getKnowledgeStats as a, incrementHitCount as c, searchKnowledgeKeyword as d, setKnowledgeEnabled as f, getKnowledgeByIDs as i, mapRow as l, deleteOrphanKnowledge as n, getPromotionCandidates as o, upsertKnowledge as p, getKnowledgeByID as r, getRecentDecisions as s, countKnowledge as t, promoteSubType as u };
+export { getKnowledgeStats as a, incrementHitCount as c, promoteSubType as d, searchKnowledgeKeyword as f, getKnowledgeByIDs as i, init_knowledge as l, upsertKnowledge as m, deleteOrphanKnowledge as n, getPromotionCandidates as o, setKnowledgeEnabled as p, getKnowledgeByID as r, getRecentDecisions as s, countKnowledge as t, mapRow as u };