@fusengine/harness 0.1.0

package/dist/refs/index.d.mts

@@ -0,0 +1,44 @@
+//#region src/refs/types.d.ts
+/** Parsed frontmatter metadata from a reference .md file. */
+interface RefMeta {
+  name: string;
+  description: string;
+  keywords: string;
+  priority: string;
+  related: string;
+  appliesTo: string;
+  triggerOnEdit: string;
+  level: string;
+  filePath: string;
+}
+/** A reference with its computed routing score. */
+interface ScoredRef {
+  meta: RefMeta;
+  score: number;
+}
+/** Routing result with categorized references. */
+interface RouteResult {
+  required: ScoredRef[];
+  optional: ScoredRef[];
+  skillPath: string;
+}
+//#endregion
+//#region src/refs/frontmatter.d.ts
+/** Extract frontmatter key/value pairs from markdown content (quotes stripped). */
+declare function parseFrontmatter(content: string): Record<string, string>;
+/** Convert a simple glob (`**`, `*`) to an anchored RegExp. */
+declare function globToRe(g: string): RegExp;
+//#endregion
+//#region src/refs/router.d.ts
+/**
+* Score references against a file edit (pure):
+* +10 per `applies-to` glob match, +5 per `trigger-on-edit` fragment, +1 per keyword.
+*/
+declare function scoreReferences(refs: RefMeta[], filePath: string, content: string): ScoredRef[];
+/**
+* Route references for a file edit: top-2 required + next-2 optional, ensuring a
+* `principle` and a `template` appear in the top 4. Returns null when nothing scores.
+*/
+declare function routeReferences(refs: RefMeta[], filePath: string, content: string, skillPath?: string): RouteResult | null;
+//#endregion
+export { RefMeta, RouteResult, ScoredRef, globToRe, parseFrontmatter, routeReferences, scoreReferences };

package/dist/refs/index.mjs

