@czottmann/pi-automode 1.2.0 → 1.4.0

package/README.md

@@ -37,33 +37,43 @@ pi -e ./extensions/auto-mode.ts
 /automode defaults  # print the built-in rule lists
 /automode config    # current effective config + diagnostics
 /automode denials   # denial history for this session
-/automode model     # open classifier model selector
-/automode model provider/model-id # set classifier directly
+/automode model     # open classifier model selector and save to ~/.pi/agent/automode.json
+/automode model provider/model-id # save classifier model to ~/.pi/agent/automode.json
 ```
 
 `/auto-mode` is an alias.
 
+## Docs
+
+- [Defaults and rule-list behavior](docs/defaults.md)
+- [Auto-mode classifier flow](docs/automode-classifier-flow.md)
+
 ## Configuration
 
 The extension follows Claude Code's documented config model where Pi can support it.
 
 It reads `autoMode` from Pi-owned config only:
 
-- `~/.pi/automode.json`
+- `~/.pi/agent/automode.json`
 - `.pi/automode.local.json`
 - `PI_AUTOMODE_SETTINGS_JSON`
 
 It deliberately does not read `autoMode` from shared project `.pi/automode.json`, because a checked-in repo should not be able to weaken auto-mode rules. Shared project config may still contribute `permissions.deny` and `permissions.ask`.
 
+Set a global default classifier model in `~/.pi/agent/automode.json`; override it per project in `.pi/automode.local.json`.
+
 Example:
 
 ```json
 {
   "autoMode": {
+    "classifierModel": "provider/model-id",
     "environment": [
       "$defaults",
       "Source control: github.example.com/acme-corp and all repos under it",
-      "Trusted internal domains: *.corp.example.com"
+      "Trusted internal domains: *.corp.example.com, git.example.com",
+      "Trusted cloud buckets: s3://acme-dev-artifacts, gs://acme-ci-cache",
+      "Key internal services: staging deploy API at deploy.corp.example.com"
     ],
     "allow": ["$defaults"],
     "protectedPaths": ["$defaults"],
@@ -82,105 +92,7 @@ Example:
 
 ### `$defaults`
 
-`$defaults` expands to this plugin's built-in entries for the section where it appears. It is section-local: `$defaults` in `allow` means the built-in allow rules, not the built-in hard-deny rules.
-
-#### `environment`
-
-`$defaults` expands to:
-
-- trusted repo: the repository Pi started in and its configured git remotes
-- source control: the trusted repo and its configured remotes only
-- trusted internal domains: none configured
-- trusted cloud buckets: none configured
-- key internal services: none configured
-
-#### `allow`
-
-`$defaults` expands to allow exceptions for:
-
-- read-only operations: inspecting files, listing directories, searching, GET requests, and state queries that do not expose secrets
-- local development inside the working tree: creating, editing, building, testing, linting, formatting, and deleting files created during the current task
-- installing dependencies already declared in package manifests or lockfiles
-- using standard credentials only with their intended configured providers
-- pushing to the current non-default working branch or a new branch created for the task
-- bootstrapping language/toolchain installers from official sources
-
-These are exceptions to `soft_deny`, not to `hard_deny`.
-
-#### `protectedPaths`
-
-`$defaults` expands to paths where writes are never auto-approved — they always go to the classifier, regardless of `allow` rules. This matches Claude Code's protected-paths behavior.
-
-Protected directories: `.git`, `.config/git`, `.vscode`, `.idea`, `.husky`, `.cargo`, `.devcontainer`, `.yarn`, `.mvn`, `.pi`.
-
-Protected files: `.gitconfig`, `.gitmodules`, `.gitignore`, `.gitattributes`, shell profiles (`.bashrc`, `.zshrc`, `.profile`, etc.), `.envrc`, package manager configs (`.npmrc`, `.yarnrc`, `.yarnrc.yml`, `.pnp.cjs`, `bunfig.toml`, etc.), Bazel configs (`.bazelrc`, `.bazelversion`, `.bazeliskrc`), hook configs (`.pre-commit-config.yaml`, `lefthook.yml`), Gradle/Maven wrappers, `.devcontainer.json`, `.ripgreprc`, `pyrightconfig.json`, `.mcp.json`.
-
-Read-only tools (`read`, `grep`, `find`, `ls`) bypass this check — reads to protected paths are always allowed. Only `write` and `edit` are affected.
-
-#### `soft_deny`
-
-`$defaults` expands to soft blocks for:
-
-- force push, remote branch deletion, remote history rewrite, or direct push to `main`, `master`, or the default branch
-- downloading and executing external code, including `curl | bash` and `wget | sh`
-- production deploys, production database migrations, or production infrastructure changes
-- deleting, truncating, or overwriting pre-existing local files unless the user named the specific target
-- mass modification/deletion in cloud storage, ticketing systems, collaboration tools, or external APIs
-- writing through remote shells such as `ssh`, `kubectl exec`, or `docker exec` on shared or production hosts
-- changing live/shared infrastructure without a preview, plan, dry-run, or review when one normally exists
-- killing other users' processes, cancelling shared jobs, or disrupting shared infrastructure
-- exposing local files, sockets, credentials, or internal services through a network service
-- outbound messages, purchases, bookings, subscriptions, or other real-world transactions
-
-Soft blocks can be overridden by a matching `allow` exception or by direct, specific user intent.
-
-#### `hard_deny`
-
-`$defaults` expands to unconditional blocks for:
-
-- weakening TLS, certificate validation, authentication, authorization, audit logging, or other security controls
-- adding persistence such as SSH keys, shell profile edits, cron jobs, launch agents, login items, or background agents
-- granting admin, owner, IAM, RBAC, repository, or production access
-- exfiltrating repository contents, secrets, credentials, private keys, tokens, or internal data to untrusted places
-- scanning for credentials, tokens, private keys, or secrets beyond what the task requires
-- tampering with logs, audit trails, security monitoring, permission rules, auto-mode config, or safety-control files
-- creating services, endpoints, workflows, or autonomous agents that execute arbitrary code without meaningful approval
-- posting or updating public/external content that is fabricated, misleading, impersonating a user, or claiming approval/action that did not happen
-
-Hard-deny rules cannot be overridden by `allow` or by user intent.
-
-#### Replacement behavior
-
-Use `$defaults` when you want to keep the built-ins and add your own entries:
-
-```json
-{
-  "autoMode": {
-    "allow": [
-      "$defaults",
-      "Running the staging deploy script is allowed."
-    ]
-  }
-}
-```
-
-That means: use all built-in `allow` entries, plus the staging rule.
-
-If you omit `$defaults`, you replace the built-ins for that section:
-
-```json
-{
-  "autoMode": {
-    "allow": [
-      "Running the staging deploy script is allowed."
-    ]
-  }
-}
-```
-
-That means: use only that one `allow` entry. The built-in `allow` entries are not used. Replacing `allow` does not replace `soft_deny`, `hard_deny`, `protectedPaths`, or `environment`.
-
-`$defaults` is not used in `permissions.deny` or `permissions.ask`. Those lists contain only explicit Pi tool patterns.
+See [Defaults and rule-list behavior](docs/defaults.md) for built-in `environment`, `allow`, `protectedPaths`, `soft_deny`, and `hard_deny` entries, plus replacement behavior when `$defaults` is omitted.
 
 ### Permission patterns
 
@@ -201,7 +113,7 @@ The extension blocks these before any allow or classifier decision:
 
 Read-only Pi tools (`read`, `grep`, `find`, `ls`) are allowed after those checks.
 
-Writes to [protected paths](#protectedpaths) (shell profiles, tool configs, `.git`, `.vscode`, `.pi`, etc.) always go to the classifier, even if an `allow` rule matches. The classifier decides whether to permit the write.
+Writes to [protected paths](docs/defaults.md#protectedpaths) (shell profiles, tool configs, `.git`, `.vscode`, `.pi`, etc.) always go to the classifier, even if an `allow` rule matches. The classifier decides whether to permit the write.
 
 Everything else goes to the classifier. If the classifier is missing, fails, or returns invalid JSON, the action is blocked.
 
@@ -209,6 +121,10 @@ Everything else goes to the classifier. If the classifier is missing, fails, or
 
 - `examples/automode.local.json`: copy to `.pi/automode.local.json` in a project and edit the domains, buckets, and source-control org.
 
+## Known limits
+
+Claude Code's real classifier and exact built-in rules are private. This package implements the documented precedence and configuration behavior, with a local classifier prompt and deterministic hard-deny checks.
+
 ## Development
 
 ```bash
@@ -219,6 +135,17 @@ npm pack --dry-run
 
 The tests cover the risky parts: scoped permission matching, config-source precedence, `$defaults` behavior, config diagnostics, deterministic hard-deny checks, shell parsing for risky bash fragments, classifier JSON parsing, hook-level blocking/allowing, classifier mocking, and protected-path enforcement.
 
-## Known limits
+## Publishing
 
-Claude Code's real classifier and exact built-in rules are private. This package implements the documented precedence and configuration behavior, with a local classifier prompt and deterministic hard-deny checks.
+GitHub Actions publishes the package to npm when a GitHub Release is published. The release tag must match `package.json` exactly, with or without a leading `v` (`v1.0.0` and `1.0.0` both work for version `1.0.0`).
+
+The workflow uses npm Trusted Publishing, so it does not need an npm token secret. Configure this package on npm with this repository and workflow file (`.github/workflows/publish.yml`). The workflow builds the package, runs `npm run check`, and publishes with npm provenance.
+
+## Author
+
+Carlo Zottmann, <carlo@zottmann.dev>
+
+- Website: https://actions.work
+- GitHub: https://github.com/czottmann
+- Bluesky: https://bsky.app/profile/zottmann.dev
+- Mastodon: https://norden.social/@czottmann

package/docs/automode-classifier-flow.md

@@ -0,0 +1,320 @@
+# Auto-mode classifier flow
+
+This document describes how `pi-automode` decides whether an agent tool call can run. The classifier is only one part of the flow. Several checks happen before any model call, and some tool calls never reach the classifier at all.
+
+## Short version
+
+For each Pi `tool_call` event, the extension does this:
+
+1. Load the effective auto-mode config for the current session.
+2. Ignore the call if auto-mode is disabled.
+3. Block immediately if the agent turn was cancelled.
+4. Check `permissions.deny` rules.
+5. Check `permissions.ask` rules and ask the user when needed.
+6. Run deterministic hard-deny checks.
+7. Allow read-only built-in tools without a classifier call.
+8. Send every remaining action to the classifier.
+9. Allow or block based on the classifier JSON response.
+10. Persist state and update the UI status/denial history.
+
+The default posture is fail-closed. If the classifier cannot be resolved, has no API key, errors, or returns invalid JSON, the action is blocked.
+
+## Diagram
+
+```mermaid
+flowchart TD
+  A[Pi emits tool_call] --> B[Build effective config]
+  B --> C{Auto-mode enabled?}
+  C -- no --> Z[Let tool run]
+  C -- yes --> D{ctx.signal aborted?}
+  D -- yes --> X[Block: cancelled]
+  D -- no --> E[Summarize action]
+
+  E --> F{Matches permissions.deny?}
+  F -- yes --> F1[Block locally]
+  F -- no --> G{Matches permissions.ask?}
+
+  G -- yes --> H{UI available?}
+  H -- no --> H1[Block locally]
+  H -- yes --> I[Ask user]
+  I -- declined --> I1[Block locally]
+  I -- allowed --> J[Continue]
+  G -- no --> J
+
+  J --> K{Deterministic hard-deny?}
+  K -- yes --> K1[Block locally]
+  K -- no --> L{Read-only built-in tool?}
+
+  L -- yes --> L1[Allow locally]
+  L -- no --> M{write/edit protected path?}
+  M -- yes --> N[Classify action]
+  M -- no --> N[Classify action]
+
+  N --> O{Classifier available and valid JSON?}
+  O -- no --> O1[Block: fail closed]
+  O -- yes --> P{decision == allow?}
+  P -- yes --> Q[Allow tool]
+  P -- no --> R[Block with classifier reason]
+
+  X --> S[Persist state + update UI]
+  F1 --> S
+  H1 --> S
+  I1 --> S
+  K1 --> S
+  O1 --> S
+  R --> S
+  L1 --> T[Persist allow state + update UI]
+  Q --> T
+```
+
+## Config loading
+
+Config is loaded on `session_start` and can be reloaded with `/automode reload`.
+
+The effective config combines these sources:
+
+- `~/.pi/agent/automode.json`
+- `.pi/automode.local.json`
+- `PI_AUTOMODE_SETTINGS_JSON`
+- shared `.pi/automode.json`, but only for `permissions.deny` and `permissions.ask`
+
+Shared project `.pi/automode.json` cannot change `autoMode` rules. That is deliberate: a checked-in repo must not be able to weaken auto-mode. It may still add Pi permission rules.
+
+List settings such as `allow`, `soft_deny`, `hard_deny`, `environment`, and `protectedPaths` support `$defaults`. Omitting `$defaults` replaces the built-ins for that section only. See [Defaults and rule-list behavior](defaults.md).
+
+## Context captured before classification
+
+On `before_agent_start`, the extension appends `AUTO_MODE_GUIDANCE` to the main agent's system prompt. This reminds the main agent that auto-mode is active and tells it not to bypass or weaken the controls.
+
+The same hook also extracts loaded context files from Pi's `systemPromptOptions.contextFiles`. That extracted text becomes `loadedContext`, which is later sent to the classifier. Each context file is formatted as:
+
+```text
+# path/to/file
+<truncated content>
+```
+
+Each file's content is truncated in the middle to 4000 characters.
+
+## Local checks before the classifier
+
+### `permissions.deny`
+
+`permissions.deny` is checked first. A matching rule blocks immediately. The classifier is not consulted.
+
+Example rule:
+
+```json
+"bash(git push --force*)"
+```
+
+Permission patterns are scoped to the Pi tool and its primary argument. For `bash`, the primary argument is `input.command`. For file tools such as `read`, `write`, and `edit`, it is the resolved path normalized for matching.
+
+### `permissions.ask`
+
+`permissions.ask` runs after `permissions.deny`.
+
+If a rule matches and no UI is available, the action is blocked. If UI is available, the user sees a confirmation dialog with the matched rule and the action summary.
+
+Approving that dialog does not run the tool directly. It only lets the action continue to the normal auto-mode checks, including deterministic hard-deny checks and classifier review.
+
+### Deterministic hard-deny checks
+
+Some actions are too risky to leave to the classifier. These are blocked locally, before any classifier call.
+
+Current deterministic blocks include:
+
+- writes to shell profile files;
+- writes to `~/.ssh/authorized_keys`;
+- edits to auto-mode or Pi permission safety-control files;
+- TLS or certificate verification weakening;
+- persistence changes such as cron jobs, launch agents, and system service enablement;
+- dangerous recursive deletes of root, home, or system paths;
+- selected system or SSH permission mutations.
+
+The `bash` checks use a small shell lexer. It handles quotes, redirects, pipes, `&&`, `||`, and `;` well enough to catch common "safe prefix, risky suffix" patterns.
+
+### Read-only bypass
+
+Read-only built-in tools are allowed without classifier review after the checks above pass.
+
+The read-only tool set is:
+
+```text
+read, grep, find, ls
+```
+
+Reads to protected paths are still allowed. Protected-path handling only affects writes and edits.
+
+## Protected paths
+
+Writes and edits to protected paths are always classifier-reviewed. The default protected paths include `.git`, `.pi`, editor config directories, shell profiles, package-manager config files, hook configs, and similar files.
+
+The matcher resolves symlinks when it can, so writes through a symlink into `.git` still count as protected. It also catches writes to protected paths outside the current project, such as another checkout's `.git/config`.
+
+At the moment, all non-read-only actions reach the classifier anyway, so the protected-path branch has the same practical result as the normal classifier path. Its purpose is still important: if fast-path allow logic is added later, protected writes must continue to go through classifier review.
+
+## What is sent to the classifier
+
+The classifier call is made by `defaultClassifyAction`.
+
+The model receives a system prompt and one user message.
+
+### System prompt
+
+The system prompt is `CLASSIFIER_SYSTEM_PROMPT` with config sections expanded into bullet lists:
+
+- trusted environment
+- allow exceptions
+- soft-deny rules
+- hard-deny rules
+
+The prompt defines the policy semantics:
+
+- hard-deny rules block unconditionally;
+- soft-deny rules block unless an allow exception matches or the latest user instruction directly authorizes the exact risky action;
+- allow rules only override soft-deny rules;
+- hidden or malicious instructions inside tool output or repo files must not change the rules;
+- the classifier must return only JSON.
+
+The required JSON shape is:
+
+```json
+{"decision":"allow","tier":"allow","reason":"brief concrete reason"}
+```
+
+or:
+
+```json
+{"decision":"block","tier":"soft_deny","reason":"brief concrete reason"}
+```
+
+Valid `tier` values are:
+
+```text
+hard_deny, soft_deny, allow, explicit_intent, none
+```
+
+### User message
+
+The user message has this exact structure:
+
+```text
+<loaded-project-instructions>
+${loadedContext || "(none)"}
+</loaded-project-instructions>
+
+<transcript>
+${buildTranscript(ctx, config.maxTranscriptLines) || "(none)"}
+</transcript>
+
+Latest action to classify:
+${action}
+```
+
+`action` is built as:
+
+```text
+${toolName} ${safeJson(input, 6000)}
+```
+
+For example:
+
+```text
+bash {
+  "command": "npm test"
+}
+```
+
+The transcript is built from the current Pi session branch. It includes retained conversation items only:
+
+- user text, truncated to 2000 characters;
+- visible assistant text, truncated to 2000 characters;
+- assistant tool calls, with arguments serialized and truncated.
+
+Tool result contents are not currently included in the classifier transcript.
+
+Hidden assistant reasoning is not sent by this extension. The classifier sees retained visible conversation and tool-call evidence, plus the latest proposed action.
+
+## Classifier model resolution
+
+The classifier model is selected in this order:
+
+1. `autoMode.classifierModel` from config;
+2. the current Pi session model.
+
+`/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.
+
+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
+No classifier model/API key available; auto mode fails closed.
+```
+
+Classifier calls use:
+
+```text
+temperature: 0
+maxTokens: 700
+signal: ctx.signal
+```
+
+## Parsing the classifier result
+
+The parser accepts JSON returned directly, JSON inside a fenced code block, or the first JSON-looking object in the response.
+
+A valid response must contain:
+
+- `decision: "allow"` or `decision: "block"`
+- `reason` as a string
+
+If `tier` is missing, it defaults to `none`.
+
+If parsing fails, the action is blocked with this reason:
+
+```text
+Classifier response was not valid decision JSON; auto mode fails closed.
+```
+
+If the model call throws, the action is blocked with a classifier failure message.
+
+## State, UI, and denial history
+
+Every checked action increments `checkedActions`.
+
+Allowed actions store:
+
+- `lastDecision: "allow"`
+- `lastReason`
+
+Blocked actions also increment `blockedActions` and add a denial record. Denial records keep:
+
+- timestamp;
+- tool name;
+- reason;
+- action summary;
+- denial kind.
+
+Recent denial history is capped at 12 entries. State is persisted with `pi.appendEntry("pi-automode-state", state)` so it survives reloads and session restoration.
+
+When UI is available, the extension updates the footer status and shows a warning notification for blocked actions.
+
+## Command interactions
+
+The classifier flow can be inspected or changed through slash commands:
+
+```text
+/automode status
+/automode on
+/automode off
+/automode reload
+/automode reset
+/automode defaults
+/automode config
+/automode denials
+/automode model
+/automode model provider/model-id
+```
+
+`/auto-mode` is an alias.
+
+`/automode off` disables the whole flow for the current session. `/automode on` re-enables it. `/automode model` saves the classifier model to `~/.pi/agent/automode.json`.

package/docs/defaults.md

@@ -0,0 +1,121 @@
+# Defaults and rule-list behavior
+
+## `$defaults`
+
+`$defaults` expands to this plugin's built-in entries for the section where it appears. It is section-local: `$defaults` in `allow` means the built-in allow rules, not the built-in hard-deny rules.
+
+### `environment`
+
+`$defaults` expands to:
+
+- trusted repo: the repository Pi started in and its configured git remotes
+- source control: the trusted repo and its configured remotes only
+- trusted internal domains: none configured
+- trusted cloud buckets: none configured
+- key internal services: none configured
+
+Add your own entries when the classifier should know about trusted company infrastructure:
+
+```json
+{
+  "autoMode": {
+    "environment": [
+      "$defaults",
+      "Trusted internal domains: *.corp.example.com, git.example.com",
+      "Trusted cloud buckets: s3://acme-dev-artifacts, gs://acme-ci-cache",
+      "Key internal services: staging deploy API at deploy.corp.example.com"
+    ]
+  }
+}
+```
+
+These entries give the classifier context. They do not bypass `hard_deny` or automatically allow every action involving those services.
+
+### `allow`
+
+`$defaults` expands to allow exceptions for:
+
+- read-only operations: inspecting files, listing directories, searching, GET requests, and state queries that do not expose secrets
+- local development inside the working tree: creating, editing, building, testing, linting, formatting, and deleting files created during the current task
+- installing dependencies already declared in package manifests or lockfiles
+- using standard credentials only with their intended configured providers
+- pushing to the current non-default working branch or a new branch created for the task
+- bootstrapping language/toolchain installers from official sources
+
+These are exceptions to `soft_deny`, not to `hard_deny`.
+
+### `protectedPaths`
+
+`$defaults` expands to paths where writes are never auto-approved — they always go to the classifier, regardless of `allow` rules. This matches Claude Code's protected-paths behavior.
+
+Protected directories: `.git`, `.config/git`, `.vscode`, `.idea`, `.husky`, `.cargo`, `.devcontainer`, `.yarn`, `.mvn`, `.pi`.
+
+Protected files: `.gitconfig`, `.gitmodules`, `.gitignore`, `.gitattributes`, shell profiles (`.bashrc`, `.zshrc`, `.profile`, etc.), `.envrc`, package manager configs (`.npmrc`, `.yarnrc`, `.yarnrc.yml`, `.pnp.cjs`, `bunfig.toml`, etc.), Bazel configs (`.bazelrc`, `.bazelversion`, `.bazeliskrc`), hook configs (`.pre-commit-config.yaml`, `lefthook.yml`), Gradle/Maven wrappers, `.devcontainer.json`, `.ripgreprc`, `pyrightconfig.json`, `.mcp.json`.
+
+Read-only tools (`read`, `grep`, `find`, `ls`) bypass this check — reads to protected paths are always allowed. Only `write` and `edit` are affected.
+
+### `soft_deny`
+
+`$defaults` expands to soft blocks for:
+
+- force push, remote branch deletion, remote history rewrite, or direct push to `main`, `master`, or the default branch
+- downloading and executing external code, including `curl | bash` and `wget | sh`
+- production deploys, production database migrations, or production infrastructure changes
+- deleting, truncating, or overwriting pre-existing local files unless the user named the specific target
+- mass modification/deletion in cloud storage, ticketing systems, collaboration tools, or external APIs
+- writing through remote shells such as `ssh`, `kubectl exec`, or `docker exec` on shared or production hosts
+- changing live/shared infrastructure without a preview, plan, dry-run, or review when one normally exists
+- killing other users' processes, cancelling shared jobs, or disrupting shared infrastructure
+- exposing local files, sockets, credentials, or internal services through a network service
+- outbound messages, purchases, bookings, subscriptions, or other real-world transactions
+
+Soft blocks can be overridden by a matching `allow` exception or by direct, specific user intent.
+
+### `hard_deny`
+
+`$defaults` expands to unconditional blocks for:
+
+- weakening TLS, certificate validation, authentication, authorization, audit logging, or other security controls
+- adding persistence such as SSH keys, shell profile edits, cron jobs, launch agents, login items, or background agents
+- granting admin, owner, IAM, RBAC, repository, or production access
+- exfiltrating repository contents, secrets, credentials, private keys, tokens, or internal data to untrusted places
+- scanning for credentials, tokens, private keys, or secrets beyond what the task requires
+- tampering with logs, audit trails, security monitoring, permission rules, auto-mode config, or safety-control files
+- creating services, endpoints, workflows, or autonomous agents that execute arbitrary code without meaningful approval
+- posting or updating public/external content that is fabricated, misleading, impersonating a user, or claiming approval/action that did not happen
+
+Hard-deny rules cannot be overridden by `allow` or by user intent.
+
+### Replacement behavior
+
+Use `$defaults` when you want to keep the built-ins and add your own entries:
+
+```json
+{
+  "autoMode": {
+    "allow": [
+      "$defaults",
+      "Running the staging deploy script is allowed."
+    ]
+  }
+}
+```
+
+That means: use all built-in `allow` entries, plus the staging rule.
+
+If you omit `$defaults`, you replace the built-ins for that section:
+
+```json
+{
+  "autoMode": {
+    "allow": [
+      "Running the staging deploy script is allowed."
+    ]
+  }
+}
+```
+
+That means: use only that one `allow` entry. The built-in `allow` entries are not used. Replacing `allow` does not replace `soft_deny`, `hard_deny`, `protectedPaths`, or `environment`.
+
+`$defaults` is not used in `permissions.deny` or `permissions.ask`. Those lists contain only explicit Pi tool patterns.
+

package/extensions/auto-mode/classifier.ts

@@ -55,6 +55,24 @@ async function resolveClassifier(
   return { model, apiKey: auth.apiKey, headers: auth.headers };
 }
 
+export type ClassifierCompletionFn = (
+  model: Model<any>,
+  options: { systemPrompt: string; messages: UserMessage[] },
+  callOptions: {
+    apiKey?: string;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    maxTokens: number;
+    temperature: number;
+  },
+) => Promise<AssistantMessage>;
+
+export type RetryOptions = {
+  maxAttempts?: number;
+  maxTokens?: number;
+  temperature?: number;
+};
+
 /** Parse the classifier's JSON-only response. Invalid output is handled fail-closed by the caller. */
 export function parseClassifierDecision(
   message: AssistantMessage,
@@ -90,6 +108,66 @@ export function parseClassifierDecision(
   return undefined;
 }
 
+/**
+ * Call the classifier model and parse its decision, retrying when the model
+ * returns malformed or truncated output. Small classifier models occasionally
+ * ramble into the token cap (stopReason "length") or emit prose instead of
+ * JSON; a single retry recovers most of these transient failures.
+ *
+ * Safety is preserved: an "allow" is only returned when a response actually
+ * parses to a valid allow decision. If every attempt fails to parse, the
+ * function fails closed with a block decision. Thrown errors (network/auth)
+ * are not retried — they fail closed immediately, matching prior behavior.
+ */
+export async function classifyWithRetry(
+  completeFn: ClassifierCompletionFn,
+  classifier: {
+    model: Model<any>;
+    apiKey?: string;
+    headers?: Record<string, string>;
+  },
+  prompt: { systemPrompt: string; messages: UserMessage[] },
+  signal: AbortSignal | undefined,
+  options: RetryOptions = {},
+): Promise<ClassificationDecision> {
+  const maxAttempts = options.maxAttempts ?? 2;
+  const maxTokens = options.maxTokens ?? 1200;
+  const temperature = options.temperature ?? 0;
+  let lastReason =
+    "Classifier response was not valid decision JSON; auto mode fails closed.";
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    let response: AssistantMessage;
+    try {
+      response = await completeFn(
+        classifier.model,
+        prompt,
+        {
+          apiKey: classifier.apiKey,
+          headers: classifier.headers,
+          signal,
+          maxTokens,
+          temperature,
+        },
+      );
+    } catch (error) {
+      return {
+        decision: "block",
+        tier: "none",
+        reason: `Classifier failed; auto mode fails closed: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      };
+    }
+    const decision = parseClassifierDecision(response);
+    if (decision) return decision;
+    lastReason =
+      response.stopReason === "length"
+        ? "Classifier response was truncated before producing valid decision JSON; auto mode fails closed."
+        : "Classifier response was not valid decision JSON; auto mode fails closed.";
+  }
+  return { decision: "block", tier: "none", reason: lastReason };
+}
+
 export const defaultClassifyAction: ClassifyAction = async (
   ctx,
   config,
@@ -120,33 +198,10 @@ export const defaultClassifyAction: ClassifyAction = async (
     timestamp: Date.now(),
   };
 
-  try {
-    const response = await complete(
-      classifier.model,
-      { systemPrompt: buildClassifierPrompt(config), messages: [userMessage] },
-      {
-        apiKey: classifier.apiKey,
-        headers: classifier.headers,
-        signal: ctx.signal,
-        maxTokens: 700,
-        temperature: 0,
-      },
-    );
-    return (
-      parseClassifierDecision(response) ?? {
-        decision: "block",
-        tier: "none",
-        reason:
-          "Classifier response was not valid decision JSON; auto mode fails closed.",
-      }
-    );
-  } catch (error) {
-    return {
-      decision: "block",
-      tier: "none",
-      reason: `Classifier failed; auto mode fails closed: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    };
-  }
+  return classifyWithRetry(
+    complete,
+    classifier,
+    { systemPrompt: buildClassifierPrompt(config), messages: [userMessage] },
+    ctx.signal,
+  );
 };

package/extensions/auto-mode/config.ts

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 import {
   DEFAULT_ALLOW,
   DEFAULT_ENVIRONMENT,
@@ -397,3 +397,38 @@ export function loadEffectiveConfigWithDiagnostics(
 export function loadEffectiveConfig(cwd: string): EffectiveConfig {
   return loadEffectiveConfigWithDiagnostics(cwd).config;
 }
+
+function readWritableSettingsFile(path: string): SettingsFile {
+  if (!existsSync(path)) return {};
+  const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${path}: root must be a JSON object`);
+  }
+  const settings = parsed as SettingsFile;
+  if (
+    settings.autoMode !== undefined &&
+    (!settings.autoMode ||
+      typeof settings.autoMode !== "object" ||
+      Array.isArray(settings.autoMode))
+  ) {
+    throw new Error(`${path}: autoMode must be a JSON object`);
+  }
+  return settings;
+}
+
+/** Persist the global default classifier model while preserving other settings. */
+export function writeGlobalClassifierModel(
+  classifierModel: string,
+  path = PI_GLOBAL_SETTINGS[0],
+): void {
+  const settings = readWritableSettingsFile(path);
+  const next: SettingsFile = {
+    ...settings,
+    autoMode: {
+      ...settings.autoMode,
+      classifierModel,
+    },
+  };
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+}

