wile 1.0.1 → 1.2.0

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);
@@ -8019,13 +8368,13 @@ Use bullet points for preflight checks, e.g.
     "- If verification is a command, state the expected result of that command.",
     "- Use one behavior per bullet.",
     "- Keep IDs stable, unique, and numeric (e.g., 1, 2, 3).",
-    "- Never reuse IDs listed in any story's `compactedFrom`.",
+    "- Never reuse IDs listed in any story's `compactedFrom` ranges.",
     '- Avoid vague terms like "should" or "nice".',
     "- Keep stories small enough to finish in one iteration.",
     '- Use `status: "pending"` for work not done yet and `status: "done"` only after all acceptance criteria are verified.',
     "- Use `dependsOn` to model prerequisites by story ID.",
     "- `dependsOn` must reference active story IDs only; never reference compacted IDs.",
-    "- When compacting completed stories, add `compactedFrom: [oldId1, oldId2, ...]` to the summary done story.",
+    '- When compacting completed stories, add a canonical range string like `compactedFrom: "1..3,5"` to the summary done story.',
     "- Prefer concrete files/commands only when they reflect the real outcome.",
     "",
     "Environment notes:",
@@ -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,
@@ -8195,6 +8540,53 @@ var toIntegerArray = (value, message) => {
   }
   return value;
 };
+var compactedFromFormatError = 'must use canonical range syntax like "1..3,5" (sorted, non-overlapping).';
+var parseCompactedFrom = (value, label) => {
+  const raw = toNonEmptyString(value, `${label}.compactedFrom ${compactedFromFormatError}`).trim();
+  const tokens = raw.split(",").map((token) => token.trim());
+  if (tokens.length === 0 || tokens.some((token) => token.length === 0)) {
+    throw new Error(`${label}.compactedFrom ${compactedFromFormatError}`);
+  }
+  const parsed = [];
+  for (const token of tokens) {
+    const match = token.match(/^(-?\d+)(?:\.\.(-?\d+))?$/);
+    if (!match) {
+      throw new Error(`${label}.compactedFrom ${compactedFromFormatError}`);
+    }
+    const start = Number(match[1]);
+    const end = match[2] === undefined ? start : Number(match[2]);
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start > end) {
+      throw new Error(`${label}.compactedFrom ${compactedFromFormatError}`);
+    }
+    parsed.push({ start, end });
+  }
+  parsed.sort((a, b) => a.start === b.start ? a.end - b.end : a.start - b.start);
+  for (let i = 1;i < parsed.length; i += 1) {
+    if (parsed[i].start <= parsed[i - 1].end) {
+      throw new Error(`${label}.compactedFrom ${compactedFromFormatError}`);
+    }
+  }
+  const merged = [];
+  for (const range of parsed) {
+    const last = merged[merged.length - 1];
+    if (!last || range.start > last.end + 1) {
+      merged.push({ ...range });
+      continue;
+    }
+    if (range.end > last.end) {
+      last.end = range.end;
+    }
+  }
+  const canonical = merged.map((range) => range.start === range.end ? `${range.start}` : `${range.start}..${range.end}`).join(",");
+  const normalizedInput = tokens.join(",");
+  if (normalizedInput !== canonical) {
+    throw new Error(`${label}.compactedFrom ${compactedFromFormatError}`);
+  }
+  return {
+    value: canonical,
+    ranges: merged
+  };
+};
 var parsePrdStory = (storyRaw, index) => {
   const label = `stories[${index}]`;
   const story = toObject(storyRaw, `${label} must be an object.`);
@@ -8208,14 +8600,14 @@ var parsePrdStory = (storyRaw, index) => {
     throw new Error(`${label}.status must be "pending" or "done".`);
   }
   let compactedFrom;
+  let compactedFromRanges;
   if (story.compactedFrom !== undefined) {
-    compactedFrom = toIntegerArray(story.compactedFrom, `${label}.compactedFrom must be an array of integer story IDs.`);
-    if (new Set(compactedFrom).size !== compactedFrom.length) {
-      throw new Error(`${label}.compactedFrom must not contain duplicate IDs.`);
-    }
     if (status !== "done") {
       throw new Error(`${label}.compactedFrom is only allowed when status is "done".`);
     }
+    const parsedCompactedFrom = parseCompactedFrom(story.compactedFrom, label);
+    compactedFrom = parsedCompactedFrom.value;
+    compactedFromRanges = parsedCompactedFrom.ranges;
   }
   return {
     id,
@@ -8224,6 +8616,7 @@ var parsePrdStory = (storyRaw, index) => {
     acceptanceCriteria,
     dependsOn,
     compactedFrom,
+    compactedFromRanges,
     status
   };
 };
@@ -8265,6 +8658,19 @@ var findDependencyCycle = (stories) => {
   }
   return null;
 };