@@ -0,0 +1,70 @@
+//#region src/refs/frontmatter.ts
+/** Extract frontmatter key/value pairs from markdown content (quotes stripped). */
+function parseFrontmatter(content) {
+	const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+	if (!m?.[1]) return {};
+	const result = {};
+	for (const line of m[1].split("\n")) {
+		const idx = line.indexOf(":");
+		if (idx > 0) result[line.slice(0, idx).trim()] = line.slice(idx + 1).trim().replace(/^["']|["']$/g, "");
+	}
+	return result;
+}
+/** Convert a simple glob (`**`, `*`) to an anchored RegExp. */
+function globToRe(g) {
+	const escaped = g.trim().replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, ".*");
+	return new RegExp(`^${escaped}$`);
+}
+//#endregion
+//#region src/refs/router.ts
+/**
+* Score references against a file edit (pure):
+* +10 per `applies-to` glob match, +5 per `trigger-on-edit` fragment, +1 per keyword.
+*/
+function scoreReferences(refs, filePath, content) {
+	const scored = [];
+	for (const meta of refs) {
+		let score = 0;
+		if (meta.appliesTo) {
+			for (const g of meta.appliesTo.split(", ")) if (globToRe(g).test(filePath)) score += 10;
+		}
+		if (meta.triggerOnEdit) {
+			for (const frag of meta.triggerOnEdit.split(", ")) if (filePath.includes(frag.trim())) score += 5;
+		}
+		if (meta.keywords) for (const kw of meta.keywords.split(", ")) {
+			const k = kw.trim();
+			if (k && (filePath.includes(k) || content.includes(k))) score += 1;
+		}
+		if (score > 0) scored.push({
+			meta,
+			score
+		});
+	}
+	return scored;
+}
+/**
+* Route references for a file edit: top-2 required + next-2 optional, ensuring a
+* `principle` and a `template` appear in the top 4. Returns null when nothing scores.
+*/
+function routeReferences(refs, filePath, content, skillPath = "") {
+	const scored = scoreReferences(refs, filePath, content);
+	if (!scored.length) return null;
+	scored.sort((a, b) => b.score - a.score);
+	const hoist = (level) => {
+		if (scored.slice(0, 4).some((r) => r.meta.level === level)) return;
+		const found = scored.find((r) => r.meta.level === level);
+		if (found) {
+			scored.splice(scored.indexOf(found), 1);
+			scored.splice(3, 0, found);
+		}
+	};
+	hoist("principle");
+	hoist("template");
+	return {
+		required: scored.slice(0, 2),
+		optional: scored.slice(2, 4),
+		skillPath
+	};
+}
+//#endregion
+export { globToRe, parseFrontmatter, routeReferences, scoreReferences };

package/dist/state/index.d.mts

@@ -0,0 +1,59 @@
+import { t as AuthEntry } from "../doc-helpers-CG1nuf-c.mjs";
+
+//#region src/state/lock.d.ts
+/**
+* Acquire a directory-based lock (atomic `mkdir`, EEXIST = already held) with a timeout.
+* @returns a release function, or null if the lock could not be acquired in time.
+*/
+declare function acquireLock(lockDir: string, timeoutMs?: number): Promise<(() => Promise<void>) | null>;
+//#endregion
+//#region src/state/apex-state.d.ts
+declare const DEFAULT_STATE: {
+  $schema: string;
+  description: string;
+  target: Record<string, string>;
+  authorizations: Record<string, AuthEntry & {
+    doc_consulted?: string;
+  }>;
+};
+/** APEX state shape. */
+type ApexState = typeof DEFAULT_STATE;
+/** APEX state directory under a home dir. */
+declare function apexStateDir(home?: string): string;
+/** Daily state file path: `<home>/.claude/logs/00-apex/<YYYY-MM-DD>-state.json`. */
+declare function stateFilePath(home?: string, today?: string): string;
+/** Ensure the state directory exists and return its path. */
+declare function ensureStateDir(home?: string): Promise<string>;
+/** Load APEX state, or a fresh default. */
+declare function loadState(path: string): Promise<ApexState>;
+/** Save APEX state. */
+declare function saveState(path: string, state: ApexState): Promise<void>;
+//#endregion
+//#region src/state/task-helpers.d.ts
+/** A task entry in task.json. */
+interface ApexTask {
+  subject: string;
+  description: string;
+  status: string;
+  phase: string;
+  started_at?: string;
+  completed_at?: string;
+  created_at?: string;
+  doc_consulted: Record<string, unknown>;
+  files_modified: string[];
+  blockedBy?: string[];
+}
+/** Structure of `.claude/apex/task.json`. */
+interface ApexTaskFile {
+  current_task: string;
+  created_at: string;
+  tasks: Record<string, ApexTask>;
+}
+/** Add a new pending task. */
+declare function taskCreate(file: string, id: string, subject: string, desc: string): Promise<void>;
+/** Mark a task in_progress (creating a stub if absent). */
+declare function taskStart(file: string, id: string, subject?: string, desc?: string, blocked?: string): Promise<void>;
+/** Mark a task completed. */
+declare function taskComplete(file: string, id: string): Promise<void>;
+//#endregion
+export { ApexState, ApexTask, ApexTaskFile, acquireLock, apexStateDir, ensureStateDir, loadState, saveState, stateFilePath, taskComplete, taskCreate, taskStart };

package/dist/state/index.mjs

@@ -0,0 +1,104 @@
+import { n as readJsonFile, r as writeJsonFile, t as ensureDir } from "../json-io-RH82El2J.mjs";
+import { mkdir, rmdir } from "node:fs/promises";
+//#region src/state/lock.ts
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+* Acquire a directory-based lock (atomic `mkdir`, EEXIST = already held) with a timeout.
+* @returns a release function, or null if the lock could not be acquired in time.
+*/
+async function acquireLock(lockDir, timeoutMs = 5e3) {
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) try {
+		await mkdir(lockDir, { recursive: false });
+		return async () => {
+			try {
+				await rmdir(lockDir);
+			} catch {}
+		};
+	} catch {
+		await sleep(100);
+	}
+	return null;
+}
+//#endregion
+//#region src/state/apex-state.ts
+const DEFAULT_STATE = {
+	$schema: "apex-state-v1",
+	description: "APEX/SOLID state - sessions[] + 2min expiry",
+	target: {},
+	authorizations: {}
+};
+/** APEX state directory under a home dir. */
+function apexStateDir(home = process.env.HOME ?? "") {
+	return `${home}/.claude/logs/00-apex`;
+}
+/** Daily state file path: `<home>/.claude/logs/00-apex/<YYYY-MM-DD>-state.json`. */
+function stateFilePath(home = process.env.HOME ?? "", today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)) {
+	return `${apexStateDir(home)}/${today}-state.json`;
+}
+/** Ensure the state directory exists and return its path. */
+async function ensureStateDir(home) {
+	const dir = apexStateDir(home);
+	await ensureDir(dir);
+	return dir;
+}
+/** Load APEX state, or a fresh default. */
+async function loadState(path) {
+	return await readJsonFile(path) ?? { ...DEFAULT_STATE };
+}
+/** Save APEX state. */
+async function saveState(path, state) {
+	await writeJsonFile(path, state);
+}
+//#endregion
+//#region src/state/task-helpers.ts
+/** Add a new pending task. */
+async function taskCreate(file, id, subject, desc) {
+	const data = await readJsonFile(file);
+	if (!data) return;
+	data.tasks[id] = {
+		subject,
+		description: desc,
+		status: "pending",
+		phase: "pending",
+		created_at: (/* @__PURE__ */ new Date()).toISOString(),
+		doc_consulted: {},
+		files_modified: [],
+		blockedBy: []
+	};
+	await writeJsonFile(file, data);
+}
+/** Mark a task in_progress (creating a stub if absent). */
+async function taskStart(file, id, subject, desc, blocked) {
+	const data = await readJsonFile(file);
+	if (!data) return;
+	const task = data.tasks[id] ?? {
+		subject: "",
+		description: "",
+		status: "in_progress",
+		phase: "analyze",
+		doc_consulted: {},
+		files_modified: []
+	};
+	data.tasks[id] = task;
+	data.current_task = id;
+	task.status = "in_progress";
+	task.phase = "analyze";
+	task.started_at = (/* @__PURE__ */ new Date()).toISOString();
+	if (subject) task.subject = subject;
+	if (desc) task.description = desc;
+	if (blocked) task.blockedBy = blocked.split(",");
+	await writeJsonFile(file, data);
+}
+/** Mark a task completed. */
+async function taskComplete(file, id) {
+	const data = await readJsonFile(file);
+	const task = data?.tasks[id];
+	if (!data || !task) return;
+	task.status = "completed";
+	task.phase = "completed";
+	task.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+	await writeJsonFile(file, data);
+}
+//#endregion
+export { acquireLock, apexStateDir, ensureStateDir, loadState, saveState, stateFilePath, taskComplete, taskCreate, taskStart };

