@fusengine/harness 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fusengine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+# @fusengine/harness
+
+Harness-agnostic toolkit for AI coding agents. One package, modular subpaths,
+**Bun-native** (the `exports` map points at the TypeScript source — no build step).
+
+It splits cleanly into a **pure policy core** (no harness coupling) and **thin
+adapters** that wire it into a specific harness's hook system.
+
+## Why
+
+The same guard logic (file-size limits, APEX freshness, framework detection,
+git guards, project memory) was duplicated across Python + TypeScript hooks and
+bound to one harness. This package is the single, tested source of truth — and
+it knows which harness it's running in.
+
+## Install
+
+```sh
+bun add @fusengine/harness
+```
+
+## Modules
+
+| Subpath | What |
+|---------|------|
+| `@fusengine/harness/detect` | `detectHarness()` / `detectMode()` — Claude Code, Codex, Cursor, Cline, Gemini, opencode, Windsurf, Copilot, Aider, Kiro, Goose, Amp (env signals + `AGENT`/`AI_AGENT` standards). `mode` is `hook` or `cli`. |
+| `@fusengine/harness/policy` | `evaluate(ctx)` → `{ decision, message }`; `evaluateFileSize`, `detectProjectType`, `detectFramework`, git/install guard patterns. |
+| `@fusengine/harness/config` | `resolveTtlSec` / `resolveMaxLines` (env-driven, robust parse), `ttlLabel`, `splitTarget`. |
+| `@fusengine/harness/memory` | Per-project "never reproduce" lessons: throttle state, multi-project registry by git root. |
+| `@fusengine/harness/cache` | `compactMarkdown`, `queryHash`, `jaccardSimilar`, atomic JSON I/O, MCP response extraction. |
+| `@fusengine/harness/freshness` | `isDocConsulted` (Context7 + Exa), trivial-edit counter. |
+| `@fusengine/harness/refs` | Frontmatter parsing, glob→regex, SOLID reference scoring/routing. |
+| `@fusengine/harness/state` | Directory locks, daily APEX state, task.json helpers. |
+| `@fusengine/harness/statusline` | Formatters, ANSI colors, progress/gradient bars. |
+| `@fusengine/harness/adapters/claude` | Claude Code adapter: read stdin → policy → `hookSpecificOutput`. |
+
+## Usage
+
+```ts
+import { detectHarness, detectMode } from "@fusengine/harness/detect";
+import { evaluate } from "@fusengine/harness/policy";
+
+const { id, mode } = detectHarness();        // e.g. { id: "cursor", mode: "hook" }
+
+const verdict = evaluate({ tool: "Write", filePath: "src/big.ts", content });
+if (verdict.decision === "deny") console.error(verdict.message);
+```
+
+Claude Code hook (thin adapter):
+
+```ts
+import { readClaudeInput, fileSizeGuard } from "@fusengine/harness/adapters/claude";
+
+const deny = fileSizeGuard(await readClaudeInput());
+if (deny) { console.log(deny); process.exit(2); }
+```
+
+Harness without hooks (Aider/Windsurf/OpenHands) → `cli` mode: run the same
+`evaluate()` from a pre-commit step instead.
+
+## Develop
+
+```sh
+bun test          # test suite
+bunx tsc --noEmit # typecheck
+```
+
+CI runs both on every PR. MIT licensed.

package/dist/adapters/claude/index.d.mts

@@ -0,0 +1,36 @@
+import { t as Prompt } from "../../types-D56jSgD9.mjs";
+
+//#region src/adapters/claude/index.d.ts
+/** Subset of the Claude Code hook stdin payload we consume. */
+interface ClaudeHookInput {
+  hook_event_name?: string;
+  tool_name?: string;
+  tool_input?: {
+    file_path?: string;
+    content?: string;
+    new_string?: string;
+    command?: string;
+  };
+  cwd?: string;
+}
+/** Read & parse the Claude hook payload from stdin (empty object on bad input). */
+declare function readClaudeInput(): Promise<ClaudeHookInput>;
+/** A `deny` hook response for a given event. */
+declare function denyResponse(event: string, reason: string): string;
+/** An `additionalContext` injection response. */
+declare function contextResponse(event: string, text: string): string;
+/**
+* Render a portable {@link Prompt} as a Claude Code hook response:
+* `block` → `permissionDecision: deny`, `ask` → `permissionDecision: ask`
+* (interactive confirm), `inform` → `additionalContext`.
+*/
+declare function toClaudeResponse(event: string, prompt: Prompt): string;
+/**
+* Run the bundled policy over a Claude payload and return the native response
+* string (deny/ask/additionalContext), or null to allow.
+*/
+declare function guard(input: ClaudeHookInput): string | null;
+/** @deprecated use {@link guard}. Kept for back-compat. */
+declare const fileSizeGuard: typeof guard;
+//#endregion
+export { ClaudeHookInput, contextResponse, denyResponse, fileSizeGuard, guard, readClaudeInput, toClaudeResponse };

