@fusengine/harness 0.1.6 → 0.1.8

package/dist/adapters/cline/index.mjs

@@ -1,2 +1,25 @@
-import { t as preToolUse } from "../../cline-BxslHtBG.mjs";
+import { t as evaluate } from "../../evaluate-CsYyUucy.mjs";
+import { t as formatPrompt } from "../../types-ernB1Dy3.mjs";
+//#region src/adapters/cline/index.ts
+/**
+* Cline adapter (hook-mode). Schema per docs.cline.bot / .clinerules/hooks (2026):
+* `PreToolUse` blocks via `{ cancel: true }`; it cannot modify tool parameters.
+*/
+/** Evaluate a tool use; cancel on a hard block, otherwise inject context. */
+function preToolUse(input) {
+	const t = input.preToolUse;
+	const r = evaluate({
+		tool: t?.toolName ?? "write_to_file",
+		filePath: t?.parameters?.path,
+		content: t?.parameters?.content,
+		command: t?.parameters?.command
+	});
+	if (r.decision === "allow" || !r.prompt) return {};
+	const msg = formatPrompt(r.prompt);
+	return r.prompt.kind === "block" ? {
+		cancel: true,
+		errorMessage: msg
+	} : { contextModification: msg };
+}
+//#endregion
 export { preToolUse };

package/dist/adapters/cursor/index.mjs

@@ -1,2 +1,37 @@
-import { n as beforeShellExecution, t as afterFileEdit } from "../../cursor-Bh7eh9y_.mjs";
+import { t as evaluate } from "../../evaluate-CsYyUucy.mjs";
+import { t as formatPrompt } from "../../types-ernB1Dy3.mjs";
+//#region src/adapters/cursor/index.ts
+/**
+* Cursor adapter (hook-mode). Schemas per cursor.com/docs/hooks (2026):
+* `beforeShellExecution` can block; `afterFileEdit` is observe-only.
+*/
+function toPermission(kind) {
+	return kind === "block" ? "deny" : kind === "ask" ? "ask" : "allow";
+}
+/** Guard a shell command (git/install policies). */
+function beforeShellExecution(payload) {
+	const r = evaluate({
+		tool: "Bash",
+		command: payload.command
+	});
+	if (r.decision === "allow" || !r.prompt) return { permission: "allow" };
+	const msg = formatPrompt(r.prompt);
+	return {
+		permission: toPermission(r.prompt.kind),
+		continue: false,
+		userMessage: msg,
+		agentMessage: msg
+	};
+}
+/** Observe a file edit (Cursor cannot block here). Returns the verdict for logging. */
+function afterFileEdit(payload) {
+	const content = payload.edits?.map((e) => e.new_string).join("\n") ?? "";
+	const r = evaluate({
+		tool: "Edit",
+		filePath: payload.file_path,
+		content
+	});
+	return { violation: r.decision === "deny" ? r.message : null };
+}
+//#endregion
 export { afterFileEdit, beforeShellExecution };

package/dist/adapters/gemini/index.mjs

@@ -1,2 +1,25 @@
-import { t as beforeTool } from "../../gemini-SrK_fFAr.mjs";
+import { t as evaluate } from "../../evaluate-CsYyUucy.mjs";
+import { t as formatPrompt } from "../../types-ernB1Dy3.mjs";
+//#region src/adapters/gemini/index.ts
+/**
+* Gemini CLI adapter (hook-mode). Schema per google-gemini/gemini-cli docs/hooks (2026):
+* `BeforeTool` blocks via `{ decision: "deny", reason }` (or exit 2).
+*/
+/** Evaluate a tool use; deny on a hard block, otherwise inject context. */
+function beforeTool(input) {
+	const i = input.tool_input;
+	const r = evaluate({
+		tool: input.tool_name ?? "write_file",
+		filePath: i?.path,
+		content: i?.content,
+		command: i?.command
+	});
+	if (r.decision === "allow" || !r.prompt) return {};
+	const msg = formatPrompt(r.prompt);
+	return r.prompt.kind === "block" ? {
+		decision: "deny",
+		reason: msg
+	} : { hookSpecificOutput: { additionalContext: msg } };
+}
+//#endregion
 export { beforeTool };

package/dist/cli/bin.mjs

@@ -1,50 +1,8 @@
 #!/usr/bin/env node
 import { t as detectHarness } from "../harness-C8Nxxyn_.mjs";
 import { n as stagedContent, r as stagedFiles, t as checkStaged } from "../run-h_2LNEA8.mjs";