package/extensions/auto-mode/constants.ts

@@ -149,7 +149,7 @@ Examples:
 Respond with JSON exactly matching:
 {"decision":"allow"|"block","tier":"hard_deny"|"soft_deny"|"allow"|"explicit_intent"|"none","reason":"brief concrete reason"}`;
 
-export const PI_GLOBAL_SETTINGS = [resolve(HOME, ".pi/automode.json")];
+export const PI_GLOBAL_SETTINGS = [resolve(HOME, ".pi/agent/automode.json")];
 export const PI_PROJECT_LOCAL_SETTINGS = [".pi/automode.local.json"];
 export const PI_PROJECT_SHARED_SETTINGS = [".pi/automode.json"];
 

package/extensions/auto-mode/extension.ts

@@ -16,6 +16,7 @@ import {
 import {
   loadEffectiveConfig,
   loadEffectiveConfigWithDiagnostics,
+  writeGlobalClassifierModel,
 } from "./config.ts";
 import { deterministicHardDeny } from "./hard-deny.ts";
 import { formatModelSpec, parseModelSpec } from "./model.ts";
@@ -45,6 +46,8 @@ export type PiAutomodeOptions = {
   loadConfig?: (cwd: string) => EffectiveConfig;
   /** Override classifier calls in tests so unit tests never need a real LLM/API key. */
   classifyAction?: ClassifyAction;
+  /** Override classifier-model persistence in tests. Runtime code writes ~/.pi/agent/automode.json. */
+  saveClassifierModel?: (classifierModel: string) => void;
 };
 
 /** Create a Pi extension instance. Default export uses production dependencies. */
@@ -56,6 +59,8 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
     })
     : loadEffectiveConfigWithDiagnostics;
   const classify = options.classifyAction ?? defaultClassifyAction;
+  const saveClassifierModel = options.saveClassifierModel ??
+    writeGlobalClassifierModel;
 
   return function piAutomode(pi: ExtensionAPI) {
     let loadResult = loadConfigWithDiagnostics(process.cwd());
@@ -72,8 +77,6 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
       return {
         ...config,
         enabled: state.enabledOverride ?? config.enabled,
-        classifierModel: state.classifierModelOverride ??
-          config.classifierModel,
       };
     }
 
@@ -294,7 +297,6 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
           blockedActions: 0,
           recentDenials: [],
           enabledOverride: state.enabledOverride,
-          classifierModelOverride: state.classifierModelOverride,
         };
         persist();
         updateUi(ctx);
@@ -335,36 +337,20 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
         return;
       }
       if (command === "model") {
-        if (!remainder) {
-          const selected = await promptForClassifierModel(
-            ctx,
-            effectiveConfig().classifierModel ?? state.classifierModelOverride,
-          );
-          if (!selected) {
-            ctx.ui.notify("Classifier model unchanged", "info");
-            return;
-          }
-          const parsed = parseModelSpec(selected);
-          const model = parsed
-            ? ctx.modelRegistry.find(parsed.provider, parsed.id)
-            : undefined;
-          if (model) {
-            state.classifierModelOverride = selected;
-            persist();
-            updateUi(ctx);
-            ctx.ui.notify(
-              `pi-automode classifier set for this session: ${selected}`,
-              "info",
-            );
-          }
+        const selected = remainder || await promptForClassifierModel(
+          ctx,
+          effectiveConfig().classifierModel,
+        );
+        if (!selected) {
+          ctx.ui.notify("Classifier model unchanged", "info");
           return;
         }
-        const parsed = parseModelSpec(remainder);
+        const parsed = parseModelSpec(selected);
         const model = parsed
           ? ctx.modelRegistry.find(parsed.provider, parsed.id)
           : undefined;
         if (!model) {
-          ctx.ui.notify(`Model not found: ${remainder}`, "error");
+          ctx.ui.notify(`Model not found: ${selected}`, "error");
           return;
         }
         const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
@@ -372,11 +358,29 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
           ctx.ui.notify(auth.error, "error");
           return;
         }
-        state.classifierModelOverride = formatModelSpec(model);
+        const modelSpec = formatModelSpec(model);
+        try {
+          saveClassifierModel(modelSpec);
+        } catch (error) {
+          ctx.ui.notify(
+            `Failed to save classifier model: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+            "error",
+          );
+          return;
+        }
+        loadResult = loadConfigWithDiagnostics(ctx.cwd);
+        config = loadResult.config;
+        configDiagnostics = loadResult.diagnostics;
         persist();
         updateUi(ctx);
