@fusengine/harness 0.1.5 → 0.1.7

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

@@ -2,49 +2,7 @@
 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 { t as handleHook } from "../handle-BGe0QZvQ.mjs";
 //#region src/cli/bin.ts
 /**
 * harness — CLI for @fusengine/harness.
@@ -66,7 +24,10 @@ 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") {

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/runtime/index.d.mts

@@ -1,10 +1,19 @@
 import { t as Prompt } from "../types-D56jSgD9.mjs";
+import { t as HarnessId } from "../harness-DwJskkz_.mjs";
 import { t as RefMeta } from "../types-CY5qT2X1.mjs";
 
 //#region src/runtime/paths.d.ts
 /** Path to a session's track file (under a per-tool base dir). */
 declare function trackFile(sessionId: string, baseDir?: string): string;
 //#endregion
+//#region src/runtime/storage.d.ts
+/**
+* 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.
+*/
+declare function harnessTrackDir(id: HarnessId, projectRoot: string): string;
+//#endregion
 //#region src/runtime/record.d.ts
 /** A unit of session activity to record (discriminated union on `kind`). */
 type Activity = {
@@ -23,6 +32,25 @@ type Activity = {
 /** Apply an activity to a session's track and persist it (PostToolUse path). */
 declare function recordActivity(file: string, activity: Activity): Promise<void>;
 //#endregion
+//#region src/runtime/activity.d.ts
+/** A live tool-use, already normalized to `tool` + `input` by the adapter. */
+interface ToolEvent {
+  /** The harness's `tool_name` (Cline: `preToolUse.toolName`), as a plain string. */
+  tool: string;
+  input?: Record<string, unknown>;
+  sessionId: string;
+  framework: string;
+  now: number;
+}
+/**
+* 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`
+*/
+declare function activityFor(event: ToolEvent): Activity | null;
+//#endregion
 //#region src/runtime/gate.d.ts
 /** Prior agents the freshness gate requires before a code edit. */
 declare const REQUIRED_AGENTS: ReadonlyArray<string>;
@@ -48,4 +76,49 @@ interface GateInput {
 */
 declare function gate(input: GateInput): Promise<Prompt | null>;
 //#endregion
-export { Activity, DEFAULT_WINDOW_MS, GateInput, REQUIRED_AGENTS, gate, 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,51 +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/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/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, gate, 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.5",
+  "version": "0.1.7",
   "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 };