feat: add yolo mode to auto-approve permission prompts (#240)

* feat: add `--yolo` mode to auto-approve permission prompts

- Add `ALTIMATE_CLI_YOLO` / `OPENCODE_YOLO` env var flag
- Add `--yolo` as global CLI option (works with any subcommand)
- Add `--yolo` on `run` command for convenience
- Auto-approve (`"once"`) instead of auto-reject in headless mode
- Auto-approve in TUI via env var (skip permission prompt rendering)
- Global `--yolo` propagates to env var in middleware so all paths pick it up
- Explicit `deny` rules still enforced (safety by construction)
- Update permissions docs with Yolo Mode section

Closes #239

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

* fix: yolo mode — dynamic getter, ACP support, adversarial tests

- CRITICAL FIX: `Flag.ALTIMATE_CLI_YOLO` was a static `const` evaluated at
  module load time. `--yolo` CLI flag sets env var in middleware (after load),
  so the flag was always `false` via CLI. Now uses `Object.defineProperty`
  dynamic getter like other runtime-set flags.
- Add yolo mode handling to ACP agent (`acp/agent.ts`) — was missing,
  causing ACP clients to hang on permission prompts even with `--yolo`
- Replace unsafe `(opts as any).yolo` with `"yolo" in opts && opts.yolo`
- Add 26 adversarial tests covering:
  - Dynamic getter timing (the critical bug)
  - Env var parsing edge cases (empty, arbitrary strings, case)
  - Deny rules cannot be bypassed by yolo (safety by construction)
  - Case sensitivity of deny patterns
  - Multiple ruleset merge precedence
  - Error type distinction (`DeniedError` vs `RejectedError`)

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

* fix: yolo mode — dynamic getter, ACP support, adversarial tests

- CRITICAL FIX: `Flag.ALTIMATE_CLI_YOLO` was a static `const` evaluated at
  module load time. `--yolo` CLI flag sets env var in middleware (after load),
  so the flag was always `false` via CLI. Now uses `Object.defineProperty`
  dynamic getter like other runtime-set flags.
- Add yolo mode handling to ACP agent (`acp/agent.ts`) — was missing,
  causing ACP clients to hang on permission prompts even with `--yolo`
- Replace unsafe `(opts as any).yolo` with `"yolo" in opts && opts.yolo`
- Add 26 adversarial tests covering:
  - Dynamic getter timing (the critical bug)
  - Env var parsing edge cases (empty, arbitrary strings, case)
  - Deny rules cannot be bypassed by yolo (safety by construction)
  - Case sensitivity of deny patterns
  - Multiple ruleset merge precedence
  - Error type distinction (`DeniedError` vs `RejectedError`)

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

* feat: E2E tests, TUI yolo indicator, minor review fixes

1. **E2E tests** (6 new integration tests):
   - Deny rules throw `DeniedError` even with yolo env var set
   - Allow rules pass without asking (no yolo needed)
   - Ask rules wait for reply, resolved by yolo-style `"once"`
   - Multiple simultaneous permissions all resolved individually
   - Mixed deny + ask: deny throws, ask waits for reply
   - Config-driven permissions: yolo auto-approves `ask`, can't touch `deny`

2. **TUI yolo indicator** — `△ YOLO` warning in footer status bar
   when yolo mode is active, matching existing permission warning style

3. **Minor review fixes:**
   - Remove duplicate `--yolo` option from `run.ts` (inherited from global)

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

* docs: update yolo mode documentation

- Remove "subcommand flag" section (duplicate --yolo removed from run.ts)
- Explain WHY deny rules are still enforced (thrown before events)
- Document env var precedence (ALTIMATE_CLI_YOLO overrides OPENCODE_YOLO)
- Mention TUI footer indicator

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <[email protected]>

Author: anandgupta42

docs/docs/configure/permissions.md

@@ -107,6 +107,30 @@ export ALTIMATE_CLI_PERMISSION='{"bash":"deny","write":"deny"}'
 altimate
 ```
 
+## Yolo Mode
+
+Auto-approve all permission prompts without asking. Useful for CI/CD pipelines, benchmarks, scripted workflows, and trusted environments.
+
+**CLI flag (works with any subcommand):**
+
+```bash
+altimate-code --yolo run "build all dbt models"
+altimate-code --yolo                              # launches TUI in yolo mode
+```
+
+**Environment variable:**
+
+```bash
+export ALTIMATE_CLI_YOLO=true
+altimate-code run "analyze my queries"
+```
+
+The fallback `OPENCODE_YOLO` env var is also supported. When both are set, `ALTIMATE_CLI_YOLO` takes precedence — setting it to `false` disables yolo even if `OPENCODE_YOLO=true`.
+
+**Safety:** Explicit `deny` rules in your config are still enforced. Deny rules throw an error *before* any permission prompt is created, so yolo mode never sees them. If you've denied `rm *` or `DROP *`, those remain blocked even with `--yolo`.
+
+When yolo mode is active in the TUI, a `△ YOLO` indicator appears in the footer status bar.
+
 ## Recommended Configurations
 
 ### Data Engineering (Default — Balanced)

packages/opencode/src/acp/agent.ts

@@ -45,6 +45,9 @@ import { z } from "zod"
 import { LoadAPIKeyError } from "ai"
 import type { AssistantMessage, Event, OpencodeClient, SessionMessageResponse, ToolPart } from "@opencode-ai/sdk/v2"
 import { applyPatch } from "diff"
+// altimate_change start - yolo mode
+import { Flag } from "@/flag/flag"
+// altimate_change end
 
 type ModeOption = { id: string; name: string; description?: string }
 type ModelOption = { modelId: string; name: string }
@@ -188,6 +191,17 @@ export namespace ACP {
           const session = this.sessionManager.tryGet(permission.sessionID)
           if (!session) return
 
+          // altimate_change start - yolo mode: auto-approve without asking ACP client
+          if (Flag.ALTIMATE_CLI_YOLO) {
+            await this.sdk.permission.reply({
+              requestID: permission.id,
+              reply: "once",
+              directory: session.cwd,
+            })
+            return
+          }
+          // altimate_change end
+
           const prev = this.permissionQueues.get(permission.sessionID) ?? Promise.resolve()
           const next = prev
             .then(async () => {

packages/opencode/src/cli/cmd/run.ts

@@ -664,15 +664,30 @@ You are speaking to a non-technical business executive. Follow these rules stric
           if (event.type === "permission.asked") {
             const permission = event.properties
             if (permission.sessionID !== sessionID) continue
-            UI.println(
-              UI.Style.TEXT_WARNING_BOLD + "!",
-              UI.Style.TEXT_NORMAL +
-                `permission requested: ${permission.permission} (${permission.patterns.join(", ")}); auto-rejecting`,
-            )
-            await sdk.permission.reply({
-              requestID: permission.id,
-              reply: "reject",
-            })
+            // altimate_change start - yolo mode: auto-approve instead of auto-reject
+            const yolo = args.yolo || Flag.ALTIMATE_CLI_YOLO
+            if (yolo) {
+              UI.println(
+                UI.Style.TEXT_WARNING_BOLD + "!",
+                UI.Style.TEXT_NORMAL +
+                  `yolo mode: auto-approved ${permission.permission} (${permission.patterns.join(", ")})`,
+              )
+              await sdk.permission.reply({
+                requestID: permission.id,
+                reply: "once",
+              })
+            } else {
+              UI.println(
+                UI.Style.TEXT_WARNING_BOLD + "!",
+                UI.Style.TEXT_NORMAL +
+                  `permission requested: ${permission.permission} (${permission.patterns.join(", ")}); auto-rejecting`,
+              )
+              await sdk.permission.reply({
+                requestID: permission.id,
+                reply: "reject",
+              })
+            }
+            // altimate_change end
           }
         }
       }

packages/opencode/src/cli/cmd/tui/context/sync.tsx

@@ -27,6 +27,9 @@ import { useExit } from "./exit"
 import { useArgs } from "./args"
 import { batch, onMount } from "solid-js"
 import { Log } from "@/util/log"
+// altimate_change start - yolo mode
+import { Flag } from "@/flag/flag"
+// altimate_change end
 import type { Path } from "@opencode-ai/sdk"
 import type { Workspace } from "@opencode-ai/sdk/v2"
 
@@ -136,6 +139,22 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
 
         case "permission.asked": {
           const request = event.properties
+          // altimate_change start - yolo mode: auto-approve without showing prompt
+          if (Flag.ALTIMATE_CLI_YOLO) {
+            sdk.client.permission
+              .reply({
+                requestID: request.id,
+                reply: "once",
+              })
+              .catch((e) => {
+                Log.Default.error("yolo mode auto-approve failed", {
+                  error: e instanceof Error ? e.message : String(e),
+                  requestID: request.id,
+                })
+              })
+            break
+          }
+          // altimate_change end
           const requests = store.permission[request.sessionID]
           if (!requests) {
             setStore("permission", request.sessionID, [request])

packages/opencode/src/cli/cmd/tui/routes/session/footer.tsx

@@ -5,6 +5,9 @@ import { useDirectory } from "../../context/directory"
 import { useConnected } from "../../component/dialog-model"
 import { createStore } from "solid-js/store"
 import { useRoute } from "../../context/route"
+// altimate_change start - yolo mode visual indicator
+import { Flag } from "@/flag/flag"
+// altimate_change end
 
 export function Footer() {
   const { theme } = useTheme()
@@ -60,6 +63,13 @@ export function Footer() {
             </text>
           </Match>
           <Match when={connected()}>
+            {/* altimate_change start - yolo mode visual indicator */}
+            <Show when={Flag.ALTIMATE_CLI_YOLO}>
+              <text fg={theme.warning}>
+                <span style={{ fg: theme.warning }}>△</span> YOLO
+              </text>
+            </Show>
+            {/* altimate_change end */}
             <Show when={permissions().length > 0}>
               <text fg={theme.warning}>
                 <span style={{ fg: theme.warning }}>△</span> {permissions().length} Permission

packages/opencode/src/flag/flag.ts

@@ -36,6 +36,11 @@ export namespace Flag {
   // altimate_change start - opt-in for session-end auto-extraction
   export const ALTIMATE_MEMORY_AUTO_EXTRACT = altTruthy("ALTIMATE_MEMORY_AUTO_EXTRACT", "OPENCODE_MEMORY_AUTO_EXTRACT")
   // altimate_change end
+  // altimate_change start - yolo mode: auto-approve all permission prompts
+  // Declared here, defined via dynamic getter below (must evaluate at access time
+  // because --yolo CLI flag sets the env var in middleware after module load)
+  export declare const ALTIMATE_CLI_YOLO: boolean
+  // altimate_change end
   // altimate_change start - opt-out for AI Teammate training system
   export const ALTIMATE_DISABLE_TRAINING = altTruthy("ALTIMATE_DISABLE_TRAINING", "OPENCODE_DISABLE_TRAINING")
   // altimate_change end
@@ -139,6 +144,23 @@ Object.defineProperty(Flag, "OPENCODE_CLIENT", {
   configurable: false,
 })
 
+// altimate_change start - yolo mode: dynamic getter (set at runtime via --yolo flag)
+// ALTIMATE_CLI_YOLO is authoritative when defined; only falls back to OPENCODE_YOLO when undefined
+Object.defineProperty(Flag, "ALTIMATE_CLI_YOLO", {
+  get() {
+    const alt = process.env["ALTIMATE_CLI_YOLO"]
+    if (alt !== undefined) {
+      const v = alt.toLowerCase()
+      return v === "true" || v === "1"
+    }
+    const oc = process.env["OPENCODE_YOLO"]?.toLowerCase()
+    return oc === "true" || oc === "1"
+  },
+  enumerable: true,
+  configurable: false,
+})
+// altimate_change end
+
 // altimate_change start - ALTIMATE_CLI_CLIENT with OPENCODE_CLIENT fallback
 Object.defineProperty(Flag, "ALTIMATE_CLI_CLIENT", {
   get() {

packages/opencode/src/index.ts

@@ -78,6 +78,13 @@ let cli = yargs(hideBin(process.argv))
     type: "string",
     choices: ["DEBUG", "INFO", "WARN", "ERROR"],
   })
+  // altimate_change start - yolo mode as global flag
+  .option("yolo", {
+    describe: "auto-approve all permission prompts (explicit deny rules still enforced)",
+    type: "boolean",
+    default: false,
+  })
+  // altimate_change end
   .middleware(async (opts) => {
     await Log.init({
       print: process.argv.includes("--print-logs"),
@@ -96,6 +103,12 @@ let cli = yargs(hideBin(process.argv))
     process.env.DATAPILOT = "1"
     // altimate_change end
 
+    // altimate_change start - propagate --yolo flag to env var so Flag.ALTIMATE_CLI_YOLO picks it up
+    if ("yolo" in opts && opts.yolo) {
+      process.env.ALTIMATE_CLI_YOLO = "true"
+    }
+    // altimate_change end
+
     // altimate_change start - telemetry init
     // Initialize telemetry early so events from MCP, engine, auth are captured.
     // init() is idempotent — safe to call again later in session prompt.