package/dist/adapters/claude/index.mjs

@@ -0,0 +1,66 @@
+import { t as evaluate } from "../../evaluate-CsYyUucy.mjs";
+import { t as formatPrompt } from "../../types-ernB1Dy3.mjs";
+//#region src/adapters/claude/index.ts
+/**
+* Claude Code adapter — the thin Claude-only shim over the portable policy core.
+* Reads the hook stdin payload and emits hookSpecificOutput responses.
+*/
+/** Read & parse the Claude hook payload from stdin (empty object on bad input). */
+async function readClaudeInput() {
+	const text = await Bun.stdin.text();
+	if (!text.trim()) return {};
+	try {
+		const parsed = JSON.parse(text);
+		return typeof parsed === "object" && parsed !== null ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+/** A `deny` hook response for a given event. */
+function denyResponse(event, reason) {
+	return JSON.stringify({ hookSpecificOutput: {
+		hookEventName: event,
+		permissionDecision: "deny",
+		permissionDecisionReason: reason
+	} });
+}
+/** An `additionalContext` injection response. */
+function contextResponse(event, text) {
+	return JSON.stringify({ hookSpecificOutput: {
+		hookEventName: event,
+		additionalContext: text
+	} });
+}
+/**
+* Render a portable {@link Prompt} as a Claude Code hook response:
+* `block` → `permissionDecision: deny`, `ask` → `permissionDecision: ask`
+* (interactive confirm), `inform` → `additionalContext`.
+*/
+function toClaudeResponse(event, prompt) {
+	const reason = formatPrompt(prompt);
+	if (prompt.kind === "block") return denyResponse(event, reason);
+	if (prompt.kind === "ask") return JSON.stringify({ hookSpecificOutput: {
+		hookEventName: event,
+		permissionDecision: "ask",
+		permissionDecisionReason: reason
+	} });
+	return contextResponse(event, reason);
+}
+/**
+* Run the bundled policy over a Claude payload and return the native response
+* string (deny/ask/additionalContext), or null to allow.
+*/
+function guard(input) {
+	const result = evaluate({
+		tool: input.tool_name ?? "Write",
+		filePath: input.tool_input?.file_path,
+		content: input.tool_input?.content ?? input.tool_input?.new_string,
+		command: input.tool_input?.command
+	});
+	if (result.decision === "allow" || !result.prompt) return null;
+	return toClaudeResponse(input.hook_event_name ?? "PreToolUse", result.prompt);
+}
+/** @deprecated use {@link guard}. Kept for back-compat. */
+const fileSizeGuard = guard;
+//#endregion
+export { contextResponse, denyResponse, fileSizeGuard, guard, readClaudeInput, toClaudeResponse };

package/dist/cache/index.d.mts

@@ -0,0 +1,30 @@
+//#region src/cache/compact.d.ts
+/** Strip HTML entities + boilerplate, normalize blank lines, truncate to ~5KB. */
+declare function compactMarkdown(content: string): string;
+/** 8-char MD5 of `${toolName}::${query}`. */
+declare function queryHash(toolName: string, query: string): string;
+/** Bag-of-words Jaccard similarity strictly greater than `threshold`. */
+declare function jaccardSimilar(a: string, b: string, threshold?: number): boolean;
+//#endregion
+//#region src/cache/io.d.ts
+/** Read a JSON array from `path`; [] on missing/corrupt/non-array. */
+declare function loadIndex(path: string): unknown[];
+/** Summary of a cache index. */
+interface IndexSummary {
+  total: number;
+  byTool: Record<string, number>;
+  oldestTs: string | null;
+  newestTs: string | null;
+}
+/** Summarize an index of `{ tool?, ts? }` entries. */
+declare function summarizeIndex(index: unknown[]): IndexSummary;
+//#endregion
+//#region src/cache/mcp-response.d.ts
+/**
+* Extract usable markdown from an MCP `tool_response`: a string, a list of
+* content blocks (non-text blocks skipped), or any JSON structure (fallback).
+* Recurses up to depth 5 to guard against pathological/cyclic structures.
+*/
+declare function extractText(resp: unknown, depth?: number): string;
+//#endregion
+export { IndexSummary, compactMarkdown, extractText, jaccardSimilar, loadIndex, queryHash, summarizeIndex };

package/dist/cache/index.mjs

@@ -0,0 +1,110 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+//#region src/cache/compact.ts
+const HTML_ENTITIES = {
+	"&": "&",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&#x27;": "'",
+	"&#39;": "'",
+	"&nbsp;": " ",
+	"&apos;": "'"
+};
+const BOILERPLATE = [
+	/^.*cookie.*(accept|consent|banner).*$/gim,
+	/^.*was this (helpful|page helpful|article helpful).*$/gim,
+	/^.*©\s*\d{4}.*all rights reserved.*$/gim,
+	/^\s*(home|about|contact|privacy|terms)\s*\|\s*.*$/gim,
+	/^.*subscribe to (our )?newsletter.*$/gim,
+	/^.*follow us on (twitter|facebook|linkedin).*$/gim
+];
+const MAX_BYTES = 5 * 1024;
+function decodeEntities(text) {
+	let out = text;
+	for (const [ent, ch] of Object.entries(HTML_ENTITIES)) out = out.split(ent).join(ch);
+	out = out.replace(/&#x([0-9a-fA-F]+);/g, (_m, h) => String.fromCodePoint(parseInt(h, 16)));
+	out = out.replace(/&#(\d+);/g, (_m, d) => String.fromCodePoint(parseInt(d, 10)));
+	return out;
+}
+/** Strip HTML entities + boilerplate, normalize blank lines, truncate to ~5KB. */
+function compactMarkdown(content) {
+	let text = decodeEntities(content);
+	for (const re of BOILERPLATE) text = text.replace(re, "");
+	text = text.replace(/\n{3,}/g, "\n\n").trim();
+	const enc = new TextEncoder().encode(text);
+	if (enc.length > MAX_BYTES) {
+		const truncated = new TextDecoder().decode(enc.slice(0, MAX_BYTES));
+		text = `${truncated}\n\n[... truncated, ${text.slice(truncated.length).split("\n").length - 1} lines]`;
+	}
+	return text;
+}
+/** 8-char MD5 of `${toolName}::${query}`. */
+function queryHash(toolName, query) {
+	return createHash("md5").update(`${toolName}::${query}`).digest("hex").slice(0, 8);
+}
+/** Bag-of-words Jaccard similarity strictly greater than `threshold`. */
+function jaccardSimilar(a, b, threshold = .8) {
+	const ta = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+	const tb = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+	if (ta.size === 0 || tb.size === 0) return false;
+	let inter = 0;
+	for (const t of ta) if (tb.has(t)) inter++;
+	const union = ta.size + tb.size - inter;
+	return inter / union > threshold;
+}
+//#endregion
+//#region src/cache/io.ts
+/** Read a JSON array from `path`; [] on missing/corrupt/non-array. */
+function loadIndex(path) {
+	try {
+		if (!existsSync(path)) return [];
+		const data = JSON.parse(readFileSync(path, "utf8"));
+		return Array.isArray(data) ? data : [];
+	} catch {
+		return [];
+	}
+}
+/** Summarize an index of `{ tool?, ts? }` entries. */
+function summarizeIndex(index) {
+	const byTool = {};
+	const timestamps = [];
+	for (const entry of index) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const e = entry;
+		if (typeof e.tool === "string") byTool[e.tool] = (byTool[e.tool] ?? 0) + 1;
+		if (typeof e.ts === "string") timestamps.push(e.ts);
+	}
+	return {
+		total: index.length,
+		byTool,
+		oldestTs: timestamps.length ? timestamps.reduce((a, b) => a < b ? a : b) : null,
+		newestTs: timestamps.length ? timestamps.reduce((a, b) => a > b ? a : b) : null
+	};
+}
+//#endregion
+//#region src/cache/mcp-response.ts
+const MAX_DEPTH = 5;
+/**
+* Extract usable markdown from an MCP `tool_response`: a string, a list of
+* content blocks (non-text blocks skipped), or any JSON structure (fallback).
+* Recurses up to depth 5 to guard against pathological/cyclic structures.
+*/
+function extractText(resp, depth = 0) {
+	if (depth >= MAX_DEPTH) return "";
+	if (typeof resp === "string") return resp;
+	if (Array.isArray(resp)) {
+		const parts = resp.filter((b) => typeof b === "object" && b !== null).filter((b) => b.type === "text").map((b) => b.text ?? "");
+		if (parts.length) return parts.join("\n\n");
+		const joined = resp.filter((b) => Array.isArray(b) || typeof b === "object" && b !== null).map((b) => extractText(b, depth + 1)).filter(Boolean).join("\n\n");
+		if (joined) return joined;
+	}
+	if (!resp) return "";
+	try {
+		return JSON.stringify(resp);
+	} catch {
+		return "";
+	}
+}
+//#endregion
+export { compactMarkdown, extractText, jaccardSimilar, loadIndex, queryHash, summarizeIndex };

package/dist/compact-json-DK2nX-MK.mjs

@@ -0,0 +1,21 @@
+//#region src/util/compact-json.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.
+*/
+function compactJson(data) {
+	if (typeof data !== "object" || data === null) return `${JSON.stringify(data)}\n`;
+	if (Array.isArray(data)) {
+		if (data.length === 0) return "[]\n";
+		return `[\n${data.map((item) => `  ${JSON.stringify(item)}`).join(",\n")}\n]\n`;
+	}
+	const lines = [];
+	for (const [key, val] of Object.entries(data)) if (Array.isArray(val) && val.length > 0) {
+		const items = val.map((item) => `    ${JSON.stringify(item)}`);
+		lines.push(`  "${key}": [\n${items.join(",\n")}\n  ]`);
+	} else lines.push(`  "${key}": ${JSON.stringify(val)}`);
+	return `{\n${lines.join(",\n")}\n}\n`;
+}
+//#endregion
+export { compactJson as t };

package/dist/config/index.d.mts

@@ -0,0 +1,37 @@
+//#region src/config/env.d.ts
+/**
+* Robust integer-from-env parser.
+* undefined / empty / whitespace / NaN / float / <= 0 all fall back to `fallback`.
+* `Number("")` is 0, so the empty guard is required before `Number()`.
+*/
+declare function parseEnvInt(raw: string | undefined, fallback: number): number;
+//#endregion
+//#region src/config/ttl.d.ts
+/** Default enforcement-freshness window, in seconds (2 minutes). */
+declare const DEFAULT_TTL_SEC = 120;
+/** Default env var name carrying the TTL override. */
+declare const TTL_ENV_KEY = "FUSE_ENFORCE_TTL_SEC";
+/**
+* Resolve the enforcement TTL (seconds) from an env map.
+* @param env - environment map (defaults to `process.env`)
+* @param key - env var name (defaults to `FUSE_ENFORCE_TTL_SEC`)
+*/
+declare function resolveTtlSec(env?: Record<string, string | undefined>, key?: string): number;
+/** Human label for a TTL: 120 -> "2min", 240 -> "4min", 90 -> "90s". */
+declare function ttlLabel(sec: number): string;
+//#endregion
+//#region src/config/limits.d.ts
+/** Default SOLID max lines per file. */
+declare const DEFAULT_MAX_LINES = 100;
+/** Default env var name carrying the max-lines override. */
+declare const MAX_LINES_ENV_KEY = "FUSE_SOLID_MAX_LINES";
+/**
+* Resolve the SOLID max-lines limit from an env map.
+* @param env - environment map (defaults to `process.env`)
+* @param key - env var name (defaults to `FUSE_SOLID_MAX_LINES`)
+*/
+declare function resolveMaxLines(env?: Record<string, string | undefined>, key?: string): number;
+/** Advisory module-split headroom = `maxLines - 10` (never below 1). */
+declare function splitTarget(maxLines: number): number;
+//#endregion
+export { DEFAULT_MAX_LINES, DEFAULT_TTL_SEC, MAX_LINES_ENV_KEY, TTL_ENV_KEY, parseEnvInt, resolveMaxLines, resolveTtlSec, splitTarget, ttlLabel };

package/dist/config/index.mjs

@@ -0,0 +1,20 @@
+import { a as parseEnvInt, i as splitTarget, n as MAX_LINES_ENV_KEY, r as resolveMaxLines, t as DEFAULT_MAX_LINES } from "../limits-CHn8AIL1.mjs";
+//#region src/config/ttl.ts
+/** Default enforcement-freshness window, in seconds (2 minutes). */
+const DEFAULT_TTL_SEC = 120;
+/** Default env var name carrying the TTL override. */
+const TTL_ENV_KEY = "FUSE_ENFORCE_TTL_SEC";
+/**
+* Resolve the enforcement TTL (seconds) from an env map.
+* @param env - environment map (defaults to `process.env`)
+* @param key - env var name (defaults to `FUSE_ENFORCE_TTL_SEC`)
+*/
+function resolveTtlSec(env = process.env, key = TTL_ENV_KEY) {
+	return parseEnvInt(env[key], 120);
+}
+/** Human label for a TTL: 120 -> "2min", 240 -> "4min", 90 -> "90s". */
+function ttlLabel(sec) {
+	return sec % 60 === 0 ? `${sec / 60}min` : `${sec}s`;
+}
+//#endregion
+export { DEFAULT_MAX_LINES, DEFAULT_TTL_SEC, MAX_LINES_ENV_KEY, TTL_ENV_KEY, parseEnvInt, resolveMaxLines, resolveTtlSec, splitTarget, ttlLabel };

package/dist/detect/index.d.mts

@@ -0,0 +1,31 @@
+//#region src/detect/harness.d.ts
+/**
+* Runtime detection of the AI coding harness, and its integration mode.
+* Env-signal names verified 2026 (agentx, agents.md#136, @vercel/detect-agent,
+* official Claude Code / Cursor / Gemini / Codex docs). Presence-based: the
+* value is ignored except for the `AGENT` / `AI_AGENT` standards.
+*/
+/** Known AI coding harnesses detectable at runtime. */
+type HarnessId = "claude-code" | "codex" | "cursor" | "cline" | "gemini-cli" | "opencode" | "windsurf" | "copilot" | "aider" | "kiro" | "goose" | "amp" | "unknown";
+/** Integration mode: `hook` = native lifecycle hooks; `cli` = run as an external step. */
+type HarnessMode = "hook" | "cli";
+/** How the harness was identified. */
+type HarnessVia = "agent-std" | "ai-agent-std" | "env" | "fallback";
+/** Result of {@link detectHarness}. */
+interface HarnessInfo {
+  id: HarnessId;
+  mode: HarnessMode;
+  via: HarnessVia;
+}
+/** Integration mode for a harness id. */
+declare function modeFor(id: HarnessId): HarnessMode;
+/**
+* Detect the current AI coding harness from environment signals.
+* Priority: `AGENT` standard -> `AI_AGENT` standard -> tool-specific vars -> unknown.
+* @param env - environment map (defaults to `process.env`)
+*/
+declare function detectHarness(env?: Record<string, string | undefined>): HarnessInfo;
+/** Convenience: the integration mode of the current harness. */
+declare function detectMode(env?: Record<string, string | undefined>): HarnessMode;
+//#endregion
+export { HarnessId, HarnessInfo, HarnessMode, HarnessVia, detectHarness, detectMode, modeFor };

package/dist/detect/index.mjs

@@ -0,0 +1,82 @@
+//#region src/detect/harness.ts
+/** Tool-specific env var (presence) -> harness id. Order = detection priority. */
+const ENV_SIGNALS = [
+	["CLAUDECODE", "claude-code"],
+	["CODEX_SANDBOX", "codex"],
+	["CURSOR_AGENT", "cursor"],
+	["CLINE", "cline"],
+	["CLINE_AGENT", "cline"],
+	["GEMINI_CLI", "gemini-cli"],
+	["OPENCODE", "opencode"],
+	["WINDSURF_AGENT", "windsurf"],
+	["CODEIUM_AGENT", "windsurf"],
+	["COPILOT_AGENT", "copilot"],
+	["AIDER", "aider"],
+	["KIRO", "kiro"],
+	["GOOSE", "goose"],
+	["AMP", "amp"]
+];
+/** `AGENT=<name>` / `AI_AGENT=<name>` standard value -> harness id. */
+const STD_NAMES = {
+	goose: "goose",
+	amp: "amp",
+	claude: "claude-code",
+	"claude-code": "claude-code",
+	cursor: "cursor",
+	codex: "codex",
+	cline: "cline",
+	aider: "aider",
+	opencode: "opencode",
+	gemini: "gemini-cli",
+	copilot: "copilot",
+	kiro: "kiro"
+};
+/** Harnesses exposing a native hook system (vs CLI-only integration). */
+const HOOK_CAPABLE = /* @__PURE__ */ new Set([
+	"claude-code",
+	"cursor",
+	"cline",
+	"gemini-cli",
+	"opencode"
+]);
+/** Integration mode for a harness id. */
+function modeFor(id) {
+	return HOOK_CAPABLE.has(id) ? "hook" : "cli";
+}
+/**
+* Detect the current AI coding harness from environment signals.
+* Priority: `AGENT` standard -> `AI_AGENT` standard -> tool-specific vars -> unknown.
+* @param env - environment map (defaults to `process.env`)
+*/
+function detectHarness(env = process.env) {
+	const agent = env.AGENT?.trim().toLowerCase();
+	const agentId = agent ? STD_NAMES[agent] : void 0;
+	if (agentId) return {
+		id: agentId,
+		mode: modeFor(agentId),
+		via: "agent-std"
+	};
+	const ai = env.AI_AGENT?.trim().toLowerCase();
+	const aiId = ai ? STD_NAMES[ai] : void 0;
+	if (aiId) return {
+		id: aiId,
+		mode: modeFor(aiId),
+		via: "ai-agent-std"
+	};
+	for (const [key, id] of ENV_SIGNALS) if (env[key]?.trim()) return {
+		id,
+		mode: modeFor(id),
+		via: "env"
+	};
+	return {
+		id: "unknown",
+		mode: "cli",
+		via: "fallback"
+	};
+}
+/** Convenience: the integration mode of the current harness. */
+function detectMode(env = process.env) {
+	return detectHarness(env).mode;
+}
+//#endregion
+export { detectHarness, detectMode, modeFor };

package/dist/doc-helpers-CG1nuf-c.d.mts

@@ -0,0 +1,30 @@
+//#region src/freshness/doc-helpers.d.ts
+/**
+* Documentation-consultation freshness: was Context7 AND Exa consulted this
+* session (via live MCP query, or a Read on a cached MCP result file)?
+*/
+/** Authorization entry from APEX state (legacy session + new sessions[]). */
+interface AuthEntry {
+  source?: string;
+  sources?: string[];
+  sessions?: string[];
+  session?: string;
+  doc_sessions?: string[];
+  read_paths?: string[];
+}
+/** Resolve the sessions array from an auth entry (legacy fallback). */
+declare function resolveSessions(auth: AuthEntry | undefined): string[];
+/** Per-source satisfaction status for a session. */
+interface DocSatisfactionStatus {
+  context7: boolean;
+  exa: boolean;
+  viaCache: boolean;
+}
+/** True when BOTH Context7 and Exa were satisfied for the session. */
+declare function isDocConsulted(authorizations: Record<string, AuthEntry> | undefined, sessionId: string): boolean;
+/** Report how each doc source was satisfied for a session. */
+declare function formatDocSatisfactionStatus(authorizations: Record<string, AuthEntry> | undefined, sessionId: string): DocSatisfactionStatus;
+/** Deny message when online documentation has not been consulted. */
+declare function formatDocDeny(framework: string): string;
+//#endregion
+export { isDocConsulted as a, formatDocSatisfactionStatus as i, DocSatisfactionStatus as n, resolveSessions as o, formatDocDeny as r, AuthEntry as t };