-import { n as writeInitFile, t as initFor } from "../run-Cc98348q.mjs";
-import { i as guard } from "../claude-DbzjbxmO.mjs";
-import { n as beforeShellExecution, t as afterFileEdit } from "../cursor-Bh7eh9y_.mjs";
-import { t as preToolUse } from "../cline-BxslHtBG.mjs";
-import { t as beforeTool } from "../gemini-SrK_fFAr.mjs";
-//#region src/cli/hook.ts
-/**
-* Route a harness hook payload to its adapter and produce the native response.
-* The deny/ask decision lives in `stdout` (the harness parses it); exit stays 0.
-*/
-function dispatchHook(id, payload) {
-	switch (id) {
-		case "claude-code":
-		case "codex": return {
-			stdout: guard(payload) ?? "",
-			exit: 0
-		};
-		case "cursor":
-			if (payload.hook_event_name === "afterFileEdit") {
-				afterFileEdit(payload);
-				return {
-					stdout: "",
-					exit: 0
-				};
-			}
-			return {
-				stdout: JSON.stringify(beforeShellExecution(payload)),
-				exit: 0
-			};
-		case "cline": return {
-			stdout: JSON.stringify(preToolUse(payload)),
-			exit: 0
-		};
-		case "gemini-cli": return {
-			stdout: JSON.stringify(beforeTool(payload)),
-			exit: 0
-		};
-		default: return {
-			stdout: "",
-			exit: 0
-		};
-	}
-}
-//#endregion
+import { n as writeInitFile, t as initFor } from "../run-Cdp2Ef9B.mjs";
+import { t as handleHook } from "../handle-BGe0QZvQ.mjs";
 //#region src/cli/bin.ts
 /**
 * harness — CLI for @fusengine/harness.
@@ -66,17 +24,21 @@ async function readStdin() {
 }
 const cmd = process.argv[2];
 if (cmd === "hook") {
-	const outcome = dispatchHook(process.argv[3] ?? detectHarness().id, await readStdin());
+	const outcome = await handleHook(process.argv[3] ?? detectHarness().id, await readStdin(), {
+		now: Date.now(),
+		cwd: process.cwd()
+	});
 	if (outcome.stdout) process.stdout.write(outcome.stdout);
 	process.exit(outcome.exit);
 } else if (cmd === "init") {
 	const id = process.argv[3] ?? detectHarness().id;
-	const file = initFor(id);
-	if (!file) {
+	const files = initFor(id);
+	if (!files) {
 		process.stderr.write(`harness: no hook integration for "${id}" — use \`harness check\` in a pre-commit step\n`);
 		process.exit(1);
 	}
-	process.stdout.write(`harness: wired ${id} -> ${writeInitFile(process.cwd(), file)}\n`);
+	const written = files.map((f) => writeInitFile(process.cwd(), f));
+	process.stdout.write(`harness: wired ${id} -> ${written.join(", ")}\n`);
 	process.exit(0);
 } else {
 	const files = stagedFiles();

package/dist/handle-BGe0QZvQ.mjs

@@ -0,0 +1,224 @@
+import { l as detectFramework, t as evaluate } from "./evaluate-CsYyUucy.mjs";
+import { r as evaluateApex } from "./apex-gGrHzvM2.mjs";
+import { t as formatPrompt } from "./types-ernB1Dy3.mjs";
+import { a as recordAgent, n as saveTrack, o as recordDoc, r as agentsFresh, s as recordRefRead, t as loadTrack } from "./store-BWvwnnf6.mjs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+//#region src/runtime/activity.ts
+/** Read tools across harnesses (Claude `Read`, Gemini/Cline `read_file`, …). */
+const READ_TOOLS = /* @__PURE__ */ new Set([
+	"Read",
+	"read_file",
+	"read_many_files"
+]);
+/**
+* Map a live tool-use to the activity to record, or null when nothing is
+* tracked. Works across harnesses — tool names are globally distinct:
+* - MCP doc calls (`context7` / `exa`, any separator) → `doc`
+* - `Task` + `subagent_type` (Claude/Cursor) → `agent` (bare agent name)
+* - a read tool opening a `.md` reference → `ref`
+*/
+function activityFor(event) {
+	if (/context7|exa/i.test(event.tool)) return {
+		kind: "doc",
+		framework: event.framework,
+		sessionId: event.sessionId,
+		source: /exa/i.test(event.tool) ? "exa" : "context7"
+	};
+	if (event.tool === "Task") {
+		const name = String(event.input?.subagent_type ?? "").split(":").pop() ?? "";
+		return name ? {
+			kind: "agent",
+			name,
+			ts: event.now
+		} : null;
+	}
+	if (READ_TOOLS.has(event.tool)) {
+		const path = String(event.input?.file_path ?? event.input?.path ?? "");
+		if (path.endsWith(".md")) return {
+			kind: "ref",
+			path
+		};
+	}
+	return null;
+}
+//#endregion
+//#region src/runtime/gate.ts
+/** Prior agents the freshness gate requires before a code edit. */
+const REQUIRED_AGENTS = ["explore-codebase", "research-expert"];
+/** Default freshness window for {@link REQUIRED_AGENTS} (4 min, the APEX TTL). */
+const DEFAULT_WINDOW_MS = 24e4;
+/**
+* Full gate: the stateless guards (file-size, git) first, then the stateful
+* APEX gates fed from the session track. Returns the first blocking prompt, or
+* null to allow. APEX gates apply only to code edits (a `filePath`).
+*/
+async function gate(input) {
+	const quick = evaluate({
+		tool: input.tool,
+		filePath: input.filePath,
+		content: input.content,
+		command: input.command
+	});
+	if (quick.decision !== "allow" && quick.prompt) return quick.prompt;
+	if (!input.filePath) return null;
+	const track = await loadTrack(input.trackFile);
+	return evaluateApex({
+		sessionId: input.sessionId,
+		framework: input.framework,
+		filePath: input.filePath,
+		content: input.content ?? "",
+		authorizations: track.authorizations,
+		refs: input.refs,
+		refsRead: track.refsRead,
+		agentsFresh: agentsFresh(track, [...REQUIRED_AGENTS], input.windowMs ?? 24e4, input.now)
+	});
+}
+//#endregion
+//#region src/runtime/normalize.ts
+function str(v) {
+	return typeof v === "string" ? v : void 0;
+}
+/**
+* Normalize a harness hook payload into a uniform event. Handles Cline's nested
+* `preToolUse`/`postToolUse` shape and the top-level `tool_name`/`tool_input`
+* shape used by Claude, Codex, Gemini, and Cursor.
+*/
+function normalizeEvent(id, payload) {
+	if (id === "cline") {
+		const post = payload.postToolUse;
+		const node = post ?? payload.preToolUse ?? {};
+		const params = node.parameters ?? {};
+		return {
+			phase: post ? "post" : "pre",
+			tool: str(node.toolName) ?? "",
+			input: params,
+			sessionId: str(payload.taskId) ?? "",
+			filePath: str(params.path),
+			content: str(params.content),
+			command: str(params.command)
+		};
+	}
+	const event = str(payload.hook_event_name) ?? "";
+	const input = payload.tool_input ?? payload;
+	return {
+		phase: /post|after/i.test(event) ? "post" : "pre",
+		tool: str(payload.tool_name) ?? "",
+		input,
+		sessionId: str(payload.session_id) ?? str(payload.conversation_id) ?? "",
+		filePath: str(input.file_path) ?? str(input.path) ?? str(payload.file_path),
+		content: str(input.content) ?? str(input.new_string),
+		command: str(input.command) ?? str(payload.command)
+	};
+}
+//#endregion
+//#region src/runtime/paths.ts
+/** Path to a session's track file (under a per-tool base dir). */
+function trackFile(sessionId, baseDir = join(tmpdir(), "fuse-harness")) {
+	return join(baseDir, `track-${sessionId.replace(/[^A-Za-z0-9_-]/g, "_") || "default"}.json`);
+}
+//#endregion
+//#region src/runtime/record.ts
+/** Apply an activity to a session's track and persist it (PostToolUse path). */
+async function recordActivity(file, activity) {
+	const track = await loadTrack(file);
+	await saveTrack(file, activity.kind === "agent" ? recordAgent(track, activity.name, activity.ts) : activity.kind === "doc" ? recordDoc(track, activity.framework, activity.sessionId, activity.source) : recordRefRead(track, activity.path));
+}
+//#endregion
+//#region src/runtime/respond.ts
+/**
+* Map a portable {@link Prompt} to a harness's native hook response. `block`
+* denies; anything else asks/injects context. (Codex/Cursor parse but ignore
+* `ask` — they only honor deny.)
+*/
+function respond(id, prompt) {
+	const message = formatPrompt(prompt);
+	const deny = prompt.kind === "block";
+	switch (id) {
+		case "claude-code":
+		case "codex": return JSON.stringify({ hookSpecificOutput: {
+			hookEventName: "PreToolUse",
+			permissionDecision: deny ? "deny" : "ask",
+			permissionDecisionReason: message
+		} });
+		case "gemini-cli": return JSON.stringify(deny ? {
+			decision: "deny",
+			reason: message
+		} : { hookSpecificOutput: { additionalContext: message } });
+		case "cursor": return JSON.stringify({
+			permission: deny ? "deny" : "ask",
+			continue: false,
+			userMessage: message,
+			agentMessage: message
+		});
+		case "cline": return JSON.stringify(deny ? {
+			cancel: true,
+			errorMessage: message
+		} : { contextModification: message });
+		default: return "";
+	}
+}
+//#endregion
+//#region src/runtime/storage.ts
+/** Per-harness config dir (relative to the project root) where state lives. */
+const STATE_DIR = {
+	"claude-code": ".claude",
+	codex: ".codex",
+	cursor: ".cursor",
+	"gemini-cli": ".gemini",
+	cline: ".clinerules"
+};
+/**
+* Directory where a harness's fuse-harness track files live — under that
+* harness's own config dir (`.claude`, `.codex`, …) so state sits next to its
+* hooks. Falls back to `.fuse-harness` for harnesses without a known config dir.
+*/
+function harnessTrackDir(id, projectRoot) {
+	return join(projectRoot, STATE_DIR[id] ?? ".fuse-harness", "harness");
+}
+//#endregion
+//#region src/runtime/handle.ts
+/**
+* The full hook handler: on a PRE event it gates the tool-use (stateless guards
+* then APEX gates from the session track) and returns the native response; on a
+* POST event it records the activity into the track. The loop that makes the
+* package behave like the Claude plugin, on any harness.
+*/
+async function handleHook(id, payload, opts) {
+	const event = normalizeEvent(id, payload);
+	const file = trackFile(event.sessionId, harnessTrackDir(id, opts.cwd));
+	const framework = detectFramework(event.filePath ?? "", event.content ?? "");
+	if (event.phase === "post") {
+		const activity = activityFor({
+			tool: event.tool,
+			input: event.input,
+			sessionId: event.sessionId,
+			framework,
+			now: opts.now
+		});
+		if (activity) await recordActivity(file, activity);
+		return {
+			stdout: "",
+			exit: 0
+		};
+	}
+	const prompt = await gate({
+		sessionId: event.sessionId,
+		framework,
+		tool: event.tool,
+		filePath: event.filePath,
+		content: event.content,
+		command: event.command,
+		now: opts.now,
+		trackFile: file
+	});
+	return prompt ? {
+		stdout: respond(id, prompt),
+		exit: 0
+	} : {
+		stdout: "",
+		exit: 0
+	};
+}
+//#endregion
+export { trackFile as a, REQUIRED_AGENTS as c, recordActivity as i, gate as l, harnessTrackDir as n, normalizeEvent as o, respond as r, DEFAULT_WINDOW_MS as s, handleHook as t, activityFor as u };