package/dist/statusline/index.d.mts

@@ -0,0 +1,84 @@
+//#region src/statusline/constants.d.ts
+/** Time interval constants (ms). */
+declare const TIME_INTERVALS: {
+  readonly MINUTE_MS: 60_000;
+  readonly HOUR_MS: 3_600_000;
+};
+/** Percentage thresholds for progressive coloring. */
+declare const COLOR_THRESHOLDS: {
+  readonly WARNING: 70;
+  readonly CRITICAL: 90;
+};
+/** Fill/empty glyphs per progress-bar style. */
+declare const PROGRESS_CHARS: {
+  readonly blocks: {
+    readonly fill: "█";
+    readonly empty: "░";
+  };
+  readonly bars: {
+    readonly fill: "▰";
+    readonly empty: "▱";
+  };
+};
+/** Defaults for {@link generateProgressBar}. */
+declare const PROGRESS_BAR_DEFAULTS: {
+  readonly STYLE: "blocks";
+  readonly LENGTH: 10;
+};
+/** 9 gradient blocks from empty to full. */
+declare const GRADIENT_BLOCKS: readonly [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"];
+//#endregion
+//#region src/statusline/colors.d.ts
+/** A text-decorating function. */
+type ColorFn = (text: string) => string;
+/** Forced ANSI palette (every entry is a colorizer, plus reset + support flag). */
+interface Palette {
+  blue: ColorFn;
+  cyan: ColorFn;
+  green: ColorFn;
+  yellow: ColorFn;
+  red: ColorFn;
+  magenta: ColorFn;
+  white: ColorFn;
+  gray: ColorFn;
+  purple: ColorFn;
+  orange: ColorFn;
+  brightRed: ColorFn;
+  brightYellow: ColorFn;
+  brightGreen: ColorFn;
+  bold: ColorFn;
+  dim: ColorFn;
+  reset: string;
+  isSupported: boolean;
+}
+/** Forced ANSI color helpers (ignore TTY detection). */
+declare const colors: Palette;
+/** Color `text` by threshold: green < WARNING <= yellow < CRITICAL <= red. */
+declare function progressiveColor(value: number, text: string): string;
+//#endregion
+//#region src/statusline/formatters.d.ts
+/** Format a path: truncated (default), full, relative (~), or basename. */
+declare function formatPath(path: string, style?: "truncated" | "full" | "relative" | "basename"): string;
+/** Basename of a path. */
+declare function formatBasename(path: string): string;
+/** Humanize a remaining duration in ms (e.g. "2h - 5m"). */
+declare function formatTimeLeft(ms: number): string;
+/** Format a token count as "12K" (or "12.3K" with decimals). */
+declare function formatTokens(tokens: number, showDecimals?: boolean): string;
+/** Format a cost as "$1.23". */
+declare function formatCost(cost: number, decimals?: number): string;
+//#endregion
+//#region src/statusline/progress-bar.d.ts
+/** Options for {@link generateProgressBar}. */
+interface ProgressBarOptions {
+  style?: keyof typeof PROGRESS_CHARS;
+  length?: number;
+  useProgressiveColor?: boolean;
+  showPercentage?: boolean;
+}
+/** Render a fill/empty progress bar. */
+declare function generateProgressBar(percentage: number, options?: ProgressBarOptions): string;
+/** Render a fine-grained gradient bar (sub-block resolution). */
+declare function generateGradientBar(percentage: number, length?: number): string;
+//#endregion
+export { COLOR_THRESHOLDS, ColorFn, GRADIENT_BLOCKS, PROGRESS_BAR_DEFAULTS, PROGRESS_CHARS, Palette, ProgressBarOptions, TIME_INTERVALS, colors, formatBasename, formatCost, formatPath, formatTimeLeft, formatTokens, generateGradientBar, generateProgressBar, progressiveColor };

package/dist/statusline/index.mjs

@@ -0,0 +1,148 @@
+import { basename } from "node:path";
+//#region src/statusline/constants.ts
+/** Time interval constants (ms). */
+const TIME_INTERVALS = {
+	MINUTE_MS: 6e4,
+	HOUR_MS: 36e5
+};
+/** Percentage thresholds for progressive coloring. */
+const COLOR_THRESHOLDS = {
+	WARNING: 70,
+	CRITICAL: 90
+};
+/** Fill/empty glyphs per progress-bar style. */
+const PROGRESS_CHARS = {
+	blocks: {
+		fill: "█",
+		empty: "░"
+	},
+	bars: {
+		fill: "▰",
+		empty: "▱"
+	}
+};
+/** Defaults for {@link generateProgressBar}. */
+const PROGRESS_BAR_DEFAULTS = {
+	STYLE: "blocks",
+	LENGTH: 10
+};
+/** 9 gradient blocks from empty to full. */
+const GRADIENT_BLOCKS = [
+	" ",
+	"▏",
+	"▎",
+	"▍",
+	"▌",
+	"▋",
+	"▊",
+	"▉",
+	"█"
+];
+//#endregion
+//#region src/statusline/colors.ts
+const ansi = (code) => (text) => `\x1b[${code}m${text}\x1b[0m`;
+const ansi256 = (code) => (text) => `\x1b[38;5;${code}m${text}\x1b[0m`;
+/** Forced ANSI color helpers (ignore TTY detection). */
+const colors = {
+	blue: ansi("0;34"),
+	cyan: ansi("0;36"),
+	green: ansi("0;32"),
+	yellow: ansi("0;33"),
+	red: ansi("0;31"),
+	magenta: ansi("0;35"),
+	white: ansi("0;37"),
+	gray: ansi256(240),
+	purple: ansi256(135),
+	orange: ansi256(208),
+	brightRed: ansi("1;91"),
+	brightYellow: ansi("1;93"),
+	brightGreen: ansi("1;92"),
+	bold: ansi("1"),
+	dim: ansi("2"),
+	reset: "\x1B[0m",
+	isSupported: true
+};
+/** Color `text` by threshold: green < WARNING <= yellow < CRITICAL <= red. */
+function progressiveColor(value, text) {
+	if (value >= COLOR_THRESHOLDS.CRITICAL) return colors.brightRed(text);
+	if (value >= COLOR_THRESHOLDS.WARNING) return colors.brightYellow(text);
+	return colors.green(text);
+}
+//#endregion
+//#region src/statusline/formatters.ts
+/** Format a path: truncated (default), full, relative (~), or basename. */
+function formatPath(path, style = "truncated") {
+	const home = process.env.HOME || "";
+	const isUnderHome = home !== "" && path.startsWith(home);
+	const withTilde = isUnderHome ? path.replace(home, "~") : path;
+	const parts = withTilde.split("/").filter(Boolean);
+	const name = parts[parts.length - 1] || withTilde;
+	switch (style) {
+		case "full": return path;
+		case "basename": return name;
+		case "relative": return withTilde;
+		default:
+			if (isUnderHome && parts.length > 2) return `~/../${name}`;
+			if (isUnderHome) return withTilde;
+			if (parts.length > 3) return `/../${name}`;
+			return withTilde;
+	}
+}
+/** Basename of a path. */
+function formatBasename(path) {
+	return basename(path);
+}
+/** Humanize a remaining duration in ms (e.g. "2h - 5m"). */
+function formatTimeLeft(ms) {
+	if (ms <= 0) return "0m";
+	const dayMs = TIME_INTERVALS.HOUR_MS * 24;
+	const days = Math.floor(ms / dayMs);
+	const hours = Math.floor(ms % dayMs / TIME_INTERVALS.HOUR_MS);
+	const minutes = Math.floor(ms % TIME_INTERVALS.HOUR_MS / TIME_INTERVALS.MINUTE_MS);
+	if (days > 0 && hours > 0) return `${days}d - ${hours}h`;
+	if (days > 0) return `${days}d`;
+	if (hours > 0 && minutes > 0) return `${hours}h - ${minutes}m`;
+	if (hours > 0) return `${hours}h`;
+	return `${minutes}m`;
+}
+/** Format a token count as "12K" (or "12.3K" with decimals). */
+function formatTokens(tokens, showDecimals = false) {
+	const k = tokens / 1e3;
+	return showDecimals ? `${k.toFixed(1)}K` : `${Math.round(k)}K`;
+}
+/** Format a cost as "$1.23". */
+function formatCost(cost, decimals = 2) {
+	return `$${cost.toFixed(decimals)}`;
+}
+//#endregion
+//#region src/statusline/progress-bar.ts
+const clampPct = (p) => Math.max(0, Math.min(100, Number.isNaN(p) ? 0 : p));
+/** Render a fill/empty progress bar. */
+function generateProgressBar(percentage, options = {}) {
+	const { style = PROGRESS_BAR_DEFAULTS.STYLE, length = PROGRESS_BAR_DEFAULTS.LENGTH, useProgressiveColor = false, showPercentage = false } = options;
+	const pct = clampPct(percentage);
+	const filled = Math.round(pct / 100 * length);
+	const empty = Math.max(0, length - filled);
+	const chars = PROGRESS_CHARS[style];
+	let bar = chars.fill.repeat(filled) + chars.empty.repeat(empty);
+	if (useProgressiveColor) bar = progressiveColor(pct, bar);
+	if (showPercentage) {
+		const pctText = `${Math.round(pct)}%`;
+		bar += ` ${useProgressiveColor ? progressiveColor(pct, pctText) : pctText}`;
+	}
+	return bar;
+}
+/** Render a fine-grained gradient bar (sub-block resolution). */
+function generateGradientBar(percentage, length = 10) {
+	const pct = clampPct(percentage);
+	const exact = pct / 100 * length;
+	const full = Math.floor(exact);
+	const remainder = exact - full;
+	let bar = GRADIENT_BLOCKS[8].repeat(full);
+	if (full < length && remainder > 0) bar += GRADIENT_BLOCKS[Math.floor(remainder * 8)] ?? "";
+	const remaining = length - bar.length;
+	if (remaining > 0) bar += " ".repeat(remaining);
+	return progressiveColor(pct, bar);
+}
+//#endregion
+export { COLOR_THRESHOLDS, GRADIENT_BLOCKS, PROGRESS_BAR_DEFAULTS, PROGRESS_CHARS, TIME_INTERVALS, colors, formatBasename, formatCost, formatPath, formatTimeLeft, formatTokens, generateGradientBar, generateProgressBar, progressiveColor };

package/dist/types-D56jSgD9.d.mts

@@ -0,0 +1,21 @@
+//#region src/prompt/types.d.ts
+/** How a policy outcome should surface in a harness. */
+type PromptKind = "ask" | "block" | "inform";
+/**
+* Portable, harness-agnostic representation of a policy outcome as a prompt.
+* Adapters render this into their harness's native shape (a Claude
+* `permissionDecision`, a Cursor block, a CLI exit + message, ...).
+*/
+interface Prompt {
+  kind: PromptKind;
+  /** Short title, e.g. "SOLID file-size limit". */
+  title: string;
+  /** Why this fired. */
+  reason: string;
+  /** Concrete next actions to proceed. */
+  actions?: string[];
+}
+/** Render a {@link Prompt} as a consistent, agent-readable memo block. */
+declare function formatPrompt(p: Prompt): string;
+//#endregion
+export { PromptKind as n, formatPrompt as r, Prompt as t };

package/dist/types-ernB1Dy3.mjs

@@ -0,0 +1,12 @@
+//#region src/prompt/types.ts
+/** Render a {@link Prompt} as a consistent, agent-readable memo block. */
+function formatPrompt(p) {
+	const lines = [`[${p.kind === "block" ? "BLOCKED" : p.kind === "ask" ? "CONFIRM" : "NOTE"}] ${p.title}`, p.reason];
+	if (p.actions?.length) {
+		lines.push("Next:");
+		p.actions.forEach((a, i) => lines.push(`  ${i + 1}. ${a}`));
+	}
+	return lines.join("\n");
+}
+//#endregion
+export { formatPrompt as t };

package/dist/util/index.d.mts

@@ -0,0 +1,20 @@
+//#region src/util/compact-json.d.ts
+/**
+* Compact JSON serializer for cache/state files.
+* Top-level keys are indented one per line; nested objects/arrays render inline.
+* Behaviour preserved from the fusengine hooks.
+*/
+declare function compactJson(data: unknown): string;
+//#endregion
+//#region src/util/project-root.d.ts
+/** True for a source-code file outside generated/vendored directories. */
+declare function isCodeFile(p: string): boolean;
+/**
+* Resolve the project root, preferring the repo boundary (`.git`) over a
+* nested `package.json` — avoids false roots in monorepos. Null if none found.
+*/
+declare function projectRootOrNull(dir: string): string | null;
+/** Like {@link projectRootOrNull} but falls back to `process.cwd()`. */
+declare function projectRoot(dir: string): string;
+//#endregion
+export { compactJson, isCodeFile, projectRoot, projectRootOrNull };

package/dist/util/index.mjs

@@ -0,0 +1,3 @@
+import { t as compactJson } from "../compact-json-DK2nX-MK.mjs";
+import { n as projectRoot, r as projectRootOrNull, t as isCodeFile } from "../project-root-C4ks_q1G.mjs";
+export { compactJson, isCodeFile, projectRoot, projectRootOrNull };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@fusengine/harness",
+  "version": "0.1.0",
+  "description": "Harness-agnostic toolkit for AI coding agents: runtime harness detection (Claude Code, Codex, Cursor, Cline, Gemini, Aider...), pure policy core (env config, project/framework detection, SOLID/file-size limits, APEX freshness, guard patterns, portable prompts), cache, project memory, ref routing, state/locks, statusline, and thin per-harness adapters. Bun-native, with a built dist for Node + bundlers.",
+  "type": "module",
+  "module": "src/index.ts",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": { "bun": "./src/index.ts", "types": "./dist/index.d.mts", "import": "./dist/index.mjs" },
+    "./config": { "bun": "./src/config/index.ts", "types": "./dist/config/index.d.mts", "import": "./dist/config/index.mjs" },
+    "./util": { "bun": "./src/util/index.ts", "types": "./dist/util/index.d.mts", "import": "./dist/util/index.mjs" },
+    "./detect": { "bun": "./src/detect/index.ts", "types": "./dist/detect/index.d.mts", "import": "./dist/detect/index.mjs" },
+    "./policy": { "bun": "./src/policy/index.ts", "types": "./dist/policy/index.d.mts", "import": "./dist/policy/index.mjs" },
+    "./prompt": { "bun": "./src/prompt/index.ts", "types": "./dist/prompt/index.d.mts", "import": "./dist/prompt/index.mjs" },
+    "./memory": { "bun": "./src/memory/index.ts", "types": "./dist/memory/index.d.mts", "import": "./dist/memory/index.mjs" },
+    "./cache": { "bun": "./src/cache/index.ts", "types": "./dist/cache/index.d.mts", "import": "./dist/cache/index.mjs" },
+    "./freshness": { "bun": "./src/freshness/index.ts", "types": "./dist/freshness/index.d.mts", "import": "./dist/freshness/index.mjs" },
+    "./refs": { "bun": "./src/refs/index.ts", "types": "./dist/refs/index.d.mts", "import": "./dist/refs/index.mjs" },
+    "./state": { "bun": "./src/state/index.ts", "types": "./dist/state/index.d.mts", "import": "./dist/state/index.mjs" },
+    "./statusline": { "bun": "./src/statusline/index.ts", "types": "./dist/statusline/index.d.mts", "import": "./dist/statusline/index.mjs" },
+    "./adapters/claude": { "bun": "./src/adapters/claude/index.ts", "types": "./dist/adapters/claude/index.d.mts", "import": "./dist/adapters/claude/index.mjs" }
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "license": "MIT",
+  "sideEffects": false,
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "build": "tsdown src/index.ts src/config/index.ts src/util/index.ts src/detect/index.ts src/policy/index.ts src/prompt/index.ts src/memory/index.ts src/cache/index.ts src/freshness/index.ts src/refs/index.ts src/state/index.ts src/statusline/index.ts src/adapters/claude/index.ts --dts --format esm --clean --out-dir dist",
+    "prepublishOnly": "bun test && tsc --noEmit && bun run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@vercel/detect-agent": "*"
+  },
+  "peerDependenciesMeta": {
+    "@vercel/detect-agent": { "optional": true }
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "tsdown": "^0.22.3",
+    "typescript": "^6.0.3"
+  }
+}