auto-mode 0.7.0 → 0.9.0

package/README.md

@@ -38,7 +38,7 @@ Create the classifier configuration:
 
 Save it as `~/.config/auto-mode/config.json` and export your TypeSafe API key, or set the entry's
 `apiKeyCommand` to a command that prints it. [Configuration](./docs/guides/configuration.md) covers
-the registries, credentials, and migrating an older file.
+the registries and credentials.
 
 ## Standing permissions
 
@@ -77,7 +77,6 @@ fit.
 | `auto-mode run --local-only` | Skip the model tier                       |
 | `auto-mode run --jev-only`   | Require Jev with a 5-second API timeout   |
 | `auto-mode print-prompt`     | Print the selected provider's base policy |
-| `auto-mode config migrate`   | Rewrite an older config file in place     |
 
 The mod evaluates only ask decisions and preserves existing allow and deny decisions. It runs the
 CLI as a bounded child process with `--jev-only`. The `spark`, `claude`, `glm`, and `messages`

package/dist/cli.js

@@ -1,67 +1,174 @@
 #!/usr/bin/env node
-import { d as resolveConfigPath, f as normalizeConfigFile, l as loadConfig, n as parseActionRequest, r as classifyAction, s as loadPolicy, t as renderVerdict } from "./render-verdict-CAg3AKWH.js";
-import { appendFile, constants, copyFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { g as string, h as strictObject, l as DEFAULT_DENIAL_BUDGET, m as number, n as parseActionRequest, r as classifyAction, s as loadPolicy, t as renderVerdict, u as loadConfig } from "./render-verdict-CK9sRJpa.js";
+import { appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { text } from "node:stream/consumers";
 import { parseArgs } from "node:util";
-//#region src/config/build-jev-only-config.ts
-function buildJevOnlyConfig(config) {
-	if (config.provider.protocol !== "system-one") return null;
+//#region src/budget/build-retry-key.ts
+const DESCRIPTIVE_FIELDS = { Bash: [
+	"description",
+	"timeout",
+	"run_in_background"
+] };
+function buildRetryKey(request) {
+	const ignored = Object.hasOwn(DESCRIPTIVE_FIELDS, request.toolName) ? DESCRIPTIVE_FIELDS[request.toolName] ?? [] : [];
+	const input = Object.fromEntries(Object.entries(request.toolInput).filter(([key]) => !ignored.includes(key)));
+	const canonical = JSON.stringify(sortKeys({
+		cwd: request.cwd,
+		toolName: request.toolName,
+		toolInput: input,
+		lastDirectUserMessage: request.decisionContext?.lastDirectUserMessage?.text ?? null
+	}));
+	return createHash("sha256").update(canonical).digest("hex");
+}
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map((item) => sortKeys(item));
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a < b ? -1 : 1).map(([key, item]) => [key, sortKeys(item)]));
+	return value;
+}
+//#endregion
+//#region src/budget/find-retry-deny.ts
+function findRetryDeny(state, retryKey) {
+	if (state.lastDenied === null || state.lastDenied.retryKey !== retryKey) return null;
 	return {
-		...config,
-		provider: {
-			...config.provider,
-			timeoutMs: Math.min(config.provider.timeoutMs, 5e3)
-		}
+		kind: "deny",
+		rule: state.lastDenied.rule,
+		reason: state.lastDenied.reason
 	};
 }
 //#endregion