package/dist/init/index.d.mts

@@ -2,8 +2,9 @@ import { t as HarnessId } from "../harness-DwJskkz_.mjs";
 
 //#region src/init/templates.d.ts
 /**
-* Wiring file templates per harness, to register `harness hook <id>` as a
-* tool-use hook. Formats verified against each harness's 2026 hook docs.
+* Wiring file templates per harness, registering `harness hook <id>` for BOTH
+* phases: PRE (gate the edit) and POST (catch-all → `activityFor` filters what
+* to record). Formats verified against each harness's 2026 hook docs.
 */
 /** A file to write during `harness init`. */
 interface InitFile {
@@ -11,23 +12,23 @@ interface InitFile {
   content: string;
   executable?: boolean;
 }
-/** Claude Code: PreToolUse(Write|Edit) -> command. Target: `.claude/settings.json`. */
-declare function claudeInit(command: string): InitFile;
-/** Codex CLI: `.codex/hooks.json` — PreToolUse (Claude-compatible shape). */
-declare function codexInit(command: string): InitFile;
-/** Cursor: `.cursor/hooks.json` (version 1) — shell + file-edit hooks. */
-declare function cursorInit(command: string): InitFile;
-/** Gemini CLI: `.gemini/settings.json` — BeforeTool, timeout in ms. */
-declare function geminiInit(command: string): InitFile;
-/** Cline: an executable `.clinerules/hooks/PreToolUse` that pipes stdin to the command. */
-declare function clineInit(command: string): InitFile;
+/** Claude Code: `.claude/settings.json` — PreToolUse(Write|Edit) + PostToolUse(all). */
+declare function claudeInit(command: string): InitFile[];
+/** Codex CLI: `.codex/hooks.json` (Claude-compatible shape). */
+declare function codexInit(command: string): InitFile[];
+/** Cursor: `.cursor/hooks.json` (version 1) — shell + tool gate + file-edit observe. */
+declare function cursorInit(command: string): InitFile[];
+/** Gemini CLI: `.gemini/settings.json` — BeforeTool(edits) + AfterTool(all, regex). */
+declare function geminiInit(command: string): InitFile[];
+/** Cline: executable `.clinerules/hooks/PreToolUse` + `PostToolUse` piping stdin. */
+declare function clineInit(command: string): InitFile[];
 //#endregion
 //#region src/init/run.d.ts
 /**
-* Build the wiring file for a harness, or null when it has no hook integration
-* (cli-mode harnesses use `harness check` in a pre-commit step instead).
+* Build the wiring file(s) for a harness, or null when it has no hook
+* integration (cli-mode harnesses use `harness check` in a pre-commit step).
 */
-declare function initFor(id: HarnessId, command?: string): InitFile | null;
+declare function initFor(id: HarnessId, command?: string): InitFile[] | null;
 /** Write an {@link InitFile} under `root` (creates dirs; `chmod +x` when executable). */
 declare function writeInitFile(root: string, file: InitFile): string;
 //#endregion

package/dist/init/index.mjs

@@ -1,2 +1,2 @@
-import { a as codexInit, i as clineInit, n as writeInitFile, o as cursorInit, r as claudeInit, s as geminiInit, t as initFor } from "../run-Cc98348q.mjs";
+import { a as codexInit, i as clineInit, n as writeInitFile, o as cursorInit, r as claudeInit, s as geminiInit, t as initFor } from "../run-Cdp2Ef9B.mjs";
 export { claudeInit, clineInit, codexInit, cursorInit, geminiInit, initFor, writeInitFile };

package/dist/run-Cdp2Ef9B.mjs

@@ -0,0 +1,128 @@
+import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/init/templates.ts
+function json(obj) {
+	return `${JSON.stringify(obj, null, 2)}\n`;
+}
+/** Claude Code: `.claude/settings.json` — PreToolUse(Write|Edit) + PostToolUse(all). */
+function claudeInit(command) {
+	return [{
+		path: ".claude/settings.json",
+		content: json({ hooks: {
+			PreToolUse: [{
+				matcher: "Write|Edit",
+				hooks: [{
+					type: "command",
+					command
+				}]
+			}],
+			PostToolUse: [{
+				matcher: "",
+				hooks: [{
+					type: "command",
+					command
+				}]
+			}]
+		} })
+	}];
+}
+/** Codex CLI: `.codex/hooks.json` (Claude-compatible shape). */
+function codexInit(command) {
+	return [{
+		path: ".codex/hooks.json",
+		content: json({ hooks: {
+			PreToolUse: [{
+				matcher: "Bash|apply_patch",
+				hooks: [{
+					type: "command",
+					command
+				}]
+			}],
+			PostToolUse: [{
+				matcher: "",
+				hooks: [{
+					type: "command",
+					command
+				}]
+			}]
+		} })
+	}];
+}
+/** Cursor: `.cursor/hooks.json` (version 1) — shell + tool gate + file-edit observe. */
+function cursorInit(command) {
+	return [{
+		path: ".cursor/hooks.json",
+		content: json({
+			version: 1,
+			hooks: {
+				beforeShellExecution: [{ command }],
+				preToolUse: [{ command }],
+				afterFileEdit: [{ command }]
+			}
+		})
+	}];
+}
+/** Gemini CLI: `.gemini/settings.json` — BeforeTool(edits) + AfterTool(all, regex). */
+function geminiInit(command) {
+	return [{
+		path: ".gemini/settings.json",
+		content: json({ hooks: {
+			BeforeTool: [{
+				matcher: "write_file|edit_file|replace",
+				hooks: [{
+					type: "command",
+					command,
+					timeout: 3e4
+				}]
+			}],
+			AfterTool: [{
+				matcher: ".*",
+				hooks: [{
+					type: "command",
+					command,
+					timeout: 3e4
+				}]
+			}]
+		} })
+	}];
+}
+/** Cline: executable `.clinerules/hooks/PreToolUse` + `PostToolUse` piping stdin. */
+function clineInit(command) {
+	const script = (phase) => `#!/usr/bin/env bash\n# fuse-harness Cline ${phase} hook\ncat | ${command}\n`;
+	return [{
+		path: ".clinerules/hooks/PreToolUse",
+		content: script("pre"),
+		executable: true
+	}, {
+		path: ".clinerules/hooks/PostToolUse",
+		content: script("post"),
+		executable: true
+	}];
+}
+//#endregion
+//#region src/init/run.ts
+const RUNNERS = {
+	"claude-code": claudeInit,
+	codex: codexInit,
+	cursor: cursorInit,
+	"gemini-cli": geminiInit,
+	cline: clineInit
+};
+/**
+* Build the wiring file(s) for a harness, or null when it has no hook
+* integration (cli-mode harnesses use `harness check` in a pre-commit step).
+*/
+function initFor(id, command = `npx harness hook ${id}`) {
+	const make = RUNNERS[id];
+	return make ? make(command) : null;
+}
+/** Write an {@link InitFile} under `root` (creates dirs; `chmod +x` when executable). */
+function writeInitFile(root, file) {
+	const full = join(root, file.path);
+	mkdirSync(dirname(full), { recursive: true });
+	writeFileSync(full, file.content);
+	if (file.executable) chmodSync(full, 493);
+	return full;
+}
+//#endregion
+export { codexInit as a, clineInit as i, writeInitFile as n, cursorInit as o, claudeInit as r, geminiInit as s, initFor as t };

package/dist/runtime/index.d.mts

@@ -76,4 +76,49 @@ interface GateInput {
 */
 declare function gate(input: GateInput): Promise<Prompt | null>;
 //#endregion
-export { Activity, DEFAULT_WINDOW_MS, GateInput, REQUIRED_AGENTS, ToolEvent, activityFor, gate, harnessTrackDir, recordActivity, trackFile };
+//#region src/runtime/normalize.d.ts
+/** A hook event normalized across harnesses. */
+interface NormalizedEvent {
+  phase: "pre" | "post";
+  tool: string;
+  input: Record<string, unknown>;
+  sessionId: string;
+  filePath?: string;
+  content?: string;
+  command?: string;
+}
+/**
+* Normalize a harness hook payload into a uniform event. Handles Cline's nested
+* `preToolUse`/`postToolUse` shape and the top-level `tool_name`/`tool_input`
+* shape used by Claude, Codex, Gemini, and Cursor.
+*/
+declare function normalizeEvent(id: string, payload: Record<string, unknown>): NormalizedEvent;
+//#endregion
+//#region src/runtime/respond.d.ts
+/**
+* Map a portable {@link Prompt} to a harness's native hook response. `block`
+* denies; anything else asks/injects context. (Codex/Cursor parse but ignore
+* `ask` — they only honor deny.)
+*/
+declare function respond(id: string, prompt: Prompt): string;
+//#endregion
+//#region src/runtime/handle.d.ts
+/** Options for {@link handleHook} (caller supplies the clock + project root). */
+interface HandleOptions {
+  now: number;
+  cwd: string;
+}
+/** What the hook bin should print + exit with. */
+interface HandleOutcome {
+  stdout: string;
+  exit: number;
+}
+/**
+* The full hook handler: on a PRE event it gates the tool-use (stateless guards
+* then APEX gates from the session track) and returns the native response; on a
+* POST event it records the activity into the track. The loop that makes the
+* package behave like the Claude plugin, on any harness.
+*/
+declare function handleHook(id: string, payload: Record<string, unknown>, opts: HandleOptions): Promise<HandleOutcome>;
+//#endregion
+export { Activity, DEFAULT_WINDOW_MS, GateInput, HandleOptions, HandleOutcome, NormalizedEvent, REQUIRED_AGENTS, ToolEvent, activityFor, gate, handleHook, harnessTrackDir, normalizeEvent, recordActivity, respond, trackFile };

package/dist/runtime/index.mjs

@@ -1,108 +1,2 @@
-import { t as evaluate } from "../evaluate-CsYyUucy.mjs";
-import { r as evaluateApex } from "../apex-gGrHzvM2.mjs";
-import { a as recordAgent, n as saveTrack, o as recordDoc, r as agentsFresh, s as recordRefRead, t as loadTrack } from "../store-BWvwnnf6.mjs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-//#region src/runtime/paths.ts
-/** Path to a session's track file (under a per-tool base dir). */
-function trackFile(sessionId, baseDir = join(tmpdir(), "fuse-harness")) {
-	return join(baseDir, `track-${sessionId.replace(/[^A-Za-z0-9_-]/g, "_") || "default"}.json`);
-}
-//#endregion
-//#region src/runtime/storage.ts
-/** Per-harness config dir (relative to the project root) where state lives. */
-const STATE_DIR = {
-	"claude-code": ".claude",
-	codex: ".codex",
-	cursor: ".cursor",
-	"gemini-cli": ".gemini",
-	cline: ".clinerules"
-};
-/**
-* Directory where a harness's fuse-harness track files live — under that
-* harness's own config dir (`.claude`, `.codex`, …) so state sits next to its
-* hooks. Falls back to `.fuse-harness` for harnesses without a known config dir.
-*/
-function harnessTrackDir(id, projectRoot) {
-	return join(projectRoot, STATE_DIR[id] ?? ".fuse-harness", "harness");
-}
-//#endregion
-//#region src/runtime/record.ts
-/** Apply an activity to a session's track and persist it (PostToolUse path). */
-async function recordActivity(file, activity) {
-	const track = await loadTrack(file);
-	await saveTrack(file, activity.kind === "agent" ? recordAgent(track, activity.name, activity.ts) : activity.kind === "doc" ? recordDoc(track, activity.framework, activity.sessionId, activity.source) : recordRefRead(track, activity.path));
-}
-//#endregion
-//#region src/runtime/activity.ts
-/** Read tools across harnesses (Claude `Read`, Gemini/Cline `read_file`, …). */
-const READ_TOOLS = /* @__PURE__ */ new Set([
-	"Read",
-	"read_file",
-	"read_many_files"
-]);
-/**
-* Map a live tool-use to the activity to record, or null when nothing is
-* tracked. Works across harnesses — tool names are globally distinct:
-* - MCP doc calls (`context7` / `exa`, any separator) → `doc`
-* - `Task` + `subagent_type` (Claude/Cursor) → `agent` (bare agent name)
-* - a read tool opening a `.md` reference → `ref`
-*/
-function activityFor(event) {
-	if (/context7|exa/i.test(event.tool)) return {
-		kind: "doc",
-		framework: event.framework,
-		sessionId: event.sessionId,
-		source: /exa/i.test(event.tool) ? "exa" : "context7"
-	};
-	if (event.tool === "Task") {
-		const name = String(event.input?.subagent_type ?? "").split(":").pop() ?? "";
-		return name ? {
-			kind: "agent",
-			name,
-			ts: event.now
-		} : null;
-	}
-	if (READ_TOOLS.has(event.tool)) {
-		const path = String(event.input?.file_path ?? event.input?.path ?? "");
-		if (path.endsWith(".md")) return {
-			kind: "ref",
-			path
-		};
-	}
-	return null;
-}
-//#endregion
-//#region src/runtime/gate.ts
-/** Prior agents the freshness gate requires before a code edit. */
-const REQUIRED_AGENTS = ["explore-codebase", "research-expert"];
-/** Default freshness window for {@link REQUIRED_AGENTS} (4 min, the APEX TTL). */
-const DEFAULT_WINDOW_MS = 24e4;
-/**
-* Full gate: the stateless guards (file-size, git) first, then the stateful
-* APEX gates fed from the session track. Returns the first blocking prompt, or
-* null to allow. APEX gates apply only to code edits (a `filePath`).
-*/
-async function gate(input) {
-	const quick = evaluate({
-		tool: input.tool,
-		filePath: input.filePath,
-		content: input.content,
-		command: input.command
-	});
-	if (quick.decision !== "allow" && quick.prompt) return quick.prompt;
-	if (!input.filePath) return null;
-	const track = await loadTrack(input.trackFile);
-	return evaluateApex({
-		sessionId: input.sessionId,
-		framework: input.framework,
-		filePath: input.filePath,
-		content: input.content ?? "",
-		authorizations: track.authorizations,
-		refs: input.refs,
-		refsRead: track.refsRead,
-		agentsFresh: agentsFresh(track, [...REQUIRED_AGENTS], input.windowMs ?? 24e4, input.now)
-	});
-}
-//#endregion
-export { DEFAULT_WINDOW_MS, REQUIRED_AGENTS, activityFor, gate, harnessTrackDir, recordActivity, trackFile };
+import { a as trackFile, c as REQUIRED_AGENTS, i as recordActivity, l as gate, n as harnessTrackDir, o as normalizeEvent, r as respond, s as DEFAULT_WINDOW_MS, t as handleHook, u as activityFor } from "../handle-BGe0QZvQ.mjs";
+export { DEFAULT_WINDOW_MS, REQUIRED_AGENTS, activityFor, gate, handleHook, harnessTrackDir, normalizeEvent, recordActivity, respond, trackFile };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusengine/harness",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "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, per-harness adapters (Claude/Cursor/Cline/Gemini) and a cli-mode harness-check binary. Bun-native, with a built dist for Node + bundlers.",
   "type": "module",
   "module": "src/index.ts",

package/dist/cline-BxslHtBG.mjs

@@ -1,25 +0,0 @@
-import { t as evaluate } from "./evaluate-CsYyUucy.mjs";
-import { t as formatPrompt } from "./types-ernB1Dy3.mjs";
-//#region src/adapters/cline/index.ts
-/**
-* Cline adapter (hook-mode). Schema per docs.cline.bot / .clinerules/hooks (2026):
-* `PreToolUse` blocks via `{ cancel: true }`; it cannot modify tool parameters.
-*/
-/** Evaluate a tool use; cancel on a hard block, otherwise inject context. */
-function preToolUse(input) {
-	const t = input.preToolUse;
-	const r = evaluate({
-		tool: t?.toolName ?? "write_to_file",
-		filePath: t?.parameters?.path,
-		content: t?.parameters?.content,
-		command: t?.parameters?.command
-	});
-	if (r.decision === "allow" || !r.prompt) return {};
-	const msg = formatPrompt(r.prompt);
-	return r.prompt.kind === "block" ? {
-		cancel: true,
-		errorMessage: msg
-	} : { contextModification: msg };
-}
-//#endregion
-export { preToolUse as t };

package/dist/cursor-Bh7eh9y_.mjs

@@ -1,37 +0,0 @@
-import { t as evaluate } from "./evaluate-CsYyUucy.mjs";
-import { t as formatPrompt } from "./types-ernB1Dy3.mjs";
-//#region src/adapters/cursor/index.ts
-/**
-* Cursor adapter (hook-mode). Schemas per cursor.com/docs/hooks (2026):
-* `beforeShellExecution` can block; `afterFileEdit` is observe-only.
-*/
-function toPermission(kind) {
-	return kind === "block" ? "deny" : kind === "ask" ? "ask" : "allow";
-}
-/** Guard a shell command (git/install policies). */
-function beforeShellExecution(payload) {
-	const r = evaluate({
-		tool: "Bash",
-		command: payload.command
-	});
-	if (r.decision === "allow" || !r.prompt) return { permission: "allow" };
-	const msg = formatPrompt(r.prompt);
-	return {
-		permission: toPermission(r.prompt.kind),
-		continue: false,
-		userMessage: msg,
-		agentMessage: msg
-	};
-}
-/** Observe a file edit (Cursor cannot block here). Returns the verdict for logging. */
-function afterFileEdit(payload) {
-	const content = payload.edits?.map((e) => e.new_string).join("\n") ?? "";
-	const r = evaluate({
-		tool: "Edit",
-		filePath: payload.file_path,
-		content
-	});
-	return { violation: r.decision === "deny" ? r.message : null };
-}
-//#endregion
-export { beforeShellExecution as n, afterFileEdit as t };

package/dist/gemini-SrK_fFAr.mjs

@@ -1,25 +0,0 @@
-import { t as evaluate } from "./evaluate-CsYyUucy.mjs";
-import { t as formatPrompt } from "./types-ernB1Dy3.mjs";
-//#region src/adapters/gemini/index.ts
-/**
-* Gemini CLI adapter (hook-mode). Schema per google-gemini/gemini-cli docs/hooks (2026):
-* `BeforeTool` blocks via `{ decision: "deny", reason }` (or exit 2).
-*/
-/** Evaluate a tool use; deny on a hard block, otherwise inject context. */
-function beforeTool(input) {
-	const i = input.tool_input;
-	const r = evaluate({
-		tool: input.tool_name ?? "write_file",
-		filePath: i?.path,
-		content: i?.content,
-		command: i?.command
-	});
-	if (r.decision === "allow" || !r.prompt) return {};
-	const msg = formatPrompt(r.prompt);
-	return r.prompt.kind === "block" ? {
-		decision: "deny",
-		reason: msg
-	} : { hookSpecificOutput: { additionalContext: msg } };
-}
-//#endregion
-export { beforeTool as t };

package/dist/run-Cc98348q.mjs

@@ -1,94 +0,0 @@
-import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-//#region src/init/templates.ts
-function json(obj) {
-	return `${JSON.stringify(obj, null, 2)}\n`;
-}
-/** Claude Code: PreToolUse(Write|Edit) -> command. Target: `.claude/settings.json`. */
-function claudeInit(command) {
-	return {
-		path: ".claude/settings.json",
-		content: json({ hooks: { PreToolUse: [{
-			matcher: "Write|Edit",
-			hooks: [{
-				type: "command",
-				command
-			}]
-		}] } })
-	};
-}
-/** Codex CLI: `.codex/hooks.json` — PreToolUse (Claude-compatible shape). */
-function codexInit(command) {
-	return {
-		path: ".codex/hooks.json",
-		content: json({ hooks: { PreToolUse: [{
-			matcher: "Bash|apply_patch",
-			hooks: [{
-				type: "command",
-				command
-			}]
-		}] } })
-	};
-}
-/** Cursor: `.cursor/hooks.json` (version 1) — shell + file-edit hooks. */
-function cursorInit(command) {
-	return {
-		path: ".cursor/hooks.json",
-		content: json({
-			version: 1,
-			hooks: {
-				beforeShellExecution: [{ command }],
-				afterFileEdit: [{ command }]
-			}
-		})
-	};
-}
-/** Gemini CLI: `.gemini/settings.json` — BeforeTool, timeout in ms. */
-function geminiInit(command) {
-	return {
-		path: ".gemini/settings.json",
-		content: json({ hooks: { BeforeTool: [{
-			matcher: "write_file|edit_file|replace",
-			hooks: [{
-				type: "command",
-				command,
-				timeout: 3e4
-			}]
-		}] } })
-	};
-}
-/** Cline: an executable `.clinerules/hooks/PreToolUse` that pipes stdin to the command. */
-function clineInit(command) {
-	return {
-		path: ".clinerules/hooks/PreToolUse",
-		content: `#!/usr/bin/env bash\n# fuse-harness Cline hook — evaluate each tool use\ncat | ${command}\n`,
-		executable: true
-	};
-}
-//#endregion
-//#region src/init/run.ts
-const RUNNERS = {
-	"claude-code": claudeInit,
-	codex: codexInit,
-	cursor: cursorInit,
-	"gemini-cli": geminiInit,
-	cline: clineInit
-};
-/**
-* Build the wiring file for a harness, or null when it has no hook integration
-* (cli-mode harnesses use `harness check` in a pre-commit step instead).
-*/
-function initFor(id, command = `npx harness hook ${id}`) {
-	const make = RUNNERS[id];
-	return make ? make(command) : null;
-}
-/** Write an {@link InitFile} under `root` (creates dirs; `chmod +x` when executable). */
-function writeInitFile(root, file) {
-	const full = join(root, file.path);
-	mkdirSync(dirname(full), { recursive: true });
-	writeFileSync(full, file.content);
-	if (file.executable) chmodSync(full, 493);
-	return full;
-}
-//#endregion
-export { codexInit as a, clineInit as i, writeInitFile as n, cursorInit as o, claudeInit as r, geminiInit as s, initFor as t };