auto-mode 0.2.0 → 0.3.0

package/README.md

@@ -113,6 +113,10 @@ was there. Set `onFailure` to `deny` to fail closed instead.
 | `auto-mode print-prompt`     | Print the assembled system prompt                  |
 | `auto-mode init <harness>`   | Print the hook entry to add                        |
 
+`init` takes `--event permission-request` to register on the event Claude Code sends when it is
+about to ask you, rather than on every tool call. The
+[harness guide](./docs/guides/harnesses.md#which-event) covers the choice.
+
 ## Documentation
 
 - [Overview](./docs/architecture/overview.md) — the two tiers, harness detection, the verdict

package/dist/{classify-locally-rTUwxBZi.js → classify-locally-BRMllwcd.js}

@@ -5663,18 +5663,30 @@ function F(t) {
 //#endregion
 //#region src/harness/render-verdict.ts
 function renderVerdict(event, verdict) {
-	const decision = M(verdict).with({ kind: "ask" }, () => ({ permissionDecision: "ask" })).with({ kind: "allow" }, () => ({ permissionDecision: "allow" })).with({ kind: "deny" }, (denied) => ({
-		permissionDecision: "deny",
-		permissionDecisionReason: `[${denied.rule}] ${denied.reason}`
-	})).exhaustive();
-	return JSON.stringify({ hookSpecificOutput: {
+	const decision = M(event).with("PreToolUse", () => buildToolGateDecision(verdict)).with("PermissionRequest", () => buildPermissionDecision(verdict)).exhaustive();
+	return decision === null ? null : JSON.stringify({ hookSpecificOutput: {
 		hookEventName: event,
 		...decision
 	} });
 }
+function buildToolGateDecision(verdict) {
+	return M(verdict).with({ kind: "ask" }, () => ({ permissionDecision: "ask" })).with({ kind: "allow" }, () => ({ permissionDecision: "allow" })).with({ kind: "deny" }, (denied) => ({
+		permissionDecision: "deny",
+		permissionDecisionReason: formatReason(denied)
+	})).exhaustive();
+}
+function buildPermissionDecision(verdict) {
+	return M(verdict).with({ kind: "ask" }, () => null).with({ kind: "allow" }, () => ({ decision: { behavior: "allow" } })).with({ kind: "deny" }, (denied) => ({ decision: {
+		behavior: "deny",
+		message: formatReason(denied)
+	} })).exhaustive();
+}
+function formatReason(denied) {
+	return `[${denied.rule}] ${denied.reason}`;
+}
 //#endregion
 //#region src/install/hook-config.ts
-function buildHookConfig(harness, command) {
+function buildHookConfig(harness, command, event = "PreToolUse") {
 	const entry = M(harness).with("claude", () => ({
 		matcher: ".*",
 		hooks: [{
@@ -5693,13 +5705,17 @@ function buildHookConfig(harness, command) {
 			command
 		}]
 	})).exhaustive();
-	return JSON.stringify({ hooks: { PreToolUse: [entry] } }, null, 2);
+	return JSON.stringify({ hooks: { [event]: [entry] } }, null, 2);
 }
 const SETTINGS_PATHS = {
 	claude: "~/.claude/settings.json",
 	codex: "~/.codex/hooks.json",
 	muse: "~/.config/muse/settings.json"
 };
+const EVENT_NOTES = {
+	PreToolUse: ["The hook judges every tool call, including the ones the harness would have run", "without asking."],
+	PermissionRequest: ["Claude Code sends this event only when it is about to ask you, so the hook", "answers those prompts and judges nothing the harness already allows."]
+};
 const SETUP_NOTES = {
 	claude: ["A tool your permission settings already deny is refused before the hook sees it, so", "auto-mode can only narrow what the harness would have allowed."],
 	codex: [
@@ -6200,4 +6216,4 @@ function toUnquoted(word) {
 	return (first === "'" || first === "\"") && word.at(-1) === first ? word.slice(1, -1) : word;
 }
 //#endregion
-export { loadPolicy as a, buildHookConfig as c, detectHarness as d, DEFAULT_CONFIG as f, resolveConfigPath as g, resolveApiKey as h, readTranscript as i, renderVerdict as l, loadConfig as m, classifyWithModel as n, SETTINGS_PATHS as o, PRESETS as p, parseModelVerdict as r, SETUP_NOTES as s, classifyLocally as t, parsePayload as u };
+export { resolveConfigPath as _, loadPolicy as a, SETUP_NOTES as c, parsePayload as d, detectHarness as f, resolveApiKey as g, loadConfig as h, readTranscript as i, buildHookConfig as l, PRESETS as m, classifyWithModel as n, EVENT_NOTES as o, DEFAULT_CONFIG as p, parseModelVerdict as r, SETTINGS_PATHS as s, classifyLocally as t, renderVerdict as u };

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as loadPolicy, c as buildHookConfig, g as resolveConfigPath, l as renderVerdict, m as loadConfig, n as classifyWithModel, o as SETTINGS_PATHS, s as SETUP_NOTES, t as classifyLocally, u as parsePayload } from "./classify-locally-rTUwxBZi.js";
+import { _ as resolveConfigPath, a as loadPolicy, c as SETUP_NOTES, d as parsePayload, h as loadConfig, l as buildHookConfig, n as classifyWithModel, o as EVENT_NOTES, s as SETTINGS_PATHS, t as classifyLocally, u as renderVerdict } from "./classify-locally-BRMllwcd.js";
 import { parseArgs } from "node:util";
 import { text } from "node:stream/consumers";
 //#region src/cli.ts
@@ -13,6 +13,7 @@ Usage:
 Options:
   --classifier <path>   Use this framework file instead of the shipped one
   --rules <path>        Use this rule list instead of the shipped one
+  --event <event>       With init: pre-tool-use, the default, or permission-request
   --explain             With run: also write the reasoning to stderr
   --local-only          With run: skip the model tier
 `;
@@ -31,19 +32,27 @@ async function run(explain, localOnly) {
 	if (payload === null) return printNote(explain, "not a tool gate this hook judges, so no verdict");
 	const local = classifyLocally(payload);
 	if (local.kind === "allow") {
-		process.stdout.write(renderVerdict(payload.event, { kind: "allow" }));
+		writeVerdict(payload.event, { kind: "allow" });
 		return printNote(explain, `allowed by ${local.exception} (${payload.harness}, local)`);
 	}
 	if (localOnly) return printNote(explain, `${payload.toolName} needs the model tier, which --local-only skipped`);
 	const config = await loadConfig();
 	const outcome = await classifyWithModel(payload, config);
-	if (outcome.verdict !== null) process.stdout.write(renderVerdict(payload.event, outcome.verdict));
+	if (outcome.verdict !== null) writeVerdict(payload.event, outcome.verdict);
 	return printNote(explain, outcome.note);
 }
+function writeVerdict(event, verdict) {
+	const rendered = renderVerdict(event, verdict);
+	if (rendered !== null) process.stdout.write(rendered);
+}
 function printNote(explain, message) {
 	if (explain) process.stderr.write(`auto-mode: ${message}\n`);
 	return 0;
 }
+const HOOK_EVENTS = {
+	"pre-tool-use": "PreToolUse",
+	"permission-request": "PermissionRequest"
+};
 async function main(argv) {
 	const args = parseArgs({
 		args: [...argv],
@@ -51,6 +60,7 @@ async function main(argv) {
 		options: {
 			classifier: { type: "string" },
 			rules: { type: "string" },
+			event: { type: "string" },
 			explain: { type: "boolean" },
 			"local-only": { type: "boolean" },
 			help: {
@@ -71,10 +81,19 @@ async function main(argv) {
 			process.stderr.write("auto-mode init: name a harness — claude, codex or muse\n");
 			return 2;
 		}
+		const event = HOOK_EVENTS[args.values.event ?? "pre-tool-use"];
+		if (event === void 0) {
+			process.stderr.write("auto-mode init: --event takes pre-tool-use or permission-request\n");
+			return 2;
+		}
+		if (event === "PermissionRequest" && harness !== "claude") {
+			process.stderr.write(`auto-mode init: only Claude Code sends PermissionRequest\n`);
+			return 2;
+		}
 		process.stdout.write(`# Add this to ${SETTINGS_PATHS[harness]}\n`);
 		process.stdout.write(`# Configuration lives at ${resolveConfigPath()}\n`);
-		process.stdout.write(`${buildHookConfig(harness, `${process.execPath} ${process.argv[1] ?? "auto-mode"} run`)}\n`);
-		for (const line of SETUP_NOTES[harness]) process.stdout.write(`# ${line}\n`);
+		process.stdout.write(`${buildHookConfig(harness, `${process.execPath} ${process.argv[1] ?? "auto-mode"} run`, event)}\n`);
+		for (const line of [...SETUP_NOTES[harness], ...EVENT_NOTES[event]]) process.stdout.write(`# ${line}\n`);
 		return 0;
 	}
 	if (command === "print-prompt") {

package/dist/index.d.ts

@@ -51,10 +51,10 @@ export declare function detectHarness(payload: Readonly<Record<string, unknown>>
 export declare function parsePayload(body: unknown): HookPayload | null;
 //#endregion
 //#region src/harness/render-verdict.d.ts
-export declare function renderVerdict(event: HookEvent, verdict: Verdict): string;
+export declare function renderVerdict(event: HookEvent, verdict: Verdict): string | null;
 //#endregion
 //#region src/install/hook-config.d.ts
-export declare function buildHookConfig(harness: Harness, command: string): string;
+export declare function buildHookConfig(harness: Harness, command: string, event?: HookEvent): string;
 export declare const SETTINGS_PATHS: Readonly<Record<Harness, string>>;
 //#endregion
 //#region src/model/classify-with-model.d.ts

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as loadPolicy, c as buildHookConfig, d as detectHarness, f as DEFAULT_CONFIG, g as resolveConfigPath, h as resolveApiKey, i as readTranscript, l as renderVerdict, m as loadConfig, n as classifyWithModel, o as SETTINGS_PATHS, p as PRESETS, r as parseModelVerdict, t as classifyLocally, u as parsePayload } from "./classify-locally-rTUwxBZi.js";
+import { _ as resolveConfigPath, a as loadPolicy, d as parsePayload, f as detectHarness, g as resolveApiKey, h as loadConfig, i as readTranscript, l as buildHookConfig, m as PRESETS, n as classifyWithModel, p as DEFAULT_CONFIG, r as parseModelVerdict, s as SETTINGS_PATHS, t as classifyLocally, u as renderVerdict } from "./classify-locally-BRMllwcd.js";
 export { DEFAULT_CONFIG, PRESETS, SETTINGS_PATHS, buildHookConfig, classifyLocally, classifyWithModel, detectHarness, loadConfig, loadPolicy, parseModelVerdict, parsePayload, readTranscript, renderVerdict, resolveApiKey, resolveConfigPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-mode",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A permission classifier that runs as a hook, so agents that are not Claude can run unattended",
   "keywords": [
     "agent",