@czottmann/pi-automode 1.8.2 → 1.9.0

package/README.md

@@ -88,12 +88,17 @@ This is project-local and should not be committed. Shared project `.pi/automode.
 
 Set a global default classifier model in `~/.pi/agent/automode.json`; override it per project in `.pi/automode.local.json`.
 
+`classifierReasoningLevel` optionally requests `low`, `medium`, `high`, `xhigh`, or `max` reasoning for both classifier stages. If the key is absent, pi-automode sends no reasoning preference and leaves the choice to the server. Pi AI clamps unsupported values to the nearest level supported by the selected model; a non-reasoning model resolves to `off`. `low` matches Codex Auto Review's reasoning effort and is the practical default when an explicit value is needed. Higher levels can consume the existing 512/1200-token stage limits before producing visible output, which causes the classifier to fail closed.
+
+The setting follows the normal scalar precedence: global, then project-local, then `PI_AUTOMODE_SETTINGS_JSON`. Shared project `.pi/automode.json` cannot set it. Omitting the key at a higher-precedence scope does not clear a lower-precedence value.
+
 Example:
 
 ```json
 {
   "autoMode": {
     "classifierModel": "provider/model-id",
+    "classifierReasoningLevel": "low",
     "maxUserTranscriptTokens": 4000,
     "maxToolTranscriptTokens": 4000,
     "environment": [

package/docs/automode-classifier-flow.md

@@ -253,6 +253,10 @@ The classifier model is selected in this order:
 
 `/automode model provider/model-id` and the interactive model picker save `autoMode.classifierModel` to `~/.pi/agent/automode.json`. Project-local `.pi/automode.local.json` can still override that global choice.
 
+`autoMode.classifierReasoningLevel` can request `low`, `medium`, `high`, `xhigh`, or `max` reasoning for both classifier stages. When the key is absent, classifier calls use the raw completion path and omit a reasoning preference so the server can choose its default. When it is set, classifier calls use Pi AI's normalized completion path. Pi AI clamps the request to the nearest level supported by the model; non-reasoning models resolve to `off`, remain on the normalized path, and receive no reasoning preference.
+
+Reasoning does not raise the stage token limits. A high level can consume the fast stage's 512 tokens or the detailed stage's 1200 tokens before producing valid visible output. Truncation still fails closed. `low` is the practical explicit setting and matches Codex Auto Review.
+
 The extension asks Pi's model registry for API credentials. If the model cannot be found or credentials are unavailable, classification returns a blocking decision:
 
 ```text

package/docs/observability-logging.md

@@ -55,6 +55,21 @@ One per tool-call decision. Every allow and every block goes through exactly one
 | `outcome` | `allow` or `block` |
 | `reason` | the reason string (classifier reason, or the deterministic/permission reason) |
 | `classifierModel` | the configured classifier model, when relevant |
+| `reasoning` | classifier reasoning mode and requested/effective level; see below |
+
+The reasoning field records either server-default mode:
+
+```json
+{"mode":"server-default"}
+```
+
+or an explicit request after model-level clamping:
+
+```json
+{"mode":"explicit","requestedLevel":"max","effectiveLevel":"xhigh"}
+```
+
+Classifier-routed decisions contain the effective level once the configured model resolves, even when `classifierIo` is off or authentication then fails. If the configured model itself cannot be resolved, an explicit entry records `requestedLevel` without `effectiveLevel` because no model-supported level exists. A local permission, deterministic, or read-only decision does not run the classifier and likewise may omit `effectiveLevel`. In `server-default` mode, the concrete server-selected level is not observable and is not inferred.
 
 ### `message` (classifier usage)
 
@@ -78,6 +93,7 @@ Written only for classifier-routed actions, and only when `classifierIo: true`.
 | `ts` | ISO timestamp |
 | `decisionId` | matches the `decision` entry for the same call |
 | `model` | classifier model used, e.g. `anthropic/claude-haiku-4` |
+| `reasoning` | `server-default`, or the explicit requested and effective model-supported level |
 | `prompt.system` | the full system policy with `environment`/`allow`/`soft_deny`/`hard_deny` rules interpolated |
 | `prompt.context` | the shared context message: loaded project instructions + classifier transcript + action |
 | `prompt.fastInstruction` | the exact one-token filter instruction |

package/examples/automode.local.json

@@ -1,5 +1,6 @@
 {
   "autoMode": {
+    "classifierReasoningLevel": "low",
     "environment": [
       "$defaults",
       "Source control: github.example.com/acme-corp and all repos under it",

package/extensions/auto-mode/classifier.ts

@@ -1,5 +1,9 @@
 import { createHash } from "node:crypto";
-import { complete } from "@earendil-works/pi-ai";
+import { clampThinkingLevel } from "@earendil-works/pi-ai";
+import {
+  complete,
+  completeSimple,
+} from "@earendil-works/pi-ai/compat";
 import type {
   AssistantMessage,
   Model,
@@ -17,7 +21,11 @@ import type {
   ClassificationDecision,
   ClassifyAction,
   ClassifierIoAttempt,
+  ClassifierReasoning,
+  ClassifierReasoningLevel,
+  ClassifierReasoningLog,
   ClassifyResult,
+  EffectiveClassifierReasoningLevel,
   EffectiveConfig,
 } from "./types.ts";
 
@@ -40,13 +48,28 @@ export function buildClassifierPrompt(config: EffectiveConfig): string {
     );
 }
 
+type ClassifierResolution = {
+  reasoning: ClassifierReasoningLog;
+  classifier?: {
+    model: Model<any>;
+    apiKey?: string;
+    headers?: Record<string, string>;
+  };
+  completionPlan?: ClassifierCompletionPlan;
+};
+
+export function classifierReasoningForConfig(
+  requestedLevel: ClassifierReasoningLevel | undefined,
+): ClassifierReasoningLog {
+  return requestedLevel === undefined
+    ? { mode: "server-default" }
+    : { mode: "explicit", requestedLevel };
+}
+
 async function resolveClassifier(
   ctx: ExtensionContext,
   config: EffectiveConfig,
-): Promise<
-  | { model: Model<any>; apiKey?: string; headers?: Record<string, string> }
-  | undefined
-> {
+): Promise<ClassifierResolution> {
   const configured = config.classifierModel;
   const model = configured
     ? (() => {
@@ -56,10 +79,27 @@ async function resolveClassifier(
         : undefined;
     })()
     : ctx.model;
-  if (!model) return undefined;
+  if (!model) {
+    return {
+      reasoning: classifierReasoningForConfig(config.classifierReasoningLevel),
+    };
+  }
+
+  const completionPlan = createClassifierCompletionPlan(
+    model,
+    config.classifierReasoningLevel,
+  );
   const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-  if (!auth.ok) return undefined;
-  return { model, apiKey: auth.apiKey, headers: auth.headers };
+  if (!auth.ok) return { reasoning: completionPlan.reasoning };
+  return {
+    reasoning: completionPlan.reasoning,
+    classifier: {
+      model,
+      apiKey: auth.apiKey,
+      headers: auth.headers,
+    },
+    completionPlan,
+  };
 }
 
 export type ClassifierCompletionFn = (
@@ -71,6 +111,7 @@ export type ClassifierCompletionFn = (
     signal?: AbortSignal;
     maxTokens: number;
     temperature?: number;
+    reasoning?: Exclude<EffectiveClassifierReasoningLevel, "off">;
     sessionId?: string;
     cacheRetention?: "none" | "short" | "long";
   },
@@ -80,6 +121,7 @@ export type RetryOptions = {
   maxAttempts?: number;
   maxTokens?: number;
   temperature?: number;
+  reasoningLevel?: Exclude<EffectiveClassifierReasoningLevel, "off">;
   sessionId?: string;
   cacheRetention?: "none" | "short" | "long";
   stage?: "fast" | "detailed";
@@ -91,9 +133,46 @@ const FAST_CLASSIFIER_MAX_TOKENS = 512;
 
 export type StagedClassifierOptions = {
   sessionId: string;
+  reasoningLevel?: Exclude<EffectiveClassifierReasoningLevel, "off">;
   onAttempt?: (attempt: ClassifierIoAttempt) => void;
 };
 
+export type ClassifierCompletionPlan = {
+  completeFn: ClassifierCompletionFn;
+  reasoning: ClassifierReasoning;
+  reasoningLevel?: Exclude<EffectiveClassifierReasoningLevel, "off">;
+};
+
+/** Select the raw or normalized Pi AI completion path and record the effective level. */
+export function createClassifierCompletionPlan(
+  model: Model<any>,
+  requestedLevel: ClassifierReasoningLevel | undefined,
+  rawComplete: ClassifierCompletionFn = complete,
+  simpleComplete: ClassifierCompletionFn = completeSimple,
+): ClassifierCompletionPlan {
+  if (requestedLevel === undefined) {
+    return {
+      completeFn: rawComplete,
+      reasoning: { mode: "server-default" },
+    };
+  }
+
+  const effectiveLevel = clampThinkingLevel(model, requestedLevel);
+  const reasoning: ClassifierReasoning = {
+    mode: "explicit",
+    requestedLevel,
+    effectiveLevel,
+  };
+  if (effectiveLevel === "off") {
+    return { completeFn: simpleComplete, reasoning };
+  }
+  return {
+    completeFn: simpleComplete,
+    reasoning,
+    reasoningLevel: effectiveLevel,
+  };
+}
+
 /** Concatenate all text blocks of an assistant message into a single string. */
 function extractAssistantText(message: AssistantMessage, trim = true): string {
   const text = message.content
@@ -250,6 +329,9 @@ export async function classifyWithRetry(
           signal,
           maxTokens,
           ...(temperature === undefined ? {} : { temperature }),
+          ...(options.reasoningLevel === undefined
+            ? {}
+            : { reasoning: options.reasoningLevel }),
           sessionId: options.sessionId,
           cacheRetention: options.cacheRetention,
         },
@@ -317,6 +399,9 @@ export async function classifyInStages(
         // Reasoning and OpenAI-compatible models may consume hidden reasoning,
         // control, and EOS tokens before emitting the required visible digit.
         maxTokens: FAST_CLASSIFIER_MAX_TOKENS,
+        ...(options.reasoningLevel === undefined
+          ? {}
+          : { reasoning: options.reasoningLevel }),
         sessionId: options.sessionId,
         cacheRetention: "short",
       },
@@ -380,6 +465,7 @@ export async function classifyInStages(
       stage: "detailed",
       sessionId: options.sessionId,
       cacheRetention: "short",
+      reasoningLevel: options.reasoningLevel,
       onAttempt: options.onAttempt,
     },
   );
@@ -398,14 +484,17 @@ export const defaultClassifyAction: ClassifyAction = async (
   action,
   loadedContext,
 ): Promise<ClassifyResult> => {
-  const classifier = await resolveClassifier(ctx, config);
-  if (!classifier) {
+  const resolution = await resolveClassifier(ctx, config);
+  if (!resolution.classifier || !resolution.completionPlan) {
     return {
       decision: "block",
       tier: "none",
       reason: "No classifier model/API key available; auto mode fails closed.",
+      reasoning: resolution.reasoning,
     };
   }
+  const classifier = resolution.classifier;
+  const completionPlan = resolution.completionPlan;
 
   const systemPrompt = buildClassifierPrompt(config);
   const transcript = buildClassifierTranscript(ctx, {
@@ -426,20 +515,23 @@ export const defaultClassifyAction: ClassifyAction = async (
   const attempts: ClassifierIoAttempt[] = [];
   const started = Date.now();
   const decision = await classifyInStages(
-    complete,
+    completionPlan.completeFn,
     classifier,
     { systemPrompt, contextMessage },
     ctx.signal,
     {
       sessionId: classifierCacheSessionId(ctx),
+      reasoningLevel: completionPlan.reasoningLevel,
       onAttempt: (attempt) => attempts.push(attempt),
     },
   );
 
   return {
     ...decision,
+    reasoning: completionPlan.reasoning,
     io: {
       model: formatModelSpec(classifier.model),
+      reasoning: completionPlan.reasoning,
       prompt: {
         system: systemPrompt,
         context: contextText,

package/extensions/auto-mode/config.ts

@@ -16,6 +16,7 @@ import {
 import { parseToolPattern } from "./permissions.ts";
 import type {
   AutoModeSettings,
+  ClassifierReasoningLevel,
   ConfigLoadResult,
   EffectiveConfig,
   LoadedSettingsFile,
@@ -97,6 +98,7 @@ export function validateSettingsFile(
       const knownAutoMode = new Set([
         "enabled",
         "classifierModel",
+        "classifierReasoningLevel",
         "maxUserTranscriptTokens",
         "maxToolTranscriptTokens",
         "environment",
@@ -126,6 +128,14 @@ export function validateSettingsFile(
           `${source}: autoMode.classifierModel must be a provider/model string`,
         );
       }
+      if (
+        hasOwn(autoMode, "classifierReasoningLevel") &&
+        !isClassifierReasoningLevel(autoMode.classifierReasoningLevel)
+      ) {
+        diagnostics.push(
+          `${source}: autoMode.classifierReasoningLevel must be one of low, medium, high, xhigh, max`,
+        );
+      }
       for (
         const key of [
           "maxUserTranscriptTokens",
@@ -273,6 +283,21 @@ function mergeLog(
   };
 }
 
+const CLASSIFIER_REASONING_LEVELS = new Set<ClassifierReasoningLevel>([
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+]);
+
+export function isClassifierReasoningLevel(
+  value: unknown,
+): value is ClassifierReasoningLevel {
+  return typeof value === "string" &&
+    CLASSIFIER_REASONING_LEVELS.has(value as ClassifierReasoningLevel);
+}
+
 function validTranscriptBudget(value: unknown): value is number {
   return Number.isInteger(value) && Number(value) >= 32;
 }
@@ -286,6 +311,11 @@ function applyAutoModeScalars(
     ...base,
     enabled: settings.enabled ?? base.enabled,
     classifierModel: settings.classifierModel ?? base.classifierModel,
+    classifierReasoningLevel: isClassifierReasoningLevel(
+        settings.classifierReasoningLevel,
+      )
+      ? settings.classifierReasoningLevel
+      : base.classifierReasoningLevel,
     maxUserTranscriptTokens: validTranscriptBudget(
         settings.maxUserTranscriptTokens,
       )

package/extensions/auto-mode/constants.ts

@@ -155,6 +155,7 @@ export const CLASSIFIER_FAST_INSTRUCTION =
 export const CLASSIFIER_DETAILED_INSTRUCTION =
   `Return only JSON exactly matching:
 {"decision":"allow"|"block","tier":"hard_deny"|"soft_deny"|"allow"|"explicit_intent"|"none","reason":"brief concrete reason"}
+Do not use Markdown, code fences, prose, or any wrapper. The first character must be { and the last character must be }.
 Valid decision/tier combinations:
 - allow: allow, explicit_intent, or none
 - block: hard_deny, soft_deny, or none

package/extensions/auto-mode/extension.ts

@@ -3,7 +3,10 @@ import type {
   ExtensionCommandContext,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { defaultClassifyAction } from "./classifier.ts";
+import {
+  classifierReasoningForConfig,
+  defaultClassifyAction,
+} from "./classifier.ts";
 import {
   AUTO_MODE_GUIDANCE,
   DEFAULT_ALLOW,
@@ -39,6 +42,7 @@ import {
 import { loadedContextFromSystemPromptOptions } from "./transcript.ts";
 import type {
   AutoModeState,
+  ClassifierReasoningLog,
   ClassifyAction,
   ClassifyResult,
   ConfigLoadResult,
@@ -61,10 +65,13 @@ type LogCtx = {
   logger: Logger;
   decisionId: string;
   classifierModel?: string;
+  reasoning: ClassifierReasoningLog;
 };
 
 /** Append ccusage-compatible usage and optional classifier I/O entries. */
 function logClassifierIo(decision: ClassifyResult, log: LogCtx): void {
+  if (decision.reasoning) log.reasoning = decision.reasoning;
+  if (decision.io) log.reasoning = decision.io.reasoning;
   if (!log.logger.enabled || !decision.io) return;
 
   for (const attempt of decision.io.attempts) {
@@ -87,6 +94,7 @@ function logClassifierIo(decision: ClassifyResult, log: LogCtx): void {
     ts: new Date().toISOString(),
     decisionId: log.decisionId,
     model: decision.io.model,
+    reasoning: decision.io.reasoning,
     prompt: decision.io.prompt,
     attempts: decision.io.attempts,
     durationMs: decision.io.durationMs,
@@ -170,6 +178,7 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
           outcome: "block",
           reason: denial.reason,
           classifierModel: logCtx.classifierModel,
+          reasoning: logCtx.reasoning,
         });
       }
       if (ctx.hasUI) {
@@ -206,6 +215,7 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
           outcome: "allow",
           reason,
           classifierModel: logCtx.classifierModel,
+          reasoning: logCtx.reasoning,
         });
       }
       return undefined;
@@ -251,6 +261,7 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
         }),
         decisionId: newDecisionId(),
         classifierModel: cfg.classifierModel,
+        reasoning: classifierReasoningForConfig(cfg.classifierReasoningLevel),
       };
 
       for (const pattern of cfg.permissionDeny) {

package/extensions/auto-mode/log.ts

@@ -4,6 +4,7 @@ import { basename, dirname, extname, join } from "node:path";
 import type {
   ClassifierIo,
   ClassifierIoAttempt,
+  ClassifierReasoningLog,
   ClassificationDecision,
   DecisionKind,
 } from "./types.ts";
@@ -21,6 +22,7 @@ export type DecisionLogEntry = {
   outcome: "allow" | "block";
   reason: string;
   classifierModel?: string;
+  reasoning: ClassifierReasoningLog;
 };
 
 /** The classifier prompt, raw responses, and parsed decision for one action. */
@@ -29,6 +31,7 @@ export type ClassifierLogEntry = {
   ts: string;
   decisionId: string;
   model: string;
+  reasoning: ClassifierIo["reasoning"];
   prompt: ClassifierIo["prompt"];
   attempts: ClassifierIoAttempt[];
   durationMs: number;

package/extensions/auto-mode/state.ts

@@ -30,6 +30,7 @@ export function statusText(
   return [
     `enabled: ${(state.enabledOverride ?? config.enabled) ? "yes" : "no"}`,
     `classifier: ${config.classifierModel ?? "current session model"}`,
+    `classifier reasoning: ${config.classifierReasoningLevel ?? "server default"}`,
     `checked actions: ${state.checkedActions}`,
     `blocked actions: ${state.blockedActions}`,
     `classifier allowed: ${state.classifierAllowed}`,

package/extensions/auto-mode/types.ts

@@ -1,6 +1,34 @@
 import type { AssistantMessage } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
+export type ClassifierReasoningLevel =
+  | "low"
+  | "medium"
+  | "high"
+  | "xhigh"
+  | "max";
+
+export type EffectiveClassifierReasoningLevel =
+  | "off"
+  | "minimal"
+  | ClassifierReasoningLevel;
+
+export type ClassifierReasoning =
+  | { mode: "server-default" }
+  | {
+    mode: "explicit";
+    requestedLevel: ClassifierReasoningLevel;
+    effectiveLevel: EffectiveClassifierReasoningLevel;
+  };
+
+export type ClassifierReasoningLog =
+  | ClassifierReasoning
+  | {
+    mode: "explicit";
+    requestedLevel: ClassifierReasoningLevel;
+    effectiveLevel?: undefined;
+  };
+
 /** Observability log configuration. Off by default. */
 export type LogConfig = {
   enabled: boolean;
@@ -11,6 +39,7 @@ export type LogConfig = {
 export type AutoModeSettings = {
   enabled?: boolean;
   classifierModel?: string;
+  classifierReasoningLevel?: ClassifierReasoningLevel;
   maxUserTranscriptTokens?: number;
   maxToolTranscriptTokens?: number;
   environment?: unknown;
@@ -46,6 +75,7 @@ export type ToolPattern = {
 export type EffectiveConfig = {
   enabled: boolean;
   classifierModel?: string;
+  classifierReasoningLevel?: ClassifierReasoningLevel;
   maxUserTranscriptTokens: number;
   maxToolTranscriptTokens: number;
   environment: string[];
@@ -111,6 +141,7 @@ export type ClassifierIoAttempt = {
 /** Full classifier I/O for an action, surfaced for optional observability logging. */
 export type ClassifierIo = {
   model: string;
+  reasoning: ClassifierReasoning;
   prompt: {
     system: string;
     context: string;
@@ -121,8 +152,11 @@ export type ClassifierIo = {
   durationMs: number;
 };
 
-/** Classification decision plus the I/O that produced it (when available). */
-export type ClassifyResult = ClassificationDecision & { io?: ClassifierIo };
+/** Classification decision plus resolved reasoning and the I/O that produced it (when available). */
+export type ClassifyResult = ClassificationDecision & {
+  reasoning?: ClassifierReasoningLog;
+  io?: ClassifierIo;
+};
 
 export type SettingsSources = {
   globalSettings?: SettingsFile[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@czottmann/pi-automode",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "description": "Claude Code-style auto mode guardrail for pi.",
   "repository": {
     "url": "https://github.com/czottmann/pi-automode"
@@ -41,9 +41,9 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.79.3",
-    "@earendil-works/pi-coding-agent": "^0.79.3",
-    "@earendil-works/pi-tui": "^0.79.3",
+    "@earendil-works/pi-ai": "^0.81.1",
+    "@earendil-works/pi-coding-agent": "^0.81.1",
+    "@earendil-works/pi-tui": "^0.81.1",
     "@types/node": "^24.0.0",
     "tsx": "^4.22.4",
     "typescript": "^5.8.0"