-//#region src/config/write-migrated-config.ts
-async function writeMigratedConfig(path) {
+//#region src/budget/types.ts
+const EMPTY_DENIAL_STATE = {
+	consecutive: 0,
+	session: 0,
+	lastDenied: null
+};
+//#endregion
+//#region src/budget/load-denial-state.ts
+const count = number().int().nonnegative();
+const stateSchema = strictObject({
+	consecutive: count,
+	session: count,
+	lastDenied: strictObject({
+		retryKey: string().min(1),
+		rule: string(),
+		reason: string()
+	}).nullable()
+});
+async function loadDenialState(path) {
 	let raw;
 	try {
 		raw = await readFile(path, "utf8");
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return `${path} does not exist; nothing to migrate`;
-		throw new Error(`${path} is unreadable`, { cause: error });
-	}
-	let json;
-	try {
-		json = JSON.parse(raw);
 	} catch {
-		throw new Error(`${path} is not valid JSON`);
+		return EMPTY_DENIAL_STATE;
 	}
-	const normalized = normalizeConfigFile(json, path);
-	if (!normalized.isLegacy) return `${path} already uses the current shape`;
-	const backup = `${path}.bak`;
-	const staged = `${path}.migrating`;
 	try {
-		await copyFile(path, backup, constants.COPYFILE_EXCL);
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "EEXIST") throw new Error(`${backup} already exists; move it aside and run the migration again`, { cause: error });
-		throw error;
+		const parsed = stateSchema.safeParse(JSON.parse(raw));
+		return parsed.success ? parsed.data : EMPTY_DENIAL_STATE;
+	} catch {
+		return EMPTY_DENIAL_STATE;
 	}
-	await writeFile(staged, `${JSON.stringify(normalized.file, null, 2)}\n`, { mode: 384 });
+}
+//#endregion
+//#region src/budget/plan-denial-budget.ts
+function planDenialBudget(state, verdict, retryKey, budget) {
+	if (verdict === null) return {
+		verdict: null,
+		state,
+		escalation: false
+	};
+	if (verdict.kind === "allow") return {
+		verdict,
+		state: {
+			...state,
+			consecutive: 0,
+			lastDenied: null
+		},
+		escalation: false
+	};
+	if (state.consecutive >= budget.consecutive || state.session >= budget.perSession) return {
+		verdict: null,
+		state: EMPTY_DENIAL_STATE,
+		escalation: true
+	};
+	const next = {
+		consecutive: state.consecutive + 1,
+		session: state.session + 1,
+		lastDenied: {
+			retryKey,
+			rule: verdict.rule,
+			reason: verdict.reason
+		}
+	};
+	const left = Math.min(budget.consecutive - next.consecutive, budget.perSession - next.session);
+	return {
+		verdict: {
+			...verdict,
+			reason: `${verdict.reason} ${formatDenialsLeft(left)}`
+		},
+		state: next,
+		escalation: false
+	};
+}
+function formatDenialsLeft(left) {
+	if (left > 0) return `Denials left before auto-mode asks the user: ${left}.`;
+	return "This is the last denial before auto-mode asks the user. Stop now, without finishing the rest of the task, and tell the user what consent you need to continue.";
+}
+//#endregion
+//#region src/state/resolve-state-dir.ts
+function resolveStateDir() {
+	const stateHome = process.env["XDG_STATE_HOME"];
+	const base = stateHome === void 0 || stateHome === "" ? join(homedir(), ".local", "state") : stateHome;
+	return join(base, "auto-mode");
+}
+//#endregion
+//#region src/budget/resolve-denial-state-path.ts
+function resolveDenialStatePath(request) {
+	const agentID = request.decisionContext?.agentID ?? "";
+	const key = createHash("sha256").update(`${request.sessionID}\0${agentID}`).digest("hex").slice(0, 32);
+	return join(resolveStateDir(), "denials", `${key}.json`);
+}
+//#endregion
+//#region src/budget/write-denial-state.ts
+async function writeDenialState(path, state) {
+	const staged = `${path}.${randomUUID()}.tmp`;
+	await mkdir(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(staged, `${JSON.stringify(state)}\n`, { mode: 384 });
 	await rename(staged, path);
-	return `rewrote ${path} in the current shape; the old file is at ${backup}`;
+}
+//#endregion
+//#region src/config/build-jev-only-config.ts
+function buildJevOnlyConfig(config) {
+	if (config.provider.protocol !== "system-one") return null;
+	return {
+		...config,
+		provider: {
+			...config.provider,
+			timeoutMs: Math.min(config.provider.timeoutMs, 5e3)
+		}
+	};
 }
 //#endregion
 //#region src/diagnostics/write-action-diagnostic.ts
 async function writeActionDiagnostic(payload, entry) {
-	const stateHome = process.env["XDG_STATE_HOME"];
-	const stateDir = stateHome === void 0 || stateHome === "" ? join(homedir(), ".local", "state") : stateHome;
-	const path = process.env["AUTO_MODE_DIAGNOSTICS_PATH"] ?? join(stateDir, "auto-mode", "actions.jsonl");
+	const path = process.env["AUTO_MODE_DIAGNOSTICS_PATH"] ?? join(resolveStateDir(), "actions.jsonl");
 	if (path === "") return;
 	const record = {
-		schemaVersion: 2,
+		schemaVersion: 3,
 		time: (/* @__PURE__ */ new Date()).toISOString(),
 		invocationID: entry.invocationID,
 		sessionHash: toHash(payload.sessionID),
 		actionHash: payload.toolUseID === void 0 ? null : toHash(payload.toolUseID),
 		status: entry.status,
 		verdict: entry.verdict ?? null,
+		decidingStage: entry.decidingStage ?? null,
+		denials: entry.denials ?? null,
+		escalation: entry.escalation ?? false,
 		diagnostics: entry.diagnostics ?? null
 	};
 	try {
@@ -84,7 +191,6 @@ const USAGE = `auto-mode — a permission classifier for the auto-mode Claude Co
 Usage:
   auto-mode run              Read an action request on stdin, write a verdict on stdout
   auto-mode print-prompt     Print the system prompt the classifier receives
-  auto-mode config migrate   Rewrite the config file from the old keys into the current shape
 
 Options:
   --classifier <path>   Use this framework file instead of the shipped one
@@ -151,24 +257,50 @@ async function run(explain, localOnly, jevOnly, deadline) {
 		process.on("SIGINT", stopEvaluation);
 	}
 	try {
-		const outcome = await classifyAction(request, config, {
+		const statePath = resolveDenialStatePath(request);
+		const retryKey = buildRetryKey(request);
+		const before = await loadDenialState(statePath);
+		const retry = findRetryDeny(before, retryKey);
+		const outcome = retry === null ? await classifyAction(request, config, {
 			localOnly,
 			deadlineAt,
 			signal: controller.signal
-		});
-		if (outcome.verdict !== null) writeVerdict(outcome.verdict);
+		}) : {
+			verdict: retry,
+			decidingStage: "retry",
+			note: "retry of the action just denied; denied again",
+			status: "deny"
+		};
+		const latest = retry === null ? await loadDenialState(statePath) : before;
+		const plan = planDenialBudget(latest, outcome.verdict, retryKey, config.denialBudget ?? DEFAULT_DENIAL_BUDGET);
+		if (plan.state !== latest) await tryWriteDenialState(statePath, plan.state);
+		if (plan.verdict !== null) writeVerdict(plan.verdict);
 		await writeActionDiagnostic(request, {
 			invocationID,
 			status: outcome.status,
-			verdict: outcome.verdict?.kind ?? "defer",
+			verdict: plan.verdict?.kind ?? "defer",
+			decidingStage: plan.escalation ? "budget" : outcome.decidingStage,
+			denials: {
+				consecutive: plan.state.consecutive,
+				session: plan.state.session
+			},
+			escalation: plan.escalation,
 			...outcome.diagnostics === void 0 ? {} : { diagnostics: outcome.diagnostics }
 		});
-		return printNote(explain || outcome.unavailable === true, outcome.note);
+		const note = plan.escalation ? "denial budget exhausted; the user decides this action" : outcome.note;
+		return printNote(explain || outcome.unavailable === true, note);
 	} finally {
 		process.off("SIGTERM", stopEvaluation);
 		process.off("SIGINT", stopEvaluation);
 	}
 }
+async function tryWriteDenialState(path, state) {
+	try {
+		await writeDenialState(path, state);
+	} catch {
+		process.stderr.write("auto-mode: denial counts unavailable\n");
+	}
+}
 function writeVerdict(verdict) {
 	process.stdout.write(renderVerdict(verdict));
 }
@@ -218,21 +350,9 @@ async function main(argv) {
 		process.stdout.write(`${prompt}\n`);
 		return 0;
 	}
-	if (command === "config" && args.positionals[1] === "migrate") return runConfigMigration();
 	process.stderr.write(`auto-mode: unknown command '${command}'\n\n${USAGE}`);
 	return 2;
 }
-async function runConfigMigration() {
-	const path = resolveConfigPath();
-	try {
-		const result = await writeMigratedConfig(path);
-		process.stdout.write(`${result}\n`);
-		return 0;
-	} catch (error) {
-		process.stderr.write(`auto-mode: ${error instanceof Error ? error.message : "config migration failed"}\n`);
-		return 1;
-	}
-}
 process.exitCode = await main(process.argv.slice(2));
 //#endregion
 export {};

package/dist/index.d.ts

@@ -1,3 +1,9 @@
+//#region src/budget/types.d.ts
+interface DenialBudget {
+  readonly consecutive: number;
+  readonly perSession: number;
+}
+//#endregion
 //#region src/config/types.d.ts
 interface EvaluationOptions {
   readonly deadlineAt?: number | undefined;
@@ -33,6 +39,7 @@ interface Config {
   readonly onFailure: 'defer' | 'deny';
   readonly claudeSettingsPath?: string | null | undefined;
   readonly minConfidence?: number | undefined;
+  readonly denialBudget?: DenialBudget;
   readonly warnings?: readonly string[];
 }
 export declare const DEFAULT_CONFIG: Config;
@@ -108,8 +115,10 @@ interface DecisionDiagnostics {
 }
 //#endregion
 //#region src/classify-action.d.ts
+type DecidingStage = 'local' | 'jev' | 'messages' | 'retry';
 interface ActionOutcome {
   readonly verdict: Verdict | null;
+  readonly decidingStage: DecidingStage;
   readonly note: string;
   readonly status: 'allow' | 'skipped' | 'failure' | DecisionDiagnostics['status'];
   readonly unavailable?: boolean;

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as classifyWithModel, c as DEFAULT_CONFIG, d as resolveConfigPath, i as classifyLocally, l as loadConfig, n as parseActionRequest, o as parseModelVerdict, p as PRESETS, r as classifyAction, s as loadPolicy, t as renderVerdict, u as resolveApiKey } from "./render-verdict-CAg3AKWH.js";
+import { a as classifyWithModel, c as DEFAULT_CONFIG, d as resolveApiKey, f as resolveConfigPath, i as classifyLocally, n as parseActionRequest, o as parseModelVerdict, p as PRESETS, r as classifyAction, s as loadPolicy, t as renderVerdict, u as loadConfig } from "./render-verdict-CK9sRJpa.js";
 export { DEFAULT_CONFIG, PRESETS, classifyAction, classifyLocally, classifyWithModel, loadConfig, loadPolicy, parseActionRequest, parseModelVerdict, renderVerdict, resolveApiKey, resolveConfigPath };

package/dist/{render-verdict-CAg3AKWH.js → render-verdict-CK9sRJpa.js}

@@ -5615,126 +5615,6 @@ function findPreset(id) {
 	return Object.hasOwn(PRESETS, id) ? PRESETS[id] : void 0;
 }
 //#endregion
-//#region src/config/normalize-config-file.ts
-function normalizeConfigFile(json, path) {
-	if (!isRecord(json)) return {
-		file: json,
-		isLegacy: false,
-		warnings: []
-	};
-	const legacyKeys = Object.keys(json).filter((key) => LEGACY_KEYS.has(key));
-	if (legacyKeys.length === 0) return {
-		file: json,
-		isLegacy: false,
-		warnings: []
-	};
-	const currentKeys = Object.keys(json).filter((key) => !LEGACY_KEYS.has(key));
-	if (currentKeys.length > 0) throw new Error(`${path} mixes the old keys (${legacyKeys.join(", ")}) with the new ones (${currentKeys.join(", ")}); run \`auto-mode config migrate\` on a copy without the new keys`);
-	const parsed = legacyConfigSchema.safeParse(json);
-	if (!parsed.success) throw new Error(`${path} is not a valid config: ${prettifyError(parsed.error)}`);
-	const legacy = parsed.data;
-	const warnings = [`${path} uses the old config keys (${legacyKeys.join(", ")}); run \`auto-mode config migrate\` to rewrite it`, ...legacy.transcriptEntries === void 0 ? [] : [`${path} sets transcriptEntries, which has no effect; migration drops it`]];
-	return {
-		file: buildFileFromLegacy(legacy, path),
-		isLegacy: true,
-		warnings
-	};
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-const LEGACY_KEYS = /* @__PURE__ */ new Set([
-	"preset",
-	"provider",
-	"classifierPath",
-	"rulesPath",
-	"transcriptEntries",
-	"onFailure",
-	"claudeSettingsPath",
-	"minConfidence"
-]);
-const text$1 = string().min(1);
-const positive$1 = number().positive();
-const legacyConfigSchema = strictObject({
-	preset: text$1.optional(),
-	provider: strictObject({
-		protocol: _enum(["messages", "system-one"]).optional(),
-		baseURL: text$1.optional(),
-		model: text$1.optional(),
-		apiKeyEnv: text$1.optional(),
-		apiKeyCommand: text$1.optional(),
-		reasoning: boolean().optional(),
-		maxTokens: positive$1.optional(),
-		timeoutMs: positive$1.optional()
-	}).optional(),
-	classifierPath: text$1.optional(),
-	rulesPath: text$1.optional(),
-	transcriptEntries: number().nonnegative().optional(),
-	onFailure: _enum(["defer", "deny"]).optional(),
-	claudeSettingsPath: text$1.nullable().optional(),
-	minConfidence: number().min(.5).max(1).optional()
-});
-function buildFileFromLegacy(legacy, path) {
-	const hasClassifier = legacy.preset !== void 0 || legacy.provider !== void 0;
-	const decision = {
-		...hasClassifier ? { classifier: getLegacyClassifierID(legacy) } : {},
-		...legacy.minConfidence === void 0 ? {} : { minConfidence: legacy.minConfidence },
-		...legacy.onFailure === void 0 ? {} : { onFailure: legacy.onFailure }
-	};
-	const policy = {
-		...legacy.rulesPath === void 0 ? {} : { rulesPath: legacy.rulesPath },
-		...legacy.classifierPath === void 0 ? {} : { frameworkPath: legacy.classifierPath },
-		...legacy.claudeSettingsPath === void 0 ? {} : { claudeSettingsPath: legacy.claudeSettingsPath }
-	};
-	return {
-		...hasClassifier ? { classifiers: { [getLegacyClassifierID(legacy)]: buildClassifierEntry(getLegacyClassifierID(legacy), buildLegacyProvider(legacy, path)) } } : {},
-		...Object.keys(decision).length === 0 ? {} : { decision },
-		...Object.keys(policy).length === 0 ? {} : { policy }
-	};
-}
-function getLegacyClassifierID(legacy) {
-	if (legacy.preset !== void 0) return legacy.preset;
-	return legacy.provider !== void 0 && legacy.provider.protocol !== "system-one" ? "spark" : "jev";
-}
-function buildLegacyProvider(legacy, path) {
-	const preset = findPreset(getLegacyClassifierID(legacy));
-	if (preset === void 0) throw new Error(`${path} names an unknown preset '${legacy.preset}'; known presets are ${Object.keys(PRESETS).join(", ")}`);
-	const override = legacy.provider ?? {};
-	return {
-		protocol: override.protocol ?? preset.protocol ?? "messages",
-		baseURL: override.baseURL ?? preset.baseURL,
-		model: override.model ?? preset.model,
-		apiKeyEnv: override.apiKeyEnv ?? preset.apiKeyEnv,
-		apiKeyCommand: override.apiKeyCommand ?? preset.apiKeyCommand,
-		reasoning: override.reasoning ?? preset.reasoning,
-		maxTokens: override.maxTokens ?? preset.maxTokens,
-		timeoutMs: override.timeoutMs ?? preset.timeoutMs
-	};
-}
-const PROVIDER_FIELDS = [
-	"baseURL",
-	"model",
-	"apiKeyEnv",
-	"apiKeyCommand",
-	"reasoning",
-	"maxTokens",
-	"timeoutMs"
-];
-function buildClassifierEntry(id, provider) {
-	const kind = pickEntryKind(id, provider);
-	const base = kind === "messages" ? MESSAGES_DEFAULTS : findPreset(kind) ?? {};
-	const fields = Object.fromEntries(PROVIDER_FIELDS.filter((field) => provider[field] !== void 0 && provider[field] !== base[field]).map((field) => [field, provider[field]]));
-	return {
-		...kind === id ? {} : { kind },
-		...fields
-	};
-}
-function pickEntryKind(id, provider) {
-	const preset = findPreset(id);
-	if (preset !== void 0 && (preset.protocol ?? "messages") === provider.protocol) return id;
-	return provider.protocol === "system-one" ? "jev" : "messages";
-}
-//#endregion
 //#region src/config/read-api-key-from-command.ts
 function readApiKeyFromCommand(command, options = {}) {
 	const remainingMs = options.deadlineAt === void 0 ? 5e3 : options.deadlineAt - Date.now();
@@ -5797,10 +5677,15 @@ const SCOPE_SOURCE_KINDS = [
 ];
 const DEFAULT_PROVIDER = findPreset("jev");
 if (DEFAULT_PROVIDER === void 0) throw new Error("the jev preset is missing");
+const DEFAULT_DENIAL_BUDGET = {
+	consecutive: 3,
+	perSession: 20
+};
 const DEFAULT_CONFIG = {
 	provider: DEFAULT_PROVIDER,
 	onFailure: "defer",
-	minConfidence: .8
+	minConfidence: .8,
+	denialBudget: DEFAULT_DENIAL_BUDGET
 };
 function resolveConfigPath() {
 	const xdg = process.env["XDG_CONFIG_HOME"];
@@ -5821,11 +5706,14 @@ async function loadConfig(path = resolveConfigPath()) {
 	} catch {
 		throw new Error(`${path} is not valid JSON`);
 	}
-	const normalized = normalizeConfigFile(json, path);
-	return buildConfig(normalized.file, path, normalized.warnings);
+	return buildConfig(json, path);
 }
 const text = string().min(1);
 const positive = number().positive();
+const denialBudgetSchema = strictObject({
+	consecutive: number().int().positive().optional(),
+	perSession: number().int().positive().optional()
+});
 const configFileSchema = strictObject({
 	classifiers: record(text, unknown()).optional(),
 	scopeSources: record(text, unknown()).optional(),
@@ -5833,7 +5721,8 @@ const configFileSchema = strictObject({
 		classifier: text.optional(),
 		judge: text.nullable().optional(),
 		minConfidence: number().min(.5).max(1).optional(),
-		onFailure: _enum(["defer", "deny"]).optional()
+		onFailure: _enum(["defer", "deny"]).optional(),
+		denialBudget: denialBudgetSchema.optional()
 	}).optional(),
 	policy: strictObject({
 		rulesPath: text.nullable().optional(),
@@ -5841,11 +5730,11 @@ const configFileSchema = strictObject({
 		claudeSettingsPath: text.nullable().optional()
 	}).optional()
 });
-function buildConfig(json, path, legacyWarnings) {
+function buildConfig(json, path) {
 	const parsed = configFileSchema.safeParse(json);
 	if (!parsed.success) throw new Error(`${path} is not a valid config: ${prettifyError(parsed.error)}`);
 	const file = parsed.data;
-	const warnings = [...legacyWarnings];
+	const warnings = [];
 	const classifiers = buildRegistry(file.classifiers ?? {}, (id, entry) => parseClassifierEntry(id, entry));
 	const scopeSources = buildRegistry(file.scopeSources ?? {}, (id, entry) => parseScopeSourceEntry(id, entry));
 	warnings.push(...classifiers.dropped.map((line) => `${path}: classifiers.${line}`), ...scopeSources.dropped.map((line) => `${path}: scopeSources.${line}`));
@@ -5861,6 +5750,10 @@ function buildConfig(json, path, legacyWarnings) {
 		onFailure: decision.onFailure ?? DEFAULT_CONFIG.onFailure,
 		claudeSettingsPath: policy.claudeSettingsPath === null ? null : expandHomePath(policy.claudeSettingsPath),
 		minConfidence: decision.minConfidence ?? DEFAULT_CONFIG.minConfidence,
+		denialBudget: {
+			consecutive: decision.denialBudget?.consecutive ?? DEFAULT_DENIAL_BUDGET.consecutive,
+			perSession: decision.denialBudget?.perSession ?? DEFAULT_DENIAL_BUDGET.perSession
+		},
 		warnings
 	};
 }
@@ -7204,6 +7097,7 @@ async function classifyAction(request, config, options = {}) {
 		const guidance = config.onFailure === "deny" ? await tryReadDenialGuidance() : null;
 		return {
 			verdict: config.onFailure === "deny" ? buildGuidedDeny("Classifier Unavailable", "Claude settings unreadable.", guidance) : null,
+			decidingStage: "jev",
 			note: "Claude settings unreadable; classifier unavailable",
 			status: "failure",
 			unavailable: true
@@ -7212,17 +7106,20 @@ async function classifyAction(request, config, options = {}) {
 	const local = configured !== null && (configured.hard_deny.length > 0 || configured.soft_deny.length > 0) ? { kind: "escalate" } : classifyLocally(request);
 	if (local.kind === "allow") return {
 		verdict: { kind: "allow" },
+		decidingStage: "local",
 		note: `allowed by ${local.exception} (local)`,
 		status: "allow"
 	};
 	if (options.localOnly === true) return {
 		verdict: null,
+		decidingStage: "local",
 		note: `${request.toolName} needs the model tier, which this run skipped`,
 		status: "skipped"
 	};
 	const [outcome, guidance] = await Promise.all([classifyWithModel(request, config, options), tryReadDenialGuidance()]);
 	return {
 		...outcome,
+		decidingStage: config.provider.protocol === "system-one" ? "jev" : "messages",
 		verdict: outcome.verdict?.kind === "deny" ? buildGuidedDeny(outcome.verdict.rule, outcome.verdict.reason, guidance) : outcome.verdict,
 		status: outcome.diagnostics?.status ?? outcome.verdict?.kind ?? "failure"
 	};
@@ -7300,4 +7197,4 @@ function renderVerdict(verdict) {
 	})).exhaustive();
 }
 //#endregion
-export { classifyWithModel as a, DEFAULT_CONFIG as c, resolveConfigPath as d, normalizeConfigFile as f, classifyLocally as i, loadConfig as l, parseActionRequest as n, parseModelVerdict as o, PRESETS as p, classifyAction as r, loadPolicy as s, renderVerdict as t, resolveApiKey as u };
+export { classifyWithModel as a, DEFAULT_CONFIG as c, resolveApiKey as d, resolveConfigPath as f, string as g, strictObject as h, classifyLocally as i, DEFAULT_DENIAL_BUDGET as l, number as m, parseActionRequest as n, parseModelVerdict as o, PRESETS as p, classifyAction as r, loadPolicy as s, renderVerdict as t, loadConfig as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-mode",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "A permission classifier library and Claude Code mod, so agents that are not Claude can run unattended",
   "keywords": [
     "agent",