wile 1.1.0 → 1.2.0

package/README.md

@@ -16,6 +16,19 @@ From your project repo:
 bunx wile config
 ```
 
+For non-interactive setup docs (useful for agents creating `.wile/secrets/.env` directly):
+
+```bash
+bunx wile config --non-interactive
+```
+
+Apply non-interactive config (agent mode):
+
+```bash
+export WILE_PROMPTS_INJECT='{"codingAgent":"OC","repoSource":"local","ocModel":"opencode/kimi-k2.5-free","branchName":"main","envProjectPath":".wile/.env.project","maxIterations":25}'
+bunx wile config --non-interactive "$WILE_PROMPTS_INJECT"
+```
+
 This creates:
 
 - `.wile/secrets/.env` for required credentials
@@ -26,7 +39,7 @@ This creates:
 Set `WILE_REPO_SOURCE=local` in `.wile/secrets/.env` to run against the current directory without GitHub.
 When `WILE_REPO_SOURCE=local`, GitHub credentials are optional.
 Set `WILE_MAX_ITERATIONS` in `.wile/secrets/.env` to change the default loop limit (default: 25).
-Set `CODING_AGENT=CX` to use Codex CLI, `CODING_AGENT=OC` to use OpenCode (OpenRouter), `CODING_AGENT=GC` to use Gemini CLI, otherwise `CODING_AGENT=CC` uses Claude Code.
+Set `CODING_AGENT=CX` to use Codex CLI, `CODING_AGENT=OC` to use OpenCode (free native models), `CODING_AGENT=GC` to use Gemini CLI, otherwise `CODING_AGENT=CC` uses Claude Code.
 
 ## Run Wile
 

package/dist/agent/.env.example

@@ -8,7 +8,7 @@
 # Choose which coding agent to run:
 # - CC = Claude Code (default)
 # - GC = Gemini CLI (Google account OAuth)
-# - OC = OpenCode (OpenRouter)
+# - OC = OpenCode (free native models)
 # - CX = Codex CLI (ChatGPT subscription)
 CODING_AGENT=CC
 
@@ -30,10 +30,8 @@ CC_CLAUDE_CODE_OAUTH_TOKEN=sk-ant-oat01-xxxxx
 # REQUIRED - OpenCode Authentication (OC only)
 # =============================================================================
 
-# OpenRouter API key (used with OpenCode)
-# OC_OPENROUTER_API_KEY=sk-or-xxxxx
-# OpenRouter model id (Wile maps `glm-4.7` to `openrouter/z-ai/glm-4.7`)
-# OC_MODEL=glm-4.7
+# Native model id (default: opencode/kimi-k2.5-free)
+# OC_MODEL=opencode/kimi-k2.5-free
 
 # =============================================================================
 # REQUIRED - Gemini CLI Authentication (GC only, choose ONE)
@@ -91,14 +89,14 @@ BRANCH_NAME=feature/my-feature
 # Maximum loop iterations before stopping (default: 25)
 MAX_ITERATIONS=25
 
-# Claude model alias or full model name (default: sonnet)
-CC_CLAUDE_MODEL=sonnet
+# Claude model alias or full model name (default: opus)
+CC_CLAUDE_MODEL=opus
 
-# Gemini model name (default: auto-gemini-3)
-# GEMINI_MODEL=auto-gemini-3
+# Gemini model name (default: gemini-3-pro)
+# GEMINI_MODEL=gemini-3-pro
 
-# Codex model name (defaults to Codex CLI default)
-# CODEX_MODEL=gpt-5.1-codex
+# Codex model name (default: gpt-5.3-codex)
+# CODEX_MODEL=gpt-5.3-codex
 
 # =============================================================================
 # PROJECT ENVIRONMENT VARIABLES

package/dist/agent/README.md

@@ -110,23 +110,22 @@ For UI work, tell the agent how to verify:
 
 | Variable | Required | Description |
 |----------|----------|-------------|
-| `CODING_AGENT` | No | `CC` (Claude Code, default), `GC` (Gemini CLI), `OC` (OpenCode via OpenRouter), or `CX` (Codex CLI) |
+| `CODING_AGENT` | No | `CC` (Claude Code, default), `GC` (Gemini CLI), `OC` (OpenCode native/free models), or `CX` (Codex CLI) |
 | `CC_CLAUDE_CODE_OAUTH_TOKEN` | Yes* | OAuth token from `claude setup-token` (uses Pro/Max subscription) |
 | `CC_ANTHROPIC_API_KEY` | Yes* | API key (uses API credits - alternative to OAuth) |
 | `GEMINI_OAUTH_CREDS_B64` | Yes (GC)* | Base64 OAuth creds from `~/.gemini/oauth_creds.json` (uses Google account) |
 | `GEMINI_API_KEY` | Yes (GC)* | Gemini API key (uses API credits - alternative to OAuth) |
-| `OC_OPENROUTER_API_KEY` | Yes (OC) | OpenRouter API key for OpenCode |
-| `OC_MODEL` | Yes (OC) | OpenRouter model id (set `glm-4.7` to target `openrouter/z-ai/glm-4.7`) |
+| `OC_MODEL` | Yes (OC) | OpenCode native model id (default: `opencode/kimi-k2.5-free`) |
 | `CODEX_AUTH_JSON_B64` | Yes (CX)* | Base64 of `~/.codex/auth.json` from `codex login` (uses ChatGPT subscription) |
 | `CODEX_API_KEY` | Yes (CX)* | OpenAI API key (uses API credits - alternative to auth.json) |
-| `GEMINI_MODEL` | No (GC) | Gemini model name (default: `auto-gemini-3`) |
+| `GEMINI_MODEL` | No (GC) | Gemini model name (default: `gemini-3-pro-preview`) |
 | `WILE_REPO_SOURCE` | No | `github` (default) or `local` |
 | `GITHUB_TOKEN` | Yes (github) | GitHub PAT with repo access |
 | `GITHUB_REPO_URL` | Yes (github) | HTTPS URL to repository |
 | `BRANCH_NAME` | Yes (github) | Branch to work on |
 | `MAX_ITERATIONS` | No | Max loops (default: 25) |
-| `CC_CLAUDE_MODEL` | No | Claude model alias/name (default: sonnet) |
-| `CODEX_MODEL` | No (CX) | Codex model name (defaults to Codex CLI default) |
+| `CC_CLAUDE_MODEL` | No | Claude model alias/name (default: `opus`) |
+| `CODEX_MODEL` | No (CX) | Codex model name (default: `gpt-5.3-codex`) |
 
 *Either `CC_CLAUDE_CODE_OAUTH_TOKEN` or `CC_ANTHROPIC_API_KEY` is required when `CODING_AGENT=CC`.  
 *Either `GEMINI_OAUTH_CREDS_B64` or `GEMINI_API_KEY` is required when `CODING_AGENT=GC`.  

package/dist/agent/entrypoint.sh

@@ -105,11 +105,6 @@ fi
 
 # Authentication for selected coding agent
 if [ "$CODING_AGENT" = "OC" ]; then
-  OC_PROVIDER="${OC_PROVIDER:-native}"
-  if [ "$OC_PROVIDER" = "openrouter" ] && [ -z "$OC_OPENROUTER_API_KEY" ]; then
-    echo "ERROR: OC_OPENROUTER_API_KEY is required for OpenCode with OpenRouter provider"
-    exit 1
-  fi
   if [ -z "$OC_MODEL" ]; then
     echo "ERROR: OC_MODEL is required for OpenCode"
     exit 1
@@ -177,23 +172,7 @@ if [ "${WILE_MOCK_CODEX:-}" = "true" ] && [ "$CODING_AGENT" = "CX" ]; then
 fi
 
 if [ "$CODING_AGENT" = "OC" ]; then
-  if [ "$OC_PROVIDER" = "openrouter" ]; then
-    echo "  Auth:       OpenRouter (OpenCode)"
-    OPENCODE_DATA_DIR="${XDG_DATA_HOME:-$HOME/.local/share}/opencode"
-    mkdir -p "$OPENCODE_DATA_DIR"
-    cat > "$OPENCODE_DATA_DIR/auth.json" << OPENCODEAUTH
-{
-  "openrouter": {
-    "type": "api",
-    "key": "$OC_OPENROUTER_API_KEY"
-  }
-}
-OPENCODEAUTH
-    chmod 600 "$OPENCODE_DATA_DIR/auth.json"
-    export OPENROUTER_API_KEY="$OC_OPENROUTER_API_KEY"
-  else
-    echo "  Auth:       Native (free models)"
-  fi
+  echo "  Auth:       Native (free models)"
 elif [ "$CODING_AGENT" = "GC" ]; then
   if [ -n "$GEMINI_OAUTH_CREDS_B64" ] || [ -n "$GEMINI_OAUTH_CREDS_PATH" ]; then
     echo "  Auth:       OAuth (Google account)"

package/dist/agent/scripts/wile-compact.sh

@@ -6,16 +6,10 @@
 set -e
 
 CODING_AGENT=${CODING_AGENT:-CC}
-CLAUDE_MODEL=${CC_CLAUDE_MODEL:-sonnet}
-OC_PROVIDER=${OC_PROVIDER:-native}
-OC_MODEL=${OC_MODEL:-opencode/grok-code}
-GEMINI_MODEL=${GEMINI_MODEL:-auto-gemini-3}
-CODEX_MODEL=${CODEX_MODEL:-}
-
-# For openrouter provider, prepend vendor prefix if missing
-if [ "$OC_PROVIDER" = "openrouter" ] && [[ "$OC_MODEL" != */* ]]; then
-  OC_MODEL="z-ai/$OC_MODEL"
-fi
+CLAUDE_MODEL=${CC_CLAUDE_MODEL:-opus}
+OC_MODEL=${OC_MODEL:-opencode/kimi-k2.5-free}
+GEMINI_MODEL=${GEMINI_MODEL:-gemini-3-pro-preview}
+CODEX_MODEL=${CODEX_MODEL:-gpt-5.3-codex}
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROMPT_FILE="$SCRIPT_DIR/prompt-compact.md"
@@ -30,7 +24,6 @@ echo "  🌵  WILE - Compact PRD & Progress"
 echo "══════════════════════════════════════════════════════"
 echo "  Agent:          $CODING_AGENT"
 if [ "$CODING_AGENT" = "OC" ]; then
-  echo "  Provider:       $OC_PROVIDER"
   echo "  Model:          $OC_MODEL"
 elif [ "$CODING_AGENT" = "GC" ]; then
   echo "  Model:          ${GEMINI_MODEL:-auto}"
@@ -67,12 +60,8 @@ run_claude() {
 
 run_opencode() {
   local prompt_path="$1"
-  local model_arg="$OC_MODEL"
-  if [ "$OC_PROVIDER" = "openrouter" ]; then
-    model_arg="openrouter/$OC_MODEL"
-  fi
   cat "$prompt_path" \
-    | opencode run --format json --model "$model_arg" \
+    | opencode run --format json --model "$OC_MODEL" \
     | bun "$SCRIPT_DIR/opencode-stream.ts"
 }
 

package/dist/agent/scripts/wile-preflight.sh

@@ -6,16 +6,10 @@
 set -e
 
 CODING_AGENT=${CODING_AGENT:-CC}
-CLAUDE_MODEL=${CC_CLAUDE_MODEL:-sonnet}
-OC_PROVIDER=${OC_PROVIDER:-native}
-OC_MODEL=${OC_MODEL:-opencode/grok-code}
-GEMINI_MODEL=${GEMINI_MODEL:-auto-gemini-3}
-CODEX_MODEL=${CODEX_MODEL:-}
-
-# For openrouter provider, prepend vendor prefix if missing
-if [ "$OC_PROVIDER" = "openrouter" ] && [[ "$OC_MODEL" != */* ]]; then
-  OC_MODEL="z-ai/$OC_MODEL"
-fi
+CLAUDE_MODEL=${CC_CLAUDE_MODEL:-opus}
+OC_MODEL=${OC_MODEL:-opencode/kimi-k2.5-free}
+GEMINI_MODEL=${GEMINI_MODEL:-gemini-3-pro-preview}
+CODEX_MODEL=${CODEX_MODEL:-gpt-5.3-codex}
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PREFLIGHT_PROMPT_FILE="$SCRIPT_DIR/prompt-preflight.md"
 PROGRESS_PATH="${WILE_PROGRESS_PATH:-.wile/progress.txt}"
@@ -29,7 +23,6 @@ echo "  🌵  WILE - Preflight"
 echo "══════════════════════════════════════════════════════"
 echo "  Agent:          $CODING_AGENT"
 if [ "$CODING_AGENT" = "OC" ]; then
-  echo "  Provider:       $OC_PROVIDER"
   echo "  Model:          $OC_MODEL"
 elif [ "$CODING_AGENT" = "GC" ]; then
   echo "  Model:          ${GEMINI_MODEL:-auto}"
@@ -56,12 +49,8 @@ run_claude() {
 
 run_opencode() {
   local prompt_path="$1"
-  local model_arg="$OC_MODEL"
-  if [ "$OC_PROVIDER" = "openrouter" ]; then
-    model_arg="openrouter/$OC_MODEL"
-  fi
   cat "$prompt_path" \
-    | opencode run --format json --model "$model_arg" \
+    | opencode run --format json --model "$OC_MODEL" \
     | bun "$SCRIPT_DIR/opencode-stream.ts"
 }
 

package/dist/agent/scripts/wile.sh

@@ -8,16 +8,10 @@ set -e
 
 MAX_ITERATIONS=${1:-25}
 CODING_AGENT=${CODING_AGENT:-CC}
-CLAUDE_MODEL=${CC_CLAUDE_MODEL:-sonnet}
-OC_PROVIDER=${OC_PROVIDER:-native}
-OC_MODEL=${OC_MODEL:-opencode/grok-code}
-GEMINI_MODEL=${GEMINI_MODEL:-auto-gemini-3}
-CODEX_MODEL=${CODEX_MODEL:-}
-
-# For openrouter provider, prepend vendor prefix if missing
-if [ "$OC_PROVIDER" = "openrouter" ] && [[ "$OC_MODEL" != */* ]]; then
-  OC_MODEL="z-ai/$OC_MODEL"
-fi
+CLAUDE_MODEL=${CC_CLAUDE_MODEL:-opus}
+OC_MODEL=${OC_MODEL:-opencode/kimi-k2.5-free}
+GEMINI_MODEL=${GEMINI_MODEL:-gemini-3-pro-preview}
+CODEX_MODEL=${CODEX_MODEL:-gpt-5.3-codex}
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROMPT_FILE="$SCRIPT_DIR/prompt.md"
 PREFLIGHT_PROMPT_FILE="$SCRIPT_DIR/prompt-preflight.md"
@@ -34,7 +28,6 @@ echo "════════════════════════
 echo "  Agent:          $CODING_AGENT"
 echo "  Max iterations: $MAX_ITERATIONS"
 if [ "$CODING_AGENT" = "OC" ]; then
-  echo "  Provider:       $OC_PROVIDER"
   echo "  Model:          $OC_MODEL"
 elif [ "$CODING_AGENT" = "GC" ]; then
   echo "  Model:          ${GEMINI_MODEL:-auto}"
@@ -73,12 +66,8 @@ run_claude() {
 
 run_opencode() {
   local prompt_path="$1"
-  local model_arg="$OC_MODEL"
-  if [ "$OC_PROVIDER" = "openrouter" ]; then
-    model_arg="openrouter/$OC_MODEL"
-  fi
   cat "$prompt_path" \
-    | opencode run --format json --model "$model_arg" \
+    | opencode run --format json --model "$OC_MODEL" \
     | bun "$SCRIPT_DIR/opencode-stream.ts"
 }
 

package/dist/cli.js

@@ -7451,6 +7451,166 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join, resolve, isAbsolute } from "node:path";
 import { homedir } from "node:os";
+
+// src/lib/env-schema.ts
+var ENV_VAR_DOC = [
+  {
+    key: "CODING_AGENT",
+    section: "core",
+    description: "Agent to run: CC (Claude), GC (Gemini), OC (OpenCode), CX (Codex).",
+    requiredWhen: "Always.",
+    defaultValue: "CC"
+  },
+  {
+    key: "WILE_REPO_SOURCE",
+    section: "core",
+    description: "Where to get the repo from.",
+    requiredWhen: "Always.",
+    defaultValue: "github"
+  },
+  {
+    key: "WILE_ENV_PROJECT_PATH",
+    section: "core",
+    description: "Path to project env file forwarded into Docker.",
+    requiredWhen: "Optional.",
+    defaultValue: ".wile/.env.project"
+  },
+  {
+    key: "WILE_MAX_ITERATIONS",
+    section: "core",
+    description: "Default max loop iterations for `wile run`.",
+    requiredWhen: "Optional.",
+    defaultValue: "25"
+  },
+  {
+    key: "GITHUB_TOKEN",
+    section: "github",
+    description: "GitHub token used for clone/push in GitHub repo mode.",
+    requiredWhen: "Required when `WILE_REPO_SOURCE=github`.",
+    secret: true
+  },
+  {
+    key: "GITHUB_REPO_URL",
+    section: "github",
+    description: "Repository URL to clone in GitHub repo mode.",
+    requiredWhen: "Required when `WILE_REPO_SOURCE=github`."
+  },
+  {
+    key: "BRANCH_NAME",
+    section: "github",
+    description: "Branch Wile checks out and pushes to.",
+    requiredWhen: "Required when `WILE_REPO_SOURCE=github`.",
+    defaultValue: "main"
+  },
+  {
+    key: "CC_CLAUDE_MODEL",
+    section: "claude",
+    description: "Claude model (`sonnet`, `opus`, `haiku`).",
+    requiredWhen: "When `CODING_AGENT=CC`.",
+    defaultValue: "opus"
+  },
+  {
+    key: "CC_CLAUDE_CODE_OAUTH_TOKEN",
+    section: "claude",
+    description: "Claude Code OAuth token (subscription auth).",
+    requiredWhen: "One of this or `CC_ANTHROPIC_API_KEY` when `CODING_AGENT=CC`.",
+    secret: true
+  },
+  {
+    key: "CC_ANTHROPIC_API_KEY",
+    section: "claude",
+    description: "Anthropic API key (pay-per-token auth).",
+    requiredWhen: "One of this or `CC_CLAUDE_CODE_OAUTH_TOKEN` when `CODING_AGENT=CC`.",
+    secret: true
+  },
+  {
+    key: "OC_MODEL",
+    section: "opencode",
+    description: "OpenCode model id (native/free model).",
+    requiredWhen: "Required when `CODING_AGENT=OC`.",
+    defaultValue: "opencode/kimi-k2.5-free"
+  },
+  {
+    key: "GEMINI_OAUTH_CREDS_B64",
+    section: "gemini",
+    description: "Base64-encoded `~/.gemini/oauth_creds.json`.",
+    requiredWhen: "One of this or `GEMINI_API_KEY` when `CODING_AGENT=GC`.",
+    secret: true
+  },
+  {
+    key: "GEMINI_API_KEY",
+    section: "gemini",
+    description: "Gemini API key.",
+    requiredWhen: "One of this or `GEMINI_OAUTH_CREDS_B64` when `CODING_AGENT=GC`.",
+    secret: true
+  },
+  {
+    key: "GEMINI_MODEL",
+    section: "gemini",
+    description: "Gemini model id.",
+    requiredWhen: "When `CODING_AGENT=GC`.",
+    defaultValue: "gemini-3-pro-preview"
+  },
+  {
+    key: "CODEX_AUTH_JSON_B64",
+    section: "codex",
+    description: "Base64-encoded `~/.codex/auth.json` (subscription auth).",
+    requiredWhen: "One of this, `CODEX_AUTH_JSON_PATH`, `CODEX_API_KEY`, or `OPENAI_API_KEY` when `CODING_AGENT=CX`.",
+    secret: true
+  },
+  {
+    key: "CODEX_AUTH_JSON_PATH",
+    section: "codex",
+    description: "Path to `~/.codex/auth.json` (used by `wile config`, then encoded).",
+    requiredWhen: "Optional. Can be used instead of `CODEX_AUTH_JSON_B64` when generating config interactively."
+  },
+  {
+    key: "CODEX_API_KEY",
+    section: "codex",
+    description: "OpenAI API key for Codex API-key auth.",
+    requiredWhen: "One of this, `OPENAI_API_KEY`, `CODEX_AUTH_JSON_B64`, or `CODEX_AUTH_JSON_PATH` when `CODING_AGENT=CX`.",
+    secret: true
+  },
+  {
+    key: "OPENAI_API_KEY",
+    section: "codex",
+    description: "Alias fallback for `CODEX_API_KEY`.",
+    requiredWhen: "Optional alias; counts as Codex API key when `CODING_AGENT=CX`.",
+    secret: true
+  },
+  {
+    key: "CODEX_MODEL",
+    section: "codex",
+    description: "Codex model override.",
+    requiredWhen: "When `CODING_AGENT=CX`.",
+    defaultValue: "gpt-5.3-codex"
+  }
+];
+var ENV_FILE_KEY_ORDER = ENV_VAR_DOC.map((entry) => entry.key);
+var knownKeySet = new Set(ENV_FILE_KEY_ORDER);
+var isEnvFileKey = (key) => knownKeySet.has(key);
+var splitEnv = (raw) => {
+  const known = {};
+  const extra = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (isEnvFileKey(key)) {
+      known[key] = value;
+      continue;
+    }
+    extra[key] = value;
+  }
+  return { known, extra };
+};
+var toEnvString = (known, extra = {}) => {
+  const ordered = ENV_FILE_KEY_ORDER.filter((key) => known[key] !== undefined);
+  const rest = Object.keys(extra).sort();
+  const lines = [...ordered, ...rest].map((key) => `${key}=${known[key] ?? extra[key]}`);
+  return lines.join(`
+`) + `
+`;
+};
+
+// src/commands/config.ts
 var prdExample = {
   stories: [
     {
@@ -7545,7 +7705,6 @@ var prdExample = {
 var tips = {
   oauth: "Tip: run 'claude setup-token' on your machine to generate an OAuth token (uses Pro/Max subscription).",
   apiKey: "Tip: create an Anthropic API key in the console (uses API credits).",
-  openrouter: "Tip: create an OpenRouter API key at https://openrouter.ai/keys (pay per token).",
   github: "Tip: use a GitHub Personal Access Token (fine-grained recommended). Create at https://github.com/settings/tokens?type=beta with Contents (read/write) and Metadata (read).",
   geminiOauth: "Tip: run 'gemini' locally and choose Login with Google to create ~/.gemini/oauth_creds.json.",
   geminiApiKey: "Tip: create a Gemini API key at https://aistudio.google.com/app/apikey (pay per token).",
@@ -7553,11 +7712,246 @@ var tips = {
   codexApiKey: "Tip: create an OpenAI API key at https://platform.openai.com/api-keys (pay per token)."
 };
 var nativeOcModels = [
-  { title: "Grok Code Fast 1 (recommended)", value: "opencode/grok-code" },
-  { title: "Big Pickle", value: "opencode/big-pickle" },
-  { title: "GLM-4.7", value: "opencode/glm-4.7-free" },
-  { title: "MiniMax M2.1", value: "opencode/minimax-m2.1-free" }
+  { title: "Kimi K2.5 Free (recommended)", value: "opencode/kimi-k2.5-free" },
+  { title: "MiniMax 2.5", value: "opencode/minimax-m2.5-free" },
+  { title: "Big Pickle", value: "opencode/big-pickle" }
 ];
+var nonInteractiveKeys = new Set([
+  "codingAgent",
+  "repoSource",
+  "branchName",
+  "envProjectPath",
+  "maxIterations",
+  "githubToken",
+  "repoUrl",
+  "ccAuthMethod",
+  "ccAuthValue",
+  "ccModel",
+  "ocModel",
+  "gcAuthMethod",
+  "gcOauthPath",
+  "gcApiKey",
+  "gcModel",
+  "cxAuthMethod",
+  "cxAuthJsonPath",
+  "cxApiKey",
+  "cxModel"
+]);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var asNonEmptyString = (value) => {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+};
+var renderNonInteractiveConfigHelp = () => {
+  const lines = [];
+  lines.push("# Wile non-interactive config");
+  lines.push("");
+  lines.push("Use one flag for both docs and config application:");
+  lines.push("- `bunx wile config --non-interactive` prints this help.");
+  lines.push("- `bunx wile config --non-interactive '<json>'` validates and applies config.");
+  lines.push("- Direct edits to `.wile/secrets/.env` are discouraged; prefer this command so validation runs before writing.");
+  lines.push("");
+  lines.push("The JSON payload is ideal to pass via `WILE_PROMPTS_INJECT`:");
+  lines.push("```bash");
+  lines.push(`export WILE_PROMPTS_INJECT='{"codingAgent":"OC","repoSource":"local","ocModel":"opencode/kimi-k2.5-free","branchName":"main","envProjectPath":".wile/.env.project","maxIterations":25}'`);
+  lines.push('bunx wile config --non-interactive "$WILE_PROMPTS_INJECT"');
+  lines.push("```");
+  lines.push("");
+  lines.push("Required fields:");
+  lines.push("- Always: `codingAgent`, `repoSource`.");
+  lines.push("- If `repoSource=github`: `githubToken`, `repoUrl`.");
+  lines.push("- If `codingAgent=CC`: `ccAuthMethod`, `ccAuthValue`.");
+  lines.push("- If `codingAgent=OC`: `ocModel`.");
+  lines.push("- If `codingAgent=GC` and `gcAuthMethod=oauth`: `gcOauthPath`.");
+  lines.push("- If `codingAgent=GC` and `gcAuthMethod=apiKey`: `gcApiKey`.");
+  lines.push("- If `codingAgent=CX` and `cxAuthMethod=oauth`: `cxAuthJsonPath`.");
+  lines.push("- If `codingAgent=CX` and `cxAuthMethod=apiKey`: `cxApiKey`.");
+  lines.push("");
+  lines.push("Optional fields:");
+  lines.push("- `branchName` (default `main`)");
+  lines.push("- `envProjectPath` (default `.wile/.env.project`)");
+  lines.push("- `maxIterations` (default `25`)");
+  lines.push("- `ccModel` (`sonnet` | `opus` | `haiku`, default `opus`)");
+  lines.push("- `gcModel` (default `gemini-3-pro-preview`)");
+  lines.push("- `cxModel` (default `gpt-5.3-codex`)");
+  lines.push("");
+  lines.push("Example (GitHub + Claude OAuth):");
+  lines.push("```json");
+  lines.push("{");
+  lines.push('  "codingAgent": "CC",');
+  lines.push('  "repoSource": "github",');
+  lines.push('  "githubToken": "ghp_xxx",');
+  lines.push('  "repoUrl": "https://github.com/owner/repo",');
+  lines.push('  "branchName": "main",');
+  lines.push('  "ccAuthMethod": "oauth",');
+  lines.push('  "ccAuthValue": "claude_oauth_token",');
+  lines.push('  "ccModel": "opus",');
+  lines.push('  "maxIterations": 25');
+  lines.push("}");
+  lines.push("```");
+  lines.push("");
+  return lines.join(`
+`);
+};
+var parseNonInteractiveConfig = (raw) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { errors: ["config is not valid JSON"] };
+  }
+  if (!isRecord(parsed)) {
+    return { errors: ["config must be a JSON object"] };
+  }
+  const errors = [];
+  for (const key of Object.keys(parsed)) {
+    if (!nonInteractiveKeys.has(key)) {
+      errors.push(`unknown key '${key}'`);
+    }
+  }
+  const codingAgentRaw = parsed.codingAgent;
+  const codingAgent = codingAgentRaw === "CC" || codingAgentRaw === "OC" || codingAgentRaw === "GC" || codingAgentRaw === "CX" ? codingAgentRaw : undefined;
+  if (!codingAgent) {
+    errors.push("codingAgent must be one of: CC, OC, GC, CX");
+  }
+  const repoSourceRaw = parsed.repoSource;
+  const repoSource = repoSourceRaw === "github" || repoSourceRaw === "local" ? repoSourceRaw : undefined;
+  if (!repoSource) {
+    errors.push("repoSource must be one of: github, local");
+  }
+  const branchName = asNonEmptyString(parsed.branchName);
+  const envProjectPath = asNonEmptyString(parsed.envProjectPath);
+  const githubToken = asNonEmptyString(parsed.githubToken);
+  const repoUrl = asNonEmptyString(parsed.repoUrl);
+  const ccAuthValue = asNonEmptyString(parsed.ccAuthValue);
+  const ocModel = asNonEmptyString(parsed.ocModel);
+  const gcOauthPath = asNonEmptyString(parsed.gcOauthPath);
+  const gcApiKey = asNonEmptyString(parsed.gcApiKey);
+  const gcModel = asNonEmptyString(parsed.gcModel);
+  const cxAuthJsonPath = asNonEmptyString(parsed.cxAuthJsonPath);
+  const cxApiKey = asNonEmptyString(parsed.cxApiKey);
+  const cxModel = asNonEmptyString(parsed.cxModel);
+  if (repoSource === "github") {
+    if (!githubToken) {
+      errors.push("githubToken is required when repoSource=github");
+    }
+    if (!repoUrl) {
+      errors.push("repoUrl is required when repoSource=github");
+    }
+  }
+  const ccAuthMethodRaw = parsed.ccAuthMethod;
+  const ccAuthMethod = ccAuthMethodRaw === "oauth" || ccAuthMethodRaw === "apiKey" ? ccAuthMethodRaw : undefined;
+  const ccModelRaw = parsed.ccModel;
+  const ccModel = ccModelRaw === "sonnet" || ccModelRaw === "opus" || ccModelRaw === "haiku" ? ccModelRaw : undefined;
+  const gcAuthMethodRaw = parsed.gcAuthMethod;
+  const gcAuthMethod = gcAuthMethodRaw === "oauth" || gcAuthMethodRaw === "apiKey" ? gcAuthMethodRaw : undefined;
+  const cxAuthMethodRaw = parsed.cxAuthMethod;
+  const cxAuthMethod = cxAuthMethodRaw === "oauth" || cxAuthMethodRaw === "apiKey" ? cxAuthMethodRaw : undefined;
+  if (codingAgent === "CC") {
+    if (!ccAuthMethod) {
+      errors.push("ccAuthMethod is required when codingAgent=CC");
+    }
+    if (!ccAuthValue) {
+      errors.push("ccAuthValue is required when codingAgent=CC");
+    }
+    if (parsed.ccModel !== undefined && !ccModel) {
+      errors.push("ccModel must be one of: sonnet, opus, haiku");
+    }
+  }
+  if (codingAgent === "OC" && !ocModel) {
+    errors.push("ocModel is required when codingAgent=OC");
+  }
+  if (codingAgent === "GC") {
+    if (!gcAuthMethod) {
+      errors.push("gcAuthMethod is required when codingAgent=GC");
+    } else if (gcAuthMethod === "oauth" && !gcOauthPath) {
+      errors.push("gcOauthPath is required when codingAgent=GC and gcAuthMethod=oauth");
+    } else if (gcAuthMethod === "apiKey" && !gcApiKey) {
+      errors.push("gcApiKey is required when codingAgent=GC and gcAuthMethod=apiKey");
+    }
+  }
+  if (codingAgent === "CX") {
+    if (!cxAuthMethod) {
+      errors.push("cxAuthMethod is required when codingAgent=CX");
+    } else if (cxAuthMethod === "oauth" && !cxAuthJsonPath) {
+      errors.push("cxAuthJsonPath is required when codingAgent=CX and cxAuthMethod=oauth");
+    } else if (cxAuthMethod === "apiKey" && !cxApiKey) {
+      errors.push("cxApiKey is required when codingAgent=CX and cxAuthMethod=apiKey");
+    }
+  }
+  const maxIterationsRaw = parsed.maxIterations;
+  let maxIterations;
+  if (maxIterationsRaw !== undefined) {
+    if (typeof maxIterationsRaw !== "number" || !Number.isFinite(maxIterationsRaw)) {
+      errors.push("maxIterations must be a number");
+    } else if (maxIterationsRaw <= 0) {
+      errors.push("maxIterations must be greater than 0");
+    } else {
+      maxIterations = Math.floor(maxIterationsRaw);
+    }
+  }
+  if (errors.length > 0 || !codingAgent || !repoSource) {
+    return { errors };
+  }
+  return {
+    config: {
+      codingAgent,
+      repoSource,
+      branchName,
+      envProjectPath,
+      maxIterations,
+      githubToken,
+      repoUrl,
+      ccAuthMethod,
+      ccAuthValue,
+      ccModel,
+      ocModel,
+      gcAuthMethod,
+      gcOauthPath,
+      gcApiKey,
+      gcModel,
+      cxAuthMethod,
+      cxAuthJsonPath,
+      cxApiKey,
+      cxModel
+    },
+    errors: []
+  };
+};
+var toPromptInjectValues = (config) => {
+  const values = [config.codingAgent];
+  if (config.codingAgent === "CC") {
+    values.push(config.ccAuthMethod, config.ccAuthValue, config.ccModel ?? "opus");
+  } else if (config.codingAgent === "OC") {
+    values.push(config.ocModel ?? "opencode/kimi-k2.5-free");
+  } else if (config.codingAgent === "GC") {
+    values.push(config.gcAuthMethod);
+    if (config.gcAuthMethod === "oauth") {
+      values.push(config.gcOauthPath);
+    } else {
+      values.push(config.gcApiKey);
+    }
+  } else {
+    values.push(config.cxAuthMethod);
+    if (config.cxAuthMethod === "oauth") {
+      values.push(config.cxAuthJsonPath);
+    } else {
+      values.push(config.cxApiKey);
+    }
+    values.push(config.cxModel ?? "gpt-5.3-codex");
+  }
+  values.push(config.repoSource);
+  if (config.repoSource === "github") {
+    values.push(config.githubToken, config.repoUrl);
+  }
+  values.push(config.branchName ?? "main");
+  values.push(config.envProjectPath ?? ".wile/.env.project");
+  values.push(config.maxIterations ?? 25);
+  return values;
+};
 var readEnvFile = async (path) => {
   if (!existsSync(path)) {
     return {};
@@ -7628,36 +8022,6 @@ var setIfDefined = (env, key, value) => {
   }
   env[key] = value;
 };
-var toEnvString = (env) => {
-  const orderedKeys = [
-    "CODING_AGENT",
-    "WILE_REPO_SOURCE",
-    "WILE_ENV_PROJECT_PATH",
-    "GITHUB_TOKEN",
-    "GITHUB_REPO_URL",
-    "BRANCH_NAME",
-    "WILE_MAX_ITERATIONS",
-    "CC_CLAUDE_MODEL",
-    "CC_CLAUDE_CODE_OAUTH_TOKEN",
-    "CC_ANTHROPIC_API_KEY",
-    "OC_PROVIDER",
-    "OC_MODEL",
-    "OC_OPENROUTER_API_KEY",
-    "GEMINI_OAUTH_CREDS_B64",
-    "GEMINI_API_KEY",
-    "CODEX_AUTH_JSON_B64",
-    "CODEX_AUTH_JSON_PATH",
-    "CODEX_API_KEY",
-    "CODEX_MODEL"
-  ];
-  const orderedSet = new Set(orderedKeys);
-  const ordered = orderedKeys.filter((key) => (key in env));
-  const rest = Object.keys(env).filter((key) => !orderedSet.has(key)).sort();
-  const lines = [...ordered, ...rest].map((key) => `${key}=${env[key]}`);
-  return lines.join(`
-`) + `
-`;
-};
 var resolvePath = (cwd, input) => {
   const expanded = input.startsWith("~") ? join(homedir(), input.slice(1)) : input;
   return isAbsolute(expanded) ? expanded : resolve(cwd, expanded);
@@ -7666,7 +8030,28 @@ var readBase64File = async (path) => {
   const contents = await readFile(path);
   return Buffer.from(contents).toString("base64");
 };
-var runConfig = async () => {
+var runConfig = async (options = {}) => {
+  const nonInteractiveInput = options.nonInteractive;
+  if (nonInteractiveInput === true) {
+    process.stdout.write(renderNonInteractiveConfigHelp());
+    return true;
+  }
+  let nonInteractiveConfig;
+  if (typeof nonInteractiveInput === "string") {
+    const parsed = parseNonInteractiveConfig(nonInteractiveInput);
+    if (!parsed.config) {
+      process.stdout.write(renderNonInteractiveConfigHelp());
+      process.stdout.write(`
+`);
+      console.error("Error: invalid non-interactive config.");
+      for (const error of parsed.errors) {
+        console.error(`- ${error}`);
+      }
+      return false;
+    }
+    nonInteractiveConfig = parsed.config;
+    import_prompts.default.inject(toPromptInjectValues(parsed.config));
+  }
   const cwd = process.cwd();
   const wileDir = join(cwd, ".wile");
   const secretsDir = join(wileDir, "secrets");
@@ -7679,8 +8064,10 @@ var runConfig = async () => {
   const preflightPath = join(wileDir, "preflight.md");
   const agentsPath = join(wileDir, "AGENTS.md");
   await mkdir(secretsDir, { recursive: true });
-  maybeInject();
-  const existingEnv = await readEnvFile(envPath);
+  if (!nonInteractiveConfig) {
+    maybeInject();
+  }
+  const { known: existingEnv, extra: extraEnv } = splitEnv(await readEnvFile(envPath));
   const codingAgentResponse = await prompt({
     type: "select",
     name: "codingAgent",
@@ -7699,10 +8086,7 @@ var runConfig = async () => {
   let codexAuthMethod = null;
   let authValueResponse = {};
   let defaultModelResponse = {};
-  let ocProviderResponse = {};
-  let ocKeyResponse = {};
   let ocModelResponse = {};
-  let ocNativeModelResponse = {};
   let geminiOauthPathResponse = {};
   let geminiApiKeyResponse = {};
   let codexAuthJsonPathResponse = {};
@@ -7742,45 +8126,14 @@ var runConfig = async () => {
       initial: existingEnv.CC_CLAUDE_MODEL === "sonnet" ? 0 : existingEnv.CC_CLAUDE_MODEL === "haiku" ? 2 : 1
     });
   } else if (codingAgent === "OC") {
-    const providerDefault = existingEnv.OC_PROVIDER === "openrouter" ? "openrouter" : "native";
-    ocProviderResponse = await prompt({
+    const existingNativeIdx = nativeOcModels.findIndex((m) => m.value === existingEnv.OC_MODEL);
+    ocModelResponse = await prompt({
       type: "select",
-      name: "ocProvider",
-      message: "OpenCode provider",
-      choices: [
-        { title: "Native free models (no API key)", value: "native" },
-        { title: "OpenRouter (pay per token)", value: "openrouter" }
-      ],
-      initial: providerDefault === "openrouter" ? 1 : 0
+      name: "ocModel",
+      message: "OpenCode model (free)",
+      choices: nativeOcModels,
+      initial: existingNativeIdx >= 0 ? existingNativeIdx : 0
     });
-    const ocProvider2 = ocProviderResponse.ocProvider;
-    if (ocProvider2 === "openrouter") {
-      console.log("");
-      console.log(tips.openrouter);
-      console.log("");
-      ocKeyResponse = await prompt({
-        type: "password",
-        name: "ocKey",
-        message: "OpenRouter API key (press enter to keep existing)",
-        initial: existingEnv.OC_OPENROUTER_API_KEY ?? ""
-      });
-      ocModelResponse = await prompt({
-        type: "select",
-        name: "ocModel",
-        message: "OpenCode model (OpenRouter)",
-        choices: [{ title: "glm-4.7", value: "glm-4.7" }],
-        initial: 0
-      });
-    } else {
-      const existingNativeIdx = nativeOcModels.findIndex((m) => m.value === existingEnv.OC_MODEL);
-      ocNativeModelResponse = await prompt({
-        type: "select",
-        name: "ocNativeModel",
-        message: "OpenCode model (free)",
-        choices: nativeOcModels,
-        initial: existingNativeIdx >= 0 ? existingNativeIdx : 0
-      });
-    }
   } else if (codingAgent === "GC") {
     const geminiAuthDefault = existingEnv.GEMINI_OAUTH_CREDS_B64 ? "oauth" : existingEnv.GEMINI_API_KEY ? "apiKey" : "oauth";
     const geminiAuthResponse = await prompt({
@@ -7849,7 +8202,7 @@ var runConfig = async () => {
       type: "text",
       name: "codexModel",
       message: "Codex model (press enter to keep existing)",
-      initial: existingEnv.CODEX_MODEL ?? ""
+      initial: existingEnv.CODEX_MODEL ?? "gpt-5.3-codex"
     });
   }
   const repoSourceResponse = await prompt({
@@ -7902,10 +8255,9 @@ var runConfig = async () => {
   const maxIterations = Number.isFinite(iterationsResponse.maxIterations) && iterationsResponse.maxIterations > 0 ? iterationsResponse.maxIterations : fallbackIterations;
   const authFallback = authMethod === "oauth" ? existingEnv.CC_CLAUDE_CODE_OAUTH_TOKEN : existingEnv.CC_ANTHROPIC_API_KEY;
   const authValue = codingAgent === "CC" ? coalesceValue(authValueResponse.authValue, authFallback) : undefined;
-  const ocProvider = codingAgent === "OC" ? ocProviderResponse.ocProvider ?? "native" : undefined;
-  const ocKey = codingAgent === "OC" && ocProvider === "openrouter" ? coalesceValue(ocKeyResponse.ocKey, existingEnv.OC_OPENROUTER_API_KEY) : undefined;
-  const ocModel = codingAgent === "OC" ? ocProvider === "openrouter" ? coalesceValue(ocModelResponse.ocModel, existingEnv.OC_MODEL ?? "glm-4.7") : coalesceValue(ocNativeModelResponse.ocNativeModel, existingEnv.OC_MODEL ?? "opencode/grok-code") : undefined;
+  const ocModel = codingAgent === "OC" ? coalesceValue(ocModelResponse.ocModel, existingEnv.OC_MODEL ?? "opencode/kimi-k2.5-free") : undefined;
   const geminiApiKey = codingAgent === "GC" ? coalesceValue(geminiApiKeyResponse.geminiApiKey, existingEnv.GEMINI_API_KEY) : undefined;
+  const geminiModel = codingAgent === "GC" ? coalesceValue(nonInteractiveConfig?.gcModel, existingEnv.GEMINI_MODEL ?? "gemini-3-pro-preview") : undefined;
   let geminiOauthCredsB64;
   if (codingAgent === "GC" && geminiAuthMethod === "oauth") {
     const configuredPath = coalesceValue(geminiOauthPathResponse.geminiOauthPath);
@@ -7935,7 +8287,7 @@ var runConfig = async () => {
       codexAuthJsonB64 = existingEnv.CODEX_AUTH_JSON_B64;
     }
   }
-  const codexModel = codingAgent === "CX" ? coalesceValue(codexModelResponse.codexModel, existingEnv.CODEX_MODEL) : undefined;
+  const codexModel = codingAgent === "CX" ? coalesceValue(codexModelResponse.codexModel, existingEnv.CODEX_MODEL ?? "gpt-5.3-codex") : undefined;
   const githubToken = repoSource === "github" ? coalesceValue(githubTokenResponse.githubToken, existingEnv.GITHUB_TOKEN) : existingEnv.GITHUB_TOKEN;
   const repoUrl = repoSource === "github" ? coalesceValue(repoResponse.repoUrl, existingEnv.GITHUB_REPO_URL) : existingEnv.GITHUB_REPO_URL;
   const envProjectPathValue = coalesceValue(envProjectPathResponse.envProjectPath, existingEnv.WILE_ENV_PROJECT_PATH ?? ".wile/.env.project") ?? ".wile/.env.project";
@@ -7956,17 +8308,14 @@ var runConfig = async () => {
       setIfDefined(envOut, "CC_ANTHROPIC_API_KEY", authValue);
     }
   } else if (codingAgent === "OC") {
-    setIfDefined(envOut, "OC_PROVIDER", ocProvider ?? "native");
-    setIfDefined(envOut, "OC_MODEL", ocModel ?? "opencode/grok-code");
-    if (ocProvider === "openrouter") {
-      setIfDefined(envOut, "OC_OPENROUTER_API_KEY", ocKey);
-    }
+    setIfDefined(envOut, "OC_MODEL", ocModel ?? "opencode/kimi-k2.5-free");
   } else if (codingAgent === "GC") {
     if (geminiAuthMethod === "apiKey") {
       setIfDefined(envOut, "GEMINI_API_KEY", geminiApiKey);
     } else {
       setIfDefined(envOut, "GEMINI_OAUTH_CREDS_B64", geminiOauthCredsB64);
     }
+    setIfDefined(envOut, "GEMINI_MODEL", geminiModel);
   } else if (codingAgent === "CX") {
     if (codexAuthMethod === "apiKey") {
       setIfDefined(envOut, "CODEX_API_KEY", codexApiKey);
@@ -7975,7 +8324,7 @@ var runConfig = async () => {
     }
     setIfDefined(envOut, "CODEX_MODEL", codexModel);
   }
-  await writeFile(envPath, toEnvString(envOut));
+  await writeFile(envPath, toEnvString(envOut, extraEnv));
   await ensureGitignore(gitignorePath);
   const envProjectTarget = envProjectPathValue === ".wile/.env.project" ? envProjectPath : envProjectPathValue;
   const envProjectResolved = envProjectTarget.startsWith("/") ? envProjectTarget : join(cwd, envProjectTarget);
@@ -8046,6 +8395,7 @@ Wile config complete.`);
   if (!hadPreflight) {
     console.log("Created .wile/preflight.md for preflight checks (optional).");
   }
+  return true;
 };
 
 // src/commands/compact.ts
@@ -8100,7 +8450,7 @@ var readWileConfig = (options = {}) => {
   if (validate) {
     ensureRequired(existsSync2(paths.envPath), "Missing .wile/secrets/.env. Run 'bunx wile config' first.");
   }
-  const env = parseEnvFile(paths.envPath);
+  const { known: env } = splitEnv(parseEnvFile(paths.envPath));
   const envProjectPath = resolveEnvProjectPath(options.cwd ?? process.cwd(), env.WILE_ENV_PROJECT_PATH);
   const envProject = parseEnvFile(envProjectPath);
   const repoSource = env.WILE_REPO_SOURCE || "github";
@@ -8115,10 +8465,6 @@ var readWileConfig = (options = {}) => {
       ensureRequired(Boolean(env.CC_CLAUDE_CODE_OAUTH_TOKEN || env.CC_ANTHROPIC_API_KEY), "Either CC_CLAUDE_CODE_OAUTH_TOKEN or CC_ANTHROPIC_API_KEY is required in .wile/secrets/.env.");
     }
     if (env.CODING_AGENT === "OC") {
-      const ocProvider = env.OC_PROVIDER || "native";
-      if (ocProvider === "openrouter") {
-        ensureRequired(Boolean(env.OC_OPENROUTER_API_KEY), "OC_OPENROUTER_API_KEY is required in .wile/secrets/.env for OpenCode with OpenRouter provider.");
-      }
       ensureRequired(Boolean(env.OC_MODEL), "OC_MODEL is required in .wile/secrets/.env for OpenCode.");
     }
     if (env.CODING_AGENT === "GC") {
@@ -8143,11 +8489,10 @@ var readWileConfig = (options = {}) => {
       maxIterations: env.WILE_MAX_ITERATIONS,
       ccClaudeCodeOauthToken: env.CC_CLAUDE_CODE_OAUTH_TOKEN,
       ccAnthropicApiKey: env.CC_ANTHROPIC_API_KEY,
-      ocProvider: env.OC_PROVIDER ?? "native",
-      ocOpenrouterApiKey: env.OC_OPENROUTER_API_KEY,
       ocModel: env.OC_MODEL,
       geminiOauthCredsB64: env.GEMINI_OAUTH_CREDS_B64,
       geminiApiKey: env.GEMINI_API_KEY,
+      geminiModel: env.GEMINI_MODEL,
       codexAuthJsonB64: env.CODEX_AUTH_JSON_B64,
       codexAuthJsonPath: env.CODEX_AUTH_JSON_PATH,
       codexApiKey: env.CODEX_API_KEY ?? env.OPENAI_API_KEY,
@@ -8670,8 +9015,11 @@ var packageJsonPath = resolve4(new URL("../package.json", import.meta.url).pathn
 var packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
 var program2 = new Command;
 program2.name("wile").description("Autonomous AI coding agent that ships features while you sleep").version(packageJson.version);
-program2.command("config").description("Configure the current project for Wile").action(async () => {
-  await runConfig();
+program2.command("config").description("Configure the current project for Wile").option("--non-interactive [config]", "No value: print agent config docs. With JSON value: validate and apply non-interactive config.").action(async (options) => {
+  const ok = await runConfig({ nonInteractive: options.nonInteractive });
+  if (!ok) {
+    process.exitCode = 1;
+  }
 });
 program2.command("run").description("Run Wile on a repository").option("--repo <repo>", "Repository URL or local path").option("--max-iterations <count>", "Maximum iterations").option("--test", "Run in test mode").option("--debug", "Print debug info before running").action(async (options) => {
   await runWile(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wile",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Autonomous AI coding agent that ships features while you sleep",
   "type": "module",
   "bin": {