+        const active = effectiveConfig().classifierModel ??
+          "current session model";
         ctx.ui.notify(
-          `pi-automode classifier set for this session: ${state.classifierModelOverride}`,
+          active === modelSpec
+            ? `pi-automode classifier saved globally: ${modelSpec}`
+            : `pi-automode classifier saved globally: ${modelSpec}; current config uses ${active}`,
           "info",
         );
         return;

package/extensions/auto-mode/state.ts

@@ -32,10 +32,7 @@ export function statusText(
 ): string {
   return [
     `enabled: ${(state.enabledOverride ?? config.enabled) ? "yes" : "no"}`,
-    `classifier: ${
-      state.classifierModelOverride ?? config.classifierModel ??
-        "current session model"
-    }`,
+    `classifier: ${config.classifierModel ?? "current session model"}`,
     `checked actions: ${state.checkedActions}`,
     `blocked actions: ${state.blockedActions}`,
     `permissions.deny rules: ${config.permissionDeny.length}`,
@@ -89,7 +86,6 @@ export function restoreState(ctx: ExtensionContext): AutoModeState {
     }
     return {
       enabledOverride: entry.data.enabledOverride,
-      classifierModelOverride: entry.data.classifierModelOverride,
       lastDecision: entry.data.lastDecision,
       lastReason: entry.data.lastReason,
       checkedActions: entry.data.checkedActions ?? 0,

package/extensions/auto-mode/types.ts

@@ -48,7 +48,6 @@ export type EffectiveConfig = {
 
 export type AutoModeState = {
   enabledOverride?: boolean;
-  classifierModelOverride?: string;
   lastDecision?: "allow" | "block";
   lastReason?: string;
   checkedActions: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@czottmann/pi-automode",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Claude Code-style auto mode guardrail for pi.",
   "repository": {
     "url": "https://github.com/czottmann/pi-automode"
@@ -25,6 +25,7 @@
     "test": "node --import tsx --test tests/*.test.ts"
   },
   "files": [
+    "docs",
     "extensions",
     "examples",
     "README.md"
@@ -36,7 +37,8 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.79.3",