+var findReservedOwner = (id, reservedRanges) => {
+  for (const range of reservedRanges) {
+    if (id >= range.start && id <= range.end) {
+      return range.ownerStoryId;
+    }
+  }
+  return;
+};
+var toPublicStory = (story) => {
+  const publicStory = { ...story };
+  delete publicStory.compactedFromRanges;
+  return publicStory;
+};
 var validatePrd = (raw) => {
   const payload = toObject(raw, "prd.json must be a JSON object.");
   if (!Array.isArray(payload.stories)) {
@@ -8278,23 +8684,31 @@ var validatePrd = (raw) => {
     }
     storyById.set(story.id, story);
   }
-  const compactedById = new Map;
+  const reservedRanges = [];
   for (const story of stories) {
-    for (const compactedId of story.compactedFrom ?? []) {
-      if (compactedById.has(compactedId)) {
-        throw new Error(`Compacted story id ${compactedId} is listed multiple times (stories ${compactedById.get(compactedId)} and ${story.id}).`);
+    for (const range of story.compactedFromRanges ?? []) {
+      for (const existingRange of reservedRanges) {
+        if (range.start <= existingRange.end && existingRange.start <= range.end) {
+          const overlapId = Math.max(range.start, existingRange.start);
+          throw new Error(`Compacted story id ${overlapId} is listed multiple times (stories ${existingRange.ownerStoryId} and ${story.id}).`);
+        }
       }
-      compactedById.set(compactedId, story.id);
+      reservedRanges.push({
+        start: range.start,
+        end: range.end,
+        ownerStoryId: story.id
+      });
     }
   }
-  for (const [compactedId, ownerStoryId] of compactedById) {
-    if (storyById.has(compactedId)) {
-      throw new Error(`Story id ${compactedId} is reserved by compactedFrom in story ${ownerStoryId}.`);
+  for (const story of stories) {
+    const ownerStoryId = findReservedOwner(story.id, reservedRanges);
+    if (ownerStoryId !== undefined) {
+      throw new Error(`Story id ${story.id} is reserved by compactedFrom in story ${ownerStoryId}.`);
     }
   }
   for (const story of stories) {
     for (const depId of story.dependsOn) {
-      const compactedOwner = compactedById.get(depId);
+      const compactedOwner = findReservedOwner(depId, reservedRanges);
       if (compactedOwner !== undefined) {
         throw new Error(`Story ${story.id} depends on compacted story id ${depId} (compacted in story ${compactedOwner}).`);
       }
@@ -8314,9 +8728,9 @@ var validatePrd = (raw) => {
     throw new Error(`No runnable pending stories in prd.json. Pending stories are blocked: ${blockedIds}.`);
   }
   return {
-    prd: { stories },
-    pendingStories,
-    runnableStory,
+    prd: { stories: stories.map(toPublicStory) },
+    pendingStories: pendingStories.map(toPublicStory),
+    runnableStory: runnableStory ? toPublicStory(runnableStory) : null,
     allDone: pendingStories.length === 0
   };
 };
@@ -